Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Anchor transcript scrolling to entries and bound viewport rendering (#46721)

Eric Trauta63ae005d464
diff --git a/codex-rs/tui/src/app/history_pagination.rs b/codex-rs/tui/src/app/history_pagination.rs
index f1eb0f7cfc..09fe84fc58 100644
--- a/codex-rs/tui/src/app/history_pagination.rs
+++ b/codex-rs/tui/src/app/history_pagination.rs
@@ -232,7 +232,7 @@ impl App {
self.scrollback_has_older_history = app_server.has_older_history(thread_id);
let mut continue_to_start = false;
if let Some(Overlay::Transcript(overlay)) = self.overlay.as_mut() {
- let index = overlay.prepend(cells.clone(), width);
+ let index = overlay.prepend(cells.clone());
self.transcript_cells.splice(index..index, cells);
let previous_state = overlay.set_history_state(if self.scrollback_has_older_history {
TranscriptHistoryState::Partial
diff --git a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs
index 3ee3a2ecc5..34101e2a9e 100644
--- a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs
+++ b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs
@@ -2651,10 +2651,6 @@ async fn underfilled_scrollback_fetches_older_pages_without_opening_the_transcri
.await;
assert!(app.scrollback_has_older_history);
if let Some(Overlay::Transcript(overlay)) = app.overlay.as_mut() {
- overlay.handle_event(
- &mut tui,
- TuiEvent::Key(KeyEvent::new(KeyCode::Home, KeyModifiers::NONE)),
- )?;
let area = Rect::new(
/*x*/ 0, /*y*/ 0, /*width*/ 100, /*height*/ 16,
);
@@ -2670,6 +2666,9 @@ async fn underfilled_scrollback_fetches_older_pages_without_opening_the_transcri
.collect::<Vec<_>>()
.join("\n")
};
+ // Inspect the loaded start without Home, which now requests all older pages.
+ render_overlay(overlay);
+ overlay.scroll(isize::MIN);
let partial = render_overlay(overlay);
assert!(partial.contains("Earlier messages are available — scroll up to load them"));
assert!(!partial.contains("OpenAI Codex"));
diff --git a/codex-rs/tui/src/app_backtrack.rs b/codex-rs/tui/src/app_backtrack.rs
index f3c5e64c7d..71cfc7600c 100644
--- a/codex-rs/tui/src/app_backtrack.rs
+++ b/codex-rs/tui/src/app_backtrack.rs
@@ -328,7 +328,7 @@ impl App {
let close_overlay = t.is_done();
if !close_overlay
&& active_key.is_some_and(|key| key.animation_tick.is_some())
- && t.is_scrolled_to_bottom()
+ && t.live_tail_visible()
{
tui.frame_requester()
.schedule_frame_in(std::time::Duration::from_millis(50));
diff --git a/codex-rs/tui/src/app_backtrack/legacy_input.rs b/codex-rs/tui/src/app_backtrack/legacy_input.rs
index c36e83bd76..6a7f8ac42e 100644
--- a/codex-rs/tui/src/app_backtrack/legacy_input.rs
+++ b/codex-rs/tui/src/app_backtrack/legacy_input.rs
@@ -13,7 +13,7 @@ impl App {
event: TuiEvent,
) -> Result<bool> {
if let TuiEvent::Key(key_event) = &event
- && let Some(Overlay::Transcript(overlay)) = self.overlay.as_ref()
+ && let Some(Overlay::Transcript(overlay)) = self.overlay.as_mut()
&& (overlay.should_load_older(*key_event)
|| (self.backtrack.overlay_preview_active
&& self.backtrack.nth_user_message == 0
diff --git a/codex-rs/tui/src/pager_overlay.rs b/codex-rs/tui/src/pager_overlay.rs
index 705bf4b1e1..0e4b9abff5 100644
--- a/codex-rs/tui/src/pager_overlay.rs
+++ b/codex-rs/tui/src/pager_overlay.rs
@@ -31,8 +31,6 @@ use crate::key_hint::KeyBinding;
use crate::key_hint::KeyBindingListExt;
use crate::key_hint::ShortcutHint;
use crate::keymap::PagerKeymap;
-use crate::render::Insets;
-use crate::render::renderable::InsetRenderable;
use crate::render::renderable::Renderable;
use crate::terminal_hyperlinks::HyperlinkLine;
use crate::tui;
@@ -50,19 +48,17 @@ use ratatui::widgets::Clear;
use ratatui::widgets::Paragraph;
use ratatui::widgets::Widget;
use ratatui::widgets::Wrap;
-use scrolling::CellRenderable;
-use scrolling::HyperlinkLinesRenderable;
use scrolling::render_offset_content;
pub(crate) enum Overlay {
- Transcript(TranscriptOverlay),
- Static(StaticOverlay),
+ Transcript(Box<TranscriptOverlay>),
+ Static(Box<StaticOverlay>),
Analytics(Box<crate::analytics::AnalyticsView>),
}
impl Overlay {
pub(crate) fn new_transcript(cells: Vec<Arc<dyn HistoryCell>>, keymap: PagerKeymap) -> Self {
- Self::Transcript(TranscriptOverlay::new(cells, keymap))
+ Self::Transcript(Box::new(TranscriptOverlay::new(cells, keymap)))
}
pub(crate) fn new_static_with_lines(
@@ -70,7 +66,7 @@ impl Overlay {
title: String,
keymap: PagerKeymap,
) -> Self {
- Self::Static(StaticOverlay::with_title(lines, title, keymap))
+ Self::Static(Box::new(StaticOverlay::with_title(lines, title, keymap)))
}
pub(crate) fn new_static_with_renderables(
@@ -78,7 +74,11 @@ impl Overlay {
title: String,
keymap: PagerKeymap,
) -> Self {
- Self::Static(StaticOverlay::with_renderables(renderables, title, keymap))
+ Self::Static(Box::new(StaticOverlay::with_renderables(
+ renderables,
+ title,
+ keymap,
+ )))
}
pub(crate) fn handle_event(&mut self, tui: &mut tui::Tui, event: TuiEvent) -> Result<()> {
@@ -159,11 +159,6 @@ struct PagerView {
title: String,
keymap: PagerKeymap,
last_content_height: Option<usize>,
- last_rendered_height: Option<usize>,
- /// Percentages are meaningful only when the full scrollable history is known.
- scroll_percentage_visible: bool,
- /// If set, on next render ensure this chunk is visible.
- pending_scroll_chunk: Option<usize>,
}
impl PagerView {
@@ -179,9 +174,6 @@ impl PagerView {
title,
keymap,
last_content_height: None,
- last_rendered_height: None,
- scroll_percentage_visible: true,
- pending_scroll_chunk: None,
}
}
@@ -198,12 +190,6 @@ impl PagerView {
let content_area = self.content_area(area);
self.update_last_content_height(content_area.height);
let content_height = self.content_height(content_area.width);
- self.last_rendered_height = Some(content_height);
- // If there is a pending request to scroll a specific chunk into view,
- // satisfy it now that wrapping is up to date for this width.
- if let Some(idx) = self.pending_scroll_chunk.take() {
- self.ensure_chunk_visible(idx, content_area);
- }
self.scroll_offset = self
.scroll_offset
.min(content_height.saturating_sub(content_area.height as usize));
@@ -270,9 +256,6 @@ impl PagerView {
Span::from("─".repeat(sep_rect.width as usize))
.dim()
.render(sep_rect, buf);
- if !self.scroll_percentage_visible {
- return;
- }
let percent = if total_len == 0 {
100
} else {
@@ -359,53 +342,6 @@ impl PagerView {
}
}
-impl PagerView {
- fn is_scrolled_to_bottom(&self) -> bool {
- if self.scroll_offset == usize::MAX {
- return true;
- }
- let Some(height) = self.last_content_height else {
- return false;
- };
- if self.renderables.is_empty() {
- return true;
- }
- let Some(total_height) = self.last_rendered_height else {
- return false;
- };
- if total_height <= height {
- return true;
- }
- let max_scroll = total_height.saturating_sub(height);
- self.scroll_offset >= max_scroll
- }
-
- /// Request that the given text chunk index be scrolled into view on next render.
- fn scroll_chunk_into_view(&mut self, chunk_index: usize) {
- self.pending_scroll_chunk = Some(chunk_index);
- }
-
- fn ensure_chunk_visible(&mut self, idx: usize, area: Rect) {
- if area.height == 0 || idx >= self.renderables.len() {
- return;
- }
- let first = self
- .renderables
- .iter()
- .take(idx)
- .map(|r| r.desired_height(area.width) as usize)
- .sum();
- let last = first + self.renderables[idx].desired_height(area.width) as usize;
- let current_top = self.scroll_offset;
- let current_bottom = current_top.saturating_add(area.height.saturating_sub(1) as usize);
- if first < current_top {
- self.scroll_offset = first;
- } else if last > current_bottom {
- self.scroll_offset = last.saturating_sub(area.height.saturating_sub(1) as usize);
- }
- }
-}
-
/// A renderable that caches its desired height.
struct CachedRenderable {
renderable: Box<dyn Renderable>,
@@ -454,14 +390,14 @@ pub(crate) enum TranscriptHistoryState {
}
impl TranscriptHistoryState {
- fn has_unloaded_history(self) -> bool {
+ pub(crate) fn has_unloaded_history(self) -> bool {
matches!(
self,
Self::LoadingOlder | Self::LoadingBeginning | Self::Partial | Self::Failed
)
}
- fn session_header_placeholder(self) -> Option<&'static str> {
+ pub(crate) fn session_header_placeholder(self) -> Option<&'static str> {
match self {
Self::LoadingOlder | Self::LoadingBeginning => Some("Loading earlier messages..."),
Self::Partial => Some("Earlier messages are available — scroll up to load them"),
@@ -605,26 +541,6 @@ mod tests {
);
}
- fn buffer_to_text(buf: &Buffer, area: Rect) -> String {
- let mut out = String::new();
- for y in area.y..area.bottom() {
- for x in area.x..area.right() {
- let symbol = buf[(x, y)].symbol();
- if symbol.is_empty() {
- out.push(' ');
- } else {
- out.push(symbol.chars().next().unwrap_or(' '));
- }
- }
- // Trim trailing spaces for stability.
- while out.ends_with(' ') {
- out.pop();
- }
- out.push('\n');
- }
- out
- }
-
#[test]
fn static_overlay_snapshot_basic() {
// Prepare a static overlay with a few lines and a title
@@ -665,84 +581,4 @@ mod tests {
assert_eq!(pv.content_height(/*width*/ 80), 5);
}
-
- #[test]
- fn pager_view_ensure_chunk_visible_scrolls_down_when_needed() {
- let mut pv = pager_view(
- vec![
- paragraph_block("a", /*lines*/ 1),
- paragraph_block("b", /*lines*/ 3),
- paragraph_block("c", /*lines*/ 3),
- ],
- "T",
- /*scroll_offset*/ 0,
- );
- let area = Rect::new(0, 0, 20, 8);
-
- pv.scroll_offset = 0;
- let content_area = pv.content_area(area);
- pv.ensure_chunk_visible(/*idx*/ 2, content_area);
-
- let mut buf = Buffer::empty(area);
- pv.render(area, &mut buf);
- let rendered = buffer_to_text(&buf, area);
-
- assert!(
- rendered.contains("c0"),
- "expected chunk top in view: {rendered:?}"
- );
- assert!(
- rendered.contains("c1"),
- "expected chunk middle in view: {rendered:?}"
- );
- assert!(
- rendered.contains("c2"),
- "expected chunk bottom in view: {rendered:?}"
- );
- }
-
- #[test]
- fn pager_view_ensure_chunk_visible_scrolls_up_when_needed() {
- let mut pv = pager_view(
- vec![
- paragraph_block("a", /*lines*/ 2),
- paragraph_block("b", /*lines*/ 3),
- paragraph_block("c", /*lines*/ 3),
- ],
- "T",
- /*scroll_offset*/ 0,
- );
- let area = Rect::new(0, 0, 20, 3);
-
- pv.scroll_offset = 6;
- pv.ensure_chunk_visible(/*idx*/ 0, area);
-
- assert_eq!(pv.scroll_offset, 0);
- }
-
- #[test]
- fn pager_view_is_scrolled_to_bottom_accounts_for_wrapped_height() {
- let mut pv = pager_view(
- vec![paragraph_block("a", /*lines*/ 10)],
- "T",
- /*scroll_offset*/ 0,
- );
- let area = Rect::new(0, 0, 20, 8);
- let mut buf = Buffer::empty(area);
-
- pv.render(area, &mut buf);
-
- assert!(
- !pv.is_scrolled_to_bottom(),
- "expected view to report not at bottom when offset < max"
- );
-
- pv.scroll_offset = usize::MAX;
- pv.render(area, &mut buf);
-
- assert!(
- pv.is_scrolled_to_bottom(),
- "expected view to report at bottom after scrolling to end"
- );
- }
}
diff --git a/codex-rs/tui/src/pager_overlay/anchor_tests.rs b/codex-rs/tui/src/pager_overlay/anchor_tests.rs
new file mode 100644
index 0000000000..440f0aa378
--- /dev/null
+++ b/codex-rs/tui/src/pager_overlay/anchor_tests.rs
@@ -0,0 +1,175 @@
+//! Reading and prompt backtracking follow current entries through live updates and completion.
+
+use super::*;
+use crate::history_cell::PlainHistoryCell;
+use crate::history_cell::UserHistoryCell;
+use crate::keymap::RuntimeKeymap;
+use pretty_assertions::assert_eq;
+use ratatui::style::Modifier;
+
+fn user(message: &str) -> Arc<dyn HistoryCell> {
+ Arc::new(UserHistoryCell {
+ message: message.to_owned(),
+ text_elements: Vec::new(),
+ local_image_paths: Vec::new(),
+ remote_image_urls: Vec::new(),
+ spoken: false,
+ })
+}
+
+fn render(overlay: &mut TranscriptOverlay, area: Rect) -> Buffer {
+ let mut buffer = Buffer::empty(area);
+ overlay.render(area, &mut buffer);
+ buffer
+}
+
+fn content_rows(overlay: &TranscriptOverlay, buffer: &Buffer) -> Vec<String> {
+ let area = overlay.content_area;
+ (area.top()..area.bottom())
+ .map(|y| {
+ (area.left()..area.right())
+ .map(|x| buffer[(x, y)].symbol())
+ .collect::<String>()
+ .trim_end()
+ .to_owned()
+ })
+ .collect()
+}
+
+#[test]
+fn reading_live_output_updates_in_place_and_stays_on_the_committed_entry() {
+ let mut overlay =
+ TranscriptOverlay::new(vec![user("first prompt")], RuntimeKeymap::defaults().pager);
+ let area = Rect::new(
+ /*x*/ 0, /*y*/ 0, /*width*/ 40, /*height*/ 9,
+ );
+ for revision in ["streaming", "updated"] {
+ let lines = (0..8)
+ .map(|row| HyperlinkLine::from(format!("{revision} row {row}")))
+ .collect();
+ overlay.sync_live_tail(area.width, /*key*/ None, |_| Some(lines));
+ if revision == "streaming" {
+ render(&mut overlay, area);
+ overlay.scroll(/*rows*/ -2);
+ }
+ let buffer = render(&mut overlay, area);
+ assert_eq!(
+ content_rows(&overlay, &buffer),
+ (2..6)
+ .map(|row| format!("{revision} row {row}"))
+ .collect::<Vec<_>>()
+ );
+ assert!(!overlay.view.is_following());
+ }
+ overlay.insert_cell(Arc::new(PlainHistoryCell::new(
+ (0..8)
+ .map(|row| Line::from(format!("completed row {row}")))
+ .collect(),
+ )));
+ overlay.sync_live_tail(area.width, /*key*/ None, |_| None);
+ overlay.insert_cell(user("queued prompt"));
+ let completed = render(&mut overlay, area);
+ assert_eq!(
+ content_rows(&overlay, &completed),
+ [
+ "completed row 2",
+ "completed row 3",
+ "completed row 4",
+ "completed row 5"
+ ]
+ );
+ overlay.set_highlight_cell(Some(2));
+ let highlighted = render(&mut overlay, area);
+ assert!(
+ content_rows(&overlay, &highlighted)
+ .iter()
+ .any(|row| row == "› queued prompt")
+ );
+ assert!(!overlay.view.is_following());
+ overlay.view.jump_to_latest();
+ let latest = render(&mut overlay, area);
+ let latest = content_rows(&overlay, &latest).join("\n");
+ assert!(latest.contains("queued prompt"));
+ assert!(!latest.contains("updated row"));
+}
+
+#[test]
+fn backtracking_reveals_a_prompt_when_only_its_final_padding_is_visible() {
+ let mut overlay = TranscriptOverlay::new(
+ vec![
+ user("first prompt"),
+ Arc::new(PlainHistoryCell::new(vec![
+ "tail zero".into(),
+ "tail one".into(),
+ "tail two".into(),
+ ])),
+ ],
+ RuntimeKeymap::defaults().pager,
+ );
+ let area = Rect::new(
+ /*x*/ 0, /*y*/ 0, /*width*/ 40, /*height*/ 10,
+ );
+ let before = render(&mut overlay, area);
+ assert_eq!(
+ content_rows(&overlay, &before),
+ ["", "", "tail zero", "tail one", "tail two"]
+ );
+
+ let first_prompt_index = 0;
+ overlay.set_highlight_cell(Some(first_prompt_index));
+ let highlighted = render(&mut overlay, area);
+ let rows = content_rows(&overlay, &highlighted);
+ let prompt_row = rows
+ .iter()
+ .position(|row| row == "› first prompt")
+ .expect("backtracking reveals the prompt body, not just its padding");
+ let y = overlay.content_area.y + prompt_row as u16;
+ assert!(
+ (2..2 + "first prompt".len() as u16)
+ .all(|x| highlighted[(x, y)].modifier.contains(Modifier::REVERSED))
+ );
+}
+
+#[test]
+fn prompt_highlight_leaves_gutters_and_padding_unreversed() {
+ crate::terminal_palette::with_test_default_colors(
+ crate::terminal_probe::DefaultColors {
+ fg: (32, 32, 32),
+ bg: (255, 255, 255),
+ },
+ || {
+ let mut snapshots = Vec::new();
+ for (width, height) in [(40, 10), (12, 12)] {
+ let mut overlay = TranscriptOverlay::new(
+ vec![
+ Arc::new(PlainHistoryCell::new(vec!["prior".into()])),
+ user("alpha beta gamma"),
+ ],
+ RuntimeKeymap::defaults().pager,
+ );
+ let first_prompt_index = 1;
+ overlay.set_highlight_cell(Some(first_prompt_index));
+ let area = Rect::new(/*x*/ 0, /*y*/ 0, width, height);
+ let buffer = render(&mut overlay, area);
+ let content = Buffer {
+ area: Rect::new(
+ /*x*/ 0,
+ /*y*/ 0,
+ width,
+ overlay.content_area.height,
+ ),
+ content: buffer
+ .content
+ .chunks(usize::from(width))
+ .skip(usize::from(overlay.content_area.y))
+ .take(usize::from(overlay.content_area.height))
+ .flatten()
+ .cloned()
+ .collect(),
+ };
+ snapshots.push(format!("{width} columns\n{content:?}"));
+ }
+ insta::assert_snapshot!(snapshots.join("\n\n"));
+ },
+ );
+}
diff --git a/codex-rs/tui/src/pager_overlay/highlight_tests.rs b/codex-rs/tui/src/pager_overlay/highlight_tests.rs
deleted file mode 100644
index 3e7d3b3855..0000000000
--- a/codex-rs/tui/src/pager_overlay/highlight_tests.rs
+++ /dev/null
@@ -1,140 +0,0 @@
-//! Backtrack selection preserves unrelated layout caches and the complete rendered viewport.
-
-use super::*;
-use crate::history_cell::UserHistoryCell;
-use crate::keymap::RuntimeKeymap;
-use pretty_assertions::assert_eq;
-use std::sync::atomic::AtomicUsize;
-use std::sync::atomic::Ordering;
-
-#[derive(Debug)]
-struct MeasuredCell {
- measurements: AtomicUsize,
-}
-
-impl HistoryCell for MeasuredCell {
- fn display_lines(&self, _width: u16) -> Vec<Line<'static>> {
- self.measurements.fetch_add(1, Ordering::Relaxed);
- vec!["history".into()]
- }
-
- fn raw_lines(&self) -> Vec<Line<'static>> {
- vec!["history".into()]
- }
-}
-
-#[test]
-fn moving_highlight_preserves_unaffected_height_caches() {
- let cells: Vec<_> = (0..32)
- .map(|_| {
- Arc::new(MeasuredCell {
- measurements: AtomicUsize::new(0),
- })
- })
- .collect();
- let mut overlay = TranscriptOverlay::new(
- cells
- .iter()
- .map(|cell| cell.clone() as Arc<dyn HistoryCell>)
- .collect(),
- RuntimeKeymap::defaults().pager,
- );
- let mut area = Rect::new(
- /*x*/ 0, /*y*/ 0, /*width*/ 40, /*height*/ 12,
- );
- overlay.render(area, &mut Buffer::empty(area));
-
- for selection in [Some(30), Some(28), Some(28), None] {
- overlay.set_highlight_cell(selection);
- overlay.render(area, &mut Buffer::empty(area));
- }
-
- let measurements = || {
- cells
- .iter()
- .map(|cell| cell.measurements.load(Ordering::Relaxed))
- .collect::<Vec<_>>()
- };
- let mut expected = vec![1; cells.len()];
- assert_eq!(measurements(), expected);
-
- // Width changes still invalidate every cached height.
- area.width = 24;
- overlay.render(area, &mut Buffer::empty(area));
- for count in &mut expected {
- *count += 1;
- }
- assert_eq!(measurements(), expected);
-}
-
-#[test]
-fn moving_highlight_matches_full_rebuild_with_live_tail() {
- let cells: Vec<Arc<dyn HistoryCell>> = ["first prompt", "second prompt"]
- .into_iter()
- .map(|message| {
- Arc::new(UserHistoryCell {
- message: message.to_string(),
- text_elements: Vec::new(),
- local_image_paths: Vec::new(),
- remote_image_urls: Vec::new(),
- spoken: false,
- }) as Arc<dyn HistoryCell>
- })
- .collect();
- let mut actual = TranscriptOverlay::new(cells.clone(), RuntimeKeymap::defaults().pager);
- let mut expected = TranscriptOverlay::new(cells, RuntimeKeymap::defaults().pager);
- for overlay in [&mut actual, &mut expected] {
- overlay.sync_live_tail(
- /*width*/ 40,
- Some(ActiveCellTranscriptKey {
- cacheable: true,
- revision: 1,
- is_stream_continuation: false,
- animation_tick: None,
- }),
- |_| Some(vec![HyperlinkLine::from("live tail")]),
- );
- }
-
- for width in [40, 24, 40] {
- for selection in [Some(0), Some(1), Some(1), None, Some(99), Some(0)] {
- actual.set_highlight_cell(selection);
- let tail = expected.take_live_tail_renderable();
- expected.highlight_cell = selection;
- expected.rebuild_renderables(tail);
- if let Some(index) = selection {
- expected.view.scroll_chunk_into_view(index);
- }
-
- let area = Rect::new(/*x*/ 0, /*y*/ 0, width, /*height*/ 12);
- let mut actual_buffer = Buffer::empty(area);
- let mut expected_buffer = Buffer::empty(area);
- actual.render(area, &mut actual_buffer);
- expected.render(area, &mut expected_buffer);
- assert_eq!(actual_buffer, expected_buffer);
- assert_eq!(actual.view.scroll_offset, expected.view.scroll_offset);
- }
- }
-
- actual.set_highlight_cell(Some(1));
- let area = Rect::new(
- /*x*/ 0, /*y*/ 0, /*width*/ 40, /*height*/ 20,
- );
- let mut buffer = Buffer::empty(area);
- actual.render(area, &mut buffer);
- let content = (1..area.height - 4)
- .map(|y| {
- (0..area.width)
- .map(|x| buffer[(x, y)].symbol())
- .collect::<String>()
- })
- .map(|line| line.trim_end().to_string())
- .filter(|line| !line.is_empty() && line != "~")
- .collect::<Vec<_>>()
- .join("\n");
- insta::assert_snapshot!(content, @"
- › first prompt
- › second prompt
- live tail
- ");
-}
diff --git a/codex-rs/tui/src/pager_overlay/scrolling.rs b/codex-rs/tui/src/pager_overlay/scrolling.rs
index a6b66a8c4e..50eaf5a149 100644
--- a/codex-rs/tui/src/pager_overlay/scrolling.rs
+++ b/codex-rs/tui/src/pager_overlay/scrolling.rs
@@ -1,88 +1,8 @@
-//! Viewport-aware transcript rendering and the fallback for generic pager content.
+//! Viewport fallback for generic static pager content.
-use crate::transcript_view::LayoutCache;
-use std::cell::RefCell;
-use std::rc::Rc;
-use std::sync::Arc;
-
-use crate::history_cell::HistoryCell;
-use crate::history_cell::UserHistoryCell;
use crate::render::renderable::Renderable;
-use crate::style::user_message_style;
-use crate::terminal_hyperlinks::HyperlinkLine;
-use crate::terminal_hyperlinks::HyperlinkParagraph;
use ratatui::buffer::Buffer;
use ratatui::layout::Rect;
-use ratatui::style::Style;
-use ratatui::widgets::Widget;
-
-/// Renders a committed history cell directly into the visible transcript viewport.
-pub(super) struct CellRenderable {
- pub(super) cell: Arc<dyn HistoryCell>,
- pub(super) highlighted: bool,
- pub(super) cache: Rc<RefCell<LayoutCache>>,
-}
-
-impl Renderable for CellRenderable {
- fn render(&self, area: Rect, buf: &mut Buffer) {
- self.render_scrolled(area, buf, /*scroll_offset*/ 0);
- }
-
- /// Scroll visible text and hyperlink metadata together without rendering hidden rows.
- fn render_scrolled(&self, area: Rect, buf: &mut Buffer, scroll_offset: u16) -> bool {
- let layout = self
- .cache
- .borrow_mut()
- .get(&self.cell, area.width, /*separated*/ false);
- let style = if self.cell.as_any().is::<UserHistoryCell>() {
- if self.highlighted {
- user_message_style().reversed()
- } else {
- user_message_style()
- }
- } else {
- Style::default()
- };
- buf.set_style(area, style);
- layout.render(area, buf, usize::from(scroll_offset));
- true
- }
-
- fn desired_height(&self, width: u16) -> u16 {
- self.cache
- .borrow_mut()
- .get(&self.cell, width, /*separated*/ false)
- .row_count()
- .try_into()
- .unwrap_or(u16::MAX)
- }
-}
-
-/// Renders the optional in-flight transcript tail without allocating hidden rows.
-pub(super) struct HyperlinkLinesRenderable {
- pub(super) lines: Vec<HyperlinkLine>,
-}
-
-impl Renderable for HyperlinkLinesRenderable {
- fn render(&self, area: Rect, buf: &mut Buffer) {
- self.render_scrolled(area, buf, /*scroll_offset*/ 0);
- }
-
- /// Keep live-tail hyperlinks aligned with the same visible rows as their text.
- fn render_scrolled(&self, area: Rect, buf: &mut Buffer, scroll_offset: u16) -> bool {
- HyperlinkParagraph::new(&self.lines, Style::default())
- .scroll(scroll_offset)
- .render(area, buf);
- true
- }
-
- fn desired_height(&self, width: u16) -> u16 {
- HyperlinkParagraph::new(&self.lines, Style::default())
- .line_count(width)
- .try_into()
- .unwrap_or(/*default*/ 0)
- }
-}
/// Render visible rows directly when supported, preserving the legacy scratch-buffer fallback.
pub(super) fn render_offset_content(
diff --git a/codex-rs/tui/src/pager_overlay/scrolling_tests.rs b/codex-rs/tui/src/pager_overlay/scrolling_tests.rs
index 26d5a22321..045afc73ce 100644
--- a/codex-rs/tui/src/pager_overlay/scrolling_tests.rs
+++ b/codex-rs/tui/src/pager_overlay/scrolling_tests.rs
@@ -1,14 +1,10 @@
+//! Static pager fallback preserves styled buffer slices at arbitrary scroll offsets.
+
use super::super::CachedRenderable;
-use super::CellRenderable;
-use super::HyperlinkLinesRenderable;
use super::render_offset_content;
-use crate::history_cell::HistoryCell;
-use crate::history_cell::UserHistoryCell;
use crate::render::Insets;
use crate::render::renderable::InsetRenderable;
use crate::render::renderable::Renderable;
-use crate::terminal_hyperlinks::HyperlinkLine;
-use crate::terminal_hyperlinks::visible_lines;
use pretty_assertions::assert_eq;
use ratatui::buffer::Buffer;
use ratatui::layout::Rect;
@@ -17,180 +13,54 @@ use ratatui::text::Line;
use ratatui::text::Text;
use ratatui::widgets::Paragraph;
use ratatui::widgets::Wrap;
-use std::sync::Arc;
-
-#[derive(Debug)]
-struct HyperlinkTestCell {
- lines: Vec<HyperlinkLine>,
-}
-
-impl HistoryCell for HyperlinkTestCell {
- fn display_lines(&self, _width: u16) -> Vec<Line<'static>> {
- visible_lines(self.lines.clone())
- }
-
- fn transcript_hyperlink_lines(&self, _width: u16) -> Vec<HyperlinkLine> {
- self.lines.clone()
- }
-
- fn raw_lines(&self) -> Vec<Line<'static>> {
- visible_lines(self.lines.clone())
- }
-
- fn has_stable_transcript_height(&self) -> bool {
- false
- }
-}
-
-/// Forces the unchanged full-height fallback while preserving the wrapped renderable's output.
-struct LegacyOnlyRenderable {
- inner: Box<dyn Renderable>,
-}
-
-impl Renderable for LegacyOnlyRenderable {
- fn render(&self, area: Rect, buf: &mut Buffer) {
- self.inner.render(area, buf);
- }
- fn desired_height(&self, width: u16) -> u16 {
- self.inner.desired_height(width)
- }
-}
-
-fn scrolled_hyperlink_lines() -> Vec<HyperlinkLine> {
- let mut linked = HyperlinkLine::new(Line::from(vec![
- "prefix ".green(),
- "漢字 ".bold(),
- "ガ ".italic(),
- ]));
- linked.push_span(
- "clickable 漢字 ガ".cyan().underlined(),
- Some("https://example.com/a/wrapped-private-destination"),
- );
- linked.push_span(
- " suffix words that continue wrapping".blue(),
- /*destination*/ None,
- );
-
- vec![
- HyperlinkLine::new(Line::from("first styled row".magenta())),
- linked,
- HyperlinkLine::new(Line::default()),
- HyperlinkLine::new(Line::from("last 漢字 ガ row".red())),
- ]
-}
-
-fn scrolled_test_renderables(lines: &[HyperlinkLine]) -> Vec<(&'static str, Box<dyn Renderable>)> {
- let cell: Arc<dyn HistoryCell> = Arc::new(HyperlinkTestCell {
- lines: lines.to_vec(),
- });
- let user: Arc<dyn HistoryCell> = Arc::new(UserHistoryCell {
- spoken: false,
- message: "highlighted 漢字 user message that wraps\nsecond user line".to_string(),
- text_elements: Vec::new(),
- local_image_paths: Vec::new(),
- remote_image_urls: Vec::new(),
- });
-
- vec![
- (
- "uncached history cell",
- Box::new(CellRenderable {
- cache: Default::default(),
- cell: cell.clone(),
- highlighted: false,
- }),
- ),
- (
- "highlighted cached user history cell",
- Box::new(CachedRenderable::new(CellRenderable {
- cache: Default::default(),
- cell: user,
- highlighted: true,
- })),
- ),
- (
- "inset cached history cell",
+#[test]
+fn scrolled_static_renderables_match_clipped_buffer_slices() {
+ let lines = vec![
+ Line::from(vec![
+ "prefix ".green(),
+ "漢字 ガ ".bold(),
+ "styled words that wrap across rows".blue(),
+ ]),
+ Line::default(),
+ Line::from("last 漢字 ガ row".red()),
+ ];
+ for width in [5, 7, 13, 28] {
+ let paragraph = || Paragraph::new(Text::from(lines.clone())).wrap(Wrap { trim: false });
+ let renderables: Vec<Box<dyn Renderable>> = vec![
+ Box::new(paragraph()),
+ Box::new(CachedRenderable::new(paragraph())),
Box::new(InsetRenderable::new(
- Box::new(CachedRenderable::new(CellRenderable {
- cache: Default::default(),
- cell,
- highlighted: false,
- })) as Box<dyn Renderable>,
+ Box::new(CachedRenderable::new(paragraph())) as Box<dyn Renderable>,
Insets::tlbr(
/*top*/ 2, /*left*/ 1, /*bottom*/ 1, /*right*/ 1,
),
)),
- ),
- (
- "live tail",
- Box::new(HyperlinkLinesRenderable {
- lines: lines.to_vec(),
- }),
- ),
- (
- "inset cached live tail",
- Box::new(InsetRenderable::new(
- Box::new(CachedRenderable::new(HyperlinkLinesRenderable {
- lines: lines.to_vec(),
- })) as Box<dyn Renderable>,
- Insets::tlbr(
- /*top*/ 1, /*left*/ 1, /*bottom*/ 1, /*right*/ 1,
- ),
- )),
- ),
- (
- "unsupported paragraph fallback",
- Box::new(
- Paragraph::new(Text::from(visible_lines(lines.to_vec())))
- .wrap(Wrap { trim: false }),
- ),
- ),
- ]
-}
-
-#[test]
-fn scrolled_transcript_renderables_match_full_height_fallback() {
- let lines = scrolled_hyperlink_lines();
-
- for width in [5, 7, 13, 28] {
- for ((name, renderable), (_, legacy_inner)) in scrolled_test_renderables(&lines)
- .into_iter()
- .zip(scrolled_test_renderables(&lines))
- {
- let legacy = LegacyOnlyRenderable {
- inner: legacy_inner,
- };
+ ];
+ for renderable in renderables {
let height = renderable.desired_height(width);
- for offset in [
- 0,
- 1,
- 2,
- 3,
- height.saturating_sub(/*rhs*/ 2),
- height.saturating_sub(/*rhs*/ 1),
- height,
- ] {
+ for offset in [0, 1, 2, 3, height.saturating_sub(/*rhs*/ 1), height] {
for (x, y, visible_height) in [(0, 0, 4), (3, 2, 3)] {
let area = Rect::new(x, y, width, visible_height);
- let full_area = Rect::new(
- /*x*/ 0,
- /*y*/ 0,
- area.right().saturating_add(/*rhs*/ 2),
- area.bottom().saturating_add(/*rhs*/ 2),
- );
- let mut expected = Buffer::empty(full_area);
- let mut actual = Buffer::empty(full_area);
-
- let expected_height =
- render_offset_content(area, &mut expected, &legacy, offset);
+ let canvas = Rect::new(/*x*/ 0, /*y*/ 0, area.right(), area.bottom());
+ let mut expected = Buffer::empty(canvas);
+ let mut actual = Buffer::empty(canvas);
+ let expected_height = visible_height.min(height.saturating_sub(offset));
+ let full_area =
+ Rect::new(/*x*/ 0, /*y*/ 0, width, offset + expected_height);
+ let mut full = Buffer::empty(full_area);
+ renderable.render(full_area, &mut full);
+ for row in 0..expected_height {
+ for column in 0..width {
+ expected[(x + column, y + row)] = full[(column, offset + row)].clone();
+ }
+ }
let actual_height =
render_offset_content(area, &mut actual, &*renderable, offset);
-
assert_eq!(
(actual_height, actual),
(expected_height, expected),
- "renderable={name}, width={width}, offset={offset}, area={area:?}",
+ "width={width}, offset={offset}, area={area:?}"
);
}
}
diff --git a/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript__anchor_tests__prompt_highlight_leaves_gutters_and_padding_unreversed.snap b/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript__anchor_tests__prompt_highlight_leaves_gutters_and_padding_unreversed.snap
new file mode 100644
index 0000000000..2b318f2d2a
--- /dev/null
+++ b/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript__anchor_tests__prompt_highlight_leaves_gutters_and_padding_unreversed.snap
@@ -0,0 +1,48 @@
+---
+source: tui/src/pager_overlay/anchor_tests.rs
+assertion_line: 187
+expression: "snapshots.join(\"\\n\\n\")"
+---
+40 columns
+Buffer {
+ area: Rect { x: 0, y: 0, width: 40, height: 5 },
+ content: [
+ "prior ",
+ " ",
+ " ",
+ "› alpha beta gamma ",
+ " ",
+ ],
+ styles: [
+ x: 0, y: 0, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,
+ x: 0, y: 2, fg: Reset, bg: Rgb(249, 249, 249), 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: Reset, bg: Rgb(249, 249, 249), underline: Reset, modifier: REVERSED,
+ x: 18, y: 3, fg: Reset, bg: Rgb(249, 249, 249), underline: Reset, modifier: NONE,
+ ]
+}
+
+12 columns
+Buffer {
+ area: Rect { x: 0, y: 0, width: 12, height: 7 },
+ content: [
+ "prior ",
+ " ",
+ " ",
+ "› alpha ",
+ " beta ",
+ " gamma ",
+ " ",
+ ],
+ styles: [
+ x: 0, y: 0, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,
+ x: 0, y: 2, fg: Reset, bg: Rgb(249, 249, 249), 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: Reset, bg: Rgb(249, 249, 249), underline: Reset, modifier: REVERSED,
+ x: 7, y: 3, fg: Reset, bg: Rgb(249, 249, 249), underline: Reset, modifier: NONE,
+ x: 2, y: 4, fg: Reset, bg: Rgb(249, 249, 249), underline: Reset, modifier: REVERSED,
+ x: 6, y: 4, fg: Reset, bg: Rgb(249, 249, 249), underline: Reset, modifier: NONE,
+ x: 2, y: 5, fg: Reset, bg: Rgb(249, 249, 249), underline: Reset, modifier: REVERSED,
+ x: 7, y: 5, fg: Reset, bg: Rgb(249, 249, 249), underline: Reset, modifier: NONE,
+ ]
+}
diff --git a/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript__tests__transcript_overlay_apply_patch_scroll_vt100.snap b/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript__tests__transcript_overlay_apply_patch_scroll_vt100.snap
index 22c3f0fc80..d54bae4a09 100644
--- a/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript__tests__transcript_overlay_apply_patch_scroll_vt100.snap
+++ b/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript__tests__transcript_overlay_apply_patch_scroll_vt100.snap
@@ -10,6 +10,6 @@ expression: snapshot
• Added foo.txt (+2 -0)
1 +hello
2 +world
-─────────────────────────────────────────────────────────────────────────── 0% ─
+────────────────────────────────────────────────────────────────────────────────
↑/↓ to scroll pgup/pgdn to page home/end to jump
q close esc to edit prev
diff --git a/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript__tests__transcript_overlay_completed_stream.snap b/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript__tests__transcript_overlay_completed_stream.snap
deleted file mode 100644
index 16049ad05a..0000000000
--- a/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript__tests__transcript_overlay_completed_stream.snap
+++ /dev/null
@@ -1,13 +0,0 @@
----
-source: tui/src/pager_overlay/transcript_tests.rs
-expression: "buffer_to_text(&actual, area)"
----
-/ T R A N S C R I P T / / / / / / / / /
-first
-last
-~
-~
-~
-───────────────────────────────── 100% ─
- ↑/↓ to scroll pgup/pgdn to page hom
- q close esc to edit prev
diff --git a/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript__tests__transcript_overlay_prepended_history.snap b/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript__tests__transcript_overlay_prepended_history.snap
deleted file mode 100644
index bbec8348a2..0000000000
--- a/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript__tests__transcript_overlay_prepended_history.snap
+++ /dev/null
@@ -1,7 +0,0 @@
----
-source: tui/src/pager_overlay/transcript_tests.rs
-expression: visible_before.trim()
----
-line2
-
-line3
diff --git a/codex-rs/tui/src/pager_overlay/transcript.rs b/codex-rs/tui/src/pager_overlay/transcript.rs
index 68fa46a2cb..f9f541aa18 100644
--- a/codex-rs/tui/src/pager_overlay/transcript.rs
+++ b/codex-rs/tui/src/pager_overlay/transcript.rs
@@ -1,432 +1,302 @@
-//! Detailed transcript overlay over committed history and the current live tail.
+//! Detailed transcript overlay with entry-based scrolling and the existing pager chrome.
+//!
+//! The overlay owns committed cells and input bindings. Its viewport displays current content
+//! and keeps readers on the same entry through pagination and stream consolidation.
use super::*;
-use crate::transcript_view::LayoutCache;
-use std::cell::RefCell;
-use std::rc::Rc;
+use crate::transcript_view::TranscriptView;
pub(crate) struct TranscriptOverlay {
- /// Pager UI state and the renderables currently displayed.
- ///
- /// The invariant is that `view.renderables` is `render_cells(cells)` plus an optional trailing
- /// live-tail renderable appended after the committed cells.
- view: PagerView,
- cache: Rc<RefCell<LayoutCache>>,
- /// Committed transcript cells (does not include the live tail).
+ view: TranscriptView,
cells: Vec<Arc<dyn HistoryCell>>,
+ keymap: PagerKeymap,
highlight_cell: Option<usize>,
- /// Cache key for the render-only live tail appended after committed cells.
- live_tail_key: Option<LiveTailKey>,
- history_state: TranscriptHistoryState,
+ reveal_highlight: bool,
+ content_area: Rect,
is_done: bool,
}
-/// Cache key for the active-cell "live tail" appended to the transcript overlay.
-///
-/// Changing any field implies a different rendered tail.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-struct LiveTailKey {
- /// Current terminal width, which affects wrapping.
- width: u16,
- /// Revision that changes on in-place active cell transcript updates.
- revision: u64,
- /// Whether the tail should be treated as a continuation for spacing.
- is_stream_continuation: bool,
- /// Optional animation tick to refresh spinners/progress indicators.
- animation_tick: Option<u64>,
-}
-
impl TranscriptOverlay {
- /// Creates a transcript overlay for a fixed set of committed cells.
- ///
- /// This overlay does not own the "active cell"; callers may optionally append a live tail via
- /// `sync_live_tail` during draws to reflect in-flight activity.
- pub(crate) fn new(transcript_cells: Vec<Arc<dyn HistoryCell>>, keymap: PagerKeymap) -> Self {
- let cache = Rc::new(RefCell::new(LayoutCache::default()));
+ pub(crate) fn new(cells: Vec<Arc<dyn HistoryCell>>, keymap: PagerKeymap) -> Self {
Self {
- view: PagerView::new(
- Self::render_cells(
- &cache,
- &transcript_cells,
- /*highlight_cell*/ None,
- TranscriptHistoryState::Idle,
- ),
- "T R A N S C R I P T".to_string(),
- usize::MAX,
- keymap,
- ),
- cache,
- cells: transcript_cells,
+ view: TranscriptView::default(),
+ cells,
+ keymap,
highlight_cell: None,
- live_tail_key: None,
- history_state: TranscriptHistoryState::Idle,
+ reveal_highlight: false,
+ content_area: Rect::default(),
is_done: false,
}
}
- pub(crate) fn set_history_state(
- &mut self,
- state: TranscriptHistoryState,
- ) -> TranscriptHistoryState {
- let previous = self.history_state;
- if previous == state {
- return previous;
+ pub(crate) fn render(&mut self, area: Rect, buf: &mut Buffer) {
+ Clear.render(area, buf);
+ let top_height = area.height.saturating_sub(/*rhs*/ 3);
+ let top = Rect::new(area.x, area.y, area.width, top_height);
+ self.content_area = Rect::new(
+ area.x,
+ area.y.saturating_add(/*rhs*/ 1),
+ area.width,
+ top_height.saturating_sub(/*rhs*/ 2),
+ )
+ .intersection(area);
+ let mut rendered =
+ self.view
+ .render(self.content_area, buf, &self.cells, self.highlight_cell);
+ if std::mem::take(&mut self.reveal_highlight)
+ && let Some(index) = self.highlight_cell
+ {
+ self.view.ensure_entry_visible(&self.cells, index);
+ rendered = self
+ .view
+ .render(self.content_area, buf, &self.cells, self.highlight_cell);
}
- if previous == TranscriptHistoryState::LoadingBeginning
- && state == TranscriptHistoryState::Complete
+ if self.view.history == TranscriptHistoryState::LoadingBeginning
+ && self.view.is_following()
+ && !self.content_area.is_empty()
{
- self.view.scroll_offset = 0;
+ // Home may arrive before the first draw; retain the first real viewport.
+ self.view.scroll(&self.cells, /*rows*/ 0);
}
- self.history_state = state;
- self.view.scroll_percentage_visible = !state.has_unloaded_history();
- if self
- .cells
- .iter()
- .any(|cell| cell.as_any().is::<SessionInfoCell>())
+ if area.width > 0 {
+ for y in self.content_area.y + rendered..self.content_area.bottom() {
+ "~".render(Rect::new(area.x, y, /*width*/ 1, /*height*/ 1), buf);
+ }
+ }
+ let header = Rect::new(area.x, area.y, area.width, area.height.min(/*other*/ 1));
+ Span::from("/ ".repeat(usize::from(area.width) / 2))
+ .dim()
+ .render(header, buf);
+ "/ T R A N S C R I P T".dim().render(header, buf);
+ self.render_history_state(top, buf);
+ let separator = Rect::new(
+ area.x,
+ self.content_area.bottom(),
+ area.width,
+ /*height*/ 1,
+ )
+ .intersection(area);
+ "─"
+ .repeat(usize::from(separator.width))
+ .dim()
+ .render(separator, buf);
+ // An exact intermediate percentage would require laying out every offscreen cell.
+ // Only the loaded tail has a known percentage without defeating bounded rendering.
+ if self.view.is_following()
+ && !self.view.history.has_unloaded_history()
+ && separator.width >= 7
{
- let live_tail = self.take_live_tail_renderable();
- self.rebuild_renderables(live_tail);
+ " 100% ".dim().render(
+ Rect::new(
+ separator.right() - 7,
+ separator.y,
+ /*width*/ 6,
+ separator.height,
+ ),
+ buf,
+ );
}
- previous
+ let footer =
+ Rect::new(area.x, area.y + top_height, area.width, /*height*/ 3).intersection(area);
+ self.render_hints(footer, buf);
}
- fn render_cells(
- cache: &Rc<RefCell<LayoutCache>>,
- cells: &[Arc<dyn HistoryCell>],
- highlight_cell: Option<usize>,
- history_state: TranscriptHistoryState,
- ) -> Vec<Box<dyn Renderable>> {
- cells
- .iter()
- .enumerate()
- .map(|(i, cell)| Self::render_cell(cache, cell, i, highlight_cell, history_state))
- .collect()
+ pub(crate) fn handle_event(&mut self, tui: &mut tui::Tui, event: TuiEvent) -> Result<()> {
+ match event {
+ TuiEvent::Key(key) => {
+ if self.keymap.close.is_pressed(key) || self.keymap.close_transcript.is_pressed(key)
+ {
+ self.is_done = true;
+ } else if self.navigate(key) {
+ tui.frame_requester()
+ .schedule_frame_in(crate::tui::TARGET_FRAME_INTERVAL);
+ }
+ Ok(())
+ }
+ TuiEvent::Draw | TuiEvent::Resume | TuiEvent::Resize(_) | TuiEvent::FocusGained => {
+ tui.draw(u16::MAX, |frame| self.render(frame.area(), frame.buffer))?;
+ Ok(())
+ }
+ _ => Ok(()),
+ }
}
- /// Build the renderable for a committed cell, caching its height when the cell is stable.
- fn render_cell(
- cache: &Rc<RefCell<LayoutCache>>,
- cell: &Arc<dyn HistoryCell>,
- index: usize,
- highlight_cell: Option<usize>,
- history_state: TranscriptHistoryState,
- ) -> Box<dyn Renderable> {
- if cell.as_any().is::<SessionInfoCell>()
- && let Some(placeholder) = history_state.session_header_placeholder()
+ pub(crate) fn set_history_state(
+ &mut self,
+ state: TranscriptHistoryState,
+ ) -> TranscriptHistoryState {
+ let previous = std::mem::replace(&mut self.view.history, state);
+ if state == TranscriptHistoryState::LoadingBeginning
+ && previous != TranscriptHistoryState::LoadingBeginning
+ && !self.content_area.is_empty()
{
- return Box::new(Line::from(placeholder).dim());
+ // App marks loading before forwarding Home, so record the current position here.
+ self.view.scroll(&self.cells, /*rows*/ 0);
}
- let cell_renderable = CellRenderable {
- cache: Rc::clone(cache),
- cell: cell.clone(),
- highlighted: highlight_cell == Some(index),
- };
- let mut cell_renderable: Box<dyn Renderable> = if cell.has_stable_transcript_height() {
- Box::new(CachedRenderable::new(cell_renderable))
- } else {
- Box::new(cell_renderable)
- };
- if !cell.is_stream_continuation() && index > 0 {
- cell_renderable = Box::new(InsetRenderable::new(
- cell_renderable,
- Insets::tlbr(
- /*top*/ 1, /*left*/ 0, /*bottom*/ 0, /*right*/ 0,
- ),
- ));
+ if previous == TranscriptHistoryState::LoadingBeginning
+ && state == TranscriptHistoryState::Complete
+ {
+ self.view.jump_to_entry(&self.cells, /*index*/ 0);
}
- cell_renderable
+ previous
}
- /// Insert a committed history cell while keeping any cached live tail.
- ///
- /// The live tail is temporarily removed, the new committed cell is appended,
- /// then the tail is reattached. If the tail previously had no leading
- /// spacing because it was the only renderable, we add the missing inset
- /// when the first committed cell arrives.
- ///
- /// This expects `cell` to be a committed transcript cell (not the in-flight active cell). If
- /// the overlay was scrolled to bottom before insertion, it remains pinned to bottom after the
- /// insertion to preserve the "follow along" behavior.
- pub(crate) fn insert_cell(&mut self, cell: Arc<dyn HistoryCell>) {
- let follow_bottom = self.view.is_scrolled_to_bottom();
- let had_prior_cells = !self.cells.is_empty();
- let tail_renderable = self.take_live_tail_renderable();
- let cell_renderable = Self::render_cell(
- &self.cache,
- &cell,
- self.cells.len(),
- self.highlight_cell,
- self.history_state,
- );
- self.cells.push(cell);
- self.view.renderables.push(cell_renderable);
- if let Some(tail) = tail_renderable {
- let tail = if !had_prior_cells
- && self
- .live_tail_key
- .is_some_and(|key| !key.is_stream_continuation)
- {
- // The tail was rendered as the only entry, so it lacks a top
- // inset; add one now that it follows a committed cell.
- Box::new(InsetRenderable::new(
- tail,
- Insets::tlbr(
- /*top*/ 1, /*left*/ 0, /*bottom*/ 0, /*right*/ 0,
- ),
- )) as Box<dyn Renderable>
- } else {
- tail
- };
- self.view.renderables.push(tail);
- }
- if follow_bottom {
- self.view.scroll_offset = usize::MAX;
- }
+ pub(crate) fn should_load_older(&mut self, key: KeyEvent) -> bool {
+ self.should_load_from_start(key)
+ || (self.view.near_start(&self.cells)
+ && [
+ &self.keymap.scroll_up,
+ &self.keymap.page_up,
+ &self.keymap.half_page_up,
+ ]
+ .iter()
+ .any(|bindings| bindings.is_pressed(key)))
}
- /// Returns whether an upward navigation is close enough to request older history.
- pub(crate) fn should_load_older(&self, key_event: KeyEvent) -> bool {
- self.should_load_from_start(key_event)
- || (self.view.scroll_offset
- <= self.view.last_content_height.unwrap_or(/*default*/ 0)
- && (self.view.keymap.scroll_up.is_pressed(key_event)
- || self.view.keymap.page_up.is_pressed(key_event)
- || self.view.keymap.half_page_up.is_pressed(key_event)))
+ pub(crate) fn should_load_from_start(&self, key: KeyEvent) -> bool {
+ self.keymap.jump_top.is_pressed(key)
}
- pub(crate) fn should_load_from_start(&self, key_event: KeyEvent) -> bool {
- self.view.keymap.jump_top.is_pressed(key_event)
+ pub(crate) fn insert_cell(&mut self, cell: Arc<dyn HistoryCell>) {
+ let index = self.cells.len();
+ self.view
+ .replace_range(&self.cells, index..index + 1, &cell);
+ self.cells.push(cell);
}
- /// Prepends history without moving visible content and returns its insertion index.
- pub(crate) fn prepend(&mut self, cells: Vec<Arc<dyn HistoryCell>>, width: u16) -> usize {
+ /// Prepends history and returns the insertion index for the canonical transcript.
+ pub(crate) fn prepend(&mut self, cells: Vec<Arc<dyn HistoryCell>>) -> usize {
if cells.is_empty() {
return 0;
}
- let follow_bottom = self.view.is_scrolled_to_bottom();
- let previous_height = self.view.content_height(width);
- let live_tail = self.take_live_tail_renderable();
- let added_cells = cells.len();
- let insert_at = self
+ let index = self
.cells
.iter()
.rposition(|cell| cell.as_any().is::<SessionInfoCell>())
- .map_or(/*default*/ 0, |index| index.saturating_add(/*rhs*/ 1));
- self.cells.splice(insert_at..insert_at, cells);
- for index in [
- &mut self.highlight_cell,
- &mut self.view.pending_scroll_chunk,
- ] {
- if let Some(index) = index.as_mut()
- && *index >= insert_at
- {
- *index = index.saturating_add(added_cells);
- }
+ .map_or(/*default*/ 0, |index| index + 1);
+ let added = cells.len();
+ self.cells.splice(index..index, cells);
+ if let Some(highlight) = self
+ .highlight_cell
+ .as_mut()
+ .filter(|highlight| **highlight >= index)
+ {
+ *highlight += added;
}
- self.rebuild_renderables(live_tail);
- let content_height = self.view.content_height(width);
- self.view.scroll_offset = if follow_bottom {
- usize::MAX
- } else {
- self.view
- .scroll_offset
- .saturating_add(content_height.saturating_sub(previous_height))
- };
- self.view.last_rendered_height = Some(content_height);
- insert_at
+ self.view.history_changed(&self.cells);
+ index
}
- /// Replace committed transcript cells while keeping any cached in-progress output that is
- /// currently shown at the end of the overlay.
- ///
- /// This is used when existing history is replaced or trimmed so the
- /// transcript overlay immediately reflects the same committed cells as the main transcript.
pub(crate) fn replace_cells(&mut self, cells: Vec<Arc<dyn HistoryCell>>) {
- let follow_bottom = self.view.is_scrolled_to_bottom();
- let live_tail = self.take_live_tail_renderable();
self.cells = cells;
- if self
+ self.view.history_changed(&self.cells);
+ self.highlight_cell = self
.highlight_cell
- .is_some_and(|idx| idx >= self.cells.len())
- {
- self.highlight_cell = None;
- }
- self.rebuild_renderables(live_tail);
- if follow_bottom {
- self.view.scroll_offset = usize::MAX;
- }
+ .filter(|index| *index < self.cells.len());
}
- /// Replace a range of committed cells with a single consolidated cell.
- ///
- /// Mirrors the splice performed on `App::transcript_cells` during
- /// `ConsolidateAgentMessage` so the Ctrl+T overlay stays in sync with the
- /// main transcript. The range is clamped defensively: cells may have been
- /// inserted after the overlay opened, leaving it with fewer entries than
- /// the main transcript.
pub(crate) fn consolidate_cells(
&mut self,
range: std::ops::Range<usize>,
consolidated: Arc<dyn HistoryCell>,
) {
- let follow_bottom = self.view.is_scrolled_to_bottom();
- // Clamp the range to the overlay's cell count to avoid panic if the overlay has fewer
- // cells than the main transcript (e.g. cells were inserted after the overlay has opened).
- let clamped_end = range.end.min(self.cells.len());
- let clamped_start = range.start.min(clamped_end);
- if clamped_start < clamped_end {
- let live_tail = self.take_live_tail_renderable();
- let removed = clamped_end - clamped_start;
- if let Some(highlight_cell) = self.highlight_cell.as_mut()
- && *highlight_cell >= clamped_start
- {
- if *highlight_cell < clamped_end {
- *highlight_cell = clamped_start;
- } else {
- *highlight_cell = highlight_cell.saturating_sub(removed.saturating_sub(1));
- }
- }
- self.cells
- .splice(clamped_start..clamped_end, std::iter::once(consolidated));
- if self
- .highlight_cell
- .is_some_and(|highlight_cell| highlight_cell >= self.cells.len())
- {
- self.highlight_cell = None;
- }
- self.rebuild_renderables(live_tail);
- }
- if follow_bottom {
- self.view.scroll_offset = usize::MAX;
+ let end = range.end.min(self.cells.len());
+ let start = range.start.min(end);
+ if start == end {
+ return;
}
+ self.view
+ .replace_range(&self.cells, start..end, &consolidated);
+ self.highlight_cell = self.highlight_cell.map(|index| {
+ if index < start {
+ index
+ } else if index < end {
+ start
+ } else {
+ index - (end - start - 1)
+ }
+ });
+ self.cells.splice(start..end, [consolidated]);
}
- /// Sync the active-cell live tail with the current width and cell state.
- ///
- /// Recomputes the tail only when the cache key changes, preserving scroll
- /// position and dropping the tail if there is nothing to render.
- ///
- /// The overlay owns committed transcript cells while the live tail is derived from the current
- /// active cell, which can mutate in place while streaming. `App` calls this during
- /// `TuiEvent::Draw` for `Overlay::Transcript`, passing a key that changes when the active cell
- /// mutates or animates so the cached tail stays fresh.
- ///
- /// Passing a key that does not change on in-place active-cell mutations will freeze the tail in
- /// `Ctrl+T` while the main viewport continues to update.
pub(crate) fn sync_live_tail(
&mut self,
width: u16,
- active_key: Option<ActiveCellTranscriptKey>,
+ key: Option<ActiveCellTranscriptKey>,
compute_lines: impl FnOnce(u16) -> Option<Vec<HyperlinkLine>>,
) {
- let next_key = active_key.map(|key| LiveTailKey {
- width,
- revision: key.revision,
- is_stream_continuation: key.is_stream_continuation,
- animation_tick: key.animation_tick,
- });
-
- if active_key.is_some_and(|key| key.cacheable) && self.live_tail_key == next_key {
- return;
- }
- let follow_bottom = self.view.is_scrolled_to_bottom();
+ self.view.sync_live_tail(width, key, compute_lines);
+ }
- self.take_live_tail_renderable();
- self.live_tail_key = next_key;
+ pub(crate) fn set_highlight_cell(&mut self, cell: Option<usize>) {
+ self.highlight_cell = cell.filter(|index| *index < self.cells.len());
+ self.reveal_highlight = self.highlight_cell.is_some();
+ }
- if let Some(key) = next_key {
- let lines = compute_lines(width).unwrap_or_default();
- if !lines.is_empty() {
- self.view.renderables.push(Self::live_tail_renderable(
- lines,
- !self.cells.is_empty(),
- key.is_stream_continuation,
- ));
- }
- }
- if follow_bottom {
- self.view.scroll_offset = usize::MAX;
+ pub(crate) fn scroll(&mut self, rows: isize) {
+ if std::mem::take(&mut self.reveal_highlight)
+ && let Some(index) = self.highlight_cell
+ {
+ self.view.ensure_entry_visible(&self.cells, index);
}
+ self.view.scroll(&self.cells, rows);
}
- pub(crate) fn set_highlight_cell(&mut self, cell: Option<usize>) {
- let previous = self.highlight_cell;
- self.highlight_cell = cell;
- // Highlighting changes only these cells' styling. Keep the other renderables and their
- // cached heights so moving between prompts does not lay out the entire transcript again.
- if previous != cell {
- for index in [previous, cell].into_iter().flatten() {
- if let Some(history_cell) = self.cells.get(index) {
- self.view.renderables[index] = Self::render_cell(
- &self.cache,
- history_cell,
- index,
- self.highlight_cell,
- self.history_state,
- );
- }
+ fn navigate(&mut self, key: KeyEvent) -> bool {
+ if self.keymap.jump_top.is_pressed(key) {
+ if self.content_area.is_empty() && self.view.history.has_unloaded_history() {
+ self.set_history_state(TranscriptHistoryState::LoadingBeginning);
+ } else {
+ self.view.jump_to_beginning(&self.cells);
}
+ return true;
}
- if let Some(idx) = self.highlight_cell {
- self.view.scroll_chunk_into_view(idx);
+ if self.keymap.jump_bottom.is_pressed(key) {
+ self.view.jump_to_latest();
+ return true;
}
- }
-
- /// Returns whether the underlying pager view is currently pinned to the bottom.
- ///
- /// The `App` draw loop uses this to decide whether to schedule animation frames for the live
- /// tail; if the user has scrolled up, we avoid driving animation work that they cannot see.
- pub(crate) fn is_scrolled_to_bottom(&self) -> bool {
- self.view.is_scrolled_to_bottom()
- }
-
- // Detach the live tail before changing cells: their old count identifies the tail renderable.
- fn rebuild_renderables(&mut self, tail_renderable: Option<Box<dyn Renderable>>) {
- self.view.renderables = Self::render_cells(
- &self.cache,
- &self.cells,
- self.highlight_cell,
- self.history_state,
- );
- if let Some(tail) = tail_renderable {
- self.view.renderables.push(tail);
+ let page = self.content_area.height.max(/*other*/ 1) as isize;
+ let half = (page + 1) / 2;
+ let delta = [
+ (&self.keymap.scroll_up, -1),
+ (&self.keymap.scroll_down, 1),
+ (&self.keymap.page_up, -page),
+ (&self.keymap.page_down, page),
+ (&self.keymap.half_page_up, -half),
+ (&self.keymap.half_page_down, half),
+ ]
+ .into_iter()
+ .find_map(|(bindings, delta)| bindings.is_pressed(key).then_some(delta));
+ let Some(delta) = delta else {
+ return false;
+ };
+ if !self.content_area.is_empty() {
+ self.scroll(delta);
}
+ true
}
- /// Removes and returns the cached live-tail renderable, if present.
- ///
- /// The live tail is represented as a single optional renderable appended after the committed
- /// cell renderables, so this relies on the live tail always being the final entry in
- /// `view.renderables` when present.
- fn take_live_tail_renderable(&mut self) -> Option<Box<dyn Renderable>> {
- (self.view.renderables.len() > self.cells.len()).then(|| self.view.renderables.pop())?
+ pub(crate) fn live_tail_visible(&self) -> bool {
+ self.view.live_tail_visible()
}
- fn live_tail_renderable(
- lines: Vec<HyperlinkLine>,
- has_prior_cells: bool,
- is_stream_continuation: bool,
- ) -> Box<dyn Renderable> {
- let mut renderable: Box<dyn Renderable> =
- Box::new(CachedRenderable::new(HyperlinkLinesRenderable { lines }));
- if has_prior_cells && !is_stream_continuation {
- renderable = Box::new(InsetRenderable::new(
- renderable,
- Insets::tlbr(
- /*top*/ 1, /*left*/ 0, /*bottom*/ 0, /*right*/ 0,
- ),
- ));
- }
- renderable
+ pub(crate) fn is_done(&self) -> bool {
+ self.is_done
}
fn render_hints(&self, area: Rect, buf: &mut Buffer) {
- let line1 = Rect::new(area.x, area.y, area.width, 1);
- let line2 = Rect::new(area.x, area.y.saturating_add(1), area.width, 1);
- render_navigation_hints(line1, buf, &self.view.keymap);
+ let line1 = Rect::new(area.x, area.y, area.width, /*height*/ 1).intersection(area);
+ let line2 = Rect::new(
+ area.x,
+ area.y.saturating_add(/*rhs*/ 1),
+ area.width,
+ /*height*/ 1,
+ )
+ .intersection(area);
+ render_navigation_hints(line1, buf, &self.keymap);
let mut pairs: Vec<(Vec<ShortcutHint>, &str)> = vec![(
- first_or_empty(&self.view.keymap, "close", &self.view.keymap.close),
+ first_or_empty(&self.keymap, "close", &self.keymap.close),
"close",
)];
if self.highlight_cell.is_some() {
@@ -448,25 +318,11 @@ impl TranscriptOverlay {
render_key_hints(line2, buf, &pairs);
}
- pub(crate) fn render(&mut self, area: Rect, buf: &mut Buffer) {
- self.cache.borrow_mut().begin_frame();
- // Preserve following the tail before the composer changes the available height.
- if self.view.is_scrolled_to_bottom() {
- self.view.scroll_offset = usize::MAX;
- }
- let top_h = area.height.saturating_sub(3);
- let top = Rect::new(area.x, area.y, area.width, top_h);
- let bottom = Rect::new(area.x, area.y + top_h, area.width, 3);
- self.view.render(top, buf);
- self.render_history_state(top, buf);
- self.render_hints(bottom, buf);
- }
-
fn render_history_state(&self, area: Rect, buf: &mut Buffer) {
if area.height == 0 {
return;
}
- let label = match self.history_state {
+ let label = match self.view.history {
TranscriptHistoryState::Idle => return,
TranscriptHistoryState::LoadingOlder | TranscriptHistoryState::LoadingBeginning => {
" loading older history... "
@@ -486,36 +342,10 @@ impl TranscriptOverlay {
}
}
-impl TranscriptOverlay {
- pub(crate) fn handle_event(&mut self, tui: &mut tui::Tui, event: TuiEvent) -> Result<()> {
- match event {
- TuiEvent::Key(key_event) => match key_event {
- e if self.view.keymap.close.is_pressed(e)
- || self.view.keymap.close_transcript.is_pressed(e) =>
- {
- self.is_done = true;
- Ok(())
- }
- other => self.view.handle_key_event(tui, other),
- },
- TuiEvent::Draw | TuiEvent::Resume | TuiEvent::Resize(_) | TuiEvent::FocusGained => {
- tui.draw(u16::MAX, |frame| {
- self.render(frame.area(), frame.buffer);
- })?;
- Ok(())
- }
- _ => Ok(()),
- }
- }
- pub(crate) fn is_done(&self) -> bool {
- self.is_done
- }
-}
-
#[cfg(test)]
#[path = "transcript_tests.rs"]
mod tests;
#[cfg(test)]
-#[path = "highlight_tests.rs"]
-mod highlight_tests;
+#[path = "anchor_tests.rs"]
+mod anchor_tests;
diff --git a/codex-rs/tui/src/pager_overlay/transcript_tests.rs b/codex-rs/tui/src/pager_overlay/transcript_tests.rs
index ff2454abaa..9ab9fb8eca 100644
--- a/codex-rs/tui/src/pager_overlay/transcript_tests.rs
+++ b/codex-rs/tui/src/pager_overlay/transcript_tests.rs
@@ -41,13 +41,13 @@ impl crate::history_cell::HistoryCell for TestCell {
}
#[derive(Debug)]
-struct HeightCountingCell {
- height_calls: Arc<AtomicUsize>,
+struct LayoutCountingCell {
+ layout_calls: Arc<AtomicUsize>,
}
-impl crate::history_cell::HistoryCell for HeightCountingCell {
+impl crate::history_cell::HistoryCell for LayoutCountingCell {
fn display_lines(&self, _width: u16) -> Vec<Line<'static>> {
- self.height_calls.fetch_add(1, Ordering::Relaxed);
+ self.layout_calls.fetch_add(/*val*/ 1, Ordering::Relaxed);
vec![Line::from("counted")]
}
@@ -66,7 +66,7 @@ fn transcript_overlay(cells: Vec<Arc<dyn HistoryCell>>) -> TranscriptOverlay {
#[test]
fn jump_top_requests_older_history_from_the_bottom() {
- let overlay = transcript_overlay(vec![Arc::new(TestCell {
+ let mut overlay = transcript_overlay(vec![Arc::new(TestCell {
lines: vec![Line::from("recent")],
})]);
@@ -81,22 +81,149 @@ fn jump_top_requests_older_history_from_the_bottom() {
}
#[test]
-fn edit_next_hint_is_visible_when_highlighted() {
- let mut overlay = transcript_overlay(vec![Arc::new(TestCell {
- lines: vec![Line::from("hello")],
- })]);
- overlay.set_highlight_cell(Some(0));
+fn first_upward_key_requests_history_when_the_loaded_start_is_visible() {
+ let area = Rect::new(
+ /*x*/ 0, /*y*/ 0, /*width*/ 40, /*height*/ 10,
+ );
+ for committed in [false, true] {
+ for (line_count, near_start) in [(0, true), (3, true), (7, true), (30, false)] {
+ let lines = (0..line_count)
+ .map(|index| Line::from(format!("line {index}")))
+ .collect::<Vec<_>>();
+ let cells = if committed && !lines.is_empty() {
+ vec![Arc::new(TestCell {
+ lines: lines.clone(),
+ }) as Arc<dyn HistoryCell>]
+ } else {
+ Vec::new()
+ };
+ let mut overlay = transcript_overlay(cells);
+ if !committed {
+ overlay.sync_live_tail(area.width, /*key*/ None, |_| {
+ Some(lines.into_iter().map(HyperlinkLine::from).collect())
+ });
+ }
+ overlay.set_history_state(TranscriptHistoryState::Partial);
+ overlay.render(area, &mut Buffer::empty(area));
+ assert!(overlay.view.is_following());
+
+ // App checks pagination before forwarding the first navigation key.
+ for key in [
+ KeyEvent::new(KeyCode::Up, KeyModifiers::NONE),
+ KeyEvent::new(KeyCode::PageUp, KeyModifiers::NONE),
+ KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL),
+ ] {
+ assert_eq!(overlay.should_load_older(key), near_start);
+ }
+ assert!(!overlay.should_load_older(KeyEvent::new(KeyCode::Down, KeyModifiers::NONE,)));
+ if line_count == 30 {
+ let up = KeyEvent::new(KeyCode::Up, KeyModifiers::NONE);
+ overlay.scroll(/*rows*/ -1);
+ assert!(
+ !overlay.should_load_older(up),
+ "one row must not prefetch a distant page"
+ );
+ overlay.scroll(/*rows*/ -18);
+ assert!(
+ !overlay.should_load_older(up),
+ "row six is outside the five-row prefetch threshold"
+ );
+ overlay.scroll(/*rows*/ -1);
+ assert!(
+ overlay.should_load_older(up),
+ "prefetch at row five even before a draw"
+ );
+ }
+ }
+ }
+}
- // Render into a wide buffer so the footer hints aren't truncated.
- let area = Rect::new(0, 0, 120, 10);
- let mut buf = Buffer::empty(area);
- overlay.render(area, &mut buf);
+#[tokio::test]
+async fn loading_beginning_keeps_the_entry_until_history_is_complete() -> Result<()> {
+ let area = Rect::new(
+ /*x*/ 0, /*y*/ 0, /*width*/ 40, /*height*/ 10,
+ );
+ let mut tui = crate::tui::test_support::make_test_tui()?;
+ for already_rendered in [false, true] {
+ let mut overlay = transcript_overlay(vec![Arc::new(TestCell {
+ lines: vec!["committed".into()],
+ })]);
+ let live = (0..20)
+ .map(|index| Line::from(format!("live {index}")))
+ .collect::<Vec<_>>();
+ overlay.sync_live_tail(area.width, /*key*/ None, |_| {
+ Some(live.iter().cloned().map(HyperlinkLine::from).collect())
+ });
+ overlay.set_history_state(TranscriptHistoryState::Partial);
+ if already_rendered {
+ overlay.render(area, &mut Buffer::empty(area));
+ }
- let s = buffer_to_text(&buf, area);
- assert!(
- s.contains("edit next"),
- "expected 'edit next' hint in overlay footer, got: {s:?}"
+ // App marks loading before forwarding Home to the overlay.
+ overlay.set_history_state(TranscriptHistoryState::LoadingBeginning);
+ overlay.handle_event(
+ &mut tui,
+ TuiEvent::Key(KeyEvent::new(KeyCode::Home, KeyModifiers::NONE)),
+ )?;
+ let mut before = Buffer::empty(area);
+ overlay.render(area, &mut before);
+ assert!(!overlay.view.is_following());
+ assert_eq!(
+ overlay.view.history,
+ TranscriptHistoryState::LoadingBeginning
+ );
+
+ overlay.insert_cell(Arc::new(TestCell { lines: live }));
+ overlay.sync_live_tail(area.width, /*key*/ None, |_| {
+ Some(
+ (20..40)
+ .map(|index| HyperlinkLine::from(format!("live {index}")))
+ .collect(),
+ )
+ });
+ overlay.prepend(vec![Arc::new(TestCell {
+ lines: vec!["oldest".into()],
+ })]);
+ let mut actual = Buffer::empty(area);
+ overlay.render(area, &mut actual);
+ assert_eq!(actual, before);
+
+ overlay.set_history_state(TranscriptHistoryState::Complete);
+ overlay.render(area, &mut actual);
+ assert!(buffer_to_text(&actual, overlay.content_area).starts_with("oldest\n"));
+ }
+ Ok(())
+}
+
+#[tokio::test]
+async fn navigation_before_the_first_draw_preserves_the_full_latest_viewport() -> Result<()> {
+ let area = Rect::new(
+ /*x*/ 0, /*y*/ 0, /*width*/ 40, /*height*/ 10,
);
+ let mut tui = crate::tui::test_support::make_test_tui()?;
+ for key in [
+ KeyEvent::new(KeyCode::Up, KeyModifiers::NONE),
+ KeyEvent::new(KeyCode::Down, KeyModifiers::NONE),
+ KeyEvent::new(KeyCode::PageUp, KeyModifiers::NONE),
+ KeyEvent::new(KeyCode::PageDown, KeyModifiers::NONE),
+ KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL),
+ KeyEvent::new(KeyCode::Char('d'), KeyModifiers::CONTROL),
+ ] {
+ let cells = vec![Arc::new(TestCell {
+ lines: (0..30)
+ .map(|index| Line::from(format!("line {index}")))
+ .collect(),
+ }) as Arc<dyn HistoryCell>];
+ let mut expected_overlay = transcript_overlay(cells.clone());
+ let mut expected = Buffer::empty(area);
+ expected_overlay.render(area, &mut expected);
+ let mut overlay = transcript_overlay(cells);
+ overlay.handle_event(&mut tui, TuiEvent::Key(key))?;
+ let mut actual = Buffer::empty(area);
+ overlay.render(area, &mut actual);
+ assert_eq!(actual, expected);
+ }
+ Ok(())
}
#[test]
@@ -146,24 +273,35 @@ fn transcript_overlay_snapshot_basic() {
}
#[test]
-fn transcript_overlay_preserves_semantic_web_links() {
+fn transcript_overlay_preserves_complete_wrapped_links_in_history_and_live_output() {
let destination = "https://example.com/a/very/long/path";
- let mut overlay = transcript_overlay(vec![Arc::new(history_cell::AgentMarkdownCell::new(
+ let cell: Arc<dyn HistoryCell> = Arc::new(history_cell::AgentMarkdownCell::new(
destination.to_string(),
std::path::Path::new("/tmp"),
- ))]);
+ ));
let area = Rect::new(
/*x*/ 0, /*y*/ 0, /*width*/ 24, /*height*/ 10,
);
- let mut buf = Buffer::empty(area);
-
- overlay.render(area, &mut buf);
-
- assert!(area.positions().any(|position| {
- buf[position]
- .symbol()
- .contains(&format!("\x1b]8;;{destination}\x07"))
- }));
+ for live in [false, true] {
+ let mut overlay = transcript_overlay(if live { Vec::new() } else { vec![cell.clone()] });
+ if live {
+ overlay.sync_live_tail(area.width, /*key*/ None, |width| {
+ Some(cell.transcript_hyperlink_lines(width))
+ });
+ }
+ let mut buf = Buffer::empty(area);
+ overlay.render(area, &mut buf);
+ let linked_text = area
+ .positions()
+ .filter_map(|position| {
+ let symbol = buf[position].symbol();
+ symbol
+ .contains(&format!("\x1b]8;;{destination}\x07"))
+ .then(|| crate::terminal_hyperlinks::strip_osc8(symbol))
+ })
+ .collect::<String>();
+ assert_eq!(linked_text, destination);
+ }
}
#[test]
@@ -186,69 +324,67 @@ fn transcript_overlay_renders_live_tail() {
term.draw(|f| overlay.render(f.area(), f.buffer_mut()))
.expect("draw");
assert_snapshot!(term.backend());
+ overlay.navigate(KeyEvent::new(KeyCode::Home, KeyModifiers::NONE));
+ term.draw(|frame| overlay.render(frame.area(), frame.buffer_mut()))
+ .expect("draw");
+ assert!(overlay.live_tail_visible());
}
#[test]
-fn transcript_overlay_preserves_live_tail_when_prepending_history() {
- let mut overlay = transcript_overlay(vec![Arc::new(TestCell {
- lines: vec![Line::from("recent")],
- })]);
- overlay.sync_live_tail(
- /*width*/ 40,
- Some(ActiveCellTranscriptKey {
- cacheable: true,
- revision: 1,
- is_stream_continuation: false,
- animation_tick: None,
- }),
- |_| Some(vec![HyperlinkLine::from("live tail")]),
- );
- overlay.prepend(
- vec![Arc::new(TestCell {
- lines: vec![Line::from("older")],
- })],
- /*width*/ 40,
- );
-
- let area = Rect::new(
- /*x*/ 0, /*y*/ 0, /*width*/ 40, /*height*/ 10,
- );
- let mut buffer = Buffer::empty(area);
- overlay.render(area, &mut buffer);
- let rendered = buffer_to_text(&buffer, area);
- assert!(rendered.contains("older"));
- assert!(rendered.contains("recent"));
- assert!(rendered.contains("live tail"));
-}
-
-#[test]
-fn transcript_overlay_live_tail_preserves_semantic_web_links() {
- let destination = "https://example.com/a/streamed/path";
- let cell =
- history_cell::AgentMarkdownCell::new(destination.to_string(), std::path::Path::new("/tmp"));
- let mut overlay = transcript_overlay(Vec::new());
- let area = Rect::new(
- /*x*/ 0, /*y*/ 0, /*width*/ 24, /*height*/ 10,
- );
- let mut buf = Buffer::empty(area);
-
- overlay.sync_live_tail(
- area.width,
- Some(ActiveCellTranscriptKey {
- cacheable: true,
- revision: 1,
- is_stream_continuation: false,
- animation_tick: None,
- }),
- |width| Some(cell.transcript_hyperlink_lines(width)),
- );
- overlay.render(area, &mut buf);
-
- assert!(area.positions().any(|position| {
- buf[position]
- .symbol()
- .contains(&format!("\x1b]8;;{destination}\x07"))
- }));
+fn transcript_overlay_prepend_preserves_reading_highlight_and_live_tail() {
+ for follow in [false, true] {
+ let mut overlay = transcript_overlay(vec![
+ Arc::new(TestCell {
+ lines: vec!["newer one".into(), "newer two".into()],
+ }),
+ Arc::new(TestCell {
+ lines: (0..20)
+ .map(|i| Line::from(format!("reading {i}")))
+ .collect(),
+ }),
+ ]);
+ overlay.highlight_cell = Some(1);
+ overlay.sync_live_tail(
+ /*width*/ 40,
+ Some(ActiveCellTranscriptKey {
+ cacheable: true,
+ revision: 1,
+ is_stream_continuation: false,
+ animation_tick: None,
+ }),
+ |_| Some(vec![HyperlinkLine::from("live tail")]),
+ );
+ let mut term = Terminal::new(TestBackend::new(/*width*/ 40, /*height*/ 8)).expect("term");
+ term.draw(|frame| overlay.render(frame.area(), frame.buffer_mut()))
+ .expect("draw");
+ if !follow {
+ overlay.view.jump_to_entry(&overlay.cells, /*index*/ 1);
+ }
+ term.draw(|frame| overlay.render(frame.area(), frame.buffer_mut()))
+ .expect("draw");
+ let content_area = overlay.content_area;
+ let before = buffer_to_text(term.backend().buffer(), content_area);
+ overlay.reveal_highlight = true;
+ overlay.prepend(vec![Arc::new(TestCell {
+ lines: vec!["older one".into(), "older two".into(), "older three".into()],
+ })]);
+ assert_eq!(
+ (overlay.highlight_cell, overlay.reveal_highlight),
+ (Some(2), true)
+ );
+ overlay.reveal_highlight = false;
+ term.draw(|frame| overlay.render(frame.area(), frame.buffer_mut()))
+ .expect("draw prepended");
+ assert_eq!(
+ buffer_to_text(term.backend().buffer(), content_area),
+ before
+ );
+ assert_eq!(overlay.view.is_following(), follow);
+ overlay.view.jump_to_latest();
+ term.draw(|frame| overlay.render(frame.area(), frame.buffer_mut()))
+ .expect("draw tail");
+ assert!(buffer_to_text(term.backend().buffer(), content_area).contains("live tail"));
+ }
}
#[test]
@@ -351,7 +487,7 @@ fn transcript_overlay_apply_patch_scroll_vt100_clears_previous_page() {
let mut buf = Buffer::empty(area);
overlay.render(area, &mut buf);
- overlay.view.scroll_offset = 0;
+ overlay.view.jump_to_entry(&overlay.cells, /*index*/ 0);
overlay.render(area, &mut buf);
let snapshot = buffer_to_text(&buf, area);
@@ -374,7 +510,7 @@ fn transcript_overlay_keeps_scroll_pinned_at_bottom() {
.expect("draw");
assert!(
- overlay.view.is_scrolled_to_bottom(),
+ overlay.view.is_following(),
"expected initial render to leave view at bottom"
);
@@ -382,318 +518,227 @@ fn transcript_overlay_keeps_scroll_pinned_at_bottom() {
term.backend_mut().resize(/*width*/ 40, height);
term.draw(|f| overlay.render(f.area(), f.buffer_mut()))
.expect("draw after composer height change");
- assert!(overlay.is_scrolled_to_bottom());
+ assert!(overlay.view.is_following());
}
overlay.insert_cell(Arc::new(TestCell {
lines: vec!["tail".into()],
}));
- assert_eq!(overlay.view.scroll_offset, usize::MAX);
+ assert!(overlay.view.is_following());
term.draw(|f| overlay.render(f.area(), f.buffer_mut()))
.expect("draw committed tail");
assert_snapshot!("transcript_overlay_follows_resized_tail", term.backend());
}
#[test]
-fn transcript_overlay_preserves_manual_scroll_position() {
- let mut overlay = transcript_overlay(
- (0..20)
- .map(|i| {
- Arc::new(TestCell {
- lines: vec![Line::from(format!("line{i}"))],
- }) as Arc<dyn HistoryCell>
- })
- .collect(),
- );
- let mut term = Terminal::new(TestBackend::new(40, 12)).expect("term");
- term.draw(|f| overlay.render(f.area(), f.buffer_mut()))
- .expect("draw");
-
- overlay.view.scroll_offset = 0;
-
- overlay.insert_cell(Arc::new(TestCell {
- lines: vec!["tail".into()],
- }));
-
- assert_eq!(overlay.view.scroll_offset, 0);
- overlay.view.scroll_offset = 3;
- term.draw(|frame| overlay.render(frame.area(), frame.buffer_mut()))
- .expect("draw");
- let content_area = Rect::new(
- /*x*/ 0, /*y*/ 1, /*width*/ 40, /*height*/ 4,
- );
- let visible_before = buffer_to_text(term.backend().buffer(), content_area);
- overlay.prepend(
- vec![Arc::new(TestCell {
- lines: (0..40).map(|i| Line::from(format!("older {i}"))).collect(),
- })],
- /*width*/ 40,
- );
- term.draw(|frame| overlay.render(frame.area(), frame.buffer_mut()))
- .expect("draw");
- assert_eq!(
- buffer_to_text(term.backend().buffer(), content_area),
- visible_before
- );
- assert_snapshot!(
- "transcript_overlay_prepended_history",
- visible_before.trim()
- );
+fn transcript_overlay_consolidation_remaps_highlight() {
+ for (selected, expected) in [(3, 2), (6, 4)] {
+ let mut overlay = transcript_overlay(
+ (0..7)
+ .map(|i| {
+ Arc::new(TestCell {
+ lines: vec![Line::from(format!("line{i}"))],
+ }) as Arc<dyn HistoryCell>
+ })
+ .collect(),
+ );
+ overlay.set_highlight_cell(Some(selected));
+ overlay.consolidate_cells(
+ 2..5,
+ Arc::new(TestCell {
+ lines: vec![Line::from("consolidated")],
+ }),
+ );
+ assert_eq!(overlay.highlight_cell, Some(expected));
+ }
}
#[test]
-fn transcript_overlay_insert_preserves_cached_cell_heights() {
- let height_calls = Arc::new(AtomicUsize::new(0));
- let mut overlay = transcript_overlay(vec![Arc::new(HeightCountingCell {
- height_calls: height_calls.clone(),
+fn transcript_overlay_paging_is_continuous_and_round_trips() {
+ let mut overlay = transcript_overlay(vec![Arc::new(TestCell {
+ lines: (0..50)
+ .map(|i| Line::from(format!("line-{i:02}")))
+ .collect(),
})]);
- let area = Rect::new(0, 0, 40, 12);
- let mut buf = Buffer::empty(area);
-
- overlay.render(area, &mut buf);
- assert_eq!(height_calls.load(Ordering::Relaxed), 1);
-
- overlay.insert_cell(Arc::new(TestCell {
- lines: vec![Line::from("inserted")],
- }));
- overlay.render(area, &mut buf);
-
- assert_eq!(height_calls.load(Ordering::Relaxed), 1);
-}
-
-#[test]
-fn transcript_overlay_history_rebuild_preserves_only_the_live_tail() {
- for replace in [false, true] {
- for tail in [
- None,
- Some(Vec::new()),
- Some(vec![HyperlinkLine::from("live")]),
- ] {
- let mut overlay = transcript_overlay(
- ["first", "last"]
- .map(|line| {
- Arc::new(TestCell {
- lines: vec![line.into()],
- }) as Arc<dyn HistoryCell>
- })
- .to_vec(),
- );
- let key = tail.as_ref().map(|_| ActiveCellTranscriptKey {
- cacheable: true,
- revision: 1,
- is_stream_continuation: false,
- animation_tick: None,
- });
- overlay.sync_live_tail(/*width*/ 40, key, |_| tail.clone());
- let consolidated = Arc::new(TestCell {
- lines: vec!["first".into(), "last".into()],
- });
- if replace {
- overlay.replace_cells(vec![consolidated]);
- } else {
- overlay.consolidate_cells(0..2, consolidated);
- }
- // A draw may arrive after the active tail has already been cleared.
- overlay.sync_live_tail(/*width*/ 40, key, |_| tail.clone());
- let mut reopened = transcript_overlay(overlay.cells.clone());
- reopened.sync_live_tail(/*width*/ 40, key, |_| tail.clone());
- let area = Rect::new(
- /*x*/ 0, /*y*/ 0, /*width*/ 40, /*height*/ 10,
- );
- let mut actual = Buffer::empty(area);
- let mut expected = Buffer::empty(area);
- overlay.render(area, &mut actual);
- reopened.render(area, &mut expected);
- assert_eq!(actual, expected);
- if tail.is_none() {
- assert_snapshot!(
- "transcript_overlay_completed_stream",
- buffer_to_text(&actual, area)
- );
- }
- }
+ let area = Rect::new(
+ /*x*/ 0, /*y*/ 0, /*width*/ 40, /*height*/ 15,
+ );
+ let mut buffer = Buffer::empty(area);
+ overlay.render(area, &mut buffer);
+ overlay.view.jump_to_entry(&overlay.cells, /*index*/ 0);
+ for start in [0, 10] {
+ overlay.render(area, &mut buffer);
+ assert_eq!(
+ buffer_to_text(&buffer, overlay.content_area),
+ (start..start + 10)
+ .map(|i| format!("line-{i:02}\n"))
+ .collect::<String>()
+ );
+ overlay.navigate(KeyEvent::new(KeyCode::PageDown, KeyModifiers::NONE));
+ }
+ overlay.scroll(/*rows*/ -17);
+ overlay.render(area, &mut buffer);
+ let before = buffer.clone();
+ for key in [KeyCode::PageDown, KeyCode::PageUp] {
+ overlay.navigate(KeyEvent::new(key, KeyModifiers::NONE));
+ overlay.render(area, &mut buffer);
}
+ assert_eq!(buffer, before);
}
-#[test]
-fn transcript_overlay_consolidation_remaps_highlight_inside_range() {
- let mut overlay = transcript_overlay(
- (0..6)
- .map(|i| {
- Arc::new(TestCell {
- lines: vec![Line::from(format!("line{i}"))],
- }) as Arc<dyn HistoryCell>
- })
+#[tokio::test]
+async fn half_page_uses_the_last_rendered_content_height() -> Result<()> {
+ let mut overlay = transcript_overlay(vec![Arc::new(TestCell {
+ lines: (0..50)
+ .map(|i| Line::from(format!("line-{i:02}")))
.collect(),
+ })]);
+ let transcript_area = Rect::new(
+ /*x*/ 0, /*y*/ 0, /*width*/ 40, /*height*/ 10,
);
- overlay.set_highlight_cell(Some(3));
+ let mut buf = Buffer::empty(transcript_area);
+ overlay.render(transcript_area, &mut buf);
+ let page_height = usize::from(overlay.content_area.height);
+ let mut tui = crate::tui::test_support::make_test_tui()?;
+ tui.terminal.set_viewport_area(Rect::new(
+ /*x*/ 0, /*y*/ 0, /*width*/ 40, /*height*/ 24,
+ ));
+ overlay.view.jump_to_entry(&overlay.cells, /*index*/ 0);
+ overlay.scroll(/*rows*/ 10);
- overlay.consolidate_cells(
- 2..5,
- Arc::new(TestCell {
- lines: vec![Line::from("consolidated")],
- }),
- );
+ overlay.handle_event(
+ &mut tui,
+ TuiEvent::Key(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::CONTROL)),
+ )?;
- assert_eq!(
- overlay.highlight_cell,
- Some(2),
- "highlight inside consolidated range should point to replacement cell",
- );
+ overlay.render(transcript_area, &mut buf);
+ let first = 10 + page_height.div_ceil(/*rhs*/ 2);
+ assert!(buffer_to_text(&buf, overlay.content_area).starts_with(&format!("line-{first:02}\n")));
+ Ok(())
}
#[test]
-fn transcript_overlay_consolidation_remaps_highlight_after_range() {
+fn transcript_highlight_scrolls_offscreen_entries_in_both_directions() {
let mut overlay = transcript_overlay(
- (0..7)
- .map(|i| {
+ (0..20)
+ .map(|index| {
Arc::new(TestCell {
- lines: vec![Line::from(format!("line{i}"))],
+ lines: vec![Line::from(format!("entry {index}"))],
}) as Arc<dyn HistoryCell>
})
.collect(),
);
- overlay.set_highlight_cell(Some(6));
-
- overlay.consolidate_cells(
- 2..5,
- Arc::new(TestCell {
- lines: vec![Line::from("consolidated")],
- }),
- );
-
- assert_eq!(
- overlay.highlight_cell,
- Some(4),
- "highlight after consolidated range should shift left by removed cells",
+ let area = Rect::new(
+ /*x*/ 0, /*y*/ 0, /*width*/ 40, /*height*/ 12,
);
-}
-
-fn transcript_line_numbers(overlay: &mut TranscriptOverlay, area: Rect) -> Vec<usize> {
- let mut buf = Buffer::empty(area);
- overlay.render(area, &mut buf);
-
- let top_h = area.height.saturating_sub(3);
- let top = Rect::new(area.x, area.y, area.width, top_h);
- let content_area = overlay.view.content_area(top);
-
- let mut nums = Vec::new();
- for y in content_area.y..content_area.bottom() {
- let mut line = String::new();
- for x in content_area.x..content_area.right() {
- line.push(buf[(x, y)].symbol().chars().next().unwrap_or(' '));
- }
- if let Some(n) = line
- .split_whitespace()
- .find_map(|w| w.strip_prefix("line-"))
- .and_then(|s| s.parse().ok())
- {
- nums.push(n);
- }
+ let mut buffer = Buffer::empty(area);
+ overlay.render(area, &mut buffer);
+ for index in [0, 19, 0] {
+ overlay.set_highlight_cell(Some(index));
+ overlay.render(area, &mut buffer);
+ assert!(buffer_to_text(&buffer, overlay.content_area).contains(&format!("entry {index}")));
}
- nums
}
#[test]
-fn transcript_overlay_paging_is_continuous_and_round_trips() {
+fn transcript_footer_does_not_format_offscreen_history_for_a_percentage() {
+ let counts = (0..200)
+ .map(|_| Arc::new(AtomicUsize::new(/*v*/ 0)))
+ .collect::<Vec<_>>();
let mut overlay = transcript_overlay(
- (0..50)
- .map(|i| {
- Arc::new(TestCell {
- lines: vec![Line::from(format!("line-{i:02}"))],
+ counts
+ .iter()
+ .map(|count| {
+ Arc::new(LayoutCountingCell {
+ layout_calls: Arc::clone(count),
}) as Arc<dyn HistoryCell>
})
.collect(),
);
- let area = Rect::new(0, 0, 40, 15);
-
- // Prime layout so last_content_height is populated and paging uses the real content height.
- let mut buf = Buffer::empty(area);
- overlay.view.scroll_offset = 0;
- overlay.render(area, &mut buf);
- let page_height = overlay.view.page_height(area);
-
- // Scenario 1: starting from the top, PageDown should show the next page of content.
- overlay.view.scroll_offset = 0;
- let page1 = transcript_line_numbers(&mut overlay, area);
- let page1_len = page1.len();
- let expected_page1: Vec<usize> = (0..page1_len).collect();
- assert_eq!(
- page1, expected_page1,
- "first page should start at line-00 and show a full page of content"
- );
-
- overlay.view.scroll_offset = overlay.view.scroll_offset.saturating_add(page_height);
- let page2 = transcript_line_numbers(&mut overlay, area);
- assert_eq!(
- page2.len(),
- page1_len,
- "second page should have the same number of visible lines as the first page"
+ let area = Rect::new(
+ /*x*/ 2, /*y*/ 1, /*width*/ 72, /*height*/ 12,
);
- let expected_page2_first = *page1.last().unwrap() + 1;
+ let mut buffer = Buffer::empty(area);
+ overlay.set_history_state(TranscriptHistoryState::Partial);
+ overlay.render(area, &mut buffer);
assert_eq!(
- page2[0], expected_page2_first,
- "second page after PageDown should immediately follow the first page"
- );
-
- // Scenario 2: from an interior offset (start=3), PageDown then PageUp should round-trip.
- let interior_offset = 3usize;
- overlay.view.scroll_offset = interior_offset;
- let before = transcript_line_numbers(&mut overlay, area);
- overlay.view.scroll_offset = overlay.view.scroll_offset.saturating_add(page_height);
- let _ = transcript_line_numbers(&mut overlay, area);
- overlay.view.scroll_offset = overlay.view.scroll_offset.saturating_sub(page_height);
- let after = transcript_line_numbers(&mut overlay, area);
+ overlay.content_area,
+ Rect::new(
+ /*x*/ 2, /*y*/ 2, /*width*/ 72, /*height*/ 7
+ )
+ );
+ assert!(!buffer_to_text(&buffer, area).contains('%'));
+ let before = counts
+ .iter()
+ .map(|count| count.load(Ordering::Relaxed))
+ .collect::<Vec<_>>();
+ assert!(before[..190].iter().all(|count| *count == 0));
+ assert!((1..10).contains(&before.iter().sum::<usize>()));
+ overlay.set_history_state(TranscriptHistoryState::Complete);
+ overlay.render(area, &mut buffer);
+ assert!(buffer_to_text(&buffer, area).contains("100%"));
assert_eq!(
- before, after,
- "PageDown+PageUp from interior offset ({interior_offset}) should round-trip"
- );
-
- // Scenario 3: from the top of the second page, PageUp then PageDown should round-trip.
- overlay.view.scroll_offset = page_height;
- let before2 = transcript_line_numbers(&mut overlay, area);
- overlay.view.scroll_offset = overlay.view.scroll_offset.saturating_sub(page_height);
- let _ = transcript_line_numbers(&mut overlay, area);
- overlay.view.scroll_offset = overlay.view.scroll_offset.saturating_add(page_height);
- let after2 = transcript_line_numbers(&mut overlay, area);
+ counts
+ .iter()
+ .map(|count| count.load(Ordering::Relaxed))
+ .collect::<Vec<_>>(),
+ before
+ );
+ for selection in [Some(199), Some(198), None] {
+ overlay.set_highlight_cell(selection);
+ overlay.render(area, &mut buffer);
+ assert_eq!(
+ counts
+ .iter()
+ .map(|count| count.load(Ordering::Relaxed))
+ .collect::<Vec<_>>(),
+ before
+ );
+ if selection.is_some() {
+ assert!(buffer_to_text(&buffer, area).contains("edit next"));
+ }
+ }
+ overlay.view.jump_to_latest();
+ overlay.insert_cell(Arc::new(TestCell {
+ lines: vec!["new output".into()],
+ }));
+ overlay.render(area, &mut buffer);
assert_eq!(
- before2, after2,
- "PageUp+PageDown from the top of the second page should round-trip"
+ counts
+ .iter()
+ .map(|count| count.load(Ordering::Relaxed))
+ .collect::<Vec<_>>(),
+ before
);
+ overlay.scroll(/*rows*/ -1);
+ overlay.render(area, &mut buffer);
+ assert!(!buffer_to_text(&buffer, area).contains('%'));
}
-#[tokio::test]
-async fn half_page_uses_the_last_rendered_content_height() -> Result<()> {
- let mut overlay = transcript_overlay(
- (0..50)
- .map(|i| {
- Arc::new(TestCell {
- lines: vec![Line::from(format!("line-{i:02}"))],
- }) as Arc<dyn HistoryCell>
- })
- .collect(),
- );
- let transcript_area = Rect::new(
- /*x*/ 0, /*y*/ 0, /*width*/ 40, /*height*/ 10,
- );
- let mut buf = Buffer::empty(transcript_area);
- overlay.render(transcript_area, &mut buf);
- let page_height = overlay.view.page_height(transcript_area);
- let mut tui = crate::tui::test_support::make_test_tui()?;
- tui.terminal.set_viewport_area(Rect::new(
- /*x*/ 0, /*y*/ 0, /*width*/ 40, /*height*/ 24,
- ));
- overlay.view.scroll_offset = 10;
-
- overlay.view.handle_key_event(
- &mut tui,
- KeyEvent::new(KeyCode::Char('d'), KeyModifiers::CONTROL),
- )?;
-
- assert_eq!(
- overlay.view.scroll_offset,
- 10 + page_height.saturating_add(1) / 2
- );
- Ok(())
+#[test]
+fn transcript_overlay_clips_zero_and_short_viewports_to_their_area() {
+ let canvas = Rect::new(
+ /*x*/ 0, /*y*/ 0, /*width*/ 48, /*height*/ 16,
+ );
+ for width in [0, 1, 40] {
+ for height in 0..=6 {
+ let area = Rect::new(/*x*/ 2, /*y*/ 3, width, height);
+ let mut overlay = transcript_overlay(vec![Arc::new(TestCell {
+ lines: vec!["content".into()],
+ })]);
+ let mut buffer = Buffer::filled(canvas, Cell::from('.'));
+ overlay.render(area, &mut buffer);
+ for position in canvas
+ .positions()
+ .filter(|position| !area.contains(*position))
+ {
+ assert_eq!(
+ buffer[position],
+ Cell::from('.'),
+ "area={area:?}, position={position:?}"
+ );
+ }
+ }
+ }
}
diff --git a/codex-rs/tui/src/transcript_view.rs b/codex-rs/tui/src/transcript_view.rs
index 140db18012..062b81e80c 100644
--- a/codex-rs/tui/src/transcript_view.rs
+++ b/codex-rs/tui/src/transcript_view.rs
@@ -1,7 +1,411 @@
-//! Retained display rows and bounded caches for transcript rendering.
+//! A conversation viewport over the app's retained cells and its current live tail.
+//!
+//! The app owns history and pagination. This view owns reading state and bounded
+//! layout caches. Reading positions track entry identity and a display-row offset.
+//! Resize and replacement clamp that offset; live content always uses its current revision.
mod layout;
mod text;
-pub(crate) use layout::LayoutCache;
-pub(crate) use text::TextLayout;
+use std::sync::Arc;
+
+use crate::chatwidget::ActiveCellTranscriptKey;
+use crate::history_cell::HistoryCell;
+use crate::history_cell::UserHistoryCell;
+use crate::pager_overlay::TranscriptHistoryState;
+use crate::terminal_hyperlinks::HyperlinkLine;
+use ratatui::buffer::Buffer;
+use ratatui::layout::Rect;
+use ratatui::style::Stylize;
+use ratatui::text::Line;
+use ratatui::widgets::Clear;
+use ratatui::widgets::Widget;
+
+use layout::LayoutCache;
+use text::TextLayout;
+
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+enum EntryKey {
+ Cell(usize),
+ Live,
+}
+
+impl EntryKey {
+ fn cell(cell: &Arc<dyn HistoryCell>) -> Self {
+ Self::Cell(Arc::as_ptr(cell).cast::<()>() as usize)
+ }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct Anchor {
+ key: EntryKey,
+ index: usize,
+ row: usize,
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+enum Position {
+ #[default]
+ Latest,
+ Reading(Anchor),
+}
+
+struct VisibleRow {
+ index: usize,
+ row: usize,
+ layout: Arc<TextLayout>,
+ key: EntryKey,
+}
+
+/// Entry-based scrolling for the detailed transcript overlay.
+#[derive(Default)]
+pub(crate) struct TranscriptView {
+ position: Position,
+ cache: LayoutCache,
+ live: Option<Arc<TextLayout>>,
+ live_separated: Option<Arc<TextLayout>>,
+ live_key: Option<(u16, ActiveCellTranscriptKey)>,
+ live_continuation: bool,
+ area: Rect,
+ visible: Vec<VisibleRow>,
+ pub(crate) history: TranscriptHistoryState,
+}
+
+impl TranscriptView {
+ pub(crate) fn render(
+ &mut self,
+ area: Rect,
+ buf: &mut Buffer,
+ cells: &[Arc<dyn HistoryCell>],
+ highlight: Option<usize>,
+ ) -> u16 {
+ self.cache.begin_frame();
+ Clear.render(area, buf);
+ self.area = area;
+ self.visible.clear();
+ if area.is_empty() {
+ return 0;
+ }
+ let mut rendered = 0;
+ let (mut index, mut row) = self.start(cells);
+ for y in area.top()..area.bottom() {
+ let Some(layout) = self.layout(cells, index) else {
+ break;
+ };
+ if row >= layout.row_count() {
+ index += 1;
+ row = 0;
+ let Some(next) = self.next_nonempty(cells, index) else {
+ break;
+ };
+ index = next;
+ }
+ let Some(layout) = self.layout(cells, index) else {
+ break;
+ };
+ let key = self.entry_key(cells, index);
+ let row_area = Rect::new(area.x, y, area.width, /*height*/ 1);
+ if (index == 0 || row > 0)
+ && cells
+ .get(index)
+ .is_some_and(|cell| cell.as_any().is::<UserHistoryCell>())
+ {
+ buf.set_style(row_area, crate::style::history_prompt_style());
+ }
+ self.visible.push(VisibleRow {
+ index,
+ row,
+ layout,
+ key,
+ });
+ row += 1;
+ rendered += 1;
+ }
+ let mut y = area.y;
+ for rows in self
+ .visible
+ .chunk_by(|a, b| Arc::ptr_eq(&a.layout, &b.layout))
+ {
+ let first = &rows[0];
+ let height = rows.len() as u16;
+ first
+ .layout
+ .render(Rect::new(area.x, y, area.width, height), buf, first.row);
+ if highlight == Some(first.index) {
+ for (offset, row) in rows.iter().enumerate() {
+ row.layout.highlight(
+ Rect::new(area.x, y + offset as u16, area.width, /*height*/ 1),
+ buf,
+ row.row,
+ );
+ }
+ }
+ y += height;
+ }
+ rendered
+ }
+
+ pub(crate) fn sync_live_tail(
+ &mut self,
+ width: u16,
+ key: Option<ActiveCellTranscriptKey>,
+ lines: impl FnOnce(u16) -> Option<Vec<HyperlinkLine>>,
+ ) {
+ let next = key.map(|key| (width, key));
+ if key.is_some_and(|key| key.cacheable) && self.live_key == next {
+ return;
+ }
+ self.live_key = next;
+ self.live_separated = None;
+ self.live_continuation = key.is_some_and(|key| key.is_stream_continuation);
+ self.live = lines(width).map(|lines| Arc::new(TextLayout::new(lines, width)));
+ }
+
+ pub(crate) fn is_following(&self) -> bool {
+ self.position == Position::Latest
+ }
+
+ pub(crate) fn live_tail_visible(&self) -> bool {
+ self.visible.iter().any(|row| row.key == EntryKey::Live)
+ }
+
+ /// Hold the current reading position until every older page has arrived.
+ pub(crate) fn jump_to_beginning(&mut self, cells: &[Arc<dyn HistoryCell>]) {
+ if self.history == TranscriptHistoryState::LoadingBeginning {
+ return;
+ }
+ if self.history.has_unloaded_history() {
+ self.scroll(cells, /*rows*/ 0);
+ self.history = TranscriptHistoryState::LoadingBeginning;
+ } else {
+ self.jump_to_entry(cells, /*index*/ 0);
+ }
+ }
+
+ pub(crate) fn jump_to_latest(&mut self) {
+ self.position = Position::Latest;
+ }
+
+ pub(crate) fn scroll(&mut self, cells: &[Arc<dyn HistoryCell>], rows: isize) {
+ let start = self.start(cells);
+ let (index, row) = self.move_rows(cells, start.0, start.1, rows);
+ if rows < 0
+ && (index, row) == start
+ && self.is_following()
+ && !self.history.has_unloaded_history()
+ {
+ return;
+ }
+ // Anchor visible content, not a hidden header that stays ahead of every older page.
+ let index = self.next_nonempty(cells, index).unwrap_or(index);
+ let bottom = self.bottom_start(cells);
+ if rows > 0 && (index, row) >= bottom {
+ self.jump_to_latest();
+ return;
+ }
+ if self.layout(cells, index).is_some() {
+ self.position = Position::Reading(Anchor {
+ key: self.entry_key(cells, index),
+ index,
+ row,
+ });
+ }
+ }
+
+ pub(crate) fn jump_to_entry(&mut self, cells: &[Arc<dyn HistoryCell>], index: usize) {
+ self.position = Position::Reading(Anchor {
+ key: self.entry_key(cells, index),
+ index,
+ row: 0,
+ });
+ }
+
+ /// Reveal an entire entry when prompt backtracking changes the highlight.
+ pub(crate) fn ensure_entry_visible(&mut self, cells: &[Arc<dyn HistoryCell>], index: usize) {
+ let key = cells.get(index).map_or(EntryKey::Live, EntryKey::cell);
+ let mut visible = self
+ .visible
+ .iter()
+ .filter(|row| row.index == index && row.key == key);
+ let fully_visible = visible
+ .next()
+ .is_some_and(|first| first.row == 0 && visible.count() + 1 == first.layout.row_count());
+ if !fully_visible {
+ self.jump_to_entry(cells, index);
+ }
+ }
+
+ /// Keep readers on the replacement entry without translating source offsets.
+ pub(crate) fn replace_range(
+ &mut self,
+ cells: &[Arc<dyn HistoryCell>],
+ range: std::ops::Range<usize>,
+ replacement: &Arc<dyn HistoryCell>,
+ ) {
+ if let Position::Reading(anchor) = self.position
+ && range.contains(&self.resolve(cells, anchor))
+ {
+ self.position = Position::Reading(Anchor {
+ key: EntryKey::cell(replacement),
+ index: range.start,
+ ..anchor
+ });
+ }
+ }
+
+ /// Preserve display rows when retained entries gain or lose a leading separator.
+ pub(crate) fn history_changed(&mut self, cells: &[Arc<dyn HistoryCell>]) {
+ if let Position::Reading(anchor) = self.position {
+ let index = self.resolve(cells, anchor);
+ let separated = cells.get(index).is_some_and(|cell| {
+ EntryKey::cell(cell) == anchor.key && !cell.is_stream_continuation()
+ });
+ let row = if separated && anchor.index == 0 && index > 0 {
+ anchor.row.saturating_add(/*rhs*/ 1)
+ } else if separated && anchor.index > 0 && index == 0 {
+ anchor.row.saturating_sub(/*rhs*/ 1)
+ } else {
+ anchor.row
+ };
+ self.position = Position::Reading(Anchor {
+ key: self.entry_key(cells, index),
+ index,
+ row,
+ });
+ }
+ }
+
+ pub(crate) fn near_start(&mut self, cells: &[Arc<dyn HistoryCell>]) -> bool {
+ if self.is_following() && self.area.is_empty() {
+ return false;
+ }
+ let (index, row) = self.start(cells);
+ self.move_rows(cells, index, row, -(self.area.height as isize)) == (0, 0)
+ }
+
+ fn start(&mut self, cells: &[Arc<dyn HistoryCell>]) -> (usize, usize) {
+ match self.position {
+ Position::Latest => self.bottom_start(cells),
+ Position::Reading(anchor) => {
+ let index = self.resolve(cells, anchor);
+ let row = self.layout(cells, index).map_or(/*default*/ 0, |layout| {
+ anchor.row.min(layout.row_count().saturating_sub(/*rhs*/ 1))
+ });
+ self.position = Position::Reading(Anchor {
+ key: self.entry_key(cells, index),
+ index,
+ row,
+ });
+ (index, row)
+ }
+ }
+ }
+
+ fn bottom_start(&mut self, cells: &[Arc<dyn HistoryCell>]) -> (usize, usize) {
+ let count = cells.len() + usize::from(self.live.is_some());
+ let Some(last) = count.checked_sub(/*rhs*/ 1) else {
+ return (0, 0);
+ };
+ let height = self
+ .layout(cells, last)
+ .map_or(/*default*/ 0, |l| l.row_count());
+ self.move_rows(cells, last, height, -(self.area.height as isize))
+ }
+
+ fn move_rows(
+ &mut self,
+ cells: &[Arc<dyn HistoryCell>],
+ mut index: usize,
+ mut row: usize,
+ rows: isize,
+ ) -> (usize, usize) {
+ if rows < 0 {
+ let mut remaining = rows.unsigned_abs();
+ while remaining > row && index > 0 {
+ remaining -= row;
+ index -= 1;
+ row = self
+ .layout(cells, index)
+ .map_or(/*default*/ 0, |l| l.row_count());
+ }
+ return (index, row.saturating_sub(remaining));
+ }
+ let mut remaining = row.saturating_add(rows as usize);
+ while let Some(layout) = self.layout(cells, index) {
+ if remaining < layout.row_count() {
+ break;
+ }
+ remaining -= layout.row_count();
+ index += 1;
+ }
+ (index, remaining)
+ }
+
+ fn next_nonempty(&mut self, cells: &[Arc<dyn HistoryCell>], mut index: usize) -> Option<usize> {
+ while let Some(layout) = self.layout(cells, index) {
+ if layout.row_count() > 0 {
+ return Some(index);
+ }
+ index += 1;
+ }
+ None
+ }
+
+ fn resolve(&self, cells: &[Arc<dyn HistoryCell>], anchor: Anchor) -> usize {
+ if anchor.key == EntryKey::Live {
+ return if self.live.is_some() {
+ cells.len()
+ } else {
+ cells.len().saturating_sub(/*rhs*/ 1)
+ };
+ }
+ if cells
+ .get(anchor.index)
+ .is_some_and(|cell| EntryKey::cell(cell) == anchor.key)
+ {
+ return anchor.index;
+ }
+ cells
+ .iter()
+ .position(|cell| EntryKey::cell(cell) == anchor.key)
+ .unwrap_or_else(|| anchor.index.min(cells.len().saturating_sub(/*rhs*/ 1)))
+ }
+
+ fn entry_key(&self, cells: &[Arc<dyn HistoryCell>], index: usize) -> EntryKey {
+ cells.get(index).map_or(EntryKey::Live, EntryKey::cell)
+ }
+}
+
+impl TranscriptView {
+ fn layout(&mut self, cells: &[Arc<dyn HistoryCell>], index: usize) -> Option<Arc<TextLayout>> {
+ let Some(cell) = cells.get(index) else {
+ if index != cells.len() {
+ return None;
+ }
+ let live = self.live.as_ref()?;
+ if cells.is_empty() || self.live_continuation {
+ return Some(Arc::clone(live));
+ }
+ return Some(Arc::clone(self.live_separated.get_or_insert_with(|| {
+ Arc::new(live.as_ref().clone().with_leading_separator())
+ })));
+ };
+ let width = self.area.width.max(/*other*/ 1);
+ if cell.as_any().is::<crate::history_cell::SessionInfoCell>()
+ && let Some(placeholder) = self.history.session_header_placeholder()
+ {
+ return Some(Arc::new(TextLayout::new(
+ vec![HyperlinkLine::from(Line::from(placeholder).dim())],
+ width,
+ )));
+ }
+ Some(
+ self.cache
+ .get(cell, width, index > 0 && !cell.is_stream_continuation()),
+ )
+ }
+}
+
+#[cfg(test)]
+#[path = "transcript_view_tests.rs"]
+mod tests;
diff --git a/codex-rs/tui/src/transcript_view/layout.rs b/codex-rs/tui/src/transcript_view/layout.rs
index 26890bfe73..9528170377 100644
--- a/codex-rs/tui/src/transcript_view/layout.rs
+++ b/codex-rs/tui/src/transcript_view/layout.rs
@@ -13,7 +13,7 @@ const MAX_CACHED_ENTRIES: usize = 64;
const MAX_CACHED_TEXT_BYTES: usize = 8 * 1024 * 1024;
#[derive(Default)]
-pub(crate) struct LayoutCache {
+pub(super) struct LayoutCache {
entries: Vec<CachedLayout>,
frame: u64,
render_state: Option<RenderState>,
@@ -37,7 +37,7 @@ struct CachedLayout {
}
impl LayoutCache {
- pub(crate) fn begin_frame(&mut self) {
+ pub(super) fn begin_frame(&mut self) {
self.frame = self.frame.wrapping_add(/*rhs*/ 1);
let state = RenderState {
theme: crate::render::highlight::syntax_theme_revision(),
@@ -51,7 +51,7 @@ impl LayoutCache {
}
}
- pub(crate) fn get(
+ pub(super) fn get(
&mut self,
cell: &Arc<dyn HistoryCell>,
width: u16,
diff --git a/codex-rs/tui/src/transcript_view/text.rs b/codex-rs/tui/src/transcript_view/text.rs
index 874e0aa628..41f84567d0 100644
--- a/codex-rs/tui/src/transcript_view/text.rs
+++ b/codex-rs/tui/src/transcript_view/text.rs
@@ -2,26 +2,30 @@
use crate::terminal_hyperlinks::HyperlinkLine;
use crate::terminal_hyperlinks::HyperlinkParagraph;
+use crate::width::display_width;
use ratatui::buffer::Buffer;
+use ratatui::buffer::CellWidth;
+use ratatui::layout::Alignment;
use ratatui::layout::Rect;
+use ratatui::style::Modifier;
use ratatui::style::Style;
use ratatui::widgets::Widget;
use std::sync::Arc;
#[derive(Clone)]
-pub(crate) struct TextLayout {
- pub(crate) rows: Vec<TextRow>,
- pub(crate) byte_len: usize,
+pub(super) struct TextLayout {
+ pub(super) rows: Vec<TextRow>,
+ pub(super) byte_len: usize,
}
#[derive(Clone)]
-pub(crate) struct TextRow {
- pub(crate) line: Arc<HyperlinkLine>,
- pub(crate) offset: u16,
+pub(super) struct TextRow {
+ pub(super) line: Arc<HyperlinkLine>,
+ pub(super) offset: u16,
}
impl TextLayout {
- pub(crate) fn new(lines: Vec<HyperlinkLine>, width: u16) -> Self {
+ pub(super) fn new(lines: Vec<HyperlinkLine>, width: u16) -> Self {
let byte_len = lines
.iter()
.flat_map(|line| &line.line.spans)
@@ -51,7 +55,7 @@ impl TextLayout {
Self { rows, byte_len }
}
- pub(crate) fn with_leading_separator(mut self) -> Self {
+ pub(super) fn with_leading_separator(mut self) -> Self {
if !self.rows.is_empty() {
self.rows.insert(
/*index*/ 0,
@@ -64,11 +68,11 @@ impl TextLayout {
self
}
- pub(crate) fn row_count(&self) -> usize {
+ pub(super) fn row_count(&self) -> usize {
self.rows.len()
}
- pub(crate) fn render(&self, area: Rect, buf: &mut Buffer, row: usize) {
+ pub(super) fn render(&self, area: Rect, buf: &mut Buffer, row: usize) {
let start = row.min(self.rows.len());
let end = row
.saturating_add(usize::from(area.height))
@@ -83,4 +87,47 @@ impl TextLayout {
y += height;
}
}
+
+ /// Highlight the entry's text while leaving synthetic gutters and padding untouched.
+ pub(super) fn highlight(&self, area: Rect, buf: &mut Buffer, row: usize) {
+ let row = &self.rows[row];
+ let line = &row.line;
+ let text = line.line.to_string();
+ let prefix = if row.offset == 0 {
+ line.source.as_ref().map_or(
+ /*default*/ 0,
+ |source| display_width(&text[..source.prefix_bytes]),
+ )
+ } else {
+ 0
+ };
+ let width = display_width(&text);
+ let columns = usize::from(area.width);
+ let alignment = match line.line.alignment.unwrap_or(Alignment::Left) {
+ Alignment::Left => 0,
+ Alignment::Center => (columns / 2).saturating_sub(width / 2),
+ Alignment::Right => columns.saturating_sub(width),
+ };
+ let (alignment, end) = if width > columns {
+ let end = (0..area.width)
+ .rfind(|x| !buf[(area.x + x, area.y)].symbol().trim().is_empty())
+ .map_or(/*default*/ 0, |x| {
+ usize::from(x + buf[(area.x + x, area.y)].cell_width())
+ });
+ let start = if line.line.alignment.unwrap_or(Alignment::Left) == Alignment::Left {
+ 0
+ } else {
+ (0..area.width)
+ .find(|x| !buf[(area.x + x, area.y)].symbol().trim().is_empty())
+ .map_or(/*default*/ 0, usize::from)
+ };
+ (start, end)
+ } else {
+ (alignment, alignment + width)
+ };
+ for column in alignment + prefix..end.min(columns) {
+ buf[(area.x + column as u16, area.y)]
+ .set_style(Style::default().add_modifier(Modifier::REVERSED));
+ }
+ }
}
diff --git a/codex-rs/tui/src/transcript_view_tests.rs b/codex-rs/tui/src/transcript_view_tests.rs
new file mode 100644
index 0000000000..dee6cba27d
--- /dev/null
+++ b/codex-rs/tui/src/transcript_view_tests.rs
@@ -0,0 +1,197 @@
+//! Viewport behavior and cache lifetime across scrolling, pagination, and redraws.
+
+use super::*;
+use pretty_assertions::assert_eq;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering;
+
+fn cell(text: impl Into<String>) -> Arc<dyn HistoryCell> {
+ Arc::new(crate::history_cell::PlainHistoryCell::new(
+ text.into()
+ .lines()
+ .map(|line| line.to_owned().into())
+ .collect(),
+ ))
+}
+
+fn render(
+ view: &mut TranscriptView,
+ cells: &[Arc<dyn HistoryCell>],
+ width: u16,
+ height: u16,
+) -> Buffer {
+ let area = Rect::new(/*x*/ 0, /*y*/ 0, width, height);
+ let mut buffer = Buffer::empty(area);
+ view.render(area, &mut buffer, cells, /*highlight*/ None);
+ buffer
+}
+
+fn text(buffer: &Buffer) -> String {
+ (buffer.area.top()..buffer.area.bottom())
+ .map(|y| {
+ (buffer.area.left()..buffer.area.right())
+ .map(|x| buffer[(x, y)].symbol())
+ .collect::<String>()
+ .trim_end()
+ .to_owned()
+ })
+ .collect::<Vec<_>>()
+ .join("\n")
+}
+
+#[derive(Debug)]
+struct MutableHistoryCell {
+ version: Arc<AtomicUsize>,
+ renders: Arc<AtomicUsize>,
+}
+
+impl HistoryCell for MutableHistoryCell {
+ fn display_lines(&self, _width: u16) -> Vec<Line<'static>> {
+ self.renders.fetch_add(/*val*/ 1, Ordering::Relaxed);
+ let version = self.version.load(Ordering::Relaxed);
+ (0..8)
+ .map(|row| Line::from(format!("version {version} row {row}")))
+ .collect()
+ }
+
+ fn raw_lines(&self) -> Vec<Line<'static>> {
+ self.display_lines(/*width*/ 80)
+ }
+
+ fn has_stable_transcript_height(&self) -> bool {
+ false
+ }
+}
+
+#[test]
+fn reading_survives_prepend_and_new_output_then_returns_to_latest() {
+ let mut cells = vec![cell("older\nline two"), cell("current\nlast line")];
+ let mut view = TranscriptView::default();
+ render(&mut view, &cells, /*width*/ 20, /*height*/ 3);
+ view.scroll(&cells, /*rows*/ -2);
+ let before = text(&render(
+ &mut view, &cells, /*width*/ 20, /*height*/ 3,
+ ));
+ cells.insert(/*index*/ 0, cell("loaded from history"));
+ view.history_changed(&cells);
+ cells.push(cell("new output"));
+ assert_eq!(
+ text(&render(
+ &mut view, &cells, /*width*/ 20, /*height*/ 3
+ )),
+ before
+ );
+ cells.remove(/*index*/ 0);
+ view.history_changed(&cells);
+ assert_eq!(
+ text(&render(
+ &mut view, &cells, /*width*/ 20, /*height*/ 3
+ )),
+ before
+ );
+ view.jump_to_latest();
+ insta::assert_snapshot!(text(&render(&mut view, &cells, /*width*/ 20, /*height*/ 3)), @"
+ last line
+
+ new output
+ ");
+}
+
+#[test]
+fn prepending_history_updates_pagination_position_before_the_next_frame() {
+ let mut cells = vec![cell("current first"), cell("current last")];
+ let mut view = TranscriptView::default();
+ view.jump_to_entry(&cells, /*index*/ 0);
+ assert!(view.near_start(&cells));
+ render(&mut view, &cells, /*width*/ 20, /*height*/ 3);
+ cells.remove(/*index*/ 0);
+ view.history_changed(&cells);
+ cells.insert(/*index*/ 0, cell("earlier\n".repeat(100)));
+ view.history_changed(&cells);
+ assert!(!view.near_start(&cells));
+ cells.remove(/*index*/ 0);
+ view.history_changed(&cells);
+ let earlier = (0..100)
+ .map(|index| cell(format!("earlier {index}")))
+ .collect::<Vec<_>>();
+ cells.splice(0..0, earlier);
+ view.history_changed(&cells);
+ assert!(!view.near_start(&cells));
+ let Position::Reading(anchor) = view.position else {
+ panic!("reading anchor");
+ };
+ assert_eq!(
+ (anchor.key, anchor.index),
+ (EntryKey::cell(&cells[100]), 100)
+ );
+}
+
+#[test]
+fn single_row_scrolling_crosses_an_entry_separator_in_both_directions() {
+ let cells = vec![cell("first"), cell("second")];
+ let mut view = TranscriptView::default();
+ render(&mut view, &cells, /*width*/ 20, /*height*/ 1);
+ let mut frames = Vec::new();
+ for rows in [-1, -1, 1, 1] {
+ view.scroll(&cells, rows);
+ frames.push(text(&render(
+ &mut view, &cells, /*width*/ 20, /*height*/ 1,
+ )));
+ }
+ assert_eq!(frames, ["", "first", "", "second"]);
+}
+
+#[test]
+fn resize_and_consolidation_clamp_the_row_within_the_same_entry() {
+ let mut cells = vec![
+ cell("older"),
+ cell("alpha beta gamma delta epsilon zeta eta theta"),
+ ];
+ let mut view = TranscriptView::default();
+ render(&mut view, &cells, /*width*/ 10, /*height*/ 2);
+ view.scroll(&cells, /*rows*/ -1);
+ let Position::Reading(anchor) = view.position else {
+ panic!("reading anchor");
+ };
+ render(&mut view, &cells, /*width*/ 8, /*height*/ 2);
+ assert_eq!(view.position, Position::Reading(anchor));
+ let wide = render(&mut view, &cells, /*width*/ 60, /*height*/ 2);
+ assert_eq!(
+ text(&wide),
+ "alpha beta gamma delta epsilon zeta eta theta\n"
+ );
+
+ let replacement = cell("final answer");
+ view.replace_range(&cells, 0..2, &replacement);
+ cells.splice(0..2, [replacement]);
+ let completed = render(&mut view, &cells, /*width*/ 60, /*height*/ 2);
+ assert!(!view.is_following());
+ insta::assert_snapshot!(text(&completed), @"
+ final answer
+
+ ");
+}
+
+#[test]
+fn mutable_history_formats_once_per_frame_and_refreshes_the_next_frame() {
+ let version = Arc::new(AtomicUsize::new(/*v*/ 1));
+ let renders = Arc::new(AtomicUsize::new(/*v*/ 0));
+ let cells: Vec<Arc<dyn HistoryCell>> = vec![Arc::new(MutableHistoryCell {
+ version: Arc::clone(&version),
+ renders: Arc::clone(&renders),
+ })];
+ let mut view = TranscriptView::default();
+ let first = render(&mut view, &cells, /*width*/ 24, /*height*/ 5);
+ assert_eq!(renders.load(Ordering::Relaxed), 1);
+ version.store(/*val*/ 2, Ordering::Relaxed);
+ let second = render(&mut view, &cells, /*width*/ 24, /*height*/ 5);
+ assert_eq!(renders.load(Ordering::Relaxed), 2);
+ assert!(text(&first).contains("version 1 row 3"));
+ insta::assert_snapshot!(text(&second), @"
+ version 2 row 3
+ version 2 row 4
+ version 2 row 5
+ version 2 row 6
+ version 2 row 7
+ ");
+}