Lightweight coding agent that runs in your terminal
Rust
Preserve logical source text and styles across TUI wrapping (#46708)
Eric Trautfcaa035438e4
diff --git a/codex-rs/tui/src/chatwidget/realtime_split_flap.rs b/codex-rs/tui/src/chatwidget/realtime_split_flap.rsindex f9635c52cc..50f0b8c57e 100644--- a/codex-rs/tui/src/chatwidget/realtime_split_flap.rs+++ b/codex-rs/tui/src/chatwidget/realtime_split_flap.rs@@ -164,6 +164,8 @@ impl SplitFlapTranscriptCell {continue;}+ // Animated glyphs and board padding no longer map to authored source bytes.+ line.source = None;let original_spans = std::mem::take(&mut line.line.spans);line.line.style = line.line.style.patch(board_style);for span in original_spans {diff --git a/codex-rs/tui/src/chatwidget/realtime_split_flap_tests.rs b/codex-rs/tui/src/chatwidget/realtime_split_flap_tests.rsindex bece1513be..5007f5382f 100644--- a/codex-rs/tui/src/chatwidget/realtime_split_flap_tests.rs+++ b/codex-rs/tui/src/chatwidget/realtime_split_flap_tests.rs@@ -90,11 +90,12 @@ fn split_flap_frames_assemble_a_transcript_from_dark_tiles() {#[test]fn split_flap_paints_the_entire_transcript_row_black() {let cell = cell("GATE", MotionMode::Animated);- let lines = cell.animate_lines(- cell.inner.display_hyperlink_lines(/*width*/ 12),- /*width*/ 12,- Duration::ZERO,- );+ let mut source_lines = cell.inner.display_hyperlink_lines(/*width*/ 12);+ source_lines[0].source = Some(crate::terminal_hyperlinks::LogicalLineSource::from_line(+ &source_lines[0].line,+ ));+ let lines = cell.animate_lines(source_lines, /*width*/ 12, Duration::ZERO);+ assert!(lines[0].source.is_none());let area = Rect::new(/*x*/ 0, /*y*/ 0, /*width*/ 12, /*height*/ 1,);diff --git a/codex-rs/tui/src/history_cell/base.rs b/codex-rs/tui/src/history_cell/base.rsindex 44db928e47..15ab8638f5 100644--- a/codex-rs/tui/src/history_cell/base.rs+++ b/codex-rs/tui/src/history_cell/base.rs@@ -80,13 +80,24 @@ impl PrefixedWrappedHistoryCell {impl HistoryCell for PrefixedWrappedHistoryCell {fn display_lines(&self, width: u16) -> Vec<Line<'static>> {+ visible_lines(self.display_hyperlink_lines(width))+ }++ fn display_hyperlink_lines(&self, width: u16) -> Vec<HyperlinkLine> {if width == 0 {return Vec::new();}- let opts = RtOptions::new(width.max(1) as usize)+ let opts = RtOptions::new(usize::from(width)).initial_indent(self.initial_prefix.clone()).subsequent_indent(self.subsequent_prefix.clone());- adaptive_wrap_lines(&self.text, opts)+ crate::terminal_hyperlinks::adaptive_wrap_hyperlink_lines(+ &plain_hyperlink_lines(self.text.lines.clone()),+ opts,+ )+ }++ fn transcript_hyperlink_lines(&self, width: u16) -> Vec<HyperlinkLine> {+ self.display_hyperlink_lines(width)}fn raw_lines(&self) -> Vec<Line<'static>> {@@ -173,3 +184,7 @@ impl HistoryCell for CompositeHistoryCell {false}}++#[cfg(test)]+#[path = "base_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/history_cell/base_tests.rs b/codex-rs/tui/src/history_cell/base_tests.rsnew file mode 100644index 0000000000..fbcbb7cbad--- /dev/null+++ b/codex-rs/tui/src/history_cell/base_tests.rs@@ -0,0 +1,95 @@+//! Prefixed rows preserve authored whitespace and exclude display gutters from source text.++use super::*;+use pretty_assertions::assert_eq;+use std::sync::Arc;++#[test]+fn prefixed_wrapping_retains_one_source_line_across_widths_and_gutters() {+ let source = " let result = compute(alpha, beta, gamma); print(result);";+ let styled = Line::from(vec![+ " let result = ".into(),+ "compute".red().bold(),+ "(alpha, beta, gamma); print(result);".into(),+ ])+ .cyan()+ .italic();+ let cell = PrefixedWrappedHistoryCell::new(styled, "✔ ".green(), " ");+ for width in [16, 24, 48] {+ let lines = cell.transcript_hyperlink_lines(width);+ let first = lines+ .first()+ .expect("wrapped source")+ .source+ .as_ref()+ .expect("source range");+ assert_eq!(first.text.as_ref(), source);+ assert_eq!(+ first.styled_range(0..source.len()),+ Line::from(vec![+ " let result = ".cyan().italic(),+ "compute".red().bold().italic(),+ "(alpha, beta, gamma); print(result);".cyan().italic(),+ ])+ );+ assert_eq!(first.range.start, 0);+ let restyled = lines[0].clone().style(Style::new().on_blue());+ assert_eq!(+ restyled+ .source+ .as_ref()+ .unwrap()+ .styled_range(0..source.len()),+ Line::from(vec![+ " let result = ".cyan().italic().on_blue(),+ "compute".red().bold().italic().on_blue(),+ "(alpha, beta, gamma); print(result);"+ .cyan()+ .italic()+ .on_blue(),+ ])+ );+ for line in &lines {+ let origin = line.source.as_ref().expect("source range");+ let visible = line.line.to_string();+ assert!(Arc::ptr_eq(&origin.text, &first.text));+ assert_eq!(+ &visible[origin.prefix_bytes..origin.prefix_bytes + origin.range.len()],+ &source[origin.range.clone()],+ );+ assert!(line.line.width() <= usize::from(width));+ }+ assert_eq!(+ lines+ .last()+ .expect("last row")+ .source+ .as_ref()+ .expect("source")+ .range+ .end,+ source.len()+ );+ }+}++#[test]+fn prefixed_wrapping_keeps_hard_lines_distinct_even_when_their_text_repeats() {+ let cell = PrefixedWrappedHistoryCell::new(+ Text::from(vec![+ Line::from("repeated text"),+ Line::from("repeated text"),+ ]),+ "✔ ",+ " ",+ );+ let lines = cell.transcript_hyperlink_lines(/*width*/ 40);+ let first = lines[0].source.as_ref().expect("first source");+ let second = lines[1].source.as_ref().expect("second source");+ assert_eq!(+ (first.text.as_ref(), second.text.as_ref()),+ ("repeated text", "repeated text")+ );+ assert!(!Arc::ptr_eq(&first.text, &second.text));+ assert!(cell.display_hyperlink_lines(/*width*/ 0).is_empty());+}diff --git a/codex-rs/tui/src/history_cell/messages.rs b/codex-rs/tui/src/history_cell/messages.rsindex c5c3002c02..555aaf4929 100644--- a/codex-rs/tui/src/history_cell/messages.rs+++ b/codex-rs/tui/src/history_cell/messages.rs@@ -4,10 +4,12 @@use super::markdown_render_cache::MarkdownRenderCache;use super::*;use crate::style::accent_color_on;+use crate::style::history_prompt_style;use crate::terminal_hyperlinks::annotate_web_urls_in_line;-use crate::terminal_hyperlinks::remap_wrapped_line;+use crate::terminal_hyperlinks::lines_with_sources_eq;+use crate::terminal_hyperlinks::remap_source_wrapped_line;use crate::wrapping::url_preserving_wrap_options;-use crate::wrapping::word_wrap_line;+use crate::wrapping::word_wrap_line_with_source;use std::borrow::Cow;#[derive(Debug)]@@ -185,9 +187,9 @@ impl HistoryCell for UserHistoryCell {.saturating_sub(LIVE_PREFIX_COLS + 1, /* keep a one-column right margin for wrapping */)- .max(1);+ .max(/*other*/ 1);- let style = user_message_style();+ let style = history_prompt_style();let element_style = style.fg(accent_color_on(style.bg));let wrapped_remote_images = if self.remote_image_urls.is_empty() {@@ -202,60 +204,7 @@ impl HistoryCell for UserHistoryCell {}.filter(|lines| !lines.is_empty());- let wrapped_message = if message.is_empty() && text_elements.is_empty() {- None- } else {- let wrap_options = RtOptions::new(usize::from(wrap_width))- .wrap_algorithm(textwrap::WrapAlgorithm::FirstFit);- let mut wrapped = if text_elements.is_empty() {- let message_without_trailing_newlines = message.trim_end_matches(['\r', '\n']);- adaptive_wrap_lines(- message_without_trailing_newlines- .split('\n')- .map(|line| Line::from(line).style(style)),- wrap_options,- )- } else {- adaptive_wrap_lines(- build_user_message_lines_with_elements(- message,- text_elements,- style,- element_style,- ),- wrap_options,- )- }- .into_iter()- .flat_map(|line| {- if line.width() <= usize::from(wrap_width) {- return vec![HyperlinkLine::new(line)];- }-- // Terminal autowrap loses the message gutter and background. Explicitly split- // oversized URL tokens while retaining their complete OSC-8 destination.- let line = annotate_web_urls_in_line(line);- let forced_lines = word_wrap_line(- &line.line,- url_preserving_wrap_options(RtOptions::new(usize::from(wrap_width)))- .break_words(/*break_words*/ true),- )- .iter()- .map(line_to_static)- .collect();- remap_wrapped_line(&line, forced_lines)- })- .collect::<Vec<_>>();- while wrapped.last().is_some_and(|line| {- line.line- .spans- .iter()- .all(|span| span.content.trim().is_empty())- }) {- wrapped.pop();- }- (!wrapped.is_empty()).then_some(wrapped)- };+ let wrapped_message = wrap_user_message(message, text_elements, style, wrap_width);if wrapped_remote_images.is_none() && wrapped_message.is_none() {return Vec::new();@@ -287,6 +236,9 @@ impl HistoryCell for UserHistoryCell {}lines.push(HyperlinkLine::new(Line::from("").style(style)));+ for source in lines.iter_mut().filter_map(|line| line.source.as_mut()) {+ source.right_reserve = 1;+ }lines}@@ -308,6 +260,61 @@ impl HistoryCell for UserHistoryCell {}}+/// Wrap a prompt body before the user-message gutter and background padding are added.+fn wrap_user_message(+ message: &str,+ text_elements: &[TextElement],+ style: Style,+ wrap_width: u16,+) -> Option<Vec<HyperlinkLine>> {+ let element_style = style.fg(accent_color_on(style.bg));+ if message.is_empty() && text_elements.is_empty() {+ return None;+ }++ let wrap_options =+ RtOptions::new(usize::from(wrap_width)).wrap_algorithm(textwrap::WrapAlgorithm::FirstFit);+ let logical_lines = if text_elements.is_empty() {+ let message_without_trailing_newlines = message.trim_end_matches(['\r', '\n']);+ message_without_trailing_newlines+ .split('\n')+ .map(|line| Line::from(line.to_owned()).style(style))+ .collect()+ } else {+ build_user_message_lines_with_elements(message, text_elements, style, element_style)+ };+ let mut wrapped = crate::terminal_hyperlinks::adaptive_wrap_hyperlink_lines(+ &plain_hyperlink_lines(logical_lines),+ wrap_options,+ )+ .into_iter()+ .flat_map(|mut line| {+ if line.width() <= usize::from(wrap_width) {+ return vec![line];+ }++ // Terminal autowrap loses the message gutter and background. Explicitly split+ // oversized URL tokens while retaining their complete OSC-8 destination.+ line.hyperlinks = annotate_web_urls_in_line(line.line.clone()).hyperlinks;+ let forced_lines = word_wrap_line_with_source(+ &line.line,+ url_preserving_wrap_options(RtOptions::new(usize::from(wrap_width)))+ .break_words(/*break_words*/ true),+ );+ remap_source_wrapped_line(&line, forced_lines)+ })+ .collect::<Vec<_>>();+ while wrapped.last().is_some_and(|line| {+ line.line+ .spans+ .iter()+ .all(|span| span.content.trim().is_empty())+ }) {+ wrapped.pop();+ }+ (!wrapped.is_empty()).then_some(wrapped)+}+#[derive(Debug)]pub(crate) struct ReasoningSummaryCell {_header: String,@@ -522,6 +529,10 @@ fn normalize_whitespace_only_hyperlink_lines(mut lines: Vec<HyperlinkLine>) -> V{line.line = Line::default().style(line.line.style);line.hyperlinks.clear();+ if let Some(source) = &mut line.source {+ source.prefix_bytes = 0;+ source.range.end = source.range.start;+ }}}lines@@ -594,13 +605,20 @@ mod tests;////// During streaming, lines that have not yet been committed to scrollback because they belong to/// an in-progress table are displayed via this cell in the `active_cell` slot. It is replaced on-/// deltas that change the visible tail and cleared when the stream finalizes.-#[derive(Debug, Eq, PartialEq)]+/// deltas that change the visible tail or retained source, and cleared when the stream finalizes.+#[derive(Debug, Eq)]pub(crate) struct StreamingAgentTailCell {lines: Vec<HyperlinkLine>,is_first_line: bool,}+impl PartialEq for StreamingAgentTailCell {+ fn eq(&self, other: &Self) -> bool {+ self.is_first_line == other.is_first_line+ && lines_with_sources_eq(&self.lines, &other.lines)+ }+}+impl StreamingAgentTailCell {pub(crate) fn new(lines: Vec<HyperlinkLine>, is_first_line: bool) -> Self {Self {diff --git a/codex-rs/tui/src/history_cell/messages_tests.rs b/codex-rs/tui/src/history_cell/messages_tests.rsindex deabffe9ad..8db0126863 100644--- a/codex-rs/tui/src/history_cell/messages_tests.rs+++ b/codex-rs/tui/src/history_cell/messages_tests.rs@@ -234,6 +234,21 @@ fn spoken_artifacts_link_only_real_workspace_files_and_preserve_existing_urls()span.content == "src/lib.rs:42" && span.style.add_modifier.contains(Modifier::UNDERLINED)}));assert_eq!(spoken.raw_lines(), vec![Line::from(markdown)]);+ for width in [90, 24] {+ for line in spoken.display_hyperlink_lines(width) {+ let source = line.source.expect("spoken source");+ assert!(+ source+ .styled_range(0..source.text.len())+ .spans+ .iter()+ .any(|span| {+ span.content == "src/lib.rs:42"+ && span.style.add_modifier.contains(Modifier::UNDERLINED)+ })+ );+ }+ }insta::assert_snapshot!(format!("{}\n{:?} -> <workspace>/src/lib.rs\n{:?} -> https://example.com",diff --git a/codex-rs/tui/src/history_cell/mod.rs b/codex-rs/tui/src/history_cell/mod.rsindex be50cc6042..97b7a856d6 100644--- a/codex-rs/tui/src/history_cell/mod.rs+++ b/codex-rs/tui/src/history_cell/mod.rs@@ -33,7 +33,6 @@ use crate::render::line_utils::push_owned_lines;use crate::render::renderable::Renderable;use crate::session_state::ThreadSessionState;use crate::style::proposed_plan_style;-use crate::style::user_message_style;use crate::terminal_hyperlinks::HyperlinkLine;use crate::terminal_hyperlinks::HyperlinkParagraph;use crate::terminal_hyperlinks::plain_hyperlink_lines;@@ -83,7 +82,6 @@ use codex_utils_absolute_path::AbsolutePathBuf;#[cfg(test)]use codex_utils_cli::format_env_display;use ratatui::prelude::*;-use ratatui::style::Color;use ratatui::style::Modifier;use ratatui::style::Style;use ratatui::style::Styled;diff --git a/codex-rs/tui/src/history_cell/plans.rs b/codex-rs/tui/src/history_cell/plans.rsindex 4847d30ca4..e7545b37a3 100644--- a/codex-rs/tui/src/history_cell/plans.rs+++ b/codex-rs/tui/src/history_cell/plans.rs@@ -2,18 +2,26 @@use super::markdown_render_cache::MarkdownRenderCache;use super::*;+use crate::terminal_hyperlinks::lines_with_sources_eq;/// Transient active-cell representation of the mutable tail of a proposed-plan stream.////// The controller prepares the full styled plan lines because plan tails need the same header,/// padding, and background treatment as committed `ProposedPlanStreamCell`s while remaining/// preview-only during streaming.-#[derive(Debug, Eq, PartialEq)]+#[derive(Debug, Eq)]pub(crate) struct StreamingPlanTailCell {lines: Vec<HyperlinkLine>,is_stream_continuation: bool,}+impl PartialEq for StreamingPlanTailCell {+ fn eq(&self, other: &Self) -> bool {+ self.is_stream_continuation == other.is_stream_continuation+ && lines_with_sources_eq(&self.lines, &other.lines)+ }+}+impl StreamingPlanTailCell {pub(crate) fn new(lines: Vec<HyperlinkLine>, is_stream_continuation: bool) -> Self {Self {diff --git a/codex-rs/tui/src/history_cell/snapshots/codex_tui__history_cell__tests__user_image_labels_follow_the_painted_prompt_surface.snap b/codex-rs/tui/src/history_cell/snapshots/codex_tui__history_cell__tests__user_image_labels_follow_the_painted_prompt_surface.snapindex ce43b56f63..2968505509 100644--- a/codex-rs/tui/src/history_cell/snapshots/codex_tui__history_cell__tests__user_image_labels_follow_the_painted_prompt_surface.snap+++ b/codex-rs/tui/src/history_cell/snapshots/codex_tui__history_cell__tests__user_image_labels_follow_the_painted_prompt_surface.snap@@ -1,5 +1,6 @@---source: tui/src/history_cell/tests.rs+assertion_line: 2425expression: "snapshots.join(\"\\n\")"---(255, 255, 255): Buffer {@@ -13,11 +14,11 @@ expression: "snapshots.join(\"\\n\")"],styles: [x: 0, y: 0, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,- x: 0, y: 1, fg: Rgb(28, 100, 200), bg: Rgb(244, 244, 244), underline: Reset, modifier: NONE,+ x: 0, y: 1, fg: Rgb(28, 100, 200), bg: Rgb(249, 249, 249), underline: Reset, modifier: NONE,x: 12, y: 1, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,- x: 0, y: 3, fg: Reset, bg: Rgb(244, 244, 244), underline: Reset, modifier: BOLD | DIM,- x: 2, y: 3, fg: Rgb(28, 100, 200), bg: Rgb(244, 244, 244), underline: Reset, modifier: NONE,- x: 12, y: 3, fg: Reset, bg: Rgb(244, 244, 244), underline: Reset, modifier: NONE,+ x: 0, y: 3, fg: Reset, bg: Rgb(249, 249, 249), underline: Reset, modifier: BOLD | DIM,+ x: 2, y: 3, fg: Rgb(28, 100, 200), bg: Rgb(249, 249, 249), underline: Reset, modifier: NONE,+ x: 12, y: 3, fg: Reset, bg: Rgb(249, 249, 249), underline: Reset, modifier: NONE,x: 27, y: 3, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,]}@@ -32,11 +33,11 @@ expression: "snapshots.join(\"\\n\")"],styles: [x: 0, y: 0, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,- x: 0, y: 1, fg: Rgb(99, 168, 248), bg: Rgb(46, 48, 57), underline: Reset, modifier: NONE,+ x: 0, y: 1, fg: Rgb(99, 168, 248), bg: Rgb(55, 57, 66), underline: Reset, modifier: NONE,x: 12, y: 1, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,- x: 0, y: 3, fg: Reset, bg: Rgb(46, 48, 57), underline: Reset, modifier: BOLD | DIM,- x: 2, y: 3, fg: Rgb(99, 168, 248), bg: Rgb(46, 48, 57), underline: Reset, modifier: NONE,- x: 12, y: 3, fg: Reset, bg: Rgb(46, 48, 57), underline: Reset, modifier: NONE,+ x: 0, y: 3, fg: Reset, bg: Rgb(55, 57, 66), underline: Reset, modifier: BOLD | DIM,+ x: 2, y: 3, fg: Rgb(99, 168, 248), bg: Rgb(55, 57, 66), underline: Reset, modifier: NONE,+ x: 12, y: 3, fg: Reset, bg: Rgb(55, 57, 66), underline: Reset, modifier: NONE,x: 27, y: 3, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,]}@@ -51,11 +52,11 @@ expression: "snapshots.join(\"\\n\")"],styles: [x: 0, y: 0, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,- x: 0, y: 1, fg: Rgb(243, 248, 254), bg: Rgb(114, 114, 114), underline: Reset, modifier: NONE,+ x: 0, y: 1, fg: Rgb(5, 9, 14), bg: Rgb(120, 120, 120), underline: Reset, modifier: NONE,x: 12, y: 1, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,- x: 0, y: 3, fg: Reset, bg: Rgb(114, 114, 114), underline: Reset, modifier: BOLD | DIM,- x: 2, y: 3, fg: Rgb(243, 248, 254), bg: Rgb(114, 114, 114), underline: Reset, modifier: NONE,- x: 12, y: 3, fg: Reset, bg: Rgb(114, 114, 114), underline: Reset, modifier: NONE,+ x: 0, y: 3, fg: Reset, bg: Rgb(120, 120, 120), underline: Reset, modifier: BOLD | DIM,+ x: 2, y: 3, fg: Rgb(5, 9, 14), bg: Rgb(120, 120, 120), underline: Reset, modifier: NONE,+ x: 12, y: 3, fg: Reset, bg: Rgb(120, 120, 120), underline: Reset, modifier: NONE,x: 27, y: 3, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,]}diff --git a/codex-rs/tui/src/history_cell/spoken_artifacts.rs b/codex-rs/tui/src/history_cell/spoken_artifacts.rsindex ae13971b9d..c44cb43c7f 100644--- a/codex-rs/tui/src/history_cell/spoken_artifacts.rs+++ b/codex-rs/tui/src/history_cell/spoken_artifacts.rs@@ -7,12 +7,14 @@ use crate::width::display_width;use ratatui::style::Modifier;use ratatui::text::Span;use std::path::Path;+use std::sync::Arc;const MAX_ARTIFACT_CANDIDATES: usize = 16;pub(super) fn annotate_spoken_artifacts(lines: &mut [HyperlinkLine], cwd: &Path) {let mut inspected = 0;- for line in lines {+ let mut source_patches = Vec::new();+ 'lines: for line in &mut *lines {let text = line.line.spans@@ -46,7 +48,7 @@ pub(super) fn annotate_spoken_artifacts(lines: &mut [HyperlinkLine], cwd: &Path)}inspected += 1;if inspected > MAX_ARTIFACT_CANDIDATES {- return;+ break 'lines;}let Some(file) = TrustedWorkspaceFile::validate(cwd, path) else {continue;@@ -61,6 +63,17 @@ pub(super) fn annotate_spoken_artifacts(lines: &mut [HyperlinkLine], cwd: &Path)}line.hyperlinks.push(TerminalHyperlink::trusted_workspace_file(columns, file));+ if let Some(source) = &line.source {+ let start = byte_start.max(source.prefix_bytes);+ let end = byte_end.min(source.prefix_bytes + source.range.len());+ if start < end {+ source_patches.push((+ Arc::clone(&source.text),+ source.range.start + start - source.prefix_bytes+ ..source.range.start + end - source.prefix_bytes,+ ));+ }+ }let mut offset = 0;for span in std::mem::take(&mut line.line.spans) {@@ -91,4 +104,52 @@ pub(super) fn annotate_spoken_artifacts(lines: &mut [HyperlinkLine], cwd: &Path)}line.hyperlinks.sort_by_key(|link| link.columns.start);}++ // Every wrapped fragment must retain all annotations on its shared logical line.+ while let Some((text, range)) = source_patches.pop() {+ let mut ranges = vec![range];+ source_patches.retain(|(other, range)| {+ if Arc::ptr_eq(&text, other) {+ ranges.push(range.clone());+ false+ } else {+ true+ }+ });+ let mut sources = lines+ .iter_mut()+ .filter_map(|line| line.source.as_mut())+ .filter(|source| Arc::ptr_eq(&source.text, &text));+ let Some(first) = sources.next() else {+ continue;+ };+ let mut styles = Vec::new();+ for (span, style) in first.styles.iter() {+ let mut boundaries = vec![span.start, span.end];+ boundaries.extend(+ ranges+ .iter()+ .flat_map(|range| [range.start, range.end])+ .filter(|offset| span.start < *offset && *offset < span.end),+ );+ boundaries.sort_unstable();+ boundaries.dedup();+ for pair in boundaries.windows(/*size*/ 2) {+ let range = pair[0]..pair[1];+ let style = if ranges+ .iter()+ .any(|patch| patch.start < range.end && range.start < patch.end)+ {+ style.add_modifier(Modifier::UNDERLINED)+ } else {+ *style+ };+ styles.push((range, style));+ }+ }+ first.styles = styles.into();+ for source in sources {+ source.styles = Arc::clone(&first.styles);+ }+ }}diff --git a/codex-rs/tui/src/history_cell/tests.rs b/codex-rs/tui/src/history_cell/tests.rsindex 8f3958011b..5cdf6eb781 100644--- a/codex-rs/tui/src/history_cell/tests.rs+++ b/codex-rs/tui/src/history_cell/tests.rs@@ -120,13 +120,17 @@ fn streaming_agent_tail_blank_line_uses_one_viewport_row() {let cell = StreamingAgentTailCell::new(vec![HyperlinkLine::from("first"),- HyperlinkLine::from(""),+ HyperlinkLine::from(" "),HyperlinkLine::from("second"),],/*is_first_line*/ false,);- let lines = cell.display_lines(/*width*/ 80);+ let rendered = cell.display_hyperlink_lines(/*width*/ 80);+ let source = rendered[1].source.as_ref().expect("blank row source");+ assert_eq!((source.prefix_bytes, source.range.clone()), (0, 0..0));+ assert_eq!(source.text.as_ref(), " ");+ let lines = visible_lines(rendered);insta::assert_snapshot!(render_lines(&lines).join("\n"), @" firstsecond");diff --git a/codex-rs/tui/src/insert_history.rs b/codex-rs/tui/src/insert_history.rsindex 73027d7581..e5ad5a277a 100644--- a/codex-rs/tui/src/insert_history.rs+++ b/codex-rs/tui/src/insert_history.rs@@ -332,6 +332,7 @@ fn write_history_line<W: Write>(}).collect();let merged_line = HyperlinkLine {+ source: None,line: Line::from(merged_spans),hyperlinks: line.hyperlinks.clone(),};diff --git a/codex-rs/tui/src/markdown_render.rs b/codex-rs/tui/src/markdown_render.rsindex 4cdd619a55..4decb1eb01 100644--- a/codex-rs/tui/src/markdown_render.rs+++ b/codex-rs/tui/src/markdown_render.rs@@ -2001,6 +2001,11 @@ where}} else {let mut spans = self.current_initial_indent.clone();+ let mut source =+ crate::terminal_hyperlinks::LogicalLineSource::from_line(&line.line);+ source.prefix_bytes = spans.iter().map(|span| span.content.len()).sum();+ source.continuation_indent = self.current_subsequent_indent.clone().into();+ line.source = Some(source);let shift = Self::spans_display_width(&spans);spans.append(&mut line.line.spans);for hyperlink in &mut line.hyperlinks {@@ -2180,6 +2185,7 @@ mod markdown_render_tests {mod tests {use super::*;use pretty_assertions::assert_eq;+ use ratatui::style::Stylize;use ratatui::text::Text;fn lines_to_strings(text: &Text<'_>) -> Vec<String> {@@ -2257,9 +2263,19 @@ mod tests {#[test]fn wraps_blockquotes() {- let markdown = "> block quote with content that should wrap nicely";- let rendered = render_markdown_text_with_width(markdown, Some(22));- let lines = lines_to_strings(&rendered);+ let markdown = "> block quote with **content** that should wrap nicely";+ let rendered =+ render_markdown_lines_with_width_and_cwd(markdown, Some(22), /*cwd*/ None);+ let source = rendered[0].source.as_ref().expect("blockquote source");+ assert_eq!(+ source.styled_range(0..source.text.len()),+ Line::from(vec![+ "block quote with ".green(),+ "content".green().bold(),+ " that should wrap nicely".green(),+ ])+ );+ let lines: Vec<_> = rendered.iter().map(|line| line.line.to_string()).collect();assert_eq!(lines,vec![diff --git a/codex-rs/tui/src/markdown_render/web_links_tests.rs b/codex-rs/tui/src/markdown_render/web_links_tests.rsindex d503f77417..608f77f406 100644--- a/codex-rs/tui/src/markdown_render/web_links_tests.rs+++ b/codex-rs/tui/src/markdown_render/web_links_tests.rs@@ -79,6 +79,7 @@ fn supporting_terminals_render_only_the_styled_label_and_keep_its_target() {assert_eq!(render(markdown, /*width*/ 80, display),vec![HyperlinkLine {+ source: None,line: Line::from(label),hyperlinks: vec![TerminalHyperlink::web(0..label_width,diff --git a/codex-rs/tui/src/multi_agents.rs b/codex-rs/tui/src/multi_agents.rsindex cfa05f74dd..1604be9b29 100644--- a/codex-rs/tui/src/multi_agents.rs+++ b/codex-rs/tui/src/multi_agents.rs@@ -318,6 +318,7 @@ pub(crate) fn sub_agent_activity_history_cell(item: &ThreadItem) -> Option<Plain))}+#[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]pub(crate) fn sub_agent_activity_summary(kind: SubAgentActivityKind, agent_path: &str) -> String {match kind {SubAgentActivityKind::Started => format!("Started `{agent_path}`"),diff --git a/codex-rs/tui/src/streaming/controller_preview_tests.rs b/codex-rs/tui/src/streaming/controller_preview_tests.rsindex 60baca07e9..19d4820f94 100644--- a/codex-rs/tui/src/streaming/controller_preview_tests.rs+++ b/codex-rs/tui/src/streaming/controller_preview_tests.rs@@ -2,6 +2,38 @@ use super::*;use crate::terminal_hyperlinks::visible_lines;use pretty_assertions::assert_eq;+#[test]+fn source_only_changes_refresh_the_preview_and_active_tail() {+ let cwd = std::env::temp_dir();+ let mut controller = StreamController::new(Some(5), &cwd, HistoryRenderMode::Rich);+ controller.push("hello");+ let before = controller.current_tail_lines();++ // An entity preserves trailing whitespace that Markdown otherwise trims at EOF.+ assert!(controller.push(" "));+ let after = controller.current_tail_lines();+ assert_eq!(visible_lines(before.clone()), visible_lines(after.clone()));+ assert_eq!(+ after[0].source,+ render_source(+ "hello ",+ Some(5),+ &cwd,+ HistoryRenderMode::Rich,+ /*inline_visualization_context*/ None,+ )[0]+ .source,+ );+ assert_ne!(+ history_cell::StreamingAgentTailCell::new(before.clone(), /*is_first_line*/ true),+ history_cell::StreamingAgentTailCell::new(after.clone(), /*is_first_line*/ true),+ );+ assert_ne!(+ history_cell::StreamingPlanTailCell::new(before, /*is_stream_continuation*/ false),+ history_cell::StreamingPlanTailCell::new(after, /*is_stream_continuation*/ false),+ );+}+#[test]fn unterminated_prose_reflows_and_finishes_without_duplication() {let cwd = std::env::temp_dir();diff --git a/codex-rs/tui/src/streaming/prose_preview.rs b/codex-rs/tui/src/streaming/prose_preview.rsindex 94a848a330..b8b4cdc1cf 100644--- a/codex-rs/tui/src/streaming/prose_preview.rs+++ b/codex-rs/tui/src/streaming/prose_preview.rs@@ -6,6 +6,7 @@ use super::render::render_source;use crate::history_cell::HistoryRenderMode;use crate::inline_visualization::InlineVisualizationContext;use crate::terminal_hyperlinks::HyperlinkLine;+use crate::terminal_hyperlinks::lines_with_sources_eq;use ratatui::text::Line;use std::path::Path;@@ -67,7 +68,7 @@ impl ProsePreview {if start > 0 {lines.insert(0, HyperlinkLine::new(Line::from("…")));}- if self.lines == lines {+ if lines_with_sources_eq(&self.lines, &lines) {return false;}self.lines = lines;diff --git a/codex-rs/tui/src/style.rs b/codex-rs/tui/src/style.rsindex 32e64ca6b8..dee9f16ed6 100644--- a/codex-rs/tui/src/style.rs+++ b/codex-rs/tui/src/style.rs@@ -62,7 +62,6 @@ pub fn user_message_style() -> Style {}/// Submitted prompts use a lighter fill than the editable composer in either theme.-#[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]pub(crate) fn history_prompt_style() -> Style {let Some(background) = default_bg() else {return Style::default();diff --git a/codex-rs/tui/src/terminal_hyperlinks.rs b/codex-rs/tui/src/terminal_hyperlinks.rsindex 390d50d309..7fa6a83045 100644--- a/codex-rs/tui/src/terminal_hyperlinks.rs+++ b/codex-rs/tui/src/terminal_hyperlinks.rs@@ -4,8 +4,10 @@//! when text reaches a terminal buffer or scrollback writer so OSC 8 bytes never affect geometry.mod paragraph;+mod source;pub(crate) use paragraph::HyperlinkParagraph;+pub(crate) use source::LogicalLineSource;use std::num::NonZeroU16;use std::ops::Range;@@ -31,7 +33,6 @@ use crate::render::line_utils::line_to_borrowed;use crate::render::line_utils::line_to_static;use crate::width::display_width;use crate::wrapping::RtOptions;-use crate::wrapping::adaptive_wrap_line;// Destinations are repeated in every linked buffer cell. Leave oversized URLs as plain text.const MAX_HYPERLINK_DESTINATION_BYTES: usize = 8 * 1024;@@ -120,7 +121,7 @@ impl TerminalHyperlink {}}- fn with_columns(&self, columns: Range<usize>) -> Self {+ pub(crate) fn with_columns(&self, columns: Range<usize>) -> Self {Self {columns,destination: self.destination.clone(),@@ -136,10 +137,40 @@ impl TerminalHyperlink {}}-#[derive(Clone, Debug, Default, Eq, PartialEq)]+#[derive(Clone, Default)]pub(crate) struct HyperlinkLine {pub(crate) line: Line<'static>,pub(crate) hyperlinks: Vec<TerminalHyperlink>,+ pub(crate) source: Option<LogicalLineSource>,+}++// Source provenance is shared layout metadata; omit it from visual diagnostics to avoid+// repeating an entire logical line for every wrapped fragment.+impl std::fmt::Debug for HyperlinkLine {+ fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ formatter+ .debug_struct("HyperlinkLine")+ .field("line", &self.line)+ .field("hyperlinks", &self.hyperlinks)+ .finish()+ }+}++impl PartialEq for HyperlinkLine {+ fn eq(&self, other: &Self) -> bool {+ self.line == other.line && self.hyperlinks == other.hyperlinks+ }+}++impl Eq for HyperlinkLine {}++/// Cache equality also tracks source whitespace hidden by display wrapping.+pub(crate) fn lines_with_sources_eq(left: &[HyperlinkLine], right: &[HyperlinkLine]) -> bool {+ left == right+ && left+ .iter()+ .map(|line| &line.source)+ .eq(right.iter().map(|line| &line.source))}impl HyperlinkLine {@@ -147,6 +178,7 @@ impl HyperlinkLine {Self {line,hyperlinks: Vec::new(),+ source: None,}}@@ -155,6 +187,7 @@ impl HyperlinkLine {}pub(crate) fn push_span(&mut self, span: Span<'static>, destination: Option<&str>) {+ self.source = None;let start = self.width();let end = start + display_width(span.content.as_ref());self.line.push_span(span);@@ -168,6 +201,9 @@ impl HyperlinkLine {pub(crate) fn style(mut self, style: ratatui::style::Style) -> Self {self.line = self.line.style(style);+ if let Some(source) = &mut self.source {+ source.line_style = style;+ }self}}@@ -220,6 +256,16 @@ pub(crate) fn prefix_hyperlink_lines(subsequent_prefix.clone()};let shift = display_width(prefix.content.as_ref());+ let mut source = line+ .source+ .take()+ .unwrap_or_else(|| LogicalLineSource::from_line(&line.line));+ source.prefix_bytes += prefix.content.len();+ source+ .continuation_indent+ .spans+ .insert(/*index*/ 0, subsequent_prefix.clone());+ line.source = Some(source);let mut spans = Vec::with_capacity(line.line.spans.len() + 1);spans.push(prefix);spans.extend(line.line.spans);@@ -245,12 +291,14 @@ pub(crate) fn adaptive_wrap_hyperlink_lines(.clone().initial_indent(options.subsequent_indent.clone())};- out.extend(remap_wrapped_line(- line,- adaptive_wrap_line(&line.line, options)- .into_iter()- .map(|wrapped| line_to_static(&wrapped))- .collect(),+ let mut source = line.clone();+ source+ .source+ .get_or_insert_with(|| LogicalLineSource::from_line(&line.line))+ .continuation_indent = options.subsequent_indent.clone();+ out.extend(remap_source_wrapped_line(+ &source,+ crate::wrapping::adaptive_wrap_line_with_source(&line.line, options),));}out@@ -271,11 +319,67 @@ pub(crate) fn annotate_web_urls_in_line(line: Line<'static>) -> HyperlinkLine {out}+/// Project annotations from the exact source slices used by the existing wrapping algorithm.+pub(crate) fn remap_source_wrapped_line(+ source: &HyperlinkLine,+ wrapped: Vec<crate::wrapping::WrappedLine<'_>>,+) -> Vec<HyperlinkLine> {+ let text = line_text(&source.line);+ let mut logical = source+ .source+ .clone()+ .unwrap_or_else(|| LogicalLineSource::from_line(&source.line));+ // Wrapping bakes the row style into each span; mirror it once for all source fragments.+ if logical.line_style != ratatui::style::Style::default() {+ logical.styles = logical+ .styles+ .iter()+ .map(|(range, style)| (range.clone(), logical.line_style.patch(*style)))+ .collect::<Vec<_>>()+ .into();+ }+ let mut source_byte = 0;+ let mut source_column = 0;+ wrapped+ .into_iter()+ .map(|wrapped| {+ let line = line_to_static(&wrapped.line);+ let displayed = line_text(&line);+ let prefix_columns = display_width(&displayed[..wrapped.prefix_bytes]);+ source_column += display_width(&text[source_byte..wrapped.range.start]);+ let start = source_column;+ let end = start + display_width(&text[wrapped.range.clone()]);+ source_byte = wrapped.range.end;+ source_column = end;+ let hyperlinks = source+ .hyperlinks+ .iter()+ .filter_map(|link| {+ let first = link.columns.start.max(start);+ let last = link.columns.end.min(end);+ (first < last).then(|| {+ link.with_columns(+ prefix_columns + first - start..prefix_columns + last - start,+ )+ })+ })+ .collect();+ HyperlinkLine {+ line,+ hyperlinks,+ source: Some(logical.wrapped(wrapped.range, wrapped.prefix_bytes)),+ }+ })+ .collect()+}+/// Re-attach source hyperlink ranges after visible-text wrapping has split a line.////// Link text is matched in display order so a URL split across table rows retains the complete/// destination on every rendered fragment. Whitespace inserted or removed at line boundaries is/// ignored while matching; hyperlink destinations themselves are never reconstructed from output.+/// This legacy projection does not infer logical source provenance. New wrapping callers should+/// pass authoritative ranges to [`remap_source_wrapped_line`].pub(crate) fn remap_wrapped_line(source: &HyperlinkLine,wrapped: Vec<Line<'static>>,@@ -284,7 +388,6 @@ pub(crate) fn remap_wrapped_line(if source.hyperlinks.is_empty() {return out;}-let source_text = line_text(&source.line);let mut source_byte = 0usize;let mut source_column = 0usize;@@ -758,6 +861,7 @@ mod tests {fn decorates_a_contiguous_web_link_with_one_osc8_pair() {let destination = "https://example.com/a/very/long/path";let line = HyperlinkLine {+ source: None,line: Line::from(destination),hyperlinks: vec![TerminalHyperlink::web(/*columns*/ 0..usize::from(destination.cell_width()),@@ -823,6 +927,7 @@ mod tests {wrapped,vec![HyperlinkLine {+ source: None,line: Line::from(" alpha 😀here"),hyperlinks: vec![TerminalHyperlink::web(/*columns*/ 10..14,@@ -830,6 +935,7 @@ mod tests {)],},HyperlinkLine {+ source: None,line: Line::from(" middle there end"),hyperlinks: vec![TerminalHyperlink::web(/*columns*/ 11..16,@@ -1091,6 +1197,7 @@ mod tests {);link.retarget_to_trusted_file(&file_url);let line = HyperlinkLine {+ source: None,line: Line::from("view"),hyperlinks: vec![link],};diff --git a/codex-rs/tui/src/terminal_hyperlinks/source.rs b/codex-rs/tui/src/terminal_hyperlinks/source.rsnew file mode 100644index 0000000000..cb1a343c52--- /dev/null+++ b/codex-rs/tui/src/terminal_hyperlinks/source.rs@@ -0,0 +1,114 @@+//! Logical text and margins retained when display wrapping removes whitespace or adds a gutter.++use ratatui::style::Style;+use ratatui::text::Line;+use ratatui::text::Span;+use std::ops::Range;+use std::sync::Arc;++/// Wrapping policy of an existing display renderer.+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]+pub(crate) enum LineWrapPolicy {+ #[default]+ Word,+}++/// A displayed line's contiguous fragment of one original logical line.+///+/// Wrapped fragments share `text`. `prefix_bytes` counts synthetic display bytes before+/// the fragment, so selection never has to infer whether a gutter belongs to the source.+#[derive(Clone, Debug, Eq, PartialEq)]+pub(crate) struct LogicalLineSource {+ pub(crate) text: Arc<str>,+ /// Span styles share the text's byte coordinates, including whitespace omitted by wrapping.+ pub(crate) styles: Arc<[(Range<usize>, Style)]>,+ /// Row style, applied beneath explicit span styles just like ratatui's `Line`.+ pub(crate) line_style: Style,+ /// A later uniform span-style patch, such as the dim/italic reasoning treatment.+ pub(crate) span_style: Style,+ pub(crate) range: Range<usize>,+ pub(crate) prefix_bytes: usize,+ pub(crate) wrap_policy: LineWrapPolicy,+ pub(crate) continuation_indent: Line<'static>,+ /// Blank columns after wrapped content; they remain outside the copied source text.+ pub(crate) right_reserve: u16,+}++impl LogicalLineSource {+ pub(crate) fn new(text: String) -> Self {+ let end = text.len();+ Self {+ text: text.into(),+ styles: vec![(0..end, Style::default())].into(),+ line_style: Style::default(),+ span_style: Style::default(),+ range: 0..end,+ prefix_bytes: 0,+ wrap_policy: LineWrapPolicy::Word,+ continuation_indent: Line::default(),+ right_reserve: 0,+ }+ }++ pub(crate) fn from_line(line: &Line<'_>) -> Self {+ let mut source = Self::new(+ line.spans+ .iter()+ .map(|span| span.content.as_ref())+ .collect(),+ );+ let mut offset = 0;+ source.line_style = line.style;+ source.styles = line+ .spans+ .iter()+ .map(|span| {+ let start = offset;+ offset += span.content.len();+ (start..offset, span.style)+ })+ .collect::<Vec<_>>()+ .into();+ source+ }++ #[allow(+ dead_code,+ reason = "Used by the activity presentation layer of this stack."+ )]+ pub(crate) fn styled_range(&self, range: Range<usize>) -> Line<'static> {+ Line::from(+ self.styles+ .iter()+ .filter_map(|(style_range, style)| {+ let start = style_range.start.max(range.start);+ let end = style_range.end.min(range.end);+ (start < end).then(|| {+ Span::styled(+ self.text[start..end].to_owned(),+ self.line_style.patch(*style).patch(self.span_style),+ )+ })+ })+ .collect::<Vec<_>>(),+ )+ }++ pub(super) fn wrapped(&self, displayed: Range<usize>, prefix_bytes: usize) -> Self {+ let source_start = self.prefix_bytes;+ let source_end = source_start + self.range.len();+ let start = displayed.start.clamp(source_start, source_end);+ let end = displayed.end.clamp(source_start, source_end);+ Self {+ text: Arc::clone(&self.text),+ styles: Arc::clone(&self.styles),+ line_style: self.line_style,+ span_style: self.span_style,+ range: self.range.start + start - source_start..self.range.start + end - source_start,+ prefix_bytes: prefix_bytes + start.saturating_sub(displayed.start).min(displayed.len()),+ wrap_policy: self.wrap_policy,+ continuation_indent: self.continuation_indent.clone(),+ right_reserve: self.right_reserve,+ }+ }+}diff --git a/codex-rs/tui/src/terminal_hyperlinks_tests.rs b/codex-rs/tui/src/terminal_hyperlinks_tests.rsindex 8648631cef..ead3f3662b 100644--- a/codex-rs/tui/src/terminal_hyperlinks_tests.rs+++ b/codex-rs/tui/src/terminal_hyperlinks_tests.rs@@ -15,6 +15,7 @@ fn oversized_destinations_remain_plain_text() {// Explicit Markdown links can reach the cell marker without bare-URL detection.let line = HyperlinkLine {+ source: None,line: Line::from("visible"),hyperlinks: vec![TerminalHyperlink::web(/*columns*/ 0..7, oversized)],};diff --git a/codex-rs/tui/src/wrapping.rs b/codex-rs/tui/src/wrapping.rsindex d65c6b88aa..a1d35ff5a4 100644--- a/codex-rs/tui/src/wrapping.rs+++ b/codex-rs/tui/src/wrapping.rs@@ -46,12 +46,16 @@ struct ProjectedText {grapheme_boundaries: Vec<usize>,}-/// Replaces halfwidth sound-mark graphemes with equally wide, textwrap-safe placeholders.+/// Replaces compound graphemes with equally wide, textwrap-safe placeholders.////// Source boundaries recover original byte offsets, while grapheme boundaries keep placeholders/// indivisible and preserve leading whitespace as a wrapping opportunity.-fn project_halfwidth_sound_marks(text: &str) -> Option<ProjectedText> {- if !text.contains(['\u{FF9E}', '\u{FF9F}']) {+fn project_complex_graphemes(text: &str) -> Option<ProjectedText> {+ if !text.contains(['\u{FF9E}', '\u{FF9F}'])+ && !text+ .graphemes(/*is_extended*/ true)+ .any(|grapheme| grapheme.chars().count() > 1)+ {return None;}@@ -59,7 +63,7 @@ fn project_halfwidth_sound_marks(text: &str) -> Option<ProjectedText> {let mut source_boundaries = vec![(0, 0)];let mut grapheme_boundaries = vec![0];for (source_start, grapheme) in text.grapheme_indices(/*is_extended*/ true) {- if grapheme.contains(['\u{FF9E}', '\u{FF9F}']) {+ if grapheme.chars().count() > 1 || grapheme.contains(['\u{FF9E}', '\u{FF9F}']) {let source_end = source_start + grapheme.len();let content_start = grapheme.find(|ch: char| !ch.is_whitespace())@@ -72,6 +76,10 @@ fn project_halfwidth_sound_marks(text: &str) -> Option<ProjectedText> {}let width = display_width(content);+ if width == 0 && !content.is_empty() {+ projected.push_str(content);+ source_boundaries.push((projected.len(), source_end));+ }let projected_start = projected.len();for _ in 0..width / 2 {if projected.len() > projected_start {@@ -233,7 +241,7 @@ whereO: Into<Options<'a>>,{let opts = width_or_options.into();- if let Some(projected) = project_halfwidth_sound_marks(text) {+ if let Some(projected) = project_complex_graphemes(text) {return wrap_projected_ranges(&projected, &opts, /*include_trailing_spaces*/ true);}let mut lines: Vec<Range<usize>> = Vec::new();@@ -279,7 +287,7 @@ whereO: Into<Options<'a>>,{let opts = width_or_options.into();- if let Some(projected) = project_halfwidth_sound_marks(text) {+ if let Some(projected) = project_complex_graphemes(text) {return wrap_projected_ranges(&projected, &opts, /*include_trailing_spaces*/ false);}let mut lines: Vec<Range<usize>> = Vec::new();@@ -701,6 +709,24 @@ pub(crate) fn url_preserving_wrap_options<'a>(opts: RtOptions<'a>) -> RtOptions</// while a genuinely overlong non-URL token can still split if needed.#[must_use]pub(crate) fn adaptive_wrap_line<'a>(line: &'a Line<'a>, base: RtOptions<'a>) -> Vec<Line<'a>> {+ adaptive_wrap_line_with_source(line, base)+ .into_iter()+ .map(|wrapped| wrapped.line)+ .collect()+}++/// A display row and the exact source fragment used to build it.+pub(crate) struct WrappedLine<'a> {+ pub(crate) line: Line<'a>,+ pub(crate) range: Range<usize>,+ pub(crate) prefix_bytes: usize,+}++/// Preserve wrapping's source ranges for selection and hyperlink projection.+pub(crate) fn adaptive_wrap_line_with_source<'a>(+ line: &'a Line<'a>,+ base: RtOptions<'a>,+) -> Vec<WrappedLine<'a>> {let (flat, span_bounds) = flatten_line(line);let mut saw_url = false;let mut saw_non_url = false;@@ -854,6 +880,20 @@ impl<'a> RtOptions<'a> {#[must_use]pub(crate) fn word_wrap_line<'a, O>(line: &'a Line<'a>, width_or_options: O) -> Vec<Line<'a>>+where+ O: Into<RtOptions<'a>>,+{+ word_wrap_line_with_source(line, width_or_options)+ .into_iter()+ .map(|wrapped| wrapped.line)+ .collect()+}++/// Standard wrapping with the same source ranges used to slice styled spans.+pub(crate) fn word_wrap_line_with_source<'a, O>(+ line: &'a Line<'a>,+ width_or_options: O,+) -> Vec<WrappedLine<'a>>whereO: Into<RtOptions<'a>>,{@@ -866,7 +906,7 @@ fn word_wrap_flattened_line<'a>(flat: &str,span_bounds: &[(Range<usize>, ratatui::style::Style)],rt_opts: RtOptions<'a>,-) -> Vec<Line<'a>> {+) -> Vec<WrappedLine<'a>> {let opts = Options::new(rt_opts.width).line_ending(rt_opts.line_ending).break_words(rt_opts.break_words)@@ -874,7 +914,7 @@ fn word_wrap_flattened_line<'a>(.word_separator(rt_opts.word_separator).word_splitter(rt_opts.word_splitter);- let mut out: Vec<Line<'a>> = Vec::new();+ let mut out: Vec<WrappedLine<'a>> = Vec::new();// Compute first line range with reduced width due to initial indent.let initial_width_available = opts@@ -883,7 +923,16 @@ fn word_wrap_flattened_line<'a>(.max(1);let initial_wrapped = wrap_ranges_trim(flat, opts.clone().width(initial_width_available));let Some(first_line_range) = initial_wrapped.first() else {- return vec![rt_opts.initial_indent.clone()];+ return vec![WrappedLine {+ line: rt_opts.initial_indent.clone().style(line.style),+ range: 0..0,+ prefix_bytes: rt_opts+ .initial_indent+ .spans+ .iter()+ .map(|span| span.content.len())+ .sum(),+ }];};// Build first wrapped line with initial indent.@@ -895,14 +944,22 @@ fn word_wrap_flattened_line<'a>(&mut sliced.spans.into_iter()- .map(|s| s.patch_style(line.style))+ .map(|span| Span::styled(span.content, line.style.patch(span.style))).collect(),);first_line.spans = spans;- out.push(first_line);+ out.push(WrappedLine {+ line: first_line,+ range: first_line_range.clone(),+ prefix_bytes: rt_opts+ .initial_indent+ .spans+ .iter()+ .map(|span| span.content.len())+ .sum(),+ });}- // Wrap the remainder using subsequent indent width and map back to original indices.let base = first_line_range.end;let skip_leading_spaces = flat[base..].chars().take_while(|c| *c == ' ').count();let base = base + skip_leading_spaces;@@ -910,24 +967,55 @@ fn word_wrap_flattened_line<'a>(.width.saturating_sub(line_width(&rt_opts.subsequent_indent)).max(1);- let remaining_wrapped = wrap_ranges_trim(&flat[base..], opts.width(subsequent_width_available));- for r in &remaining_wrapped {- if r.is_empty() {+ // First-fit decisions do not depend on later rows. Reuse the full first pass when+ // both indents leave the same width and the remainder starts after a complete word.+ // Splitting inside a word can change hyphenation when the remainder is tokenized again.+ // Custom tokenizers can also repartition the remainder, so they retain the second pass.+ let remaining_wrapped = if initial_width_available == subsequent_width_available+ && matches!(rt_opts.wrap_algorithm, textwrap::WrapAlgorithm::FirstFit)+ && matches!(+ rt_opts.word_separator,+ WordSeparator::AsciiSpace | WordSeparator::UnicodeBreakProperties+ )+ && (skip_leading_spaces > 0 || base == flat.len())+ // The projected and plain text wrappers interpret control characters differently.+ && !flat.as_bytes().iter().any(u8::is_ascii_control)+ && initial_wrapped+ .get(/*index*/ 1)+ .map_or(base == flat.len(), |range| range.start == base)+ {+ initial_wrapped.into_iter().skip(/*n*/ 1).collect()+ } else {+ wrap_ranges_trim(&flat[base..], opts.width(subsequent_width_available))+ .into_iter()+ .map(|range| (range.start + base)..(range.end + base))+ .collect::<Vec<_>>()+ };+ for offset_range in remaining_wrapped {+ if offset_range.is_empty() {continue;}let mut subsequent_line = rt_opts.subsequent_indent.clone().style(line.style);- let offset_range = (r.start + base)..(r.end + base);let sliced = slice_line_spans(line, span_bounds, &offset_range);let mut spans = subsequent_line.spans;spans.append(&mut sliced.spans.into_iter()- .map(|s| s.patch_style(line.style))+ .map(|span| Span::styled(span.content, line.style.patch(span.style))).collect(),);subsequent_line.spans = spans;- out.push(subsequent_line);+ out.push(WrappedLine {+ line: subsequent_line,+ range: offset_range,+ prefix_bytes: rt_opts+ .subsequent_indent+ .spans+ .iter()+ .map(|span| span.content.len())+ .sum(),+ });}out@@ -950,7 +1038,7 @@ fn mixed_url_wrap_line<'a>(flat: &str,span_bounds: &[(Range<usize>, ratatui::style::Style)],rt_opts: RtOptions<'a>,-) -> Vec<Line<'a>> {+) -> Vec<WrappedLine<'a>> {let initial_width_available = rt_opts.width.saturating_sub(line_width(&rt_opts.initial_indent))@@ -969,20 +1057,38 @@ fn mixed_url_wrap_line<'a>(rt_opts.subsequent_indent.clone()}.style(line.style);+ let prefix_bytes = wrapped_line+ .spans+ .iter()+ .map(|span| span.content.len())+ .sum();let sliced = slice_line_spans(line, span_bounds, range);let mut spans = wrapped_line.spans;spans.extend(sliced.spans.into_iter()- .map(|span| span.patch_style(line.style)),+ .map(|span| Span::styled(span.content, line.style.patch(span.style))),);wrapped_line.spans = spans;- out.push(wrapped_line);+ out.push(WrappedLine {+ line: wrapped_line,+ range: range.clone(),+ prefix_bytes,+ });}if out.is_empty() {- vec![rt_opts.initial_indent.clone()]+ vec![WrappedLine {+ line: rt_opts.initial_indent.clone().style(line.style),+ range: 0..0,+ prefix_bytes: rt_opts+ .initial_indent+ .spans+ .iter()+ .map(|span| span.content.len())+ .sum(),+ }]} else {out}@@ -1269,6 +1375,10 @@ fn slice_line_spans<'a>(}}+#[cfg(test)]+#[path = "wrapping_reuse_tests.rs"]+mod reuse_tests;+#[cfg(test)]mod tests {use super::*;@@ -1293,6 +1403,24 @@ mod tests {assert_eq!(concat_line(&out[0]), "hello");}+ #[test]+ fn narrow_wrap_ranges_preserve_compound_graphemes() {+ assert_eq!(+ wrap_ranges_trim("👩💻e\u{301}x", /*width_or_options*/ 2),+ vec![0..11, 11..15],+ );+ for text in ["\u{301}\u{302}", " \u{301}\u{302}"] {+ assert_eq!(+ wrap_ranges_trim(text, /*width_or_options*/ 2),+ vec![0..text.len()]+ );+ }+ assert_eq!(+ wrap_ranges("\u{301}\u{302}", /*width_or_options*/ 2),+ vec![0..5],+ );+ }+#[test]fn simple_unstyled_wrap_narrow_width() {let line = Line::from("hello world");diff --git a/codex-rs/tui/src/wrapping_reuse_tests.rs b/codex-rs/tui/src/wrapping_reuse_tests.rsnew file mode 100644index 0000000000..0dcd15c8a0--- /dev/null+++ b/codex-rs/tui/src/wrapping_reuse_tests.rs@@ -0,0 +1,114 @@+//! Compare reused first-fit rows with the generic wrapping path, including source provenance.++use super::*;+use pretty_assertions::assert_eq;+use ratatui::style::Stylize;++#[test]+fn custom_word_separator_reprocesses_the_remainder() {+ let separator = WordSeparator::Custom(|text| {+ let Some(space) = text.find(' ') else {+ return Box::new(std::iter::once(Word::from(text)));+ };+ Box::new([Word::from(&text[..=space]), Word::from(&text[space + 1..])].into_iter())+ });+ let line = Line::from("one two three");+ let rows =+ word_wrap_line_with_source(&line, RtOptions::new(/*width*/ 5).word_separator(separator))+ .into_iter()+ .map(|row| (row.line, row.range))+ .collect::<Vec<_>>();+ assert_eq!(+ rows,+ vec![+ (Line::from("one"), 0..3),+ (Line::from("two"), 4..7),+ (Line::from("three"), 8..13),+ ]+ );+}++#[test]+fn first_fit_reuse_preserves_styled_rows_and_source_ranges() {+ // A custom first-fit function exercises the unchanged generic path without copying+ // its implementation into the test. Compare complete rows, styles and byte ranges.+ let generic_first_fit = textwrap::WrapAlgorithm::Custom(|words, widths| {+ textwrap::WrapAlgorithm::FirstFit.wrap(words, widths)+ });+ // Cover distinct split, width, indentation and separator boundaries without a random matrix.+ for (text, width, initial, subsequent, break_words, separator) in [+ ("", 0, "", "", true, WordSeparator::AsciiSpace),+ (+ "hello world",+ 0,+ "> ",+ " ",+ true,+ WordSeparator::AsciiSpace,+ ),+ (+ "cafe\u{301} 中文 👩🏽💻 🇧🇷 ガ",+ 2,+ "",+ "",+ true,+ WordSeparator::UnicodeBreakProperties,+ ),+ (+ "a-very-long-hyphenated-word",+ 5,+ "界",+ "ab",+ true,+ WordSeparator::AsciiSpace,+ ),+ (+ "https://example.com/a/b tail",+ 17,+ "> ",+ " ",+ false,+ WordSeparator::AsciiSpace,+ ),+ (+ "alpha beta\u{a0}gamma\u{200b}delta",+ 5,+ "",+ " ",+ true,+ WordSeparator::UnicodeBreakProperties,+ ),+ (+ "one\n two\r\nthree\tfour",+ 5,+ "> ",+ " ",+ true,+ WordSeparator::AsciiSpace,+ ),+ (+ "\u{1b}[31mred\u{1b}[0m tail",+ 80,+ "",+ "",+ false,+ WordSeparator::AsciiSpace,+ ),+ ] {+ let line = Line::from(vec![text.bold(), " suffix".cyan()]).italic();+ let options = RtOptions::new(width)+ .initial_indent(Line::from(initial.red()))+ .subsequent_indent(Line::from(subsequent.green()))+ .break_words(break_words)+ .word_separator(separator);+ let actual = word_wrap_line_with_source(&line, options.clone())+ .into_iter()+ .map(|row| (row.line, row.range, row.prefix_bytes))+ .collect::<Vec<_>>();+ let expected = word_wrap_line_with_source(&line, options.wrap_algorithm(generic_first_fit))+ .into_iter()+ .map(|row| (row.line, row.range, row.prefix_bytes))+ .collect::<Vec<_>>();+ assert_eq!(actual, expected, "text={text:?}, width={width}");+ }+}