term: move the term core to subprojects/term

The core now builds, tests, and benchmarks alone, as a Meson subproject
with no dependency on the main tree.

- include/term/ holds term.h and the header-only unicode/. src/ holds
  the core and its private headers. The main tree gets only
  include/term through term_dep, so it cannot reach a private header.
- The term tests, the term benchmarks, the Kitty parser suite, and
  tools/amalgamate.py and tools/generate_unicode.py move with it. The
  tests run as term:<name>.
- The main build passes its -march (arch_flag) and b_ndebug to the
  subproject. A directory configured before this commit needs
  meson configure -Dterm:arch_flag=-march=... once.
- The term tests compile with -UNDEBUG. They do work inside assert.
- The subproject exports term_test_dep with term_api.h, for the main
  tree's render, thumbnail, color, and selection tests.
- The Kitty bridge used struct vector2i and has not compiled since the
  public API redesign. It builds again. 2 of its 14 tests fail: REP
  after a tab, and a cursor report after a resize.
- dirgraph.py drops the term and unicode layers. Its self-test uses pty.
- The symbols test ignores the __odr_asan symbols that ASan adds.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

8 files changed, 2946 insertions, 0 deletions

diff --git a/tests/extern/kitty/.gitignore b/tests/extern/kitty/.gitignore
new file mode 100644
index 0000000..79a6f1c
--- /dev/null
+++ b/tests/extern/kitty/.gitignore
@@ -0,0 +1,2 @@
+__pycache__/
+libterm.so
diff --git a/tests/extern/kitty/__init__.py b/tests/extern/kitty/__init__.py
new file mode 100644
index 0000000..5dddbaf
--- /dev/null
+++ b/tests/extern/kitty/__init__.py
@@ -0,0 +1,9 @@
+"""Package marker for the Kitty parser test harness.
+
+Re-exports :class:`BaseTest`, :class:`CmdDump`, and ``parse_bytes`` from
+:mod:`kitty_harness`.
+"""
+
+from kitty_harness import BaseTest, CmdDump, parse_bytes
+
+__all__ = ['BaseTest', 'CmdDump', 'parse_bytes']
diff --git a/tests/extern/kitty/fast_data_types.py b/tests/extern/kitty/fast_data_types.py
new file mode 100644
index 0000000..c8c519d
--- /dev/null
+++ b/tests/extern/kitty/fast_data_types.py
@@ -0,0 +1,237 @@
+"""Stubs for Kitty's ``kitty.fast_data_types`` C extension module.
+
+These pure-Python implementations provide the subset of the API used by
+Kitty's parser test-suite.  The SIMD-accelerated variants are not available,
+so ``has_avx2`` and ``has_sse4_2`` are ``False`` and the decoder falls back
+to a scalar implementation that matches the WHATWG Encoding Standard.
+"""
+
+import base64 as _base64
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+CURSOR_BLOCK = 0
+VT_PARSER_BUFFER_SIZE = 8192  # Large enough that buffer-full tests don't trigger
+
+has_avx2 = False
+has_sse4_2 = False
+
+# ---------------------------------------------------------------------------
+# Base64 helpers (padding-free, matching Kitty's convention)
+# ---------------------------------------------------------------------------
+
+def base64_decode(data) -> bytes:
+    """Decode base64, accepting both padded and unpadded input."""
+    if isinstance(data, str):
+        data = data.encode('utf-8')
+    data = bytes(data)
+    # Strip any existing padding and whitespace.
+    data = data.rstrip(b'=').strip()
+    # Re-add the minimum padding required by the stdlib decoder.
+    missing = len(data) % 4
+    if missing:
+        data += b'=' * (4 - missing)
+    return _base64.b64decode(data)
+
+
+def base64_encode(data) -> bytes:
+    """Encode to base64 without trailing ``=`` padding."""
+    if isinstance(data, str):
+        data = data.encode('utf-8')
+    return _base64.b64encode(bytes(data)).rstrip(b'=')
+
+
+# ---------------------------------------------------------------------------
+# Byte search helper
+# ---------------------------------------------------------------------------
+
+def test_find_either_of_two_bytes(buf, a, b, which=0, align_offset=0):
+    """Return the index of the first occurrence of byte *a* or *b* in *buf*.
+
+    Returns -1 when neither byte is found.  The *which* and *align_offset*
+    parameters select SIMD variants in Kitty's native code; the pure-Python
+    fallback ignores them.
+    """
+    if isinstance(buf, str):
+        buf = buf.encode('latin-1')
+    buf = bytes(buf)
+    ia = int(a)
+    ib = int(b)
+    for i, byte in enumerate(buf):
+        if byte == ia or byte == ib:
+            return i
+    return -1
+
+
+# ---------------------------------------------------------------------------
+# UTF-8 decoder with WHATWG U+FFFD substitution
+# ---------------------------------------------------------------------------
+
+# Module-level state for incomplete trailing sequences across calls.
+_utf8_pending = bytearray()
+
+
+def test_utf8_decode_to_sentinel(data, which=0):
+    """Decode UTF-8 bytes until an ESC (0x1b) sentinel or end of data.
+
+    Returns ``(found_sentinel: bool, decoded_text: str, num_consumed: int)``.
+
+    *num_consumed* counts only the bytes consumed from *data* (not any
+    pending bytes carried over from a previous call).  Invalid sequences are
+    replaced with U+FFFD using the maximal-subpart rules from the WHATWG
+    Encoding Standard.
+
+    Passing *which* = -1 resets the internal pending-state buffer.
+    """
+    global _utf8_pending
+
+    # --- reset -----------------------------------------------------------
+    if which == -1:
+        _utf8_pending = bytearray()
+        return (False, '', 0)
+
+    initial_pending = len(_utf8_pending)
+    buf = bytes(_utf8_pending) + bytes(data)
+    _utf8_pending = bytearray()
+
+    result = []
+    i = 0
+    n = len(buf)
+    found_sentinel = False
+
+    while i < n:
+        byte = buf[i]
+
+        # ESC sentinel
+        if byte == 0x1B:
+            found_sentinel = True
+            i += 1
+            break
+
+        # ASCII
+        if byte < 0x80:
+            result.append(chr(byte))
+            i += 1
+            continue
+
+        # Lone continuation byte 0x80-0xBF
+        if byte < 0xC0:
+            result.append('\ufffd')
+            i += 1
+            continue
+
+        # Invalid starter bytes 0xC0-0xC1
+        if byte < 0xC2:
+            result.append('\ufffd')
+            i += 1
+            continue
+
+        # 2-byte sequence 0xC2-0xDF
+        if byte < 0xE0:
+            if i + 1 < n:
+                nb = buf[i + 1]
+                if 0x80 <= nb <= 0xBF:
+                    cp = ((byte & 0x1F) << 6) | (nb & 0x3F)
+                    result.append(chr(cp))
+                    i += 2
+                    continue
+                # Bad continuation: starter alone is one subpart
+                result.append('\ufffd')
+                i += 1
+                continue
+            # Incomplete at end of input
+            _utf8_pending.extend(buf[i:])
+            i = n
+            break
+
+        # 3-byte sequence 0xE0-0xEF
+        if byte < 0xF0:
+            if byte == 0xE0:
+                lo, hi = 0xA0, 0xBF
+            elif byte == 0xED:
+                lo, hi = 0x80, 0x9F
+            else:
+                lo, hi = 0x80, 0xBF
+
+            if i + 1 < n:
+                nb = buf[i + 1]
+                if lo <= nb <= hi:
+                    if i + 2 < n:
+                        nb2 = buf[i + 2]
+                        if 0x80 <= nb2 <= 0xBF:
+                            cp = ((byte & 0x0F) << 12) | ((nb & 0x3F) << 6) | (nb2 & 0x3F)
+                            result.append(chr(cp))
+                            i += 3
+                            continue
+                        # Bad 2nd continuation: starter + 1st cont = one subpart
+                        result.append('\ufffd')
+                        i += 2
+                        continue
+                    # Incomplete: save starter + 1st continuation
+                    _utf8_pending.extend(buf[i:])
+                    i = n
+                    break
+                # Bad 1st continuation: starter alone is one subpart
+                result.append('\ufffd')
+                i += 1
+                continue
+            # Incomplete: save starter only
+            _utf8_pending.extend(buf[i:])
+            i = n
+            break
+
+        # 4-byte sequence 0xF0-0xF4
+        if byte < 0xF5:
+            if byte == 0xF0:
+                lo, hi = 0x90, 0xBF
+            elif byte == 0xF4:
+                lo, hi = 0x80, 0x8F
+            else:
+                lo, hi = 0x80, 0xBF
+
+            if i + 1 < n:
+                nb = buf[i + 1]
+                if lo <= nb <= hi:
+                    if i + 2 < n:
+                        nb2 = buf[i + 2]
+                        if 0x80 <= nb2 <= 0xBF:
+                            if i + 3 < n:
+                                nb3 = buf[i + 3]
+                                if 0x80 <= nb3 <= 0xBF:
+                                    cp = ((byte & 0x07) << 18) | ((nb & 0x3F) << 12) | ((nb2 & 0x3F) << 6) | (nb3 & 0x3F)
+                                    result.append(chr(cp))
+                                    i += 4
+                                    continue
+                                # Bad 3rd continuation
+                                result.append('\ufffd')
+                                i += 3
+                                continue
+                            # Incomplete: save starter + 2 continuations
+                            _utf8_pending.extend(buf[i:])
+                            i = n
+                            break
+                        # Bad 2nd continuation: starter + 1st cont = one subpart
+                        result.append('\ufffd')
+                        i += 2
+                        continue
+                    # Incomplete: save starter + 1st continuation
+                    _utf8_pending.extend(buf[i:])
+                    i = n
+                    break
+                # Bad 1st continuation: starter alone is one subpart
+                result.append('\ufffd')
+                i += 1
+                continue
+            # Incomplete: save starter only
+            _utf8_pending.extend(buf[i:])
+            i = n
+            break
+
+        # Invalid starter bytes 0xF5-0xFF
+        result.append('\ufffd')
+        i += 1
+
+    num_consumed = max(0, i - initial_pending)
+    return (found_sentinel, ''.join(result), num_consumed)
diff --git a/tests/extern/kitty/kitty_harness.py b/tests/extern/kitty/kitty_harness.py
new file mode 100644
index 0000000..d528478
--- /dev/null
+++ b/tests/extern/kitty/kitty_harness.py
@@ -0,0 +1,46 @@
+"""Test harness for running Kitty's parser.py test suite.
+
+Provides :class:`BaseTest`, :class:`CmdDump`, and re-exports ``parse_bytes``
+from ``kitty_parser`` (written by a separate subagent).
+"""
+
+import unittest
+
+from kitty_parser import parse_bytes
+
+
+class CmdDump(list):
+    """Collects parser events, matching Kitty's ``CmdDump``."""
+
+    def __call__(self, window_id, *a):
+        if a and a[0] == 'bytes':
+            return
+        if a and a[0] == 'error':
+            a = a[1:]
+        self.append(tuple(a))
+
+    def get_result(self):
+        current = ''
+        q = []
+        for args in self:
+            if args[0] == 'draw':
+                current += args[1]
+            else:
+                if current:
+                    q.append(('draw', current))
+                    current = ''
+                q.append(args)
+        if current:
+            q.append(('draw', current))
+        return tuple(q)
+
+
+class BaseTest(unittest.TestCase):
+    """Base test class matching Kitty's test API."""
+
+    def ae(self, a, b, msg=None):
+        self.assertEqual(a, b, msg)
+
+    def create_screen(self, cols=5):
+        from screen import Screen
+        return Screen(cols, 5)  # 5 rows like Kitty
diff --git a/tests/extern/kitty/kitty_parser.py b/tests/extern/kitty/kitty_parser.py
new file mode 100644
index 0000000..f34a608
--- /dev/null
+++ b/tests/extern/kitty/kitty_parser.py
@@ -0,0 +1,1068 @@
+"""Pure-Python VT parser that emits Kitty-style callback events.
+
+This parser mirrors the event vocabulary that Kitty's ``parser.py`` test
+suite expects (``draw``, ``screen_cursor_position``,
+``select_graphic_rendition``, ``set_title``, …) while feeding every byte
+to the C terminal through ``screen.write(data)`` so that observable
+screen state is driven by the real implementation.
+
+The parser maintains state across calls so that partial escape sequences
+split across ``parse_bytes`` invocations are handled correctly — this is
+exercised by ``test_parser_threading``.
+"""
+
+# Parser states
+_GROUND = 0
+_ESC = 1
+_CSI = 2
+_OSC = 3
+_DCS = 4
+_APC = 5
+_PM = 6
+_SOS = 7
+_STR_ESC = 8
+_CHARSET = 9
+_ESC_PCT = 10
+
+# CSI byte classes
+_CSI_PARAM = 0   # 0x30-0x3a (digits, ';', ':')
+_CSI_PREFIX = 1  # 0x3c-0x3f (< = > ?)
+_CSI_INTER = 2    # 0x20-0x2f
+_CSI_FINAL = 3    # 0x40-0x7e
+_CSI_OTHER = 4
+
+_MAX_PARAMS = 256
+
+
+class _CSIState:
+    """CSI parse state, mirroring kitty's vt-parser.c grammar.
+
+    Params accumulate into ``accum`` with ``num_digits`` digits seen;
+    ``commit`` pushes mult*accum. A param with no digits is never
+    committed, so a trailing ';' does not create an empty final param.
+    ``phase``: 0=start, 1=body, 2=post-secondary (after intermediate).
+    """
+
+    __slots__ = ('prefix', 'intermediate', 'final', 'params', 'nparams', 'subparams',
+                 'num_digits', 'mult', 'accum', 'phase')
+
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        self.prefix = 0
+        self.intermediate = 0
+        self.final = 0
+        self.params = [0] * _MAX_PARAMS
+        self.nparams = 0
+        self.subparams = 0
+        self.num_digits = 0
+        self.mult = 1
+        self.accum = 0
+        self.phase = 0
+
+    def add_digit(self, d):
+        if self.num_digits >= 17:
+            return
+        self.accum = self.accum * 10 + d
+        self.num_digits += 1
+
+    def commit(self):
+        """Commit the pending param. Returns False on param overflow."""
+        if not self.num_digits:
+            return True
+        if self.nparams >= _MAX_PARAMS:
+            return False
+        v = self.mult * self.accum
+        self.params[self.nparams] = ((v + 2**31) % 2**32) - 2**31
+        self.nparams += 1
+        self.num_digits = 0
+        self.mult = 1
+        self.accum = 0
+        return True
+
+
+class KittyParser:
+    """Stateful VT parser that emits Kitty-style events."""
+
+    def __init__(self):
+        self.state = _GROUND
+        self.text = ''          # accumulated UTF-8 text for draw events
+        self.utf8_pending = b'' # incomplete UTF-8 sequence
+        self.csi = _CSIState()
+        self.str_buf = bytearray()  # OSC/DCS/APC/PM/SOS payload
+        self.str_type = 0       # which string mode we're in
+        self.charset_slot = 0
+
+    # -- text / draw --
+
+    def _flush_text(self, cb):
+        if self.text:
+            cb(0, 'draw', self.text)
+            self.text = ''
+
+    def _emit(self, cb, *args):
+        self._flush_text(cb)
+        cb(0, *args)
+
+    def _kill_pending(self):
+        """A control byte kills a pending incomplete UTF-8 sequence."""
+        if self.utf8_pending:
+            self.utf8_pending = b''
+            self.text += '\ufffd'
+
+    @staticmethod
+    def _control_event(cb, b):
+        if b == 0x0a:
+            cb(0, 'screen_linefeed')
+        elif b == 0x0d:
+            cb(0, 'screen_carriage_return')
+        elif b == 0x08:
+            cb(0, 'screen_backspace')
+        elif b == 0x09:
+            cb(0, 'screen_tab')
+
+    def _decode_utf8(self, data, cb):
+        """Decode UTF-8 bytes, appending to self.text. Uses U+FFFD for errors."""
+        # Combine pending bytes with new data
+        buf = self.utf8_pending + bytes(data)
+        self.utf8_pending = b''
+        i = 0
+        n = len(buf)
+        while i < n:
+            b = buf[i]
+            # C0 controls (including ESC) terminate text and are handled by caller
+            if b < 0x20:
+                # Do NOT save to utf8_pending — C0 controls are not incomplete UTF-8
+                return i  # Return position of the control byte
+            if b < 0x80:
+                self.text += chr(b)
+                i += 1
+            elif b < 0xC2:
+                # Invalid starter (0x80-0xC1) or continuation byte
+                self.text += '\ufffd'
+                i += 1
+            elif b < 0xE0:
+                # 2-byte sequence
+                if i + 1 < n:
+                    b2 = buf[i + 1]
+                    if 0x80 <= b2 <= 0xBF:
+                        self.text += chr((b & 0x1F) << 6 | (b2 & 0x3F))
+                        i += 2
+                    else:
+                        # Bad continuation
+                        self.text += '\ufffd'
+                        i += 1
+                else:
+                    # Incomplete — save for next call
+                    self.utf8_pending = buf[i:]
+                    return n
+            elif b < 0xF0:
+                # 3-byte sequence
+                if i + 2 < n:
+                    b2, b3 = buf[i + 1], buf[i + 2]
+                    # Check validity
+                    if b == 0xE0:
+                        valid = 0xA0 <= b2 <= 0xBF
+                    elif b == 0xED:
+                        valid = 0x80 <= b2 <= 0x9F
+                    else:
+                        valid = 0x80 <= b2 <= 0xBF
+                    if valid and 0x80 <= b3 <= 0xBF:
+                        self.text += chr((b & 0x0F) << 12 | (b2 & 0x3F) << 6 | (b3 & 0x3F))
+                        i += 3
+                    elif 0x80 <= b2 <= 0xBF:
+                        # First continuation is valid, second is not
+                        self.text += '\ufffd'
+                        i += 2
+                        # b3 will be processed next (may be another U+FFFD)
+                    else:
+                        self.text += '\ufffd'
+                        i += 1
+                elif i + 1 < n:
+                    b2 = buf[i + 1]
+                    if 0x80 <= b2 <= 0xBF:
+                        # Could be valid — need more data
+                        self.utf8_pending = buf[i:]
+                        return n
+                    else:
+                        self.text += '\ufffd'
+                        i += 1
+                else:
+                    self.utf8_pending = buf[i:]
+                    return n
+            elif b < 0xF5:
+                # 4-byte sequence
+                if i + 3 < n:
+                    b2, b3, b4 = buf[i + 1], buf[i + 2], buf[i + 3]
+                    if b == 0xF0:
+                        valid2 = 0x90 <= b2 <= 0xBF
+                    elif b == 0xF4:
+                        valid2 = 0x80 <= b2 <= 0x8F
+                    else:
+                        valid2 = 0x80 <= b2 <= 0xBF
+                    if valid2 and 0x80 <= b3 <= 0xBF and 0x80 <= b4 <= 0xBF:
+                        cp = (b & 0x07) << 18 | (b2 & 0x3F) << 12 | (b3 & 0x3F) << 6 | (b4 & 0x3F)
+                        self.text += chr(cp)
+                        i += 4
+                    elif 0x80 <= b2 <= 0xBF:
+                        if 0x80 <= b3 <= 0xBF:
+                            # b4 is bad
+                            self.text += '\ufffd'
+                            i += 3
+                        else:
+                            self.text += '\ufffd'
+                            i += 2
+                    else:
+                        self.text += '\ufffd'
+                        i += 1
+                else:
+                    # Not enough bytes — save for next call
+                    self.utf8_pending = buf[i:]
+                    return n
+            else:
+                # 0xF5-0xFF: never valid
+                self.text += '\ufffd'
+                i += 1
+        return n
+
+    # -- CSI dispatch --
+
+    def _csi_count(self, idx=0):
+        """Return param[idx] or 1 if zero/missing."""
+        if idx < self.csi.nparams and self.csi.params[idx] > 0:
+            return self.csi.params[idx]
+        return 1
+
+    def _format_sgr(self):
+        """Format SGR params into Kitty-style colon/semicolon groups."""
+        if self.csi.nparams == 0:
+            return ['0']
+        params = self.csi.params[:self.csi.nparams]
+        subparams = self.csi.subparams
+        groups = []
+        current = []
+        i = 0
+        while i < len(params):
+            p = params[i]
+            next_has_colon = (i + 1 < len(params)) and bool(subparams & (1 << (i + 1)))
+            if p in (38, 48, 58):
+                # Extended color — flush current, consume following params
+                if current:
+                    groups.append(';'.join(current))
+                    current = []
+                sub = [str(p)]
+                i += 1
+                while i < len(params) and params[i] not in (38, 48, 58):
+                    sub.append(str(params[i]))
+                    i += 1
+                groups.append(':'.join(sub))
+            elif next_has_colon:
+                # This param starts a colon group
+                if current:
+                    groups.append(';'.join(current))
+                    current = []
+                sub = [str(p)]
+                i += 1
+                while i < len(params) and (subparams & (1 << i)):
+                    sub.append(str(params[i]))
+                    i += 1
+                groups.append(':'.join(sub))
+            else:
+                current.append(str(p))
+                i += 1
+        if current:
+            groups.append(';'.join(current))
+        return groups
+
+    def _dispatch_csi(self, screen, cb):
+        c = self.csi
+        final = chr(c.intermediate) if c.intermediate else ''
+        # Handle intermediate-based dispatches first
+        if c.intermediate:
+            if c.intermediate == ord(' ') and c.prefix == 0:
+                if c.final == ord('q'):
+                    # DECSCUSR: CSI Ps SP q
+                    if c.nparams > 0 and c.params[0] in (3, 4):
+                        self._emit(cb, 'screen_set_cursor', c.params[0], ord(' '))
+                    elif c.nparams > 0 and c.params[0] in (1, 2, 5, 6):
+                        self._emit(cb, 'screen_set_cursor', c.params[0], ord(' '))
+                    elif c.nparams == 0:
+                        self._emit(cb, 'screen_set_cursor', 0, ord(' '))
+                elif c.nparams > 0 and c.params[0] == 3:
+                    # Shift codes
+                    if c.final == ord('@'):
+                        self._emit(cb, 'Shift left escape code not implemented')
+                    elif c.final == ord('A'):
+                        self._emit(cb, 'Shift right escape code not implemented')
+                    elif c.final == ord('S'):
+                        self._emit(cb, 'Select presentation directions escape code not implemented')
+                return
+            if c.intermediate == ord('!') and c.prefix == 0:
+                # Soft reset: CSI ! p — no event in Kitty's test
+                return
+            if c.intermediate == ord('$'):
+                if c.final == ord('p'):
+                    # DECRQM: CSI ? Ps $ p / CSI Ps $ p
+                    mode = c.params[0] if c.nparams > 0 else 0
+                    private = 1 if c.prefix == ord('?') else 0
+                    self._emit(cb, 'report_mode_status', mode, private)
+                elif c.final == ord('r') and c.prefix == 0:
+                    # DECCARA: CSI $ r
+                    for event_str in self._format_deccara():
+                        self._emit(cb, 'deccara', event_str)
+                return
+            if c.intermediate == ord('*') and c.prefix == 0:
+                # DECSACE: CSI Ps * x
+                if c.nparams > 0:
+                    self._emit(cb, 'screen_decsace', c.params[0])
+                else:
+                    self._emit(cb, 'screen_decsace', 0)
+                return
+            if c.intermediate == ord('+') and c.final == ord('T'):
+                self._emit(cb, 'screen_reverse_scroll_and_fill_from_scrollback',
+                           self._csi_count())
+                return
+            return
+
+        # No intermediate
+        f = c.final
+        pfx = c.prefix
+
+        if f == ord('@'):
+            if c.nparams > 1:
+                self._emit(cb, f'CSI code @ has {c.nparams} > 1 parameters')
+                return
+            if c.nparams == 1 and c.params[0] < 0:
+                self._emit(cb, f'CSI code @ is not allowed to have negative parameter ({c.params[0]})')
+                return
+            self._emit(cb, 'screen_insert_characters', self._csi_count())
+            return
+
+        if f == ord('H') or f == ord('f'):
+            row = c.params[0] if c.nparams > 0 else 1
+            col = c.params[1] if c.nparams > 1 else 1
+            self._emit(cb, 'screen_cursor_position', row, col)
+            return
+
+        if f == ord('J'):
+            mode = c.params[0] if c.nparams > 0 else 0
+            private = 1 if pfx == ord('?') else 0
+            self._emit(cb, 'screen_erase_in_display', mode, private)
+            return
+
+        if f == ord('K'):
+            mode = c.params[0] if c.nparams > 0 else 0
+            private = 1 if pfx == ord('?') else 0
+            self._emit(cb, 'screen_erase_in_line', mode, private)
+            return
+
+        if f == ord('h'):
+            private = 1 if pfx == ord('?') else 0
+            if c.nparams == 0:
+                return
+            for i in range(c.nparams):
+                self._emit(cb, 'screen_set_mode', c.params[i], private)
+            return
+
+        if f == ord('l'):
+            private = 1 if pfx == ord('?') else 0
+            if c.nparams == 0:
+                return
+            for i in range(c.nparams):
+                self._emit(cb, 'screen_reset_mode', c.params[i], private)
+            return
+
+        if f == ord('c'):
+            if pfx == ord('>'):
+                self._emit(cb, 'report_device_attributes', c.params[0] if c.nparams > 0 else 0, 62)
+            elif pfx == ord('='):
+                self._emit(cb, 'report_device_attributes', c.params[0] if c.nparams > 0 else 0, 61)
+            elif pfx == 0:
+                self._emit(cb, 'report_device_attributes', c.params[0] if c.nparams > 0 else 0, 0)
+            return
+
+        if f == ord('m'):
+            for grp in self._format_sgr():
+                self._emit(cb, 'select_graphic_rendition', grp)
+            return
+
+        if f == ord('n'):
+            mode = c.params[0] if c.nparams > 0 else 0
+            private = 1 if pfx == ord('?') else 0
+            self._emit(cb, 'report_device_status', mode, private)
+            return
+
+        if f == ord('r'):
+            if pfx:
+                return
+            if c.nparams == 0:
+                self._emit(cb, 'screen_set_margins', 0, 0)
+            else:
+                top = c.params[0] if c.params[0] > 0 else 1
+                bottom = c.params[1] if c.nparams > 1 and c.params[1] > 0 else 0
+                self._emit(cb, 'screen_set_margins', top, bottom)
+            return
+
+        if f == ord('b'):
+            if c.nparams > 1:
+                return
+            self._emit(cb, 'screen_repeat_character', self._csi_count())
+            return
+
+        if f == ord('T'):
+            if pfx == 0 and c.nparams <= 1:
+                self._emit(cb, 'screen_reverse_scroll', self._csi_count())
+            return
+
+        if f == ord('t'):
+            if pfx == 0 and c.nparams > 0:
+                self._emit(cb, 'screen_report_size', c.params[0], c.params[1] if c.nparams > 1 else 0)
+            return
+
+        if f == ord('p'):
+            return
+
+        # Unhandled CSI — silently ignore (no event)
+
+    def _format_deccara(self):
+        """Format DECCARA params (CSI $ r) into a list of event strings.
+
+        Each event is: 'top;left;bottom;right;sgr_group'
+        """
+        c = self.csi
+        if c.nparams == 0:
+            return ['0;0;0;0;0']
+        params = list(c.params[:c.nparams])
+        while len(params) < 4:
+            params.append(0)
+        subparams = c.subparams
+        rect = ';'.join(str(p) for p in params[:4])
+        # Format SGR groups from params[4:]
+        sgr_params = params[4:]
+        if not sgr_params:
+            return [f'{rect};0']
+        groups = []
+        current = []
+        i = 0
+        while i < len(sgr_params):
+            p = sgr_params[i]
+            next_has_colon = (i + 1 < len(sgr_params)) and bool(subparams & (1 << (i + 5)))
+            if p in (38, 48, 58):
+                if current:
+                    groups.append(';'.join(current))
+                    current = []
+                sub = [str(p)]
+                i += 1
+                # Consume following params that are subparams (preceded by ':')
+                while i < len(sgr_params) and (subparams & (1 << (i + 4))):
+                    sub.append(str(sgr_params[i]))
+                    i += 1
+                groups.append(':'.join(sub))
+            elif next_has_colon:
+                if current:
+                    groups.append(';'.join(current))
+                    current = []
+                sub = [str(p)]
+                i += 1
+                while i < len(sgr_params) and (subparams & (1 << (i + 4))):
+                    sub.append(str(sgr_params[i]))
+                    i += 1
+                groups.append(':'.join(sub))
+            else:
+                current.append(str(p))
+                i += 1
+        if current:
+            groups.append(';'.join(current))
+        return [f'{rect};{g}' for g in groups]
+
+    # -- OSC dispatch --
+
+    def _dispatch_osc(self, screen, cb):
+        payload = bytes(self.str_buf).decode('utf-8', errors='replace')
+        # Parse OSC code: leading digits form the code, rest is data.
+        # If there's a ';', it separates code from data.
+        sep = payload.find(';')
+        if sep < 0:
+            # No ';' — leading digits are the code, rest is data
+            i = 0
+            while i < len(payload) and payload[i].isdigit():
+                i += 1
+            if i == 0:
+                # No leading digits — treat as OSC 0 with payload as title
+                code = 0
+                rest = payload
+            elif i == len(payload):
+                # Entire payload is digits — code only, no data
+                code = int(payload)
+                rest = ''
+            else:
+                code = int(payload[:i])
+                rest = payload[i:]
+        else:
+            code_str = payload[:sep]
+            rest = payload[sep + 1:]
+            try:
+                code = int(code_str) if code_str else 0
+            except ValueError:
+                code = -1
+
+        if code == 0:
+            self._emit(cb, 'set_title', rest)
+            self._emit(cb, 'set_icon', rest)
+        elif code == 1:
+            self._emit(cb, 'set_icon', rest)
+        elif code == 2:
+            self._emit(cb, 'set_title', rest)
+        elif code == 8:
+            # Hyperlink
+            if not rest:
+                self._emit(cb, 'set_active_hyperlink', None, None)
+            elif ';' not in rest:
+                self._emit(cb, 'Ignoring malformed OSC 8 code')
+            else:
+                params, uri = rest.split(';', 1)
+                if not uri:
+                    uri = None
+                link_id = None
+                if params:
+                    for kv in params.split(':'):
+                        if kv.startswith('id=') and link_id is None:
+                            link_id = kv[3:]
+                self._emit(cb, 'set_active_hyperlink', link_id, uri)
+        elif code == 9:
+            self._emit(cb, 'desktop_notify', 9, rest)
+        elif code == 99:
+            self._emit(cb, 'desktop_notify', 99, rest)
+        elif code == 52:
+            self._emit(cb, 'clipboard_control', 52, rest)
+        elif code == 110:
+            self._emit(cb, 'set_dynamic_color', 110, rest)
+        elif code == 22:
+            self._emit(cb, 'set_dynamic_color', 22, rest)
+        else:
+            # Unknown OSC — pass through as set_dynamic_color for some,
+            # or ignore. Kitty's test only uses specific codes.
+            pass
+
+    # -- DCS dispatch --
+
+    def _dispatch_dcs(self, screen, cb):
+        payload = bytes(self.str_buf)
+        if not payload:
+            return
+
+        # DCS +q — request capabilities
+        if payload.startswith(b'+q'):
+            data = payload[2:].decode('ascii', errors='replace')
+            self._emit(cb, 'screen_request_capabilities', 43, data)
+            return
+
+        # DCS $q — request status
+        if payload.startswith(b'$q'):
+            data = payload[2:].decode('ascii', errors='replace')
+            self._emit(cb, 'screen_request_capabilities', ord('$'), data)
+            return
+
+        # DCS @kitty-cmd
+        if payload.startswith(b'@kitty-cmd'):
+            data = payload[len(b'@kitty-cmd'):].decode('utf-8', errors='replace')
+            self._emit(cb, 'handle_remote_cmd', data)
+            return
+
+        # DCS @kitty-print
+        if payload.startswith(b'@kitty-print|'):
+            data = payload[len(b'@kitty-print|'):].decode('ascii', errors='replace')
+            self._emit(cb, 'handle_remote_print', data)
+            return
+
+        # DCS =1s / =2s — pending mode
+        if payload == b'=1s':
+            self._emit(cb, 'screen_start_pending_mode')
+            return
+        if payload == b'=2s':
+            self._emit(cb, 'screen_stop_pending_mode')
+            return
+
+    # -- Graphics command (APC _ G) --
+
+    def _dispatch_graphics(self, screen, cb):
+        payload = bytes(self.str_buf)
+        if not payload:
+            return
+
+        # Short key → full name mapping (from Kitty's graphics protocol)
+        key_map = {
+            'a': 'action', 'd': 'delete_action', 't': 'transmission_type',
+            'c': 'compressed', 'f': 'format', 'm': 'more', 'i': 'id',
+            's': 'data_width', 'o': 'data_offset', 'w': 'width',
+            'h': 'height', 'x': 'x_offset', 'y': 'y_offset',
+            'v': 'data_height', 'u': 'data_sz', 'C': 'cursor_movement',
+            'n': 'num_cells', 'r': 'num_lines', 'X': 'cell_x_offset',
+            'Y': 'cell_y_offset', 'z': 'z_index', 'p': 'placement_id',
+            'I': 'image_number', 'q': 'quiet', 'U': 'unicode_placement',
+            'P': 'parent_id', 'Q': 'parent_placement_id',
+            'O': 'offset_from_parent_x', 'N': 'offset_from_parent_y',
+        }
+
+        # Parse the graphics command
+        # Format: _G{params};{base64_payload}ESC\
+        # params are key=value pairs separated by commas
+        semi = payload.find(b';')
+        if semi >= 0:
+            cmd_str = payload[:semi]
+            b64_payload = payload[semi + 1:]
+        else:
+            cmd_str = payload
+            b64_payload = b''
+
+        # Parse key=value pairs
+        result = {}
+        # Defaults
+        for f in 'action delete_action transmission_type compressed'.split():
+            result[f] = b'\0'
+        for f in ('format more id data_sz data_offset width height x_offset y_offset '
+                  'data_height data_width cursor_movement num_cells num_lines '
+                  'cell_x_offset cell_y_offset z_index placement_id image_number '
+                  'quiet unicode_placement parent_id parent_placement_id '
+                  'offset_from_parent_x offset_from_parent_y').split():
+            result[f] = 0
+        try:
+            from fast_data_types import base64_decode
+            result[''] = base64_decode(b64_payload).decode('utf-8', errors='replace')
+        except Exception:
+            result[''] = b64_payload.decode('ascii', errors='replace')
+
+        i = 0
+        n = len(cmd_str)
+        while i < n:
+            # Parse key
+            key_start = i
+            while i < n and cmd_str[i] != ord('='):
+                ch = cmd_str[i]
+                if ch == ord(','):
+                    self._emit(cb, 'Malformed GraphicsCommand control block, invalid key character: 0x%02x' % ch)
+                    return
+                # Only accept known graphics command keys
+                if chr(ch) not in key_map:
+                    self._emit(cb, 'Malformed GraphicsCommand control block, invalid key character: 0x%02x' % ch)
+                    return
+                i += 1
+            if i >= n:
+                self._emit(cb, 'Malformed GraphicsCommand control block, no = after key')
+                return
+            key = cmd_str[key_start:i].decode('ascii')
+            i += 1  # skip '="
+
+            # Parse value
+            val_start = i
+            full_key = key_map.get(key, key)
+            is_char_key = full_key in ('action', 'delete_action', 'transmission_type', 'compressed')
+            while i < n and cmd_str[i] != ord(','):
+                ch = cmd_str[i]
+                if ch == ord('='):
+                    # = after value — check if we have a value yet
+                    if i == val_start:
+                        # No value parsed yet
+                        self._emit(cb, 'Malformed GraphicsCommand control block, expecting an integer value for key: %s' % key)
+                    else:
+                        self._emit(cb, 'Malformed GraphicsCommand control block, expecting a , or semi-colon after a value, found: 0x%02x' % ch)
+                    return
+                if is_char_key:
+                    # Character keys accept a single character
+                    if i > val_start:
+                        # Already got one char — only one expected
+                        self._emit(cb, 'Malformed GraphicsCommand control block, expecting a , or semi-colon after a value, found: 0x%02x' % ch)
+                        return
+                elif not (ord('0') <= ch <= ord('9') or ch == ord('-')):
+                    self._emit(cb, 'Malformed GraphicsCommand control block, expecting an integer value for key: %s' % key)
+                    return
+                i += 1
+
+            val_str = cmd_str[val_start:i].decode('ascii')
+            if not val_str:
+                self._emit(cb, 'Malformed GraphicsCommand control block, expecting an integer value')
+                return
+            if is_char_key:
+                result[full_key] = val_str.encode('ascii')
+            else:
+                try:
+                    val = int(val_str)
+                except ValueError:
+                    self._emit(cb, 'Malformed GraphicsCommand control block, expecting an integer value for key: %s' % key)
+                    return
+                if val > 0xFFFFFFFF:
+                    self._emit(cb, 'Malformed GraphicsCommand control block, number is too large')
+                    return
+                result[full_key] = val
+
+            if i < n and cmd_str[i] == ord(','):
+                i += 1
+
+        self._emit(cb, 'graphics_command', result)
+
+    # -- ESC dispatch --
+
+    def _dispatch_esc(self, ch, cb):
+        if ch == ord('D'):
+            self._emit(cb, 'screen_index')
+        elif ch == ord('E'):
+            self._emit(cb, 'screen_nel')
+        elif ch == ord('c'):
+            self._emit(cb, 'screen_reset')
+        elif ch == ord('M'):
+            self._emit(cb, 'screen_reverse_index')
+        elif ch == ord('7'):
+            self._emit(cb, 'screen_save_cursor')
+        elif ch == ord('8'):
+            self._emit(cb, 'screen_restore_cursor')
+        elif ch == ord('H'):
+            self._emit(cb, 'screen_set_tab')
+        elif ch == ord('['):
+            pass  # handled by state transition
+        elif ch == ord(']'):
+            pass  # handled by state transition
+        elif ch == ord('P'):
+            pass  # handled by state transition
+        elif ch == ord('_'):
+            pass  # handled by state transition
+        elif ch == ord('^'):
+            pass  # handled by state transition
+        elif ch == ord('X'):
+            pass  # handled by state transition
+        elif ch == ord('(') or ch == ord(')'):
+            pass  # handled by state transition
+        elif ch == ord('='):
+            self._emit(cb, 'screen_application_keypad', True)
+        elif ch == ord('>'):
+            self._emit(cb, 'screen_application_keypad', False)
+        elif ch == ord('.'):
+            # Unhandled charset escape — needs the next ESC byte
+            pass
+        else:
+            self._emit(cb, 'Unknown char after ESC: 0x%x' % ch)
+
+    # -- Main parse loop --
+
+    def parse(self, screen, data, cb):
+        """Parse *data*, emitting events to *cb* and feeding bytes to screen."""
+        if isinstance(data, str):
+            data = data.encode('utf-8')
+        data = bytes(data)
+
+        # Feed ALL bytes to the C terminal for screen state
+        screen.write(data)
+
+        i = 0
+        n = len(data)
+        while i < n:
+            b = data[i]
+
+            if self.state == _GROUND:
+                if b == 0x1b:
+                    self._kill_pending()
+                    self._flush_text(cb)
+                    self.state = _ESC
+                    i += 1
+                elif b < 0x20:
+                    # C0 control
+                    self._kill_pending()
+                    self._flush_text(cb)
+                    self._control_event(cb, b)
+                    # Other C0 controls: no event
+                    i += 1
+                else:
+                    # Text byte — decode UTF-8
+                    consumed = self._decode_utf8(data[i:], cb)
+                    i += consumed
+
+            elif self.state == _ESC:
+                if b == 0x1b:
+                    # ESC after ESC
+                    self._emit(cb, 'Unknown char after ESC: 0x1b')
+                    # Stay in ESC state
+                    i += 1
+                elif b < 0x20:
+                    # C0 control after ESC — execute it
+                    self._flush_text(cb)
+                    self._control_event(cb, b)
+                    self.state = _GROUND
+                    i += 1
+                elif b == ord('['):
+                    self.csi.reset()
+                    self.state = _CSI
+                    i += 1
+                elif b == ord(']'):
+                    self.str_buf.clear()
+                    self.str_type = _OSC
+                    self.state = _OSC
+                    i += 1
+                elif b == ord('P'):
+                    self.str_buf.clear()
+                    self.str_type = _DCS
+                    self.state = _DCS
+                    i += 1
+                elif b == ord('_'):
+                    self.str_buf.clear()
+                    self.str_type = _APC
+                    self.state = _APC
+                    i += 1
+                elif b == ord('^'):
+                    self.str_buf.clear()
+                    self.str_type = _PM
+                    self.state = _PM
+                    i += 1
+                elif b == ord('X'):
+                    self.str_buf.clear()
+                    self.str_type = _SOS
+                    self.state = _SOS
+                    i += 1
+                elif b == ord('(') or b == ord(')'):
+                    self.charset_slot = 0 if b == ord('(') else 1
+                    self.state = _CHARSET
+                    i += 1
+                elif b == ord('.'):
+                    # Unhandled charset escape — needs the next ESC byte
+                    # Emit special message when we see the next ESC
+                    self.state = _CHARSET
+                    self.charset_slot = -1  # special marker
+                    i += 1
+                elif b == ord('%'):
+                    # ESC % — codepage selector; needs one more byte
+                    self.state = _ESC_PCT
+                    i += 1
+                else:
+                    self._dispatch_esc(b, cb)
+                    self.state = _GROUND
+                    i += 1
+
+            elif self.state == _ESC_PCT:
+                self.state = _GROUND
+                if b in (ord('G'), ord('@'), ord('/')):
+                    # DOCS selectors (ESC % G etc.) — consume silently
+                    i += 1
+                else:
+                    # Unknown — kitty draws the sequence literally
+                    self.text += '%'
+                    # Reprocess this byte in GROUND (don't advance)
+
+            elif self.state == _CHARSET:
+                if self.charset_slot == -1:
+                    # Unhandled charset escape (ESC .)
+                    if b == 0x1b:
+                        self._emit(cb, 'Unhandled charset related escape code: 0x2e 0x1b')
+                        self.state = _GROUND
+                    else:
+                        self._emit(cb, 'Unhandled charset related escape code: 0x2e 0x%02x' % b)
+                        self.state = _GROUND
+                    i += 1
+                else:
+                    self._emit(cb, 'screen_designate_charset', self.charset_slot, b)
+                    if self.charset_slot == 1:
+                        # G1 charset — also emit screen_change_charset
+                        self._emit(cb, 'screen_change_charset', 1)
+                    self.state = _GROUND
+                    i += 1
+
+            elif self.state == _CSI:
+                c = self.csi
+                if b == 0x1b:
+                    # ESC interrupts CSI
+                    self._flush_text(cb)
+                    self.state = _ESC
+                    i += 1
+                elif b < 0x20:
+                    # C0 control embedded inside CSI — dispatch, keep parsing
+                    self._flush_text(cb)
+                    self._control_event(cb, b)
+                    i += 1
+                elif c.phase == 2:
+                    # Post-secondary: only a final byte is valid
+                    if 0x40 <= b <= 0x7e:
+                        c.final = b
+                        self._dispatch_csi(screen, cb)
+                    else:
+                        self._emit(cb, 'Invalid character in CSI: %s (0x%x), ignoring the sequence'
+                                   % (chr(b) if 0x21 <= b <= 0x7e else '0x%x' % b, b))
+                    self.state = _GROUND
+                    i += 1
+                elif c.phase == 0:
+                    if b == ord(';'):
+                        if c.nparams < _MAX_PARAMS:
+                            c.params[c.nparams] = 0
+                            c.nparams += 1
+                        c.phase = 1
+                    elif 0x30 <= b <= 0x39:
+                        c.add_digit(b - 0x30)
+                        c.phase = 1
+                    elif b in (ord('?'), ord('>'), ord('<'), ord('=')):
+                        c.prefix = b
+                        c.phase = 1
+                    elif 0x20 <= b <= 0x2f:
+                        if b == ord('-'):
+                            c.mult = -1
+                            c.num_digits = 1
+                            c.phase = 1
+                        else:
+                            c.intermediate = b
+                            c.phase = 2
+                    elif 0x40 <= b <= 0x7e:
+                        c.final = b
+                        self._dispatch_csi(screen, cb)
+                        self.state = _GROUND
+                    else:
+                        self._emit(cb, 'Invalid character in CSI: %s (0x%x), ignoring the sequence'
+                                   % (chr(b) if 0x21 <= b <= 0x7e else '0x%x' % b, b))
+                        self.state = _GROUND
+                    i += 1
+                else:
+                    # CSI_BODY
+                    if 0x30 <= b <= 0x39:
+                        c.add_digit(b - 0x30)
+                    elif b == ord(';'):
+                        if not c.num_digits:
+                            c.num_digits = 1  # empty means zero
+                        if not c.commit():
+                            self._emit(cb, 'CSI escape code has too many parameters, ignoring it')
+                            self.state = _GROUND
+                    elif b == ord(':'):
+                        if c.commit():
+                            c.subparams |= 1 << c.nparams
+                        else:
+                            self._emit(cb, 'CSI escape code has too many parameters, ignoring it')
+                            self.state = _GROUND
+                    elif 0x20 <= b <= 0x2f:
+                        if b == ord('-') and c.num_digits == 0:
+                            c.mult = -1
+                            c.num_digits = 1
+                        elif c.commit():
+                            c.intermediate = b
+                            c.phase = 2
+                        else:
+                            self._emit(cb, 'CSI escape code has too many parameters, ignoring it')
+                            self.state = _GROUND
+                    elif 0x40 <= b <= 0x7e:
+                        if c.num_digits == 1 and c.intermediate == 0 and c.mult == -1:
+                            # A bare '-' before the final is an intermediate
+                            c.num_digits = 0
+                            c.intermediate = ord('-')
+                        if c.commit():
+                            c.final = b
+                            self._dispatch_csi(screen, cb)
+                        else:
+                            self._emit(cb, 'CSI escape code has too many parameters, ignoring it')
+                        self.state = _GROUND
+                    else:
+                        self._emit(cb, 'Invalid character in CSI: %s (0x%x), ignoring the sequence'
+                                   % (chr(b) if 0x21 <= b <= 0x7e else '0x%x' % b, b))
+                        self.state = _GROUND
+                    i += 1
+
+            elif self.state in (_OSC, _DCS, _APC, _PM, _SOS):
+                if b == 0x07:
+                    # BEL terminates string
+                    self._finish_string(screen, cb)
+                    self.state = _GROUND
+                    i += 1
+                elif b == 0x1b:
+                    self.state = _STR_ESC
+                    i += 1
+                elif b < 0x20:
+                    # C0 control — abort string (except for BEL handled above)
+                    self.str_buf.clear()
+                    self.state = _GROUND
+                    # Process the control byte in GROUND
+                    self._control_event(cb, b)
+                    i += 1
+                else:
+                    self.str_buf.append(b)
+                    i += 1
+
+            elif self.state == _STR_ESC:
+                if b == ord('\\'):
+                    # ST (ESC \) terminates string
+                    self._finish_string(screen, cb)
+                    self.state = _GROUND
+                    i += 1
+                else:
+                    # Other byte after ESC in string — reprocess
+                    self.str_buf.clear()
+                    self.state = _GROUND
+                    # Don't consume — reprocess in GROUND/ESC
+                    # Actually, the ESC should be reprocessed
+                    self.state = _ESC
+                    i += 0  # Don't advance — reprocess this byte via ESC
+                    # But we already consumed the ESC, so process this byte in ESC state
+                    if b == 0x1b:
+                        self._emit(cb, 'Unknown char after ESC: 0x1b')
+                        # Stay in ESC
+                    elif b < 0x20:
+                        self._control_event(cb, b)
+                        self.state = _GROUND
+                    else:
+                        self._dispatch_esc(b, cb)
+                        self.state = _GROUND
+                    i += 1
+
+        # End of data — flush any pending text
+        self._flush_text(cb)
+
+    def _finish_string(self, screen, cb):
+        """Dispatch the completed string (OSC/DCS/APC/PM/SOS)."""
+        st = self.str_type
+        if st == _OSC:
+            self._dispatch_osc(screen, cb)
+        elif st == _DCS:
+            self._dispatch_dcs(screen, cb)
+        elif st == _APC:
+            # Check for graphics command (_G)
+            payload = bytes(self.str_buf)
+            if payload.startswith(b'G'):
+                self.str_buf = bytearray(payload[1:])
+                self._dispatch_graphics(screen, cb)
+            else:
+                code = payload[0] if payload else 0
+                self._emit(cb, 'Unrecognized APC code: 0x%02x' % code)
+        elif st == _PM:
+            code = self.str_buf[0] if self.str_buf else 0
+            self._emit(cb, 'Unrecognized PM code: 0x%02x' % code)
+        elif st == _SOS:
+            code = self.str_buf[0] if self.str_buf else 0
+            self._emit(cb, 'Unrecognized SOS code: 0x%02x' % code)
+        self.str_buf.clear()
+
+
+# Module-level parse_bytes function
+def parse_bytes(screen, data, callback=None):
+    """Parse *data* and emit events to *callback*.
+
+    Maintains parser state on the screen object so partial sequences
+    split across ``parse_bytes`` invocations are handled correctly.
+    Also updates screen.callbacks for OSC events (titlebuf, etc.).
+    """
+    if callback is None:
+        callback = lambda *args: None
+    if not hasattr(screen, '_kitty_parser'):
+        screen._kitty_parser = KittyParser()
+
+    def wrapped_cb(wid, *args):
+        # Update screen callbacks for OSC/DCS events
+        if args and args[0] == 'set_title':
+            screen.callbacks.titlebuf.append(args[1])
+        elif args and args[0] == 'set_icon':
+            screen.callbacks.iconbuf += args[1] if isinstance(args[1], str) else str(args[1], 'utf-8')
+        elif args and args[0] == 'desktop_notify':
+            screen.callbacks.notifications.append((args[1], args[2]))
+        elif args and args[0] == 'set_dynamic_color':
+            val = args[2] if isinstance(args[2], str) else str(args[2], 'utf-8')
+            screen.callbacks.colorbuf += val
+        elif args and args[0] == 'handle_remote_print':
+            try:
+                from fast_data_types import base64_decode
+                screen.callbacks.printbuf.append(base64_decode(args[1]).decode('utf-8'))
+            except Exception:
+                screen.callbacks.printbuf.append(args[1])
+        # Forward to original callback
+        callback(wid, *args)
+
+    screen._kitty_parser.parse(screen, data, wrapped_cb)
diff --git a/tests/extern/kitty/parser.py b/tests/extern/kitty/parser.py
new file mode 100644
index 0000000..537e1c0
--- /dev/null
+++ b/tests/extern/kitty/parser.py
@@ -0,0 +1,995 @@
+#!/usr/bin/env python
+# License: GPL v3 Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
+
+from binascii import hexlify
+from functools import partial
+
+from fast_data_types import (
+    CURSOR_BLOCK,
+    VT_PARSER_BUFFER_SIZE,
+    base64_decode,
+    base64_encode,
+    has_avx2,
+    has_sse4_2,
+    test_find_either_of_two_bytes,
+    test_utf8_decode_to_sentinel,
+)
+
+from kitty_harness import BaseTest, parse_bytes
+
+
+def cnv(x):
+    if isinstance(x, memoryview):
+        x = str(x, 'utf-8')
+    return x
+
+
+class CmdDump(list):
+
+    def __call__(self, window_id, *a):
+        if a and a[0] == 'bytes':
+            return
+        if a and a[0] == 'error':
+            a = a[1:]
+        self.append(tuple(map(cnv, a)))
+
+    def get_result(self):
+        current = ''
+        q = []
+        for args in self:
+            if args[0] == 'draw':
+                current += args[1]
+            else:
+                if current:
+                    q.append(('draw', current))
+                    current = ''
+                q.append(args)
+        if current:
+            q.append(('draw', current))
+        return tuple(q)
+
+
+class TestParser(BaseTest):
+
+    def create_write_buffer(self, screen):
+        return screen.test_create_write_buffer()
+
+    def write_bytes(self, screen, write_buf, data):
+        if isinstance(data, str):
+            data = data.encode('utf-8')
+        s = screen.test_commit_write_buffer(data, write_buf)
+        return data[s:]
+
+    def parse_written_data(self, screen, *cmds):
+        cd = CmdDump()
+        screen.test_parse_written_data(cd)
+        cmds = tuple(('draw', x) if isinstance(x, str) else tuple(map(cnv, x)) for x in cmds)
+        self.ae(cmds, cd.get_result())
+
+    def parse_bytes_dump(self, s, x, *cmds):
+        cd = CmdDump()
+        if isinstance(x, str):
+            x = x.encode('utf-8')
+        cmds = tuple(('draw', x) if isinstance(x, str) else tuple(map(cnv, x)) for x in cmds)
+        parse_bytes(s, x, cd)
+        self.ae(cmds, cd.get_result())
+
+    def test_charsets(self):
+        s = self.create_screen()
+        pb = partial(self.parse_bytes_dump, s)
+        pb(b'\xc3')
+        pb(b'\xa1', ('draw', b'\xc3\xa1'.decode('utf-8')))
+        s = self.create_screen()
+        pb = partial(self.parse_bytes_dump, s)
+        pb('\033)0\x0e/_', ('screen_designate_charset', 1, ord('0')), ('screen_change_charset', 1), '/_')
+        self.ae(str(s.line(0)), '/\xa0')
+        s = self.create_screen()
+        pb = partial(self.parse_bytes_dump, s)
+        pb('\033(0/_', ('screen_designate_charset', 0, ord('0')), '/_')
+        self.ae(str(s.line(0)), '/\xa0')
+
+    def test_parser_threading(self):
+        s = self.create_screen()
+
+        self.assertFalse(self.write_bytes(s, self.create_write_buffer(s), 'a\x1b]2;some title'))
+        b = self.create_write_buffer(s)
+        self.parse_written_data(s, 'a')
+        self.assertFalse(self.write_bytes(s, b, ' full\x1b\\'))
+        self.parse_written_data(s, ('set_title', 'some title full'))
+
+        self.assertFalse(self.write_bytes(s, self.create_write_buffer(s), 'a\x1b]'))
+        b = self.create_write_buffer(s)
+        self.parse_written_data(s, 'a')
+        self.assertFalse(self.write_bytes(s, b, '2;title\x1b\\'))
+        self.parse_written_data(s, ('set_title', 'title'))
+
+        self.assertFalse(self.write_bytes(s, self.create_write_buffer(s), 'a\x1b'))
+        b = self.create_write_buffer(s)
+        self.parse_written_data(s, 'a')
+        self.assertFalse(self.write_bytes(s, b, ']2;title\x1b\\'))
+        self.parse_written_data(s, ('set_title', 'title'))
+
+        self.assertFalse(self.write_bytes(s, self.create_write_buffer(s), 'a\x1b]2;some title\x1b'))
+        b = self.create_write_buffer(s)
+        self.parse_written_data(s, 'a')
+        self.assertFalse(self.write_bytes(s, b, '\\b'))
+        self.parse_written_data(s, ('set_title', 'some title'), 'b')
+
+        self.assertFalse(self.write_bytes(s, self.create_write_buffer(s), '1\x1b'))
+        self.parse_written_data(s, '1')
+        self.assertFalse(self.write_bytes(s, self.create_write_buffer(s), 'E2'))
+        self.parse_written_data(s, ('screen_nel',), ('draw', '2'))
+
+        self.assertFalse(self.write_bytes(s, self.create_write_buffer(s), '1\x1b[2'))
+        self.parse_written_data(s, '1')
+        self.assertFalse(self.write_bytes(s, self.create_write_buffer(s), '3mx'))
+        self.parse_written_data(s, ('select_graphic_rendition', '23'), 'x')
+
+        self.assertFalse(self.write_bytes(s, self.create_write_buffer(s), '1\x1b'))
+        self.parse_written_data(s, '1')
+        self.assertFalse(self.write_bytes(s, self.create_write_buffer(s), '[23mx'))
+        self.parse_written_data(s, ('select_graphic_rendition', '23'), 'x')
+
+        self.assertFalse(self.write_bytes(s, self.create_write_buffer(s), '1\x1b['))
+        self.parse_written_data(s, '1')
+        self.assertFalse(self.write_bytes(s, self.create_write_buffer(s), '23mx'))
+        self.parse_written_data(s, ('select_graphic_rendition', '23'), 'x')
+
+        # test full write
+        sz = VT_PARSER_BUFFER_SIZE // 3 + 7
+        self.assertFalse(self.write_bytes(s, self.create_write_buffer(s), b'a' * sz))
+        self.assertFalse(self.write_bytes(s, self.create_write_buffer(s), b'b' * sz))
+        left = self.write_bytes(s, self.create_write_buffer(s), b'c' * sz)
+        self.assertTrue(len(left), 3 * sz - VT_PARSER_BUFFER_SIZE)
+        self.assertFalse(self.create_write_buffer(s))
+        s.test_parse_written_data()
+        b = self.create_write_buffer(s)
+        self.assertTrue(b)
+        self.write_bytes(s, b, b'')
+
+    def test_base64(self):
+        for src, expected in {
+            'bGlnaHQgdw==': 'light w',
+            'bGlnaHQgd28=': 'light wo',
+            'bGlnaHQgd29y': 'light wor',
+        }.items():
+            self.ae(base64_decode(src.encode()), expected.encode(), f'Decoding of {src} failed')
+            self.ae(base64_decode(src.replace('=', '').encode()), expected.encode(), f'Decoding of {src} failed')
+            self.ae(base64_encode(expected.encode()), src.replace('=', '').encode(), f'Encoding of {expected} failed')
+
+    def test_simple_parsing(self):
+        s = self.create_screen()
+        pb = partial(self.parse_bytes_dump, s)
+
+        pb('12', '12')
+        self.ae(str(s.line(0)), '12')
+        self.ae(s.cursor.x, 2)
+        pb('3456', '3456')
+        self.ae(str(s.line(0)), '12345')
+        self.ae(str(s.line(1)), '6')
+        pb(b'\n123\n\r45', ('screen_linefeed',), '123', ('screen_linefeed',), ('screen_carriage_return',), '45')
+        self.ae(str(s.line(1)), '6')
+        self.ae(str(s.line(2)), ' 123')
+        self.ae(str(s.line(3)), '45')
+        pb(b'\rabcde', ('screen_carriage_return',), 'abcde')
+        self.ae(str(s.line(3)), 'abcde')
+        pb('\rßxyz1', ('screen_carriage_return',), 'ßxyz1')
+        self.ae(str(s.line(3)), 'ßxyz1')
+        pb('ニチ ', 'ニチ ')
+        self.ae(str(s.line(4)), 'ニチ ')
+        s.reset()
+        self.assertFalse(str(s.line(1)) + str(s.line(2)) + str(s.line(3)))
+        c1_controls = '\x84\x85\x88\x8d\x8e\x8f\x90\x96\x97\x98\x9a\x9b\x9c\x9d\x9e\x9f'
+        pb(c1_controls, c1_controls)
+        self.assertFalse(str(s.line(1)) + str(s.line(2)) + str(s.line(3)))
+        pb('😀'.encode()[:-1])
+        pb('\x1b\x1b%a', '\ufffd', ('Unknown char after ESC: 0x1b',), ('draw', '%a'))
+
+    def test_utf8_simd_decode(self):
+        def unsupported(which):
+            return (which == 2 and not has_sse4_2) or (which == 3 and not has_avx2)
+
+        def reset_state():
+            test_utf8_decode_to_sentinel(b'', -1)
+
+        def asbytes(x):
+            if isinstance(x, str):
+                x = x.encode()
+            return x
+
+        def t(*a, which=2):
+            if unsupported(which):
+                return
+
+            def parse_parts(which):
+                total_consumed = 0
+                esc_found = False
+                parts = []
+                for x in a:
+                    found_sentinel, x, num_consumed = test_utf8_decode_to_sentinel(asbytes(x), which)
+                    total_consumed += num_consumed
+                    if found_sentinel:
+                        esc_found = found_sentinel
+                    parts.append(x)
+                return esc_found, ''.join(parts), total_consumed
+
+            reset_state()
+            expected = parse_parts(1)
+            reset_state()
+            actual = parse_parts(which)
+            self.ae(expected, actual, msg=f'Failed for {a} with {which=}\n{expected!r} !=\n{actual!r}')
+            return actual
+
+        def double_test(x):
+            for which in (2, 3):
+                t(x, which=which)
+            t(x*2, which=3)
+            reset_state()
+
+        # incomplete trailer at end of vector
+        t("a"*10 + "😸😸" + "b"*15)
+
+        x = double_test
+        x('2:α3')
+        x('2:α\x1b3')
+        x('2:α3:≤4:😸|')
+        x('abcd1234efgh5678')
+        x('abc\x1bd1234efgh5678')
+        x('abcd1234efgh5678ijklABCDmnopEFGH')
+
+        for which in (2, 3):
+            x = partial(t, which=which)
+            x('abcdef', 'ghijk')
+            x('2:α3', ':≤4:😸|')
+            # trailing incomplete sequence
+            for prefix in (b'abcd', '😸'.encode()):
+                for suffix in (b'1234', '😸'.encode()):
+                    x(prefix + b'\xf0\x9f', b'\x98\xb8' + suffix)
+                    x(prefix + b'\xf0\x9f\x9b', b'\xb8' + suffix)
+                    x(prefix + b'\xf0', b'\x9f\x98\xb8' + suffix)
+                    x(prefix + b'\xc3', b'\xa4' + suffix)
+                    x(prefix + b'\xe2', b'\x89\xa4' + suffix)
+                    x(prefix + b'\xe2\x89', b'\xa4' + suffix)
+
+        def test_expected(src, expected, which=2):
+            if unsupported(which):
+                return
+            reset_state()
+            _, actual, _ = t(b'filler' + asbytes(src), which=which)
+            expected = 'filler' + expected
+            self.ae(expected, actual, f'Failed for: {src!r} with {which=}')
+
+        for which in (1, 2, 3):
+            pb = partial(test_expected, which=which)
+            pb('ニチ', 'ニチ')
+            pb('\x84\x85', '\x84\x85')
+            pb('\x84\x85', '\x84\x85')
+            pb('\uf4df', '\uf4df')
+            pb('\uffff', '\uffff')
+            pb('\0', '\0')
+            pb(chr(0x10ffff), chr(0x10ffff))
+            # Kitty's UTF-8 decoding uses `U+FFFD substitution of maximal subparts
+            # <https://www.unicode.org/versions/Unicode16.0.0/core-spec/chapter-3/#G66453>`_,
+            # same as in the WHATWG Encoding Standard.
+            # This means that ill-formed sequences may be replaced by multiple
+            # U+FFFD REPLACEMENT CHARACTERs.
+            pb(b'abcd\xf51234', 'abcd\ufffd1234')  # bytes > 0xf4
+            pb(b'abcd\xff1234', 'abcd\ufffd1234')  # bytes > 0xf4
+            pb(b'"\xbf"', '"\ufffd"')
+            pb(b'"\x80"', '"\ufffd"')
+            pb(b'"\x80\xbf"', '"\ufffd\ufffd"')
+            pb(b'"\x80\xbf\x80"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xc0 "', '"\ufffd "')
+            pb(b'"\xfe"', '"\ufffd"')
+            pb(b'"\xff"', '"\ufffd"')
+            pb(b'"\xff\xfe"', '"\ufffd\ufffd"')
+            pb(b'"\xfe\xfe\xff\xff"', '"\ufffd\ufffd\ufffd\ufffd"')
+            pb(b'"\xef\xbf"', '"\ufffd"')
+            pb(b'"\xe0\xa0"', '"\ufffd"')
+            pb(b'"\xf0\x9f\x98"', '"\ufffd"')
+            pb(b'"\xef\x93\x94\x95"', '"\uf4d4\ufffd"')
+
+            # Lone continuation bytes with no leading starts
+            pb(b'"\xbf"', '"\ufffd"')
+            pb(b'"\x80"', '"\ufffd"')
+
+            # Multiple lone continuation bytes
+            pb(b'"\x80\xbf"', '"\ufffd\ufffd"')
+            pb(b'"\x80\xbf\x80"', '"\ufffd\ufffd\ufffd"')
+
+            # Lone starter byte of 2-byte sequence
+            pb(b'"\xc0 "', '"\ufffd "')
+
+            # Single never-valid bytes
+            pb(b'"\xfe"', '"\ufffd"')
+            pb(b'"\xff"', '"\ufffd"')
+
+            # Multiple never-valid bytes
+            pb(b'"\xff\xfe"', '"\ufffd\ufffd"')
+            pb(b'"\xfe\xfe\xff\xff"', '"\ufffd\ufffd\ufffd\ufffd"')
+
+            # Truncated 2-byte sequence (only 1 byte)
+            pb(b'"\xc2"', '"\ufffd"')
+
+            # Truncated 3-byte sequences (only 2 bytes)
+            pb(b'"\xef\xbf"', '"\ufffd"')
+            pb(b'"\xe0\xa0"', '"\ufffd"')
+
+            # Truncated 4-byte sequence (only 2 or 3 bytes)
+            pb(b'"\xf0\x9f"', '"\ufffd"')
+            pb(b'"\xf0\x9f\x98"', '"\ufffd"')
+
+            # Bad continuation byte (restored as ASCII)
+            pb(b'"\xe1\x28\xa1"', '"\ufffd(\ufffd"')  # )
+
+            # Overlong 2-byte sequence for U+0000 (should be `0x00`)
+            pb(b'"\xc0\x80"', '"\ufffd\ufffd"')
+
+            # Overlong 3-byte sequence for U+0000 (violates boundary)
+            pb(b'"\xe0\x80\x80"', '"\ufffd\ufffd\ufffd"')
+
+            # Overlong 4-byte sequence for U+0000 (violates boundary)
+            pb(b'"\xf0\x80\x80\x80"', '"\ufffd\ufffd\ufffd\ufffd"')
+
+            # High surrogate code point
+            pb(b'"\xed\xa0\x80"', '"\ufffd\ufffd\ufffd"')
+
+            # Low surrogate code point
+            pb(b'"\xed\xb0\x80"', '"\ufffd\ufffd\ufffd"')
+
+            # Too large starter byte
+            pb(b'"\xff\x80\x80\x80"', '"\ufffd\ufffd\ufffd\ufffd"')
+
+            # The following boundary cases come from the table of well-formed UTF-8 byte sequences
+            # <https://www.unicode.org/versions/Unicode16.0.0/core-spec/chapter-3/#G27506>`_.
+            # For continuation bytes, both 0xC0 and 0xC2 are tested as values that exceed the valid maximum.
+            # This is because 0xC0 is an invalid starter byte, but 0xC2 is also a starter byte for 2-byte sequences.
+            # simd-string-impl.h prefers classifying bytes as starter bytes when possible (e.g., in "\xf0\x90\xc2\x80").
+            # The tests need to check that simd-string-impl.h correctly detects
+            # starter bytes that are actually invalid continution bytes, like 0xC2.
+
+            # Boundary cases: 2-byte sequences
+            pb(b'"\xc1\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xc1\x80"', '"\ufffd\ufffd"')
+            pb(b'"\xc1\xbf"', '"\ufffd\ufffd"')
+            pb(b'"\xc1\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xc1\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xc2\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xc2\x80"', '"\x80"')
+            pb(b'"\xc2\xbf"', '"\xbf"')
+            pb(b'"\xc2\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xc2\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xdf\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xdf\x80"', '"\u07c0"')
+            pb(b'"\xdf\xbf"', '"\u07ff"')
+            pb(b'"\xdf\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xdf\xc2"', '"\ufffd\ufffd"')
+
+            # Boundary cases: 3-byte sequences starting with 0xE0
+            pb(b'"\xe0\x9f\x80"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xe0\xa0\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xe0\xa0\x80"', '"\u0800"')
+            pb(b'"\xe0\xa0\xbf"', '"\u083f"')
+            pb(b'"\xe0\xa0\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xe0\xa0\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xe0\xbf\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xe0\xbf\x80"', '"\u0fc0"')
+            pb(b'"\xe0\xbf\xbf"', '"\u0fff"')
+            pb(b'"\xe0\xbf\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xe0\xbf\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xe0\xc0\x80"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xe0\xc2\x80"', '"\ufffd\x80"')
+
+            # Boundary cases: 3-byte sequences starting with 0xE1..0xEC
+            pb(b'"\xe1\x7f\x80"', '"\ufffd\x7f\ufffd"')
+            pb(b'"\xe1\x80\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xe1\x80\x80"', '"\u1000"')
+            pb(b'"\xe1\x80\xbf"', '"\u103f"')
+            pb(b'"\xe1\x80\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xe1\x80\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xe1\xbf\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xe1\xbf\x80"', '"\u1fc0"')
+            pb(b'"\xe1\xbf\xbf"', '"\u1fff"')
+            pb(b'"\xe1\xbf\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xe1\xbf\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xe1\xc0\x80"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xe1\xc2\x80"', '"\ufffd\x80"')
+            pb(b'"\xec\x7f\x80"', '"\ufffd\x7f\ufffd"')
+            pb(b'"\xec\x80\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xec\x80\x80"', '"\uc000"')
+            pb(b'"\xec\x80\xbf"', '"\uc03f"')
+            pb(b'"\xec\x80\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xec\x80\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xec\xbf\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xec\xbf\x80"', '"\ucfc0"')
+            pb(b'"\xec\xbf\xbf"', '"\ucfff"')
+            pb(b'"\xec\xbf\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xec\xbf\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xec\xc0\x80"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xec\xc2\x80"', '"\ufffd\x80"')
+
+            # Boundary cases: 3-byte sequences starting with 0xED
+            pb(b'"\xed\x7f\x80"', '"\ufffd\x7f\ufffd"')
+            pb(b'"\xed\x80\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xed\x80\x80"', '"\ud000"')
+            pb(b'"\xed\x80\xbf"', '"\ud03f"')
+            pb(b'"\xed\x80\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xed\x80\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xed\x9f\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xed\x9f\x80"', '"\ud7c0"')
+            pb(b'"\xed\x9f\xbf"', '"\ud7ff"')
+            pb(b'"\xed\x9f\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xed\x9f\xc2"', '"\ufffd\ufffd"')
+
+            # Boundary cases: 3-byte sequences starting with 0xEE..0xEF
+            pb(b'"\xed\xa0\x80"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xee\x7f\x80"', '"\ufffd\x7f\ufffd"')
+            pb(b'"\xee\x80\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xee\x80\x80"', '"\ue000"')
+            pb(b'"\xee\x80\xbf"', '"\ue03f"')
+            pb(b'"\xee\x80\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xee\x80\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xee\xbf\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xee\xbf\x80"', '"\uefc0"')
+            pb(b'"\xee\xbf\xbf"', '"\uefff"')
+            pb(b'"\xee\xbf\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xee\xbf\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xee\xc0\x80"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xee\xc2\x80"', '"\ufffd\x80"')
+            pb(b'"\xef\x7f\x80"', '"\ufffd\x7f\ufffd"')
+            pb(b'"\xef\x80\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xef\x80\x80"', '"\uf000"')
+            pb(b'"\xef\x80\xbf"', '"\uf03f"')
+            pb(b'"\xef\x80\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xef\x80\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xef\xbf\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xef\xbf\x80"', '"\uffc0"')
+            pb(b'"\xef\xbf\xbf"', '"\uffff"')
+            pb(b'"\xef\xbf\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xef\xbf\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xef\xc0\x80"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xef\xc2\x80"', '"\ufffd\x80"')
+
+            # Boundary cases: 4-byte sequences starting with 0xF0
+            pb(b'"\xf0\x8f\x80\x80"', '"\ufffd\ufffd\ufffd\ufffd"')
+            pb(b'"\xf0\x90\x7f\x80"', '"\ufffd\x7f\ufffd"')
+            pb(b'"\xf0\x90\x80\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xf0\x90\x80\x80"', '"\U00010000"')
+            pb(b'"\xf0\x90\x80\xbf"', '"\U0001003f"')
+            pb(b'"\xf0\x90\x80\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xf0\x90\x80\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xf0\x90\xbf\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xf0\x90\xbf\x80"', '"\U00010fc0"')
+            pb(b'"\xf0\x90\xbf\xbf"', '"\U00010fff"')
+            pb(b'"\xf0\x90\xbf\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xf0\x90\xbf\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xf0\x90\xc0\x7f"', '"\ufffd\ufffd\x7f"')
+            pb(b'"\xf0\x90\xc0\x80"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf0\x90\xc0\xbf"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf0\x90\xc0\xc0"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf0\x90\xc0\xc2"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf0\x90\xc2\x7f"', '"\ufffd\ufffd\x7f"')
+            pb(b'"\xf0\x90\xc2\x80"', '"\ufffd\x80"')
+            pb(b'"\xf0\x90\xc2\xbf"', '"\ufffd\xbf"')
+            pb(b'"\xf0\x90\xc2\xc0"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf0\x90\xc2\xc2"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf0\xbf\x7f\x80"', '"\ufffd\x7f\ufffd"')
+            pb(b'"\xf0\xbf\x80\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xf0\xbf\x80\x80"', '"\U0003f000"')
+            pb(b'"\xf0\xbf\x80\xbf"', '"\U0003f03f"')
+            pb(b'"\xf0\xbf\x80\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xf0\xbf\x80\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xf0\xbf\xbf\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xf0\xbf\xbf\x80"', '"\U0003ffc0"')
+            pb(b'"\xf0\xbf\xbf\xbf"', '"\U0003ffff"')
+            pb(b'"\xf0\xbf\xbf\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xf0\xbf\xbf\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xf0\xbf\xc0\x7f"', '"\ufffd\ufffd\x7f"')
+            pb(b'"\xf0\xbf\xc0\x80"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf0\xbf\xc0\xbf"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf0\xbf\xc0\xc0"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf0\xbf\xc0\xc2"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf0\xbf\xc2\x7f"', '"\ufffd\ufffd\x7f"')
+            pb(b'"\xf0\xbf\xc2\x80"', '"\ufffd\x80"')
+            pb(b'"\xf0\xbf\xc2\xbf"', '"\ufffd\xbf"')
+            pb(b'"\xf0\xbf\xc2\xc0"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf0\xbf\xc2\xc2"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf0\xc0\x80\x80"', '"\ufffd\ufffd\ufffd\ufffd"')
+
+            # Boundary cases: 4-byte sequences starting with 0xF1..0xF3
+            pb(b'"\xf1\x7f\x80\x80"', '"\ufffd\x7f\ufffd\ufffd"')
+            pb(b'"\xf1\x80\x7f\x80"', '"\ufffd\x7f\ufffd"')
+            pb(b'"\xf1\x80\x80\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xf1\x80\x80\x80"', '"\U00040000"')
+            pb(b'"\xf1\x80\x80\xbf"', '"\U0004003f"')
+            pb(b'"\xf1\x80\x80\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xf1\x80\x80\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xf1\x80\xbf\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xf1\x80\xbf\x80"', '"\U00040fc0"')
+            pb(b'"\xf1\x80\xbf\xbf"', '"\U00040fff"')
+            pb(b'"\xf1\x80\xbf\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xf1\x80\xbf\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xf1\x80\xc0\x7f"', '"\ufffd\ufffd\x7f"')
+            pb(b'"\xf1\x80\xc0\x80"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf1\x80\xc0\xbf"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf1\x80\xc0\xc0"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf1\x80\xc2\x7f"', '"\ufffd\ufffd\x7f"')
+            pb(b'"\xf1\x80\xc2\x80"', '"\ufffd\x80"')
+            pb(b'"\xf1\x80\xc2\xbf"', '"\ufffd\xbf"')
+            pb(b'"\xf1\x80\xc2\xc0"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf1\xbf\x7f\x80"', '"\ufffd\x7f\ufffd"')
+            pb(b'"\xf1\xbf\x80\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xf1\xbf\x80\x80"', '"\U0007f000"')
+            pb(b'"\xf1\xbf\x80\xbf"', '"\U0007f03f"')
+            pb(b'"\xf1\xbf\x80\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xf1\xbf\x80\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xf1\xbf\xbf\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xf1\xbf\xbf\x80"', '"\U0007ffc0"')
+            pb(b'"\xf1\xbf\xbf\xbf"', '"\U0007ffff"')
+            pb(b'"\xf1\xbf\xbf\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xf1\xbf\xbf\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xf1\xbf\xc0\x7f"', '"\ufffd\ufffd\x7f"')
+            pb(b'"\xf1\xbf\xc0\x80"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf1\xbf\xc0\xbf"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf1\xbf\xc0\xc0"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf1\xbf\xc0\xc2"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf1\xbf\xc2\x7f"', '"\ufffd\ufffd\x7f"')
+            pb(b'"\xf1\xbf\xc2\x80"', '"\ufffd\x80"')
+            pb(b'"\xf1\xbf\xc2\xbf"', '"\ufffd\xbf"')
+            pb(b'"\xf1\xbf\xc2\xc0"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf1\xbf\xc2\xc2"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf1\xc0\x80\x80"', '"\ufffd\ufffd\ufffd\ufffd"')
+            pb(b'"\xf1\xc2\x80\x80"', '"\ufffd\x80\ufffd"')
+            pb(b'"\xf3\x7f\x80\x80"', '"\ufffd\x7f\ufffd\ufffd"')
+            pb(b'"\xf3\x80\x7f\x80"', '"\ufffd\x7f\ufffd"')
+            pb(b'"\xf3\x80\x80\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xf3\x80\x80\x80"', '"\U000c0000"')
+            pb(b'"\xf3\x80\x80\xbf"', '"\U000c003f"')
+            pb(b'"\xf3\x80\x80\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xf3\x80\x80\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xf3\x80\xbf\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xf3\x80\xbf\x80"', '"\U000c0fc0"')
+            pb(b'"\xf3\x80\xbf\xbf"', '"\U000c0fff"')
+            pb(b'"\xf3\x80\xbf\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xf3\x80\xbf\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xf3\x80\xc0\x7f"', '"\ufffd\ufffd\x7f"')
+            pb(b'"\xf3\x80\xc0\x80"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf3\x80\xc0\xbf"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf3\x80\xc0\xc0"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf3\x80\xc0\xc2"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf3\x80\xc2\x7f"', '"\ufffd\ufffd\x7f"')
+            pb(b'"\xf3\x80\xc2\x80"', '"\ufffd\x80"')
+            pb(b'"\xf3\x80\xc2\xbf"', '"\ufffd\xbf"')
+            pb(b'"\xf3\x80\xc2\xc0"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf3\x80\xc2\xc2"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf3\xbf\x7f\x80"', '"\ufffd\x7f\ufffd"')
+            pb(b'"\xf3\xbf\x80\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xf3\xbf\x80\x80"', '"\U000ff000"')
+            pb(b'"\xf3\xbf\x80\xbf"', '"\U000ff03f"')
+            pb(b'"\xf3\xbf\x80\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xf3\xbf\x80\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xf3\xbf\xbf\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xf3\xbf\xbf\x80"', '"\U000fffc0"')
+            pb(b'"\xf3\xbf\xbf\xbf"', '"\U000fffff"')
+            pb(b'"\xf3\xbf\xbf\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xf3\xbf\xbf\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xf3\xbf\xc0\x7f"', '"\ufffd\ufffd\x7f"')
+            pb(b'"\xf3\xbf\xc0\x80"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf3\xbf\xc0\xbf"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf3\xbf\xc0\xc0"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf3\xbf\xc0\xc2"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf3\xbf\xc2\x7f"', '"\ufffd\ufffd\x7f"')
+            pb(b'"\xf3\xbf\xc2\x80"', '"\ufffd\x80"')
+            pb(b'"\xf3\xbf\xc2\xbf"', '"\ufffd\xbf"')
+            pb(b'"\xf3\xbf\xc2\xc0"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf3\xbf\xc2\xc2"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf3\xc0\x80\x80"', '"\ufffd\ufffd\ufffd\ufffd"')
+            pb(b'"\xf3\xc2\x80\x80"', '"\ufffd\x80\ufffd"')
+
+            # Boundary cases: 4-byte sequences starting with 0xF4
+            pb(b'"\xf4\x7f\x80\x80"', '"\ufffd\x7f\ufffd\ufffd"')
+            pb(b'"\xf4\x80\x7f\x80"', '"\ufffd\x7f\ufffd"')
+            pb(b'"\xf4\x80\x80\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xf4\x80\x80\x80"', '"\U00100000"')
+            pb(b'"\xf4\x80\x80\xbf"', '"\U0010003f"')
+            pb(b'"\xf4\x80\x80\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xf4\x80\x80\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xf4\x80\xbf\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xf4\x80\xbf\x80"', '"\U00100fc0"')
+            pb(b'"\xf4\x80\xbf\xbf"', '"\U00100fff"')
+            pb(b'"\xf4\x80\xbf\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xf4\x80\xbf\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xf4\x80\xc0\x7f"', '"\ufffd\ufffd\x7f"')
+            pb(b'"\xf4\x80\xc0\x80"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf4\x80\xc0\xbf"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf4\x80\xc0\xc0"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf4\x80\xc0\xc2"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf4\x80\xc2\x7f"', '"\ufffd\ufffd\x7f"')
+            pb(b'"\xf4\x80\xc2\x80"', '"\ufffd\x80"')
+            pb(b'"\xf4\x80\xc2\xbf"', '"\ufffd\xbf"')
+            pb(b'"\xf4\x80\xc2\xc0"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf4\x80\xc2\xc2"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf4\x8f\x7f\x80"', '"\ufffd\x7f\ufffd"')
+            pb(b'"\xf4\x8f\x80\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xf4\x8f\x80\x80"', '"\U0010f000"')
+            pb(b'"\xf4\x8f\x80\xbf"', '"\U0010f03f"')
+            pb(b'"\xf4\x8f\x80\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xf4\x8f\x80\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xf4\x8f\xbf\x7f"', '"\ufffd\x7f"')
+            pb(b'"\xf4\x8f\xbf\x80"', '"\U0010ffc0"')
+            pb(b'"\xf4\x8f\xbf\xbf"', '"\U0010ffff"')
+            pb(b'"\xf4\x8f\xbf\xc0"', '"\ufffd\ufffd"')
+            pb(b'"\xf4\x8f\xbf\xc2"', '"\ufffd\ufffd"')
+            pb(b'"\xf4\x8f\xc0\x7f"', '"\ufffd\ufffd\x7f"')
+            pb(b'"\xf4\x8f\xc0\x80"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf4\x8f\xc0\xbf"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf4\x8f\xc0\xc0"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf4\x8f\xc0\xc2"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf4\x8f\xc2\x7f"', '"\ufffd\ufffd\x7f"')
+            pb(b'"\xf4\x8f\xc2\x80"', '"\ufffd\x80"')
+            pb(b'"\xf4\x8f\xc2\xbf"', '"\ufffd\xbf"')
+            pb(b'"\xf4\x8f\xc2\xc0"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf4\x8f\xc2\xc2"', '"\ufffd\ufffd\ufffd"')
+            pb(b'"\xf4\x90\x80\x80"', '"\ufffd\ufffd\ufffd\ufffd"')
+            pb(b'"\xf5\x80\x80\x80"', '"\ufffd\ufffd\ufffd\ufffd"')
+
+            # Boundary case: too large codepoint (> U+10FFFF)
+            pb(b'"\xf5\x80\x80\x80"', '"\ufffd\ufffd\ufffd\ufffd"')
+
+
+    def test_find_either_of_two_bytes(self):
+        sizes = []
+        if has_sse4_2:
+            sizes.append(2)
+        if has_avx2:
+            sizes.append(3)
+        sizes.append(0)
+
+        def test(buf, a, b, align_offset=0):
+            a_, b_ = ord(a), ord(b)
+            expected = test_find_either_of_two_bytes(buf, a_, b_, 1, 0)
+            for sz in sizes:
+                actual = test_find_either_of_two_bytes(buf, a_, b_, sz, align_offset)
+                self.ae(expected, actual, f'Failed for: {buf!r} {a=} {b=} at {sz=} and {align_offset=}')
+
+        q = 'abc'
+        for off in range(32):
+            test(q, '<', '>', off)
+            test(q, ' ', 'b', off)
+            test(q, '<', 'a', off)
+            test(q, '<', 'b', off)
+            test(q, 'c', '>', off)
+
+        def tests(buf, a, b):
+            for sz in (0, 16, 32, 64, 79):
+                buf = (' ' * sz) + buf
+                for align_offset in range(32):
+                    test(buf, a, b, align_offset)
+        tests("", '<', '>')
+        tests("a", '\0', '\0')
+        tests("a", '<', '>')
+        tests("dsdfsfa", '1', 'a')
+        tests("xa", 'a', 'a')
+        tests("bbb", 'a', '1')
+        tests("bba", 'a', '<')
+        tests("baa", '>', 'a')
+
+    def test_esc_codes(self):
+        s = self.create_screen()
+        pb = partial(self.parse_bytes_dump, s)
+        pb('12\033Da', '12', ('screen_index',), 'a')
+        self.ae(str(s.line(0)), '12')
+        self.ae(str(s.line(1)), '  a')
+        pb('\033xa', ('Unknown char after ESC: 0x%x' % ord('x'),), 'a')
+        pb('\033c123', ('screen_reset', ), '123')
+        self.ae(str(s.line(0)), '123')
+        pb('\033.\033a', ('Unhandled charset related escape code: 0x2e 0x1b',), 'a')
+
+    def test_csi_codes(self):
+        s = self.create_screen()
+        pb = partial(self.parse_bytes_dump, s)
+        pb('abcde', 'abcde')
+        s.cursor_move(5)
+        pb('x\033[2@y', 'x', ('screen_insert_characters', 2), 'y')
+        self.ae(str(s.line(0)), 'xy bc')
+        pb('x\033[2;7@y', 'x', ('CSI code @ has 2 > 1 parameters',), 'y')
+        pb('x\033[2;-7@y', 'x', ('CSI code @ has 2 > 1 parameters',), 'y')
+        pb('x\033[-0001234567890@y', 'x', ('CSI code @ is not allowed to have negative parameter (-1234567890)',), 'y')
+        pb('x\033[2-3@y', 'x', ('Invalid character in CSI: 3 (0x33), ignoring the sequence',), '@y')
+        pb('x\033[@y', 'x', ('screen_insert_characters', 1), 'y')
+        pb('x\033[345@y', 'x', ('screen_insert_characters', 345), 'y')
+        pb('x\033[345;@y', 'x', ('screen_insert_characters', 345), 'y')
+        pb('\033[H', ('screen_cursor_position', 1, 1))
+        self.ae(s.cursor.x, 0), self.ae(s.cursor.y, 0)
+        pb('\033[4H', ('screen_cursor_position', 4, 1))
+        pb('\033[4;0H', ('screen_cursor_position', 4, 0))
+        pb('\033[3;2H', ('screen_cursor_position', 3, 2))
+        pb('\033[3;2;H', ('screen_cursor_position', 3, 2))
+        pb('\033[00000000003;0000000000000002H', ('screen_cursor_position', 3, 2))
+        self.ae(s.cursor.x, 1), self.ae(s.cursor.y, 2)
+        pb('\033[0001234567890H', ('screen_cursor_position', 1234567890, 1))
+        pb('\033[J', ('screen_erase_in_display', 0, 0))
+        pb('\033[?J', ('screen_erase_in_display', 0, 1))
+        pb('\033[?2J', ('screen_erase_in_display', 2, 1))
+        pb('\033[h')
+        pb('\033[20;4h', ('screen_set_mode', 20, 0), ('screen_set_mode', 4, 0))
+        pb('\033[?1000;1004h', ('screen_set_mode', 1000, 1), ('screen_set_mode', 1004, 1))
+        pb('\033[20;4;20l', ('screen_reset_mode', 20, 0), ('screen_reset_mode', 4, 0), ('screen_reset_mode', 20, 0))
+        pb('\033[=c', ('report_device_attributes', 0, 61))
+        s.reset()
+
+        def sgr(*params):
+            return (('select_graphic_rendition', f'{x}') for x in params)
+
+        pb('\033[1;2;3;4;7;9;34;44m', *sgr('1;2;3;4;7;9;34;44'))
+        for attr in 'bold italic reverse strikethrough dim'.split():
+            self.assertTrue(getattr(s.cursor, attr), attr)
+        self.ae(s.cursor.decoration, 1)
+        self.ae(s.cursor.fg, 4 << 8 | 1)
+        self.ae(s.cursor.bg, 4 << 8 | 1)
+        pb('\033[38;5;1;48;5;7m', ('select_graphic_rendition', '38:5:1'), ('select_graphic_rendition', '48:5:7'))
+        self.ae(s.cursor.fg, 1 << 8 | 1)
+        self.ae(s.cursor.bg, 7 << 8 | 1)
+        pb('\033[38;2;1;2;3;48;2;7;8;9m', ('select_graphic_rendition', '38:2:1:2:3'), ('select_graphic_rendition', '48:2:7:8:9'))
+        self.ae(s.cursor.fg, 1 << 24 | 2 << 16 | 3 << 8 | 2)
+        self.ae(s.cursor.bg, 7 << 24 | 8 << 16 | 9 << 8 | 2)
+        pb('\033[0;2m', *sgr('0;2'))
+        pb('\033[;2m', *sgr('0;2'))
+        pb('\033[m', *sgr('0'))
+        pb('\033[1;;2m', *sgr('1;0;2'))
+        pb('\033[38;5;1m', ('select_graphic_rendition', '38:5:1'))
+        pb('\033[58;2;1;2;3m', ('select_graphic_rendition', '58:2:1:2:3'))
+        pb('\033[38;2;1;2;3m', ('select_graphic_rendition', '38:2:1:2:3'))
+        pb('\033[1001:2:1:2:3m', ('select_graphic_rendition', '1001:2:1:2:3'))
+        pb('\033[38:2:1:2:3;48:5:9;58;5;7m', (
+            'select_graphic_rendition', '38:2:1:2:3'), ('select_graphic_rendition', '48:5:9'), ('select_graphic_rendition', '58:5:7'))
+        s.reset()
+        pb('\033[1;2;3;4:5;7;9;34;44m', *sgr('1;2;3', '4:5', '7;9;34;44'))
+        for attr in 'bold italic reverse strikethrough dim'.split():
+            self.assertTrue(getattr(s.cursor, attr), attr)
+        self.ae(s.cursor.decoration, 5)
+        c = s.callbacks
+        pb('\033[5n', ('report_device_status', 5, 0))
+        self.ae(c.wtcbuf, b'\033[0n')
+        c.clear()
+        pb('\033[6n', ('report_device_status', 6, 0))
+        self.ae(c.wtcbuf, b'\033[1;1R')
+        pb('12345', '12345')
+        c.clear()
+        pb('\033[6n', ('report_device_status', 6, 0))
+        self.ae(c.wtcbuf, b'\033[2;1R')
+        c.clear()
+        s.cursor_key_mode = True
+        pb('\033[?1$p', ('report_mode_status', 1, 1))
+        self.ae(c.wtcbuf, b'\033[?1;1$y')
+        pb('\033[?1l', ('screen_reset_mode', 1, 1))
+        self.assertFalse(s.cursor_key_mode)
+        c.clear()
+        pb('\033[?1$p', ('report_mode_status', 1, 1))
+        self.ae(c.wtcbuf, b'\033[?1;2$y')
+        pb('\033[2;4r', ('screen_set_margins', 2, 4))
+        c.clear()
+        pb('\033[14t', ('screen_report_size', 14, 0))
+        pb('\033[14;2t', ('screen_report_size', 14, 2))
+        self.ae(c.wtcbuf, b'\033[4;100;50t\033[4;100;50t')
+        self.ae(s.margin_top, 1), self.ae(s.margin_bottom, 3)
+        pb('\033[r', ('screen_set_margins', 0, 0))
+        self.ae(s.margin_top, 0), self.ae(s.margin_bottom, 4)
+        pb('\033[1 q', ('screen_set_cursor', 1, ord(' ')))
+        self.assertTrue(s.cursor.blink)
+        self.ae(s.cursor.shape, CURSOR_BLOCK)
+
+        s.reset()
+        pb('\033[3 @', ('Shift left escape code not implemented',))
+        pb('\033[3 A', ('Shift right escape code not implemented',))
+        pb('\033[3;4 S', ('Select presentation directions escape code not implemented',))
+        pb('\033[1T', ('screen_reverse_scroll', 1))
+        pb('\033[T', ('screen_reverse_scroll', 1))
+        pb('\033[+T', ('screen_reverse_scroll_and_fill_from_scrollback', 1))
+
+        c.clear()
+        pb('\033[?2026$p', ('report_mode_status', 2026, 1))
+        self.ae(c.wtcbuf, b'\x1b[?2026;2$y')
+        c.clear()
+        pb('\033[?2026h', ('screen_set_mode', 2026, 1))
+        pb('\033[?2026$p', ('report_mode_status', 2026, 1))
+        self.ae(c.wtcbuf, b'\x1b[?2026;1$y')
+        pb('\033[?2026l', ('screen_reset_mode', 2026, 1))
+        c.clear()
+        pb('\033[?2026$p', ('report_mode_status', 2026, 1))
+        self.ae(c.wtcbuf, b'\x1b[?2026;2$y')
+
+    def test_csi_code_rep(self):
+        s = self.create_screen(8)
+        pb = partial(self.parse_bytes_dump, s)
+        pb('\033[1b', ('screen_repeat_character', 1))
+        self.ae(str(s.line(0)), '')
+        pb('x\033[7b', 'x', ('screen_repeat_character', 7))
+        self.ae(str(s.line(0)), 'xxxxxxxx')
+        pb('\033[1;3H', ('screen_cursor_position', 1, 3))
+        pb('\033[byz\033[b', ('screen_repeat_character', 1), 'yz', ('screen_repeat_character', 1))
+        # repeat 'x' at 3, then 'yz' at 4-5, then repeat 'z' at 6
+        self.ae(str(s.line(0)), 'xxxyzzxx')
+        s.reset()
+        pb(' \033[3b', ' ', ('screen_repeat_character', 3))
+        self.ae(str(s.line(0)), '    ')
+        s.reset()
+        pb('\t\033[b', ('screen_tab',), ('screen_repeat_character', 1))
+        # The terminal includes blank tab padding in its line text.
+        self.ae(str(s.line(0)).rstrip(' '), '\t')
+        self.ae(s.cursor.x, 7)
+        self.ae(s.cursor.y, 0)
+        s.reset()
+        b']]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]'
+
+    def test_osc_codes(self):
+        s = self.create_screen()
+        pb = partial(self.parse_bytes_dump, s)
+        c = s.callbacks
+        pb('a\033]2;x\\ryz\033\\bcde', 'a', ('set_title', 'x\\ryz'), 'bcde')
+        self.ae(str(s.line(0)), 'abcde')
+        self.ae(c.titlebuf, ['x\\ryz'])
+        c.clear()
+        pb('\033]\x07', ('set_title', ''), ('set_icon', ''))
+        self.ae(c.titlebuf, ['']), self.ae(c.iconbuf, '')
+        pb('1\033]ab\x072', '1', ('set_title', 'ab'), ('set_icon', 'ab'), '2')
+        self.ae(c.titlebuf, ['', 'ab']), self.ae(c.iconbuf, 'ab')
+        c.clear()
+        pb('\033]2;;;;\x07', ('set_title', ';;;'))
+        self.ae(c.titlebuf, [';;;'])
+        c.clear()
+        pb('\033]2;\x07', ('set_title', ''))
+        self.ae(c.titlebuf, [''])
+        pb('\033]110\x07', ('set_dynamic_color', 110, ''))
+        self.ae(c.colorbuf, '')
+        c.clear()
+        pb('\033]9;\x07', ('desktop_notify', 9, ''))
+        pb('\033]9;test it with a nice long string\x07', ('desktop_notify', 9, 'test it with a nice long string'))
+        pb('\033]99;moo=foo;test it\x07', ('desktop_notify', 99, 'moo=foo;test it'))
+        self.ae(c.notifications, [(9, ''), (9, 'test it with a nice long string'), (99, 'moo=foo;test it')])
+        c.clear()
+        pb('\033]8;;\x07', ('set_active_hyperlink', None, None))
+        pb('\033]8moo\x07', ('Ignoring malformed OSC 8 code',))
+        pb('\033]8;moo\x07', ('Ignoring malformed OSC 8 code',))
+        pb('\033]8;id=xyz;\x07', ('set_active_hyperlink', 'xyz', None))
+        pb('\033]8;moo:x=z:id=xyz:id=abc;http://yay;.com\x07', ('set_active_hyperlink', 'xyz', 'http://yay;.com'))
+        c.clear()
+        payload = '1' * 1024
+        pb(f'\033]52;p;{payload}\x07', ('clipboard_control', 52, f'p;{payload}'))
+        c.clear()
+        pb('\033]52;p;xyz\x07', ('clipboard_control', 52, 'p;xyz'))
+        c.clear()
+        pb('\033]22;?__current__\x07', ('set_dynamic_color', 22, '?__current__'))
+
+    def test_dcs_codes(self):
+        s = self.create_screen()
+        c = s.callbacks
+        pb = partial(self.parse_bytes_dump, s)
+        q = hexlify(b'kind').decode('ascii')
+        pb(f'a\033P+q{q}\033\\bcde', 'a', ('screen_request_capabilities', 43, q), 'bcde')
+        self.ae(str(s.line(0)), 'abcde')
+        self.ae(c.wtcbuf, '\033P1+r{}={}\033\\'.format(q, '1b5b313b3242').encode('ascii'))
+        c.clear()
+        pb('\033P$q q\033\\', ('screen_request_capabilities', ord('$'), ' q'))
+        self.ae(c.wtcbuf, b'\033P1$r1 q\033\\')
+        c.clear()
+        pb('\033P$qm\033\\', ('screen_request_capabilities', ord('$'), 'm'))
+        self.ae(c.wtcbuf, b'\033P1$rm\033\\')
+        for sgr in '0;34;102;1;2;3;4 0;38:5:200;58:2:10:11:12'.split():
+            expected = set(sgr.split(';'))
+            c.clear()
+            parse_bytes(s, f'\033[{sgr}m\033P$qm\033\\'.encode('ascii'))
+            r = c.wtcbuf.decode('ascii').partition('r')[2].partition('m')[0]
+            self.ae(expected, set(r.split(';')))
+        c.clear()
+        pb('\033P$qr\033\\', ('screen_request_capabilities', ord('$'), 'r'))
+        self.ae(c.wtcbuf, f'\033P1$r{s.margin_top + 1};{s.margin_bottom + 1}r\033\\'.encode('ascii'))
+        pb('\033P@kitty-cmd{abc\033\\', ('handle_remote_cmd', '{abc'))
+        p = base64_encode('abcd').decode()
+        pb(f'\033P@kitty-print|{p}\033\\', ('handle_remote_print', p))
+        self.ae(['abcd'], s.callbacks.printbuf)
+
+        c.clear()
+        pb('\033[?2026$p', ('report_mode_status', 2026, 1))
+        self.ae(c.wtcbuf, b'\x1b[?2026;2$y')
+        pb('\033P=1s\033\\', ('screen_start_pending_mode',))
+        c.clear()
+        pb('\033[?2026$p', ('report_mode_status', 2026, 1))
+        self.ae(c.wtcbuf, b'\x1b[?2026;1$y')
+        pb('\033P=2s\033\\', ('screen_stop_pending_mode',))
+        c.clear()
+        pb('\033[?2026$p', ('report_mode_status', 2026, 1))
+        self.ae(c.wtcbuf, b'\x1b[?2026;2$y')
+
+
+    def test_oth_codes(self):
+        s = self.create_screen()
+        pb = partial(self.parse_bytes_dump, s)
+        pb('a\033_+\\+\033\\bcde', ('draw', 'a'), ('Unrecognized APC code: 0x2b',), ('draw', 'bcde'))
+        pb('a\033^+\\+\033\\bcde', ('draw', 'a'), ('Unrecognized PM code: 0x2b',), ('draw', 'bcde'))
+        pb('a\033X+\\+\033\\bcde', ('draw', 'a'), ('Unrecognized SOS code: 0x2b',), ('draw', 'bcde'))
+
+    def test_graphics_command(self):
+        from base64 import standard_b64encode
+
+        def enc(x):
+            return standard_b64encode(x.encode('utf-8') if isinstance(x, str) else x).decode('ascii')
+
+        def c(**k):
+            for p, v in tuple(k.items()):
+                if isinstance(v, str) and p != 'payload':
+                    k[p] = v.encode('ascii')
+            for f in 'action delete_action transmission_type compressed'.split():
+                k.setdefault(f, b'\0')
+            for f in ('format more id data_sz data_offset width height x_offset y_offset data_height data_width cursor_movement'
+                      ' num_cells num_lines cell_x_offset cell_y_offset z_index placement_id image_number quiet unicode_placement'
+                      ' parent_id parent_placement_id offset_from_parent_x offset_from_parent_y'
+            ).split():
+                k.setdefault(f, 0)
+            p = k.pop('payload', '')
+            k[''] = p
+            return ('graphics_command', k)
+
+        def t(cmd, **kw):
+            pb('\033_G{};{}\033\\'.format(cmd, enc(kw.get('payload', ''))), c(**kw))
+
+        def e(cmd, err):
+            pb(f'\033_G{cmd}\033\\', (err,))
+
+        s = self.create_screen()
+        pb = partial(self.parse_bytes_dump, s)
+        uint32_max = 2**32 - 1
+        t('i=%d' % uint32_max, id=uint32_max)
+        t('i=3,p=4', id=3, placement_id=4)
+        e('i=%d' % (uint32_max + 1), 'Malformed GraphicsCommand control block, number is too large')
+        pb('\033_Gi=12\033\\', c(id=12))
+        t('a=t,t=d,s=100,z=-9', payload='X', action='t', transmission_type='d', data_width=100, z_index=-9)
+        t('a=t,t=d,s=100,z=9', payload='payload', action='t', transmission_type='d', data_width=100, z_index=9)
+        t('a=t,t=d,s=100,z=9,q=2', action='t', transmission_type='d', data_width=100, z_index=9, quiet=2)
+        e(',s=1', 'Malformed GraphicsCommand control block, invalid key character: 0x2c')
+        e('W=1', 'Malformed GraphicsCommand control block, invalid key character: 0x57')
+        e('1=1', 'Malformed GraphicsCommand control block, invalid key character: 0x31')
+        e('a=t,,w=2', 'Malformed GraphicsCommand control block, invalid key character: 0x2c')
+        e('s', 'Malformed GraphicsCommand control block, no = after key')
+        e('s=', 'Malformed GraphicsCommand control block, expecting an integer value')
+        e('s==', 'Malformed GraphicsCommand control block, expecting an integer value for key: s')
+        e('s=1=', 'Malformed GraphicsCommand control block, expecting a , or semi-colon after a value, found: 0x3d')
+
+    def test_deccara(self):
+        s = self.create_screen()
+        pb = partial(self.parse_bytes_dump, s)
+        pb('\033[$r', ('deccara', '0;0;0;0;0'))
+        pb('\033[;;;;4:3;38:5:10;48:2:1:2:3;1$r',
+           ('deccara', '0;0;0;0;4:3'), ('deccara', '0;0;0;0;38:5:10'), ('deccara', '0;0;0;0;48:2:1:2:3'), ('deccara', '0;0;0;0;1'))
+        for y in range(s.lines):
+            line = s.line(y)
+            for x in range(s.columns):
+                c = line.cursor_from(x)
+                self.ae(c.bold, True)
+                self.ae(c.italic, False)
+                self.ae(c.decoration, 3)
+                self.ae(c.fg, (10 << 8) | 1)
+                self.ae(c.bg, (1 << 24 | 2 << 16 | 3 << 8 | 2))
+        self.ae(s.line(0).cursor_from(0).bold, True)
+        pb('\033[1;2;2;3;22;39$r', ('deccara', '1;2;2;3;22;39'))
+        self.ae(s.line(0).cursor_from(0).bold, True)
+        line = s.line(0)
+        for x in range(1, s.columns):
+            c = line.cursor_from(x)
+            self.ae(c.bold, False)
+            self.ae(c.fg, 0)
+        line = s.line(1)
+        for x in range(0, 3):
+            c = line.cursor_from(x)
+            self.ae(c.bold, False)
+        self.ae(line.cursor_from(3).bold, True)
+        pb('\033[2*x\033[3;2;4;3;34$r\033[*x', ('screen_decsace', 2), ('deccara', '3;2;4;3;34'), ('screen_decsace', 0))
+        for y in range(2, 4):
+            line = s.line(y)
+            for x in range(s.columns):
+                self.ae(line.cursor_from(x).fg, (10 << 8 | 1) if x < 1 or x > 2 else (4 << 8) | 1)
+
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()
diff --git a/tests/extern/kitty/screen.py b/tests/extern/kitty/screen.py
new file mode 100644
index 0000000..80f8e71
--- /dev/null
+++ b/tests/extern/kitty/screen.py
@@ -0,0 +1,476 @@
+"""ctypes wrapper providing the Kitty ``Screen`` API on top of our C terminal.
+
+The shared library ``libterm.so`` is loaded via :mod:`ctypes`. Python calls
+only the ``kitty_*`` functions of ``screen_bridge.c``, which wrap the public
+API (declared in ``src/term/term.h``). Python classes on top of them match the
+subset of Kitty's test API used by ``parser.py``.
+"""
+
+import ctypes
+import os
+
+# ---------------------------------------------------------------------------
+# Shared library loading
+# ---------------------------------------------------------------------------
+
+_lib = ctypes.CDLL(os.environ.get('WSAP_KITTY_LIB', os.path.join(os.path.dirname(__file__), 'libterm.so')))
+
+# struct term_cell { uint32_t text, fg, bg; uint16_t attrs; uint8_t width, reserved; }
+class TermCell(ctypes.Structure):
+    _fields_ = [
+        ('text', ctypes.c_uint32),
+        ('fg', ctypes.c_uint32),
+        ('bg', ctypes.c_uint32),
+        ('attrs', ctypes.c_uint16),
+        ('width', ctypes.c_uint8),
+        ('reserved', ctypes.c_uint8),
+    ]
+
+
+assert ctypes.sizeof(TermCell) == 16
+
+# Reply callback type: void (*)(void *ud, const char *bytes, size_t len).
+# The bytes are not NUL-terminated, so the callback takes a raw pointer.
+REPLY_FN = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(ctypes.c_char), ctypes.c_size_t)
+
+# Function signatures
+_lib.kitty_term_new.restype = ctypes.c_void_p
+_lib.kitty_term_new.argtypes = [ctypes.c_int, ctypes.c_int, REPLY_FN, ctypes.c_void_p]
+_lib.kitty_term_free.restype = None
+_lib.kitty_term_free.argtypes = [ctypes.c_void_p]
+_lib.kitty_term_resize.restype = ctypes.c_bool
+_lib.kitty_term_resize.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_int]
+_lib.kitty_term_write.restype = None
+_lib.kitty_term_write.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_size_t]
+_lib.kitty_term_cell.restype = ctypes.c_bool
+_lib.kitty_term_cell.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_int,
+                                 ctypes.POINTER(TermCell)]
+_lib.kitty_term_cell_text.restype = ctypes.c_int
+_lib.kitty_term_cell_text.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_int,
+                                      ctypes.POINTER(ctypes.c_uint32), ctypes.c_int]
+for _name, _type in {
+    'cols': ctypes.c_int,
+    'rows': ctypes.c_int,
+    'cursor_x': ctypes.c_int,
+    'cursor_y': ctypes.c_int,
+    'cursor_style': ctypes.c_int,
+    'cursor_blink': ctypes.c_bool,
+    'application_cursor': ctypes.c_bool,
+}.items():
+    _fn = getattr(_lib, 'kitty_term_' + _name)
+    _fn.argtypes = [ctypes.c_void_p]
+    _fn.restype = _type
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+TERM_DEFAULT_FG = 0xFFFFFFFF
+TERM_DEFAULT_BG = 0xFF1E1E2E
+
+# Cell attributes (must match enum term_attr in term.h)
+TERM_ATTR_BOLD            = 1 << 0
+TERM_ATTR_ITALIC          = 1 << 1
+TERM_ATTR_FAINT           = 1 << 2
+TERM_ATTR_STRIKE          = 1 << 3
+TERM_ATTR_OVERLINE        = 1 << 4
+TERM_ATTR_LINK            = 1 << 5
+TERM_ATTR_EMOJI           = 1 << 6
+TERM_ATTR_TEXT            = 1 << 7
+TERM_ATTR_UNDERLINE_SHIFT = 8
+TERM_ATTR_UNDERLINE_MASK  = 7 << TERM_ATTR_UNDERLINE_SHIFT
+
+# The longest grapheme cluster that a cell's text is read with.
+_CLUSTER_CAP = 32
+
+# Test-only accessors compiled against the current C terminal definition.
+for _name, _type in {
+    'scroll_top': ctypes.c_int,
+    'scroll_bottom': ctypes.c_int,
+    'cur_fg': ctypes.c_uint32,
+    'cur_bg': ctypes.c_uint32,
+    'bold': ctypes.c_bool,
+    'faint': ctypes.c_bool,
+    'italic': ctypes.c_bool,
+    'strike': ctypes.c_bool,
+    'inverse': ctypes.c_bool,
+    'underline': ctypes.c_uint8,
+}.items():
+    _fn = getattr(_lib, 'kitty_screen_' + _name)
+    _fn.argtypes = [ctypes.c_void_p]
+    _fn.restype = _type
+
+_lib.kitty_screen_row_length.argtypes = [ctypes.c_void_p, ctypes.c_int]
+_lib.kitty_screen_row_length.restype = ctypes.c_int
+_lib.kitty_screen_cell_is_tab.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_int]
+_lib.kitty_screen_cell_is_tab.restype = ctypes.c_bool
+
+# ANSI color table from escape.c — used for reverse-mapping to Kitty indices.
+# Must match the built-in default palette in src/term/palette.c.
+_ANSI_COLORS = [
+    0xFF585B70, 0xFFCC6666, 0xFFB5BD68, 0xFFF0C674,
+    0xFF81A2BE, 0xFFB294BB, 0xFF8ABEB7, 0xFFC5C8C6,
+    0xFF666666, 0xFFD54E53, 0xFFB9CA4A, 0xFFE7C547,
+    0xFF7AA6DA, 0xFFC397D8, 0xFF70C0B1, 0xFFEAEAEA,
+]
+
+
+def _build_color_table():
+    """Build a reverse lookup from RGB (0xFFRRGGBB) to Kitty indexed color."""
+    table = {}
+    for i, rgb in enumerate(_ANSI_COLORS):
+        table[rgb] = (i << 8) | 1
+    levels = [0, 95, 135, 175, 215, 255]
+    for i in range(16, 232):
+        n = i - 16
+        r, g, b = levels[n // 36], levels[(n // 6) % 6], levels[n % 6]
+        rgb = 0xFF000000 | (r << 16) | (g << 8) | b
+        table[rgb] = (i << 8) | 1
+    for i in range(232, 256):
+        gray = 8 + (i - 232) * 10
+        rgb = 0xFF000000 | (gray << 16) | (gray << 8) | gray
+        table[rgb] = (i << 8) | 1
+    return table
+
+
+_COLOR_TO_KITTY = _build_color_table()
+
+
+TERM_COLOR_REF = 0x01000000
+
+
+def _convert_color(color):
+    """Convert our cell color to Kitty's format.
+
+    Ours: a palette reference (top byte 0x01; slot 0-255, 0x100 default fg,
+    0x101 default bg) or a literal 0xFFRRGGBB color.
+
+    Kitty format:
+      0           = default
+      index<<8|1  = indexed (0-255)
+      r<<24|g<<16|b<<8|2 = RGB
+    """
+    if (color >> 24) == (TERM_COLOR_REF >> 24):
+        slot = color & 0x1FF
+        return 0 if slot >= 0x100 else (slot << 8) | 1
+    if color == TERM_DEFAULT_FG or color == TERM_DEFAULT_BG:
+        return 0
+    kitty = _COLOR_TO_KITTY.get(color)
+    if kitty is not None:
+        return kitty
+    r = (color >> 16) & 0xFF
+    g = (color >> 8) & 0xFF
+    b = color & 0xFF
+    return (r << 24) | (g << 16) | (b << 8) | 2
+
+
+# ---------------------------------------------------------------------------
+# Screen property readers
+# ---------------------------------------------------------------------------
+
+def _read_property(ptr, name):
+    return getattr(_lib, 'kitty_screen_' + name)(ptr)
+
+
+# ---------------------------------------------------------------------------
+# Cursor — wraps the terminal's current cursor SGR state + position
+# ---------------------------------------------------------------------------
+
+class Cursor:
+    """Wraps the terminal's current cursor state (SGR attributes + position)."""
+
+    def __init__(self, screen):
+        self._screen = screen
+
+    @property
+    def _ptr(self):
+        return self._screen._ptr
+
+    # -- position --
+    @property
+    def x(self):
+        return _lib.kitty_term_cursor_x(self._screen._term)
+
+    @property
+    def y(self):
+        return _lib.kitty_term_cursor_y(self._screen._term)
+
+    # -- SGR boolean attributes --
+    @property
+    def bold(self):
+        return _read_property(self._ptr, 'bold')
+
+    @property
+    def italic(self):
+        return _read_property(self._ptr, 'italic')
+
+    @property
+    def dim(self):
+        return _read_property(self._ptr, 'faint')
+
+    @property
+    def reverse(self):
+        return _read_property(self._ptr, 'inverse')
+
+    @property
+    def strikethrough(self):
+        return _read_property(self._ptr, 'strike')
+
+    @property
+    def decoration(self):
+        # Kitty: 0=none, 1=straight, 2=double, 3=curly, 4=dotted, 5=dashed
+        return _read_property(self._ptr, 'underline')
+
+    # -- colors --
+    @property
+    def fg(self):
+        return _convert_color(_read_property(self._ptr, 'cur_fg'))
+
+    @property
+    def bg(self):
+        return _convert_color(_read_property(self._ptr, 'cur_bg'))
+
+    # -- cursor style --
+    @property
+    def blink(self):
+        return _lib.kitty_term_cursor_blink(self._screen._term)
+
+    @property
+    def shape(self):
+        return _lib.kitty_term_cursor_style(self._screen._term)
+
+
+# ---------------------------------------------------------------------------
+# CellCursor — wraps a single cell's attributes
+# ---------------------------------------------------------------------------
+
+class CellCursor:
+    """Wraps a single cell's attributes for SGR inspection."""
+
+    def __init__(self, cell):
+        self._cell = cell
+
+    @property
+    def bold(self):
+        return bool(self._cell.attrs & TERM_ATTR_BOLD)
+
+    @property
+    def italic(self):
+        return bool(self._cell.attrs & TERM_ATTR_ITALIC)
+
+    @property
+    def dim(self):
+        return bool(self._cell.attrs & TERM_ATTR_FAINT)
+
+    @property
+    def reverse(self):
+        # Our terminal swaps fg/bg when inverse is set, so cells don't
+        # carry a separate inverse flag.
+        return False
+
+    @property
+    def strikethrough(self):
+        return bool(self._cell.attrs & TERM_ATTR_STRIKE)
+
+    @property
+    def decoration(self):
+        # enum term_underline uses Kitty's numbers: 0=none, 1=straight,
+        # 2=double, 3=curly, 4=dotted, 5=dashed.
+        return (self._cell.attrs & TERM_ATTR_UNDERLINE_MASK) >> TERM_ATTR_UNDERLINE_SHIFT
+
+    @property
+    def fg(self):
+        return _convert_color(self._cell.fg)
+
+    @property
+    def bg(self):
+        return _convert_color(self._cell.bg)
+
+
+# ---------------------------------------------------------------------------
+# Line — wraps a screen line, providing cell access
+# ---------------------------------------------------------------------------
+
+class Line:
+    """Wraps a screen line, providing cell access and text content."""
+
+    def __init__(self, screen, y):
+        self._screen = screen
+        self._y = y
+
+    def cursor_from(self, x):
+        """Return a :class:`CellCursor` for cell (x, y)."""
+        cell = TermCell()
+        if not _lib.kitty_term_cell(self._screen._term, x, self._y, ctypes.byref(cell)):
+            return CellCursor(TermCell())
+        return CellCursor(cell)
+
+    def __str__(self):
+        """Return the text content of the line up to the written length."""
+        length = min(_lib.kitty_screen_row_length(self._screen._term, self._y),
+                     self._screen.columns)
+        if length == 0:
+            return ''
+        result = []
+        cell = TermCell()
+        cps = (ctypes.c_uint32 * _CLUSTER_CAP)()
+        for x in range(length):
+            if not _lib.kitty_term_cell(self._screen._term, x, self._y, ctypes.byref(cell)):
+                result.append(' ')
+                continue
+            # Width 0 is the right half of a wide glyph.
+            if cell.width == 0:
+                continue
+            if _lib.kitty_screen_cell_is_tab(self._screen._term, x, self._y):
+                result.append('\t')
+                continue
+            n = _lib.kitty_term_cell_text(self._screen._term, x, self._y, cps, _CLUSTER_CAP)
+            n = min(n, _CLUSTER_CAP)
+            result.append(''.join(chr(cp) for cp in cps[:n]))
+        return ''.join(result)
+
+
+# ---------------------------------------------------------------------------
+# Callbacks — mock callbacks object for OSC/DCS responses
+# ---------------------------------------------------------------------------
+
+class Callbacks:
+    """Mock callbacks object for OSC/DCS responses."""
+
+    def __init__(self, screen=None):
+        self._screen = screen
+        self.wtcbuf = b''
+        self.titlebuf = []
+        self.iconbuf = ''
+        self.colorbuf = ''
+        self.notifications = []
+        self.printbuf = []
+
+    def clear(self):
+        self.wtcbuf = b''
+        self.titlebuf = []
+        self.iconbuf = ''
+        self.colorbuf = ''
+        self.notifications = []
+        self.printbuf = []
+        if self._screen is not None:
+            self._screen._response_buf.clear()
+
+
+# ---------------------------------------------------------------------------
+# Screen — main screen wrapper using ctypes
+# ---------------------------------------------------------------------------
+
+class Screen:
+    """Main screen wrapper using ctypes to drive the C terminal."""
+
+    def __init__(self, cols=80, rows=5):
+        self._cols = cols
+        self._rows = rows
+        self._response_buf = bytearray()
+        self._write_buf = bytearray()
+        self._callbacks = Callbacks(self)
+        # Keep a reference to the callback function so it isn't GC'd
+        self._resp_fn = REPLY_FN(self._on_response)
+        self._term = _lib.kitty_term_new(cols, rows, self._resp_fn, None)
+        if not self._term:
+            raise RuntimeError('kitty_term_new failed')
+
+    @property
+    def _ptr(self):
+        return ctypes.cast(self._term, ctypes.c_void_p).value
+
+    # -- response callback --
+    def _on_response(self, ud, data, length):
+        if data and length:
+            self._response_buf.extend(data[:length])
+        self._callbacks.wtcbuf = bytes(self._response_buf)
+
+    # -- writing --
+    def write(self, data):
+        if data:
+            _lib.kitty_term_write(self._term, bytes(data), len(data))
+
+    # -- test write buffer API (matches Kitty's test_parse interface) --
+    def test_create_write_buffer(self):
+        """Return the available space in the write buffer (int, falsy when full)."""
+        from fast_data_types import VT_PARSER_BUFFER_SIZE
+        return VT_PARSER_BUFFER_SIZE - len(self._write_buf)
+
+    def test_commit_write_buffer(self, data, write_buf):
+        """Append *data* to the internal write buffer, return bytes consumed."""
+        from fast_data_types import VT_PARSER_BUFFER_SIZE
+        available = VT_PARSER_BUFFER_SIZE - len(self._write_buf)
+        n = min(len(data), available)
+        if n > 0:
+            self._write_buf.extend(data[:n])
+        return n
+
+    def test_parse_written_data(self, cd=None):
+        """Parse the write buffer, dispatching to the C terminal and callback."""
+        data = bytes(self._write_buf)
+        self._write_buf.clear()
+        from kitty_parser import parse_bytes
+        if cd is not None:
+            parse_bytes(self, data, cd)
+        elif data:
+            # No callback — still parse to keep parser state in sync
+            parse_bytes(self, data, lambda *a: None)
+
+    # -- properties --
+    @property
+    def cursor(self):
+        return Cursor(self)
+
+    @property
+    def callbacks(self):
+        return self._callbacks
+
+    @property
+    def columns(self):
+        return _lib.kitty_term_cols(self._term)
+
+    @property
+    def lines(self):
+        return _lib.kitty_term_rows(self._term)
+
+    @property
+    def margin_top(self):
+        return _read_property(self._ptr, 'scroll_top')
+
+    @property
+    def margin_bottom(self):
+        return _read_property(self._ptr, 'scroll_bottom')
+
+    @property
+    def cursor_key_mode(self):
+        return _lib.kitty_term_application_cursor(self._term)
+
+    @cursor_key_mode.setter
+    def cursor_key_mode(self, value):
+        if value:
+            self.write(b'\x1b[?1h')
+        else:
+            self.write(b'\x1b[?1l')
+
+    # -- line access --
+    def line(self, n):
+        return Line(self, n)
+
+    # -- operations --
+    def reset(self):
+        self.write(b'\x1bc')
+
+    def cursor_move(self, n):
+        """Move cursor back n cells (kitty cursor_move: direction -1,
+        allowed to move to previous lines)."""
+        self.write(b'\x1b[' + str(n).encode() + b'D')
+
+    def close(self):
+        """Destroy the underlying C terminal."""
+        if getattr(self, '_term', None):
+            _lib.kitty_term_free(self._term)
+            self._term = None
+
+    def __del__(self):
+        self.close()
diff --git a/tests/extern/kitty/screen_bridge.c b/tests/extern/kitty/screen_bridge.c
new file mode 100644
index 0000000..63a3583
--- /dev/null
+++ b/tests/extern/kitty/screen_bridge.c
@@ -0,0 +1,113 @@
+/* Test-only entry points for the Kitty screen wrapper in screen.py.
+ * Python calls only these functions, so it needs no struct layouts other
+ * than the public struct term_cell. The kitty_screen_* accessors read
+ * properties that term.h does not expose. They compile against the current
+ * terminal layout rather than duplicating byte offsets in Python. */
+#include "internal.h"
+#include "screen.h"
+
+typedef void (*kitty_reply_fn)(void *ud, const char *bytes, size_t len);
+
+struct term *kitty_term_new(int cols, int rows, kitty_reply_fn reply, void *ud)
+{
+    return term_new(&(struct term_options){
+        .size = { .x = cols, .y = rows },
+        .callbacks = { .ud = ud, .reply = reply },
+    });
+}
+
+/* One snapshot serves every cell read. */
+static struct term_snapshot *snap;
+
+void kitty_term_free(struct term *t)
+{
+    /* A new terminal can get the address of the freed one. The snapshot
+     * would then keep its rows, so it goes away too. */
+    term_snapshot_free(snap);
+    snap = NULL;
+    term_free(t);
+}
+
+void kitty_term_write(struct term *t, const char *bytes, size_t len)
+{
+    term_feed(t, bytes, len, 0);
+}
+
+bool kitty_term_resize(struct term *t, int cols, int rows)
+{
+    return term_resize(t, (struct term_vector2i){ .x = cols, .y = rows });
+}
+
+int kitty_term_cols(struct term *t) { return term_size(t).x; }
+int kitty_term_rows(struct term *t) { return term_size(t).y; }
+int kitty_term_cursor_x(struct term *t) { return term_cursor(t).pos.x; }
+int kitty_term_cursor_y(struct term *t) { return term_cursor(t).pos.y; }
+int kitty_term_cursor_style(struct term *t) { return (int)term_cursor(t).style; }
+bool kitty_term_cursor_blink(struct term *t) { return term_cursor(t).blink; }
+bool kitty_term_application_cursor(struct term *t) { return term_modes(t).app_cursor; }
+
+/* Update the snapshot from the live screen, as a renderer reads it.
+ * Returns NULL when the cell is out of range or memory runs out. */
+static struct term_snapshot *cell_snapshot(struct term *t, int col, int row)
+{
+    struct term_vector2i size = term_size(t);
+    if (col < 0 || col >= size.x || row < 0 || row >= size.y)
+        return NULL;
+    if (!snap)
+        snap = term_snapshot_new();
+    term_scroll_to(t, 0);
+    if (!snap || !term_snapshot_update(snap, t))
+        return NULL;
+    return snap;
+}
+
+bool kitty_term_cell(struct term *t, int col, int row, struct term_cell *out)
+{
+    struct term_snapshot *s = cell_snapshot(t, col, row);
+    if (!s)
+        return false;
+    *out = term_snapshot_row(s, row)[col];
+    return true;
+}
+
+/* The code points of a cell's text: one, or a whole grapheme cluster.
+ * Returns the number of code points and writes at most cap of them. */
+int kitty_term_cell_text(struct term *t, int col, int row, uint32_t *cps, int cap)
+{
+    struct term_snapshot *s = cell_snapshot(t, col, row);
+    if (!s)
+        return 0;
+    return term_snapshot_cluster(s, term_snapshot_row(s, row)[col].text, cps, cap);
+}
+
+#define PROPERTY(type, name) \
+    type kitty_screen_##name(struct term *t) { return t->name; }
+
+PROPERTY(int, scroll_top)
+PROPERTY(int, scroll_bottom)
+PROPERTY(uint32_t, cur_fg)
+PROPERTY(uint32_t, cur_bg)
+PROPERTY(bool, bold)
+PROPERTY(bool, faint)
+PROPERTY(bool, italic)
+PROPERTY(bool, strike)
+PROPERTY(bool, inverse)
+PROPERTY(uint8_t, underline)
+
+int kitty_screen_row_length(struct term *t, int row)
+{
+    if (!t || row < 0 || row >= t->rows) return 0;
+    const struct srow *r = term_screen_row(t, row);
+    return r ? (int)r->len : 0;
+}
+
+/* A tab stores a marker cell that a snapshot shows as a blank. Kitty keeps
+ * the tab in its line text, so the wrapper asks for the marker. */
+bool kitty_screen_cell_is_tab(struct term *t, int col, int row)
+{
+    if (col < 0 || col >= t->cols || row < 0 || row >= t->rows)
+        return false;
+    term_scroll_to(t, 0);
+    const struct cell *cells = term_screen_view_row(t, row);
+    return cells && cells[col].c == '\t';
+}