PR review follow-ups

Rolling up all post-initial-push fixes from CI, Copilot review, and
the second-round review agent into one commit.

Loader & tests
- Honour `(fboundp 'ghostel--new)' in the unified module loader so
  `cl-letf' stubs in the pure-Elisp test suite short-circuit as they
  did before the consolidation.  Restores the title-tracking tests
  on the elisp-only CI job.

CRLF across calls
- Persist `last_input_was_cr' on the Terminal struct so a CRLF pair
  split across two `ghostel--write-input' calls isn't double-
  normalized into \r\r\n.  Reset in `resize' alongside the other
  reset state.  Regression tests: canonical split, empty chunk
  between CR and LF, standalone CR followed by complete CRLF.

OSC iterator correctness
- Treat a following `\e]' introducer as a payload boundary so one
  OSC missing its terminator doesn't cannibalize the next OSC's
  bytes as its own payload.  Input `\e]7;PARTIAL\e]52;c;aGVsbG8=\a'
  previously dispatched OSC 7 with garbage and starved OSC 52
  entirely; now OSC 7 is recognized as partial and skipped, OSC 52
  dispatches normally.  Regression test added.
- Rename `OscEntry.term' -> `OscEntry.terminator' to remove the
  visual collision with `Terminal *term' in dispatchPostWriteOscs.
- Clarify the `dispatchPostWriteOscs' docstring: it handles the
  four post-vtWrite OSCs; color queries use the same iterator from
  a different call site.

Redraw hash gate
- Skip `computeFirstScrollbackRowHash' at end-of-redraw when no
  writes happened this frame and the start-of-redraw rotation
  check didn't populate `cached_row0_hash'.  Row 0 can't have
  moved, so the stored hash is still current.  Covers cursor-only
  and idle-timer redraws.

Naming and comments
- Rename `last_wrote_cr' -> `last_input_was_cr': the field names
  the input-stream property, not a normalizer implementation
  detail that might change underneath it.
- `loadRawCell' docstring notes the memoize assumes idempotent
  fetch (true today in libghostty).

README
- Refresh the 5 MB PTY throughput table: ghostel 70 -> 87 MB/s
  plain, 56 -> 64 MB/s URL-heavy.  Other backends within noise.

Author: dakra

README.md

@@ -646,11 +646,11 @@ Emacs 31.0.50:
 
 | Backend              | Plain ASCII | URL-heavy |
 |----------------------|------------:|----------:|
-| ghostel              |    70 MB/s  |  56 MB/s  |
-| ghostel (no detect)  |    70 MB/s  |  70 MB/s  |
-| vterm                |    34 MB/s  |  27 MB/s  |
-| eat                  |   4.4 MB/s  | 3.5 MB/s  |
-| term                 |   5.6 MB/s  | 4.7 MB/s  |
+| ghostel              |    87 MB/s  |  64 MB/s  |
+| ghostel (no detect)  |    86 MB/s  |  86 MB/s  |
+| vterm                |    35 MB/s  |  27 MB/s  |
+| eat                  |   4.7 MB/s  | 3.5 MB/s  |
+| term                 |   5.7 MB/s  | 4.7 MB/s  |
 
 Ghostel scans terminal output for URLs and file paths, making them clickable.
 The "no detect" row shows throughput with this detection disabled

ghostel.el

@@ -675,8 +675,13 @@ When the module file is missing, trigger `ghostel-module-auto-install'.
 When PROMPT-USER is non-nil (called from an interactive command like
 `ghostel'), failures signal `user-error' so the calling flow aborts.
 Otherwise (load time), failures `display-warning' instead so the user
-can still compile ghostel, read docs, and so on."
-  (unless (featurep 'ghostel-module)
+can still compile ghostel, read docs, and so on.
+
+The guard also honours `ghostel--new' being already `fboundp', which
+covers the pure-Elisp test path where `cl-letf' stubs the native
+entry points so tests run without the module present."
+  (unless (or (featurep 'ghostel-module)
+              (fboundp 'ghostel--new))
     (let* ((dir (file-name-directory (or load-file-name
                                          (locate-library "ghostel")
                                          buffer-file-name)))

src/module.zig

@@ -157,8 +157,14 @@ fn fnWriteInput(raw_env: ?*c.emacs_env, _: isize, args: [*c]c.emacs_value, _: ?*
     // and then "\r\n".  libghostty's VT state machine handles arbitrary
     // chunking (that's how the process filter already works), so no
     // scratch buffer, no allocation, no truncation fallback.
+    //
+    // `prev_was_cr` is seeded from `term.last_input_was_cr` so a CRLF
+    // pair split across two writes — chunk A ending with \r, chunk B
+    // starting with \n — is not mis-normalized into \r\r\n.  The final
+    // value is persisted back for the next call. An empty input
+    // round-trips the flag unchanged.
     var seg_start: usize = 0;
-    var prev_was_cr: bool = false;
+    var prev_was_cr: bool = term.last_input_was_cr;
     for (raw, 0..) |ch, i| {
         if (ch == '\n' and !prev_was_cr) {
             if (i > seg_start) term.vtWrite(raw[seg_start..i]);
@@ -172,6 +178,7 @@ fn fnWriteInput(raw_env: ?*c.emacs_env, _: isize, args: [*c]c.emacs_value, _: ?*
     if (seg_start < raw.len) {
         term.vtWrite(raw[seg_start..]);
     }
+    term.last_input_was_cr = prev_was_cr;
 
     // Scan for OSC sequences that libghostty-vt discards (7, 51, 52, 133).
     // One pass, dispatched by code in document order.
@@ -191,14 +198,22 @@ const OscEntry = struct {
     /// Payload bytes between the code's trailing `;` and the terminator.
     payload: []const u8,
     /// Terminator bytes (BEL or ESC \) — forwarded back on replies.
-    term: []const u8,
+    terminator: []const u8,
 };
 
 /// Single-pass iterator over well-formed OSC sequences in a byte slice.
 /// Advances past `ESC ]`, parses the decimal code up to `;`, locates the
-/// BEL/ST terminator, and yields `(code, payload, term)`. Partial
-/// sequences at the end of the buffer stop iteration so the caller
-/// doesn't act on half-received data.
+/// BEL/ST terminator, and yields `(code, payload, terminator)`.
+///
+/// An OSC payload is bounded by a real terminator (BEL or ESC \) OR by
+/// the next OSC introducer (ESC ]).  Stopping at a following introducer
+/// handles malformed input where one OSC is missing its terminator
+/// before the next begins — otherwise the partial OSC would cannibalize
+/// the following OSC's bytes (including its terminator) as its own
+/// payload, producing a garbage dispatch AND starving the next OSC.
+/// On partial detection we advance past the current introducer and let
+/// iteration continue, so well-formed OSCs later in the same buffer
+/// still dispatch.
 const OscIterator = struct {
     data: []const u8,
     pos: usize = 0,
@@ -222,43 +237,57 @@ const OscIterator = struct {
             }
             const payload_start = code_end + 1;
 
-            // Terminator search. A partial OSC (no terminator before EOF)
-            // stops iteration entirely: bytes after an unterminated payload
-            // are opaque, so there's no safe way to continue scanning.
+            // Scan for a terminator (BEL or ESC \) or the next OSC
+            // introducer (ESC ]), whichever comes first. An intervening
+            // introducer means the current OSC is partial.
             var end = payload_start;
             var term_len: usize = 0;
             while (end < self.data.len) : (end += 1) {
-                if (self.data[end] == 0x07) {
+                const ch = self.data[end];
+                if (ch == 0x07) {
                     term_len = 1;
                     break;
                 }
-                if (self.data[end] == 0x1b and end + 1 < self.data.len and self.data[end + 1] == '\\') {
-                    term_len = 2;
-                    break;
+                if (ch == 0x1b and end + 1 < self.data.len) {
+                    const next_ch = self.data[end + 1];
+                    if (next_ch == '\\') {
+                        term_len = 2;
+                        break;
+                    }
+                    if (next_ch == ']') {
+                        // Next introducer — current OSC is partial.
+                        break;
+                    }
                 }
             }
             if (term_len == 0) {
-                self.pos = self.data.len;
-                return null;
+                // Partial OSC: skip past the current introducer (which
+                // we already parsed) and resume scanning. If `end` is
+                // still `self.data.len` there were no more introducers,
+                // and the next indexOfPos call will terminate iteration.
+                self.pos = if (end > code_start) end else code_start;
+                continue;
             }
 
             self.pos = end + term_len;
             const code = std.fmt.parseInt(u32, self.data[code_start..code_end], 10) catch continue;
             return .{
                 .code = code,
                 .payload = self.data[payload_start..end],
-                .term = self.data[end .. end + term_len],
+                .terminator = self.data[end .. end + term_len],
             };
         }
         return null;
     }
 };
 
 /// Dispatch OSC 7 / 51 / 52 / 133 from `data` in document order.
-/// These are the sequences that libghostty-vt discards, so ghostel
-/// has to scan for them itself.  All four used to scan the buffer
-/// independently; one unified pass is strictly less work for bulk
-/// output and preserves source-order dispatch.
+/// These are the post-vtWrite sequences that libghostty-vt discards,
+/// so ghostel has to scan for them itself.  All four used to scan the
+/// buffer independently; one unified pass is strictly less work for
+/// bulk output and preserves source-order dispatch.  (OSC 4/10/11
+/// color queries use the same iterator but run before vtWrite — see
+/// `extractOscColorQueries`.)
 ///
 /// Runs AFTER `vtWrite` so libghostty has already seen the bytes —
 /// OSC 7 calls back into libghostty (`setPwd`) and the others call
@@ -388,13 +417,13 @@ fn extractOscColorQueries(env: emacs.Env, term: *Terminal, data: []const u8) voi
                 if (!std.mem.eql(u8, osc.payload, "?")) continue;
                 var fg: gt.ColorRgb = undefined;
                 if (!term.getColorForeground(&fg)) continue;
-                sendDynamicColorReply(env, 10, fg, osc.term);
+                sendDynamicColorReply(env, 10, fg, osc.terminator);
             },
             11 => {
                 if (!std.mem.eql(u8, osc.payload, "?")) continue;
                 var bg: gt.ColorRgb = undefined;
                 if (!term.getColorBackground(&bg)) continue;
-                sendDynamicColorReply(env, 11, bg, osc.term);
+                sendDynamicColorReply(env, 11, bg, osc.terminator);
             },
             4 => {
                 // Payload is a ';'-separated list of `index;value` pairs.
@@ -409,7 +438,7 @@ fn extractOscColorQueries(env: emacs.Env, term: *Terminal, data: []const u8) voi
                         if (!term.getColorPalette(&palette)) break;
                         palette_loaded = true;
                     }
-                    sendPaletteColorReply(env, @intCast(idx), palette[idx], osc.term);
+                    sendPaletteColorReply(env, @intCast(idx), palette[idx], osc.terminator);
                 }
             },
             else => {},

src/render.zig

@@ -94,6 +94,12 @@ const RawTag = enum { unset, loaded, failed };
 
 /// Lazily populate `out` with the raw cell; memoizes success/failure
 /// in `tag` so repeated calls within one cell do not re-issue the get.
+///
+/// The cache assumes `cells_get(RAW)` is idempotent for a given
+/// iterator position (which it is in libghostty today — it returns a
+/// handle into already-materialized cell data).  If that ever
+/// changes, a failed first call would become sticky for the rest of
+/// the current cell.
 fn loadRawCell(cells: gt.RenderStateRowCells, out: *gt.c.GhosttyCell, tag: *RawTag) bool {
     switch (tag.*) {
         .unset => {
@@ -1291,8 +1297,18 @@ pub fn redraw(env: emacs.Env, term: *Terminal, force_full_arg: bool) void {
     // rotation check. Reuse the start-of-redraw hash when it's still
     // valid (no rotation, no trim) — avoids a second scroll-to-top +
     // render_state_update round trip per redraw.
+    //
+    // If nothing was written AND we didn't populate `cached_row0_hash`
+    // at the top, row 0 cannot have moved since the previous redraw
+    // set `first_scrollback_row_hash`, so skip the compute entirely.
+    // This covers cursor-only redraws and idle-timer fires.
     if (term.scrollback_in_buffer > 0) {
-        term.first_scrollback_row_hash = cached_row0_hash orelse computeFirstScrollbackRowHash(term);
+        if (cached_row0_hash) |h| {
+            term.first_scrollback_row_hash = h;
+        } else if (term.wrote_since_redraw) {
+            term.first_scrollback_row_hash = computeFirstScrollbackRowHash(term);
+        }
+        // else: no writes, no cached hash → existing value is still current.
     } else {
         term.first_scrollback_row_hash = 0;
     }

src/terminal.zig

@@ -49,6 +49,18 @@ wrote_since_redraw: bool = false,
 /// into the redraw pass where `inhibit-redisplay` prevents flicker.
 resize_pending: bool = false,
 
+/// True iff the last byte of the previous `fnWriteInput` input was
+/// `\r`. Carries the bare-LF detection state across write-input calls
+/// so that a CR at the tail of one write and an LF at the head of the
+/// next don't get normalized into an extra `\r` (producing `\r\r\n`).
+///
+/// Named after the input stream rather than what was fed to libghostty
+/// because the two only differ in that the normalizer may insert a
+/// `\r` before a bare LF — it never drops or rewrites a trailing CR.
+/// Reset by `resize` since a reflow means the stream is effectively
+/// new.
+last_input_was_cr: bool = false,
+
 /// Hash of the first scrollback row's content, sampled at the end of
 /// each redraw that touched scrollback. Used to detect rotation
 /// (libghostty evicting the oldest row in lockstep with new ones being
@@ -226,6 +238,7 @@ pub fn resize(self: *Self, cols: u16, rows: u16) !void {
     self.scrollback_in_buffer = 0;
     self.first_scrollback_row_hash = 0;
     self.resize_pending = true;
+    self.last_input_was_cr = false;
 }
 
 /// Scroll the viewport.

test/ghostel-test.el

@@ -643,6 +643,50 @@ than the full terminal `cols'."
       (should (equal 6 (car cur)))                          ; cursor col after LF
       (should (> (cdr cur) 0)))))                           ; cursor moved to row 1+
 
+(ert-deftest ghostel-test-crlf-split-across-writes ()
+  "CRLF pair split across two write-input calls must not double-insert \\r.
+Chunk A ends with \\r, chunk B starts with \\n.  Without cross-call
+state the normalizer would treat the leading \\n as bare and emit
+\\r\\r\\n to libghostty.  Visible effect: cursor lands on row 1 col 6
+after \"first\\r\" + \"\\nsecond\", exactly as if the pair were sent in
+one call; a bug would leave it on row 2 or otherwise desynced."
+  (let ((term (ghostel--new 25 80 1000))
+        (term-single (ghostel--new 25 80 1000)))
+    (ghostel--write-input term "first\r")
+    (ghostel--write-input term "\nsecond")
+    (ghostel--write-input term-single "first\r\nsecond")
+    (should (equal (ghostel-test--cursor term)
+                   (ghostel-test--cursor term-single)))))
+
+(ert-deftest ghostel-test-crlf-split-with-empty-chunk ()
+  "An empty write between \\r and \\n preserves the cross-call CR flag.
+Regression guard for a naive implementation that resets `last_input_was_cr'
+on every entry rather than only when input was consumed."
+  (let ((term (ghostel--new 25 80 1000))
+        (term-single (ghostel--new 25 80 1000)))
+    (ghostel--write-input term "first\r")
+    (ghostel--write-input term "")          ; empty chunk must not clear flag
+    (ghostel--write-input term "\nsecond")
+    (ghostel--write-input term-single "first\r\nsecond")
+    (should (equal (ghostel-test--cursor term)
+                   (ghostel-test--cursor term-single)))))
+
+(ert-deftest ghostel-test-crlf-standalone-cr-then-crlf ()
+  "A lone CR followed by a complete CRLF stays two logical line-endings.
+The normalizer must not collapse the trailing CR of write A and the
+leading \\r of write B's \\r\\n into a single sequence: the input
+\"a\\r\" + \"\\r\\nb\" is equivalent to sending \"a\\r\\r\\nb\" in one
+call.  (Bare \\n comes from Emacs PTYs lacking ONLCR; bare \\r from
+programs that explicitly emit a carriage return — both must be passed
+through without cross-call munging.)"
+  (let ((term (ghostel--new 25 80 1000))
+        (term-single (ghostel--new 25 80 1000)))
+    (ghostel--write-input term "a\r")
+    (ghostel--write-input term "\r\nb")
+    (ghostel--write-input term-single "a\r\r\nb")
+    (should (equal (ghostel-test--cursor term)
+                   (ghostel-test--cursor term-single)))))
+
 ;; -----------------------------------------------------------------------
 ;; Test: raw key sequence fallback
 ;; -----------------------------------------------------------------------
@@ -993,6 +1037,25 @@ Mirrors the real zsh case where the directory still contains a
       (ghostel--write-input term "\e]52;c;?\e\\")
       (should (equal nil kill-ring)))))                     ; osc52 query ignored
 
+(ert-deftest ghostel-test-osc-partial-does-not-starve-later ()
+  "A partial OSC must not cannibalize or starve a following complete OSC.
+Input \"\\e]7;PARTIAL\\e]52;c;aGVsbG8=\\a\" would, under a naive
+single-pass scanner, let the OSC 7 payload absorb the OSC 52's BEL
+terminator — yielding a garbage PWD dispatch and no clipboard.  The
+iterator must treat the intervening \\e] as a partial-OSC boundary,
+skip the OSC 7, and still dispatch the OSC 52."
+  (let ((term (ghostel--new 25 80 1000))
+        (ghostel-enable-osc52 t)
+        (kill-ring nil)
+        (pwd-before (ghostel--get-pwd (ghostel--new 25 80 1000))))
+    (ghostel--write-input term "\e]7;PARTIAL\e]52;c;aGVsbG8=\a")
+    ;; OSC 52 dispatched: "hello" in kill-ring.
+    (should kill-ring)
+    (should (equal "hello" (car kill-ring)))
+    ;; OSC 7 NOT dispatched with the garbage payload "PARTIAL\e]52;c;aGVsbG8="
+    ;; — the PWD should still be whatever a fresh terminal reports (nil).
+    (should (equal pwd-before (ghostel--get-pwd term)))))
+
 ;; -----------------------------------------------------------------------
 ;; Test: OSC 4/10/11 color query responses
 ;; -----------------------------------------------------------------------