fix(client): text wraps to a measured width, not a column count (UI/UX v3 N-6b) (#110)

`wrap_text(s, max_cols)` は表示列数で折り返していた。列で折り返して正しい
のはセルサイズで描く場合だけだが、**3 つの呼び出し元すべてが
`add_run_verts` で ramp step 描画している**。つまりどの呼び出しも、実際に
描く幅とは無関係な予算に対して折り返していた。

`wrap_run(s, style, max_w_px, font)` に置き換える。advance は描画パスと
同じ `chrome_advance` から取るため、返る行が予算を超えることは原理的に
ない（1 文字が予算より広い場合を除く。これ以上は分割できない）。

呼び出し元 3 箇所:

- dialog.rs: consent preview の `56` は 60 桁パネルから推測した列数リテラル
  だった → パネル幅そのものを渡す
- dialog.rs: close-window message の `(pw - cell_w*2)/cell_w` は px を列に
  変換していた → px のまま渡す
- settings/row.rs: `draw_description_rows` の `max_cols: usize` を
  `max_w: f32` に変更。呼び出し元 security_tab.rs も同様

単語境界ではなく文字境界で折る点は列版と同じ。単語折り返しは別の変更で、
呼び出し側の見え方が変わる。

Spec: docs/plans/2026-08-30-n4-menus-and-dialogs.md §8（settings 残件の②）

Author: mizu-jun

nexterm-client-gpu/src/renderer/overlay/dialog.rs

@@ -12,7 +12,7 @@ use crate::vertex_util::{add_px_rect, add_run_verts, measure_run};
 use super::super::WgpuState;
 use super::util::{
     SCRIM_ALPHA_FLOOR, caution_fill, danger_fill, draw_overlay_panel, pane_id_for, preview_text,
-    scrim_color, wrap_text,
+    scrim_color, wrap_run,
 };
 use nexterm_config::SurfaceLevel;
 
@@ -450,9 +450,12 @@ impl WgpuState {
             content_y += cell_h * 1.3;
         }
 
-        // Payload preview (up to 2 lines, 56 chars each)
+        // Payload preview (up to 2 lines). The budget is the panel's own
+        // width now, measured at the step the preview is drawn at — the old
+        // literal 56 was a column count guessed from a 60-cell panel.
         let preview = preview_text(&dialog.kind);
-        for (i, line) in wrap_text(&preview, 56).iter().take(2).enumerate() {
+        let preview_lines = wrap_run(&preview, &metrics.type_ramp.body, pw - cell_w * 2.0, font);
+        for (i, line) in preview_lines.iter().take(2).enumerate() {
             add_run_verts(
                 line,
                 &metrics.type_ramp.body,
@@ -631,14 +634,15 @@ impl WgpuState {
         add_px_rect(px, py, pw, 3.0, err_color, sw, sh, bg_verts, bg_idx);
 
         // Title = render the confirmation message directly (short enough to skip a separate title).
-        // If it overflows the width, wrap_text breaks it to up to 2 lines.
+        // If it overflows the width, `wrap_run` breaks it to up to 3 lines.
         let content_y = py + cell_h * 1.2;
-        let max_cols = ((pw - cell_w * 2.0) / cell_w).max(20.0) as usize;
-        for (i, line) in wrap_text(&dialog.message, max_cols)
-            .iter()
-            .take(3)
-            .enumerate()
-        {
+        let message_lines = wrap_run(
+            &dialog.message,
+            &metrics.type_ramp.body,
+            pw - cell_w * 2.0,
+            font,
+        );
+        for (i, line) in message_lines.iter().take(3).enumerate() {
             add_run_verts(
                 line,
                 &metrics.type_ramp.body,

nexterm-client-gpu/src/renderer/overlay/settings/row.rs

@@ -10,7 +10,7 @@
 //!     block below a row.
 //!
 //! All three truncate their text to the column widths in [`RowLayout`] via
-//! [`truncate_to_width`] / [`wrap_text`] so long labels/values/descriptions
+//! [`truncate_run_to_width`] / [`wrap_run`] so long labels/values/descriptions
 //! can no longer overflow the content area.
 //!
 //! UI/UX v3 P5d retired `ensure_readable` from here. It raised alpha and
@@ -23,9 +23,9 @@
 
 use crate::font::FontManager;
 use crate::glyph_atlas::{GlyphAtlas, TextVertex};
-use crate::vertex_util::{add_run_verts, add_string_verts, truncate_run_to_width};
+use crate::vertex_util::{add_run_verts, truncate_run_to_width};
 
-use super::super::util::{danger_fill, wrap_text};
+use super::super::util::{danger_fill, wrap_run};
 use nexterm_config::SurfaceLevel;
 
 /// Fill / label pair for a destructive-confirmation button.
@@ -93,37 +93,41 @@ pub(in crate::renderer) fn draw_section_header(
     );
 }
 
-/// Draw a word-wrapped description/hint block starting at `(x, y)`, one
-/// line per `line_h`. Returns the y position immediately below the last
-/// line, so callers can stack further content beneath it.
+/// Draw a wrapped description/hint block starting at `(x, y)`, one line per
+/// `line_h`. Returns the y position immediately below the last line, so
+/// callers can stack further content beneath it.
+///
+/// `max_w` is a pixel budget (UI/UX v3 N-6b). It used to be a column count,
+/// which only bounds the drawn width if the text is drawn at the cell — and it
+/// never was here: the block is prose at `body`, so the wrap and the draw were
+/// measuring different things.
 #[allow(clippy::too_many_arguments)]
 pub(in crate::renderer) fn draw_description_rows(
     text: &str,
     x: f32,
     y: f32,
     line_h: f32,
-    max_cols: usize,
+    max_w: f32,
     color: [f32; 4],
     sw: f32,
     sh: f32,
-    cell_w: f32,
     font: &mut FontManager,
     atlas: &mut GlyphAtlas,
     queue: &wgpu::Queue,
     text_verts: &mut Vec<TextVertex>,
     text_idx: &mut Vec<u16>,
 ) -> f32 {
-    let lines = wrap_text(text, max_cols);
+    let style = nexterm_config::MetricTokens::default().type_ramp.body;
+    let lines = wrap_run(text, &style, max_w, font);
     for (i, line) in lines.iter().enumerate() {
-        add_string_verts(
+        add_run_verts(
             line,
+            &style,
             x,
             y + line_h * i as f32,
             color,
-            false,
             sw,
             sh,
-            cell_w,
             font,
             atlas,
             queue,

nexterm-client-gpu/src/renderer/overlay/settings/security_tab.rs

@@ -68,11 +68,10 @@ pub(in crate::renderer) fn draw_security_tab(
         content_inner_x,
         note_y(&geometry),
         cell_h,
-        (content_w / cell_w).floor() as usize,
+        content_w,
         tokens.text_on(SurfaceLevel::S2).muted,
         sw,
         sh,
-        cell_w,
         font,
         atlas,
         queue,

nexterm-client-gpu/src/renderer/overlay/util.rs

@@ -1,5 +1,6 @@
 //! Shared helpers used by overlay rendering.
 
+use crate::font::FontManager;
 use nexterm_config::MIN_TEXT_CONTRAST;
 
 /// Extract the requesting pane ID from a consent-dialog kind
@@ -38,19 +39,39 @@ pub(super) fn preview_text(kind: &crate::state::ConsentKind) -> String {
     }
 }
 
-/// Wrap text to multiple lines at the given column width (CJK full-width chars count as 2 columns)
-pub(super) fn wrap_text(s: &str, max_cols: usize) -> Vec<String> {
+/// Wrap text to lines that fit `max_w_px` when drawn at `style` (UI/UX v3 N-6b).
+///
+/// Replaces a column-counting `wrap_text`. Counting columns wraps correctly
+/// only if the text is drawn at the cell — and all three callers draw through
+/// `add_run_verts`, at a ramp step, which is a different size. Every one of
+/// them therefore wrapped against a budget that had nothing to do with the
+/// width it then drew.
+///
+/// The advance comes from the same `chrome_advance` the drawing pass uses, so
+/// a line this returns cannot be wider than the budget it was given, whatever
+/// the font reports for any glyph.
+///
+/// Breaks between characters, not at word boundaries — the same thing the
+/// column version did. Wrapping on words is a separate change and would alter
+/// what every caller looks like.
+pub(super) fn wrap_run(
+    s: &str,
+    style: &nexterm_config::TypeStyle,
+    max_w_px: f32,
+    font: &mut FontManager,
+) -> Vec<String> {
+    let (size_px, _line_h, bold) = font.chrome_metrics(style);
     let mut lines = Vec::new();
     let mut current = String::new();
-    let mut current_cols = 0usize;
+    let mut current_w = 0.0_f32;
     for c in s.chars() {
-        let w = unicode_width::UnicodeWidthChar::width(c).unwrap_or(1);
-        if current_cols + w > max_cols && !current.is_empty() {
+        let w = font.chrome_advance(c, size_px, bold);
+        if current_w + w > max_w_px && !current.is_empty() {
             lines.push(std::mem::take(&mut current));
-            current_cols = 0;
+            current_w = 0.0;
         }
         current.push(c);
-        current_cols += w;
+        current_w += w;
     }
     if !current.is_empty() {
         lines.push(current);
@@ -515,6 +536,71 @@ mod tests {
             }
         }
     }
+
+    /// UI/UX v3 N-6b: a wrapped line fits the budget it was given.
+    ///
+    /// The property the column version could not offer: it counted display
+    /// columns while all three callers drew at a ramp step, so the budget it
+    /// enforced was not the width that got drawn. Asserted as an equality
+    /// between the wrap and the measurement, never as a claim about CJK
+    /// metrics — CI's font stack answers one advance for every character
+    /// (N-3 spec §6).
+    #[test]
+    fn every_wrapped_line_fits_the_budget() {
+        let mut font = FontManager::new("monospace", 14.0, &[], 1.0, true);
+        let style = nexterm_config::MetricTokens::default().type_ramp.body;
+        let budget = 120.0;
+
+        for text in [
+            "a short line",
+            "a much longer line that will certainly have to be broken somewhere",
+            "このウィンドウだけ閉じるかどうかを確認しています",
+            "mixed 日本語 and latin in one run",
+        ] {
+            let lines = wrap_run(text, &style, budget, &mut font);
+            assert!(!lines.is_empty(), "{text:?} produced no lines");
+            for line in &lines {
+                let w = crate::vertex_util::measure_run(line, &style, &mut font);
+                // A single character wider than the budget cannot be broken
+                // further, so the guarantee is "fits, or is one character".
+                assert!(
+                    w <= budget || line.chars().count() == 1,
+                    "{line:?} measures {w} against a {budget} budget"
+                );
+            }
+            assert_eq!(
+                lines.concat(),
+                text,
+                "wrapping must not add or drop characters"
+            );
+        }
+    }
+
+    /// A narrower budget never yields fewer lines.
+    #[test]
+    fn a_narrower_budget_never_wraps_into_fewer_lines() {
+        let mut font = FontManager::new("monospace", 14.0, &[], 1.0, true);
+        let style = nexterm_config::MetricTokens::default().type_ramp.body;
+        let text = "a line long enough to be broken at several different budgets";
+
+        let wide = wrap_run(text, &style, 400.0, &mut font).len();
+        let narrow = wrap_run(text, &style, 100.0, &mut font).len();
+        assert!(narrow >= wide, "{wide} lines at 400px, {narrow} at 100px");
+    }
+
+    /// No caller counts columns any more.
+    #[test]
+    fn no_overlay_wraps_text_by_column_count() {
+        for (name, src) in [
+            ("dialog.rs", include_str!("dialog.rs")),
+            ("settings/row.rs", include_str!("settings/row.rs")),
+        ] {
+            assert!(
+                !src.contains("wrap_text("),
+                "{name} wraps by column count again; wrap_run measures"
+            );
+        }
+    }
 }
 
 #[cfg(test)]