fix(ui): strip ANSI escapes from terminal selection (copy/paste)

Markdown rendering bakes SGR codes (`\x1b[31m` …) directly into
`LineEntry::text` for inline-styled spans (see markdown.rs:291).
Without filtering, a user dragging to select styled text — bold,
emphasis, code spans, diff highlights — copied the raw escape
sequences into the clipboard. Paste lands in editors / shells as
visible `[31m` garbage and the actual content fragmented around it.

- New `ui::ansi::strip_ansi(&str) -> String` shares the CSI-skip
  loop with `wrap::visible_width` (terminator set 0x40..=0x7E so
  cursor-moves / scroll-region escapes also strip — anything a
  misbehaving producer might leave in the buffer). Lone ESC (not
  followed by `[`) also drops, defensive against truncated
  OSC/DCS heads.
- `Renderer::selected_text` strips per-row before applying the
  column slice. Selection columns are user-perceived character
  offsets in the visible glyphs, so column-indexing the cleaned
  string is correct; the prior implementation column-indexed
  the escape-laden source, which could land mid-escape and
  produce mojibake on the substring path too.

Tests: 7 new — 6 ANSI-strip cases (SGR sequences, nested escapes,
lone ESC, unicode payload, non-SGR CSI, truncated escape) + 1
end-to-end through selected_text. 1071 → 1078 with plugin
feature; 866 → 873 without.

Author: Yogthos

src/ui/ansi.rs

@@ -100,6 +100,53 @@ pub fn strip_controls_compact(s: &str, policy: StripPolicy) -> CompactString {
     CompactString::from(out)
 }
 
+/// Strip ANSI CSI escape sequences (`\x1b[…m` and friends) from `s`,
+/// returning a clean printable string. Used by clipboard / selection
+/// paths: the renderer bakes SGR codes into `LineEntry::text` for
+/// inline-styled markdown (see markdown.rs:291), and we don't want
+/// the user copying `\x1b[31mbold\x1b[0m` into their clipboard.
+///
+/// Mirrors the CSI-skip loop in `wrap::visible_width` (line 37) so
+/// the two stay consistent. Final-byte range matches the ECMA-48 CSI
+/// terminator set (0x40..=0x7E) so non-SGR sequences (cursor moves,
+/// scroll regions) also strip cleanly — anything a misbehaving
+/// producer might leave behind in the buffer.
+pub fn strip_ansi(s: &str) -> String {
+    let bytes = s.as_bytes();
+    let mut out = String::with_capacity(s.len());
+    let mut i = 0;
+    while i < bytes.len() {
+        if bytes[i] == 0x1b && i + 1 < bytes.len() && bytes[i + 1] == b'[' {
+            // CSI introducer. Skip to (and past) the final byte in
+            // the 0x40..=0x7E range.
+            let mut j = i + 2;
+            while j < bytes.len() && !(0x40..=0x7e).contains(&bytes[j]) {
+                j += 1;
+            }
+            i = j.saturating_add(1).min(bytes.len());
+            continue;
+        }
+        // Single ESC not followed by `[` — drop it alone to be
+        // safe (could be an OSC/DCS start; better not to copy).
+        if bytes[i] == 0x1b {
+            i += 1;
+            continue;
+        }
+        // UTF-8 step.
+        let step = match bytes[i] {
+            b if b < 0x80 => 1,
+            b if b < 0xC0 => 1,
+            b if b < 0xE0 => 2,
+            b if b < 0xF0 => 3,
+            _ => 4,
+        };
+        let end = (i + step).min(bytes.len());
+        out.push_str(&s[i..end]);
+        i = end;
+    }
+    out
+}
+
 fn keep_char(c: char, policy: StripPolicy) -> bool {
     let cp = c as u32;
     if cp == 0x0A {
@@ -157,6 +204,49 @@ mod tests {
         }
     }
 
+    #[test]
+    fn strip_ansi_removes_sgr_sequences_keeps_payload() {
+        let s = "hello \x1b[31mred\x1b[0m world";
+        assert_eq!(strip_ansi(s), "hello red world");
+    }
+
+    #[test]
+    fn strip_ansi_handles_consecutive_and_nested_escapes() {
+        let s = "\x1b[1m\x1b[31mbold-red\x1b[0m\x1b[0m";
+        assert_eq!(strip_ansi(s), "bold-red");
+    }
+
+    #[test]
+    fn strip_ansi_drops_lone_esc() {
+        // ESC not followed by `[` — drop it on its own to keep the
+        // clipboard payload safe (could be the head of an OSC/DCS).
+        let s = "a\x1bb";
+        assert_eq!(strip_ansi(s), "ab");
+    }
+
+    #[test]
+    fn strip_ansi_preserves_unicode_payload() {
+        let s = "\x1b[32m日本語\x1b[0m 🚀";
+        assert_eq!(strip_ansi(s), "日本語 🚀");
+    }
+
+    #[test]
+    fn strip_ansi_handles_non_sgr_csi() {
+        // Cursor moves and scroll regions also end in a 0x40..=0x7E
+        // final byte; the helper handles them too.
+        let s = "before\x1b[2;5Hafter\x1b[Kend";
+        assert_eq!(strip_ansi(s), "beforeafterend");
+    }
+
+    #[test]
+    fn strip_ansi_handles_truncated_escape() {
+        // Trailing ESC with nothing after it (truncated stream).
+        // Drop trailing bytes safely.
+        let s = "abc\x1b[31";
+        // No final byte → we consume to end of input.
+        assert_eq!(strip_ansi(s), "abc");
+    }
+
     #[test]
     fn non_ascii_letters_pass_through() {
         let s = "naïve 日本語 🚀";

src/ui/renderer.rs

@@ -307,33 +307,42 @@ impl Renderer {
             (Some(s), Some(e)) => (e, s),
             _ => return None,
         };
+        // Markdown rendering bakes SGR escapes into `LineEntry::text`
+        // (see markdown.rs:291 — inline emphasis / code spans embed
+        // `\x1b[…m` directly in the line text). The selection
+        // columns are user-perceived character offsets, NOT byte
+        // offsets into the escape-laden source — slicing the raw
+        // text would either land mid-escape or include the escape
+        // in the clipboard. Strip per-row first, then index into
+        // the cleaned form.
+        let row_clean = |i: usize| -> Option<Vec<char>> {
+            self.buffer
+                .get(i)
+                .map(|e| crate::ui::ansi::strip_ansi(&e.text).chars().collect())
+        };
         let mut result = String::new();
         if start.0 == end.0 {
-            // Single-row selection: substring from start.1 to end.1.
-            if let Some(entry) = self.buffer.get(start.0) {
-                let chars: Vec<char> = entry.text.chars().collect();
+            if let Some(chars) = row_clean(start.0) {
                 let lo = start.1.min(chars.len());
                 let hi = end.1.min(chars.len());
                 if lo < hi {
                     result.extend(&chars[lo..hi]);
                 }
             }
         } else {
-            // Multi-row: tail of start row, full middle rows, head of end row.
-            if let Some(entry) = self.buffer.get(start.0) {
-                let chars: Vec<char> = entry.text.chars().collect();
+            if let Some(chars) = row_clean(start.0) {
                 let lo = start.1.min(chars.len());
                 result.extend(&chars[lo..]);
             }
             for i in (start.0 + 1)..end.0 {
                 result.push('\n');
-                if let Some(entry) = self.buffer.get(i) {
-                    result.push_str(&entry.text);
+                if let Some(chars) = row_clean(i) {
+                    let s: String = chars.into_iter().collect();
+                    result.push_str(&s);
                 }
             }
             result.push('\n');
-            if let Some(entry) = self.buffer.get(end.0) {
-                let chars: Vec<char> = entry.text.chars().collect();
+            if let Some(chars) = row_clean(end.0) {
                 let hi = end.1.min(chars.len());
                 result.extend(&chars[..hi]);
             }
@@ -1807,6 +1816,34 @@ mod tests {
         assert_eq!(r.selected_text(), Some("café 🦀".to_string()));
     }
 
+    /// Markdown rendering bakes SGR escapes into LineEntry::text;
+    /// the selection path must strip them before handing the
+    /// string to the clipboard. Columns reflect user-perceived
+    /// character offsets in the visible glyphs, not the
+    /// escape-laden source.
+    #[test]
+    fn selected_text_strips_ansi_escapes() {
+        // Visible text is "hello red world" (15 chars). The buffer
+        // line carries `\x1b[31m` around "red".
+        let mut r = fresh_with_text(&[]);
+        r.buffer.clear();
+        r.buffer.push(LineEntry {
+            text: CompactString::from("hello \x1b[31mred\x1b[0m world"),
+            color: Color::Reset,
+        });
+        r.selection_active = true;
+        // Select the full visible content (cols 0..15).
+        r.selection_start = Some((0, 0));
+        r.selection_end = Some((0, 15));
+        assert_eq!(r.selected_text(), Some("hello red world".to_string()));
+
+        // Substring selection lands on clean chars too —
+        // "red world" is cols 6..15 of the stripped text.
+        r.selection_end = Some((0, 15));
+        r.selection_start = Some((0, 6));
+        assert_eq!(r.selected_text(), Some("red world".to_string()));
+    }
+
     /// `buffer_pos_at` clamps char_col to the line's length so dragging
     /// past the right edge anchors at end-of-line rather than
     /// silently extending past visible content.