renderer: emit conceal replacement when concealed token is Space/Newline/Break

The renderer's `apply_conceal_ranges` had two code paths for tokens
that overlap a conceal range:

  - Text tokens emit the conceal range's `replacement` text via
    `emitted_replacements`.
  - Space / Newline / Break tokens silently dropped the token
    *without* emitting the replacement.

Fresh tokenizes whitespace separately from word characters, so
matching a word that ends right before a space (e.g. typing `PID`
in a buffer that contains `PID file lockup`) hits the second path.
Result: the space cell disappears AND the conceal's replacement
(flash plugin's label letter) never renders.  Surrounding text
shifts left by one cell.  User saw `PIDfile lockup` instead of
`PIDafile lockup` — a real layout-shifting bug.

Fix: have the Space/Newline/Break branch run the same replacement-
emission logic as the Text branch.  `null` replacement still hides
the byte range with no output (existing behaviour preserved); a
non-empty `replacement` now emits its first char with the source
offset (so cursor/click positioning still works) plus the rest as
a continuation.

Reproducer test (CONTRIBUTING #1):
  flash_label_does_not_eat_space_after_match — opens a buffer with
  `PID file lockup` and typed `PID`, then asserts the rendered
  screen does NOT contain `PIDfile`/`PIDfor`/`PIDline` (the buggy
  collapse) AND that at least one match shows `PID<pool-letter><word>`
  (the expected substituted-cell layout).

  Verified the test FAILS without the renderer fix and PASSES with
  it via a transient `git stash` cycle on the editor change.

Tests: 7 flash + 41 markdown_compose e2e tests all pass.  Markdown
compose was the only other plugin using conceal — its substitutions
target Text tokens, so the Space/Newline/Break path never fired
for it and the fix is non-disruptive.

Author: claude

crates/fresh-editor/src/view/ui/split_rendering/transforms.rs

@@ -687,8 +687,43 @@ pub(crate) fn apply_conceal_ranges(
                 }
             }
             ViewTokenWireKind::Space | ViewTokenWireKind::Newline | ViewTokenWireKind::Break => {
-                if is_concealed(conceal_ranges, &sorted, &mut conceal_cursor, offset).is_some() {
-                    // Skip concealed single-byte tokens
+                if let Some(cidx) =
+                    is_concealed(conceal_ranges, &sorted, &mut conceal_cursor, offset)
+                {
+                    // Concealed single-byte token.  If the conceal
+                    // range carries a `replacement`, we still need
+                    // to emit it — the Text branch above does this
+                    // via `emitted_replacements`, and dropping the
+                    // token here without doing the same was a real
+                    // bug: e.g. flash plugin labels overlay the
+                    // next char after each match, and when that
+                    // next char is a space the renderer used to
+                    // eat the cell entirely (label letter never
+                    // shown, surrounding text shifted left).
+                    if let Some(repl) = conceal_ranges[cidx].1 {
+                        if !emitted_replacements.contains(&cidx) {
+                            emitted_replacements.insert(cidx);
+                            if !repl.is_empty() {
+                                let mut chars = repl.chars();
+                                if let Some(first_ch) = chars.next() {
+                                    output.push(ViewTokenWire {
+                                        source_offset: Some(conceal_ranges[cidx].0.start),
+                                        kind: ViewTokenWireKind::Text(first_ch.to_string()),
+                                        style: None,
+                                    });
+                                    let rest: String = chars.collect();
+                                    if !rest.is_empty() {
+                                        output.push(ViewTokenWire {
+                                            source_offset: None,
+                                            kind: ViewTokenWireKind::Text(rest),
+                                            style: None,
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    // null replacement = hide the byte range; nothing to emit.
                 } else {
                     output.push(token);
                 }

crates/fresh-editor/tests/e2e/flash.rs

@@ -299,6 +299,88 @@ fn flash_label_substitutes_rendered_glyph() {
     );
 }
 
+/// Regression for the conceal-eats-space bug, 2026-04: when the
+/// next char after a flash match is a Space (or Newline / Break)
+/// token, the renderer's `apply_conceal_ranges` used to drop the
+/// token without emitting the conceal-range's replacement text.
+/// Effect: the label letter never appeared and the surrounding
+/// text shifted left by one cell.
+///
+/// User-visible reproducer: type `PID` against a buffer containing
+/// `PID file lockup`.  The space between `PID` and `file` was
+/// consumed by the bug, rendering `PIDfile lockup`.  With the fix
+/// the conceal range emits its label letter (e.g. `a`) into the
+/// space's cell, producing `PIDafile lockup` (label letter painted
+/// magenta on top of where the space was) — same column count,
+/// no layout shift.
+#[test]
+fn flash_label_does_not_eat_space_after_match() {
+    let (mut harness, _temp, project_root) = flash_harness(120, 24);
+    let path = write_fixture(
+        &project_root,
+        "test.txt",
+        "PID file lockup\nthe PID for that\nsome other PID line\n",
+    );
+    harness.open_file(&path).unwrap();
+    harness.render().unwrap();
+
+    arm_flash(&mut harness);
+    type_pattern(&mut harness, "PID");
+    harness.render().unwrap();
+
+    let screen = harness.screen_to_string();
+
+    // The bug: with pattern "PID" the next char of every match is a
+    // space, and the buggy renderer dropped the space without
+    // emitting the conceal replacement, producing `PIDfile`,
+    // `PIDfor`, `PIDline`.  None of those should appear after the
+    // fix.
+    assert!(
+        !screen.contains("PIDfile"),
+        "rendered output collapsed `PID file` into `PIDfile` — \
+         conceal range was applied but its label-letter replacement \
+         was dropped.  Screen:\n{}",
+        screen,
+    );
+    assert!(
+        !screen.contains("PIDfor"),
+        "rendered output collapsed `PID for` into `PIDfor`.  Screen:\n{}",
+        screen,
+    );
+    assert!(
+        !screen.contains("PIDline"),
+        "rendered output collapsed `PID line` into `PIDline`.  Screen:\n{}",
+        screen,
+    );
+
+    // Positive check: at least one of the three matches MUST have a
+    // label letter rendered between `PID` and the following word.
+    // Iterate the pool and match via concatenation — we don't care
+    // which specific letter the labeler picked, only that *some*
+    // pool character occupies the space's cell.
+    let pool: &[char] = &[
+        'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', 'q', 'w', 'r', 't', 'y', 'u', 'i', 'o', 'p',
+        'z', 'x', 'c', 'v', 'b', 'n', 'm',
+    ];
+    let mut substituted_count = 0usize;
+    for c in pool {
+        let needle_file = format!("PID{}file", c);
+        let needle_for = format!("PID{}for", c);
+        let needle_line = format!("PID{}line", c);
+        substituted_count += screen.matches(&needle_file).count()
+            + screen.matches(&needle_for).count()
+            + screen.matches(&needle_line).count();
+    }
+    assert!(
+        substituted_count >= 1,
+        "expected at least one match to render with a label letter \
+         occupying the cell that was the space (e.g. `PIDafile`).  \
+         Without the fix, that cell is empty and the next word \
+         shifts left.  Screen:\n{}",
+        screen,
+    );
+}
+
 #[test]
 fn flash_jumps_across_splits() {
     // Two vertical splits, each with a different buffer that contains