fix(client): the tab's process icon leaves the label, and stays on the cell path (UI/UX v3 N-3c) (#103)

Last of the three N-3 PRs. The Nerd Font glyph for the foreground process was
prepended to the label string, so after N-3b it was measured and drawn as part
of a chrome run. `rasterize_chrome_char` boxes a glyph to its advance without
cropping to ink, and Nerd Font icons commonly overhang, so it drew the icon into
a box that could cut it.

It is now drawn beside the label, in a slot the tab reserves for it through
`tab_width`'s `icon_w` parameter — the one N-3a shipped and tested.

The spec's D3 said to draw it "through the icon path, which crops". Checking
that before building on it: `icons.rs` documents that the bundled Fluent
subset's codepoints "live in the Private Use Area, which overlaps the Nerd Font
range `tab_icons.rs` uses", and that they are only safe to draw through
`FontRole::Icon` precisely so the two sets cannot resolve against each other.
Asking the icon path for a process glyph would have silently returned a Fluent
icon at that codepoint — a wrong glyph rather than a clipped one.

So the icon stays on the cell path, which is where it has always come from: it
resolves against the user's terminal font and boxes a glyph to a whole cell
rather than to its advance, which is the clipping fix. D3 is corrected in the
spec with the evidence.

A test pins that the process glyph is not routed through the chrome icon path.

Generated with [Claude Code](https://claude.ai/code)
via [Happy](https://happy.engineering)

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Happy <yesreply@happy.engineering>

Author: 3 people

docs/plans/2026-08-30-n3-tab-bar-labels.md

@@ -145,23 +145,37 @@ The budget is the room left in the tab area, and truncation goes through
 `truncate_run_to_width`, so the drawn label provably fits the pill it is
 measured into. This is what closes §1.2 for long titles as well as CJK ones.
 
-### D3 — The process icon is its own run, for clipping, not for width
-
-The Nerd Font glyph leaves the label string and is drawn as a separate run at a
-measured offset. **The reason is clipping, not measurement** (§1.3): the chrome
-rasteriser boxes a glyph to its advance without cropping to ink, and a Nerd Font
-icon commonly overhangs. Drawing it through the icon path, which crops, keeps it
-whole.
-
-Width is *not* a reason: chrome and terminal share a family and a fallback
-chain, and measurement and drawing share `chrome_advance`, so an icon left in
-the label would be measured exactly as wide as it is drawn — merely, perhaps,
-clipped.
+### D3 — The process icon leaves the label and stays on the *cell* path
+
+The Nerd Font glyph is drawn beside the label, in a cell-wide slot reserved
+before it, rather than prepended to the label string.
+
+**The reason is clipping, not measurement** (§1.3): the chrome rasteriser boxes
+a glyph to its advance without cropping to ink, and a Nerd Font icon commonly
+overhangs. Width is *not* a reason — chrome and terminal share a family and a
+fallback chain, and measurement and drawing share `chrome_advance`, so an icon
+left in the label would be measured exactly as wide as it is drawn, merely
+perhaps clipped.
+
+**And it must not go through the chrome icon path.** An earlier draft of this
+decision said to draw it "through the icon path, which crops". That would be a
+worse bug than the one it fixes: `icons.rs` states that the bundled Fluent
+subset's codepoints "live in the Private Use Area, which overlaps the Nerd Font
+range `tab_icons.rs` uses", and that they are only safe to draw through
+`FontRole::Icon` precisely so the two sets cannot resolve against each other.
+Asking the icon path for a process glyph would silently return a *Fluent* icon
+at that codepoint.
+
+The cell path is where the glyph has always come from, it resolves against the
+user's terminal font, and it boxes a glyph to a whole cell instead of to its
+advance — which is the clipping fix. The tab reserves
+`visual_width(glyph) * cell_w` for it through `tab_width`'s `icon_w` parameter,
+so the label cannot be drawn over it.
 
 The `[N]` prefix and the activity dot stay inside the label. The dot carries the
 same non-risk: a missing glyph measures **zero** (`font.rs:339` keeps it at zero
 deliberately), which costs the dot its space rather than overflowing the tab.
-§7 asks what to do in that case.
+§7 records what was decided about that.
 
 ### D4 — Tabs stay content-sized
 
@@ -238,7 +252,7 @@ though it looks tautological: today it fails.
 |---|---|---|
 | **N-3a** | `fit_tab_width` + the measured `tab_width`, with the pure tests. No call sites; the tab bar still counts characters. **Shipped 2026-08-30** as `renderer/tab_layout.rs`. | G-fit |
 | **N-3b** | Adopt both in `build_tab_bar_verts`: measured width, width-budget truncation, ramp step, `line_h` centring. The seven consumers follow the corrected number. **Shipped 2026-08-30.** | G-width, G-hit, G-single, G-truncate |
-| **N-3c** | The process icon becomes its own run (D3). | G-icon |
+| **N-3c** | The process icon becomes its own run (D3). **Shipped 2026-08-30**, on the cell path rather than the icon path — see D3. | G-icon |
 
 N-3b is the risk concentration: it is the PR that changes what every tab looks
 like and where every tab click lands.

docs/plans/ui-ux-modernization-v3.md

@@ -732,8 +732,10 @@ gated behind a spike.
         (`2026-08-30-n3-tab-bar-labels.md`), §7 signed off; N-3a shipped
         (`renderer/tab_layout.rs`) and N-3b with it — tabs are measured, cut to
         the room the strip has, and drawn at the ramp, so the CJK overflow and
-        the click region that belonged to the next tab are both fixed. N-3c
-        (the process icon as its own run, for clipping) is open. Measuring found
+        the click region that belonged to the next tab are both fixed. N-3c shipped
+        with them: the process icon is drawn beside the label on the cell path,
+        because the bundled chrome-icon subset shares its Private Use Area and
+        the icon path would resolve a Fluent glyph in its place (spec D3). Measuring found
         the roadmap's framing wrong in both directions: the hit computation
         does **not** need rebuilding (the renderer already publishes
         `tab_hit_rects` every frame), and there is a live defect underneath —

nexterm-client-gpu/src/renderer/tab_layout.rs

@@ -227,8 +227,29 @@ mod tests {
         );
     }
 
-    /// A process icon widens the tab it sits in — the icon is drawn beside the
-    /// label (spec D3), so its width has to be in the tab's.
+    /// N-3c: the process glyph is a Nerd Font codepoint from the *user's*
+    /// terminal font, and `icons.rs` documents that the bundled chrome-icon
+    /// subset occupies the same Private Use Area. Drawing it through the icon
+    /// path would therefore resolve a Fluent icon in its place — a silently
+    /// wrong glyph rather than a missing one.
+    #[test]
+    fn the_process_icon_is_not_drawn_through_the_chrome_icon_path() {
+        let src = include_str!("ui_verts.rs");
+        let region = tab_region(src);
+        assert!(
+            region.contains("glyph_for_process"),
+            "the tab bar still draws a process icon"
+        );
+        assert!(
+            !region.contains("add_icon_verts(\n                    glyph"),
+            "the process glyph is drawn through the chrome icon path, which \
+             resolves the bundled Fluent subset over the same PUA range"
+        );
+    }
+
+    /// A process icon widens the tab it sits in — since N-3c it is drawn
+    /// beside the label in a cell-wide slot rather than prepended to it, so
+    /// its width has to be in the tab's or the label would be drawn over it.
     #[test]
     fn a_process_icon_widens_its_tab() {
         let mut font = FontManager::new("monospace", 14.0, &[], 1.0, true);

nexterm-client-gpu/src/renderer/ui_verts.rs

@@ -342,24 +342,34 @@ impl WgpuState {
             } else {
                 raw_title.clone()
             };
-            // Phase 2c: prepend the Nerd Font glyph when (a) the user
-            // opted in via `tab_bar.show_process_icon` and (b) the
-            // glyph map has an entry for the current foreground
-            // process. Unknown processes render the label as before
-            // (no fallback glyph — the absence is signal).
-            let iconified = if cfg.show_process_icon
-                && let Some(name) = process_name.as_deref()
-                && let Some(glyph) = crate::tab_icons::glyph_for_process(name)
-            {
-                format!("{} {}", glyph, base_label)
+            // Phase 2c: the Nerd Font glyph for the foreground process, when
+            // (a) the user opted in via `tab_bar.show_process_icon` and (b) the
+            // glyph map has an entry for it. Unknown processes get nothing —
+            // no fallback glyph, because the absence is signal.
+            //
+            // N-3c: it is drawn beside the label rather than prepended to it,
+            // and on the *cell* path. It is a Nerd Font codepoint from the
+            // user's terminal font, and `icons.rs` warns that the bundled
+            // chrome-icon subset occupies the same Private Use Area — so
+            // drawing it through the icon path would resolve a Fluent icon in
+            // its place. The cell path is where it has always come from, and it
+            // boxes a glyph to a whole cell instead of to its advance, which is
+            // what keeps an overhanging icon from being clipped.
+            let process_glyph = if cfg.show_process_icon {
+                process_name
+                    .as_deref()
+                    .and_then(crate::tab_icons::glyph_for_process)
             } else {
-                base_label
+                None
             };
+            let icon_w = process_glyph
+                .map(|glyph| crate::vertex_util::visual_width(glyph) as f32 * cell_w)
+                .unwrap_or(0.0);
             // Tab number prefix (Windows Terminal style): prepends `[N]` when the option is on
             let numbered = if cfg.show_tab_number {
-                format!("[{}] {}", i + 1, iconified)
+                format!("[{}] {}", i + 1, base_label)
             } else {
-                iconified
+                base_label
             };
             // The cell path wrapped every label in spaces because `padding`
             // alone did not read as padding at cell precision. It does now, and
@@ -385,11 +395,11 @@ impl WgpuState {
             let label = crate::vertex_util::truncate_run_to_width(
                 &label,
                 &tab_style,
-                (room_left - padding * 2.0).max(0.0),
+                (room_left - padding * 2.0 - icon_w).max(0.0),
                 font,
             );
             let Some(label_w) = crate::renderer::tab_layout::tab_width(
-                &label, &tab_style, 0.0, padding, room_left, font,
+                &label, &tab_style, icon_w, padding, room_left, font,
             ) else {
                 break; // no more room to draw additional tabs
             };
@@ -491,12 +501,30 @@ impl WgpuState {
                 );
             }
 
-            // Tab label (vertically centred on the run's own line box).
+            // Tab label (vertically centred on the run's own line box), with
+            // the process icon in the cell-wide slot reserved before it.
             let fg = if is_active { text_fg } else { inactive_fg };
+            if let Some(glyph) = process_glyph {
+                add_string_verts(
+                    glyph,
+                    x_offset + padding,
+                    text_y,
+                    fg,
+                    false,
+                    sw,
+                    sh,
+                    cell_w,
+                    font,
+                    atlas,
+                    &self.queue,
+                    text_verts,
+                    text_idx,
+                );
+            }
             add_run_verts(
                 &label,
                 &tab_style,
-                x_offset + padding,
+                x_offset + padding + icon_w,
                 tab_text_y,
                 fg,
                 sw,