Fix bottom cutoff when long lines wrap in the TUI

max_scroll used Text::height() (raw Line count), but Paragraph is rendered
with Wrap { trim: false }, so long lines wrap to multiple visual rows at
display time. Result: documents with prose that exceeded the viewport
width silently lost rows off the bottom — ~10 rows for README.md at 60
cols, ~48 rows for typical plan docs at 80 cols.

Compute wrapped row count ourselves via unicode_width per span, summing
ceil(display_width / render_width) per Line. Thread the render width
onto App so max_scroll and clamp_scroll can use it.

Also split the crate into lib + thin bin: App and the scroll math now
live in src/scroll.rs with tests inline, alongside the existing render /
highlight / watch modules. src/main.rs is now just CLI, event loop, and
--dump output.

Bump to 0.1.1.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: skibitsky

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "mdview"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2024"
 description = "A terminal markdown viewer"
 license = "MIT"

Cargo.toml

@@ -0,0 +1,4 @@
+pub mod highlight;
+pub mod render;
+pub mod scroll;
+pub mod watch;

src/lib.rs

@@ -1,7 +1,3 @@
-mod highlight;
-mod render;
-mod watch;
-
 use std::io::{self, Write as _};
 use std::path::PathBuf;
 use std::sync::mpsc;
@@ -17,9 +13,10 @@ use ratatui::backend::CrosstermBackend;
 use ratatui::layout::Rect;
 use ratatui::widgets::{Paragraph, Wrap};
 use ratatui::Terminal;
-use ratatui::text::Text;
 
-use render::render_markdown;
+use mdview::render::render_markdown;
+use mdview::scroll::App;
+use mdview::watch;
 
 const MAX_FILE_SIZE: u64 = 10 * 1024 * 1024;
 
@@ -31,31 +28,6 @@ impl Drop for TerminalGuard {
     }
 }
 
-struct App {
-    text: Text<'static>,
-    scroll: u16,
-    viewport_height: u16,
-}
-
-impl App {
-    fn max_scroll(&self) -> u16 {
-        let content_height = (self.text.height() as u32).min(u16::MAX as u32) as u16;
-        content_height.saturating_sub(self.viewport_height)
-    }
-
-    fn scroll_down(&mut self, n: u16) {
-        self.scroll = self.scroll.saturating_add(n).min(self.max_scroll());
-    }
-
-    fn scroll_up(&mut self, n: u16) {
-        self.scroll = self.scroll.saturating_sub(n);
-    }
-
-    fn clamp_scroll(&mut self) {
-        self.scroll = self.scroll.min(self.max_scroll());
-    }
-}
-
 fn main() -> Result<()> {
     let args: Vec<String> = std::env::args().collect();
 
@@ -110,11 +82,11 @@ fn main() -> Result<()> {
     let mut terminal = Terminal::new(backend)?;
 
     let size = terminal.size()?;
-    let mut render_width = size.width;
     let mut app = App {
-        text: render_markdown(&content, render_width),
+        text: render_markdown(&content, size.width),
         scroll: 0,
         viewport_height: size.height,
+        render_width: size.width,
     };
 
     let (tx, rx) = mpsc::channel();
@@ -146,8 +118,8 @@ fn main() -> Result<()> {
             if size_ok {
                 if let Ok(new_content) = std::fs::read_to_string(&path) {
                     content = new_content;
-                    render_width = terminal.size()?.width;
-                    app.text = render_markdown(&content, render_width);
+                    app.render_width = terminal.size()?.width;
+                    app.text = render_markdown(&content, app.render_width);
                     app.clamp_scroll();
                 }
             }
@@ -176,9 +148,9 @@ fn main() -> Result<()> {
                 },
                 Event::Resize(w, h) => {
                     app.viewport_height = h;
-                    if w != render_width {
-                        render_width = w;
-                        app.text = render_markdown(&content, render_width);
+                    if w != app.render_width {
+                        app.render_width = w;
+                        app.text = render_markdown(&content, app.render_width);
                     }
                     app.clamp_scroll();
                 }

src/main.rs

@@ -0,0 +1,130 @@
+use ratatui::text::Text;
+use unicode_width::UnicodeWidthStr;
+
+pub struct App {
+    pub text: Text<'static>,
+    pub scroll: u16,
+    pub viewport_height: u16,
+    pub render_width: u16,
+}
+
+pub fn wrapped_row_count(text: &Text<'_>, width: u16) -> u32 {
+    if width == 0 {
+        return text.lines.len() as u32;
+    }
+    let w = width as u32;
+    text.lines
+        .iter()
+        .map(|line| {
+            let display: u32 = line
+                .spans
+                .iter()
+                .map(|s| UnicodeWidthStr::width(s.content.as_ref()) as u32)
+                .sum();
+            if display == 0 { 1 } else { display.div_ceil(w) }
+        })
+        .sum()
+}
+
+impl App {
+    pub fn max_scroll(&self) -> u16 {
+        let content_height = wrapped_row_count(&self.text, self.render_width)
+            .min(u16::MAX as u32) as u16;
+        content_height.saturating_sub(self.viewport_height)
+    }
+
+    pub fn scroll_down(&mut self, n: u16) {
+        self.scroll = self.scroll.saturating_add(n).min(self.max_scroll());
+    }
+
+    pub fn scroll_up(&mut self, n: u16) {
+        self.scroll = self.scroll.saturating_sub(n);
+    }
+
+    pub fn clamp_scroll(&mut self) {
+        self.scroll = self.scroll.min(self.max_scroll());
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ratatui::text::{Line, Span};
+
+    fn line_of(s: &str) -> Line<'static> {
+        Line::from(Span::raw(s.to_string()))
+    }
+
+    #[test]
+    fn wrapped_row_count_short_line_is_one_row() {
+        let text = Text::from(vec![line_of("short")]);
+        assert_eq!(wrapped_row_count(&text, 80), 1);
+    }
+
+    #[test]
+    fn wrapped_row_count_empty_line_is_one_row() {
+        let text = Text::from(vec![Line::default()]);
+        assert_eq!(wrapped_row_count(&text, 80), 1);
+    }
+
+    #[test]
+    fn wrapped_row_count_wraps_long_line() {
+        let text = Text::from(vec![line_of(&"a".repeat(150))]);
+        assert_eq!(wrapped_row_count(&text, 60), 3);
+    }
+
+    #[test]
+    fn wrapped_row_count_sums_across_lines() {
+        let text = Text::from(vec![
+            line_of("aaa"),
+            line_of(&"b".repeat(9)),
+            line_of("ccc"),
+        ]);
+        assert_eq!(wrapped_row_count(&text, 4), 5);
+    }
+
+    #[test]
+    fn wrapped_row_count_uses_display_width_for_cjk() {
+        let text = Text::from(vec![line_of("你好世界")]);
+        assert_eq!(wrapped_row_count(&text, 4), 2);
+    }
+
+    #[test]
+    fn wrapped_row_count_sums_span_widths_within_line() {
+        let text = Text::from(vec![Line::from(vec![
+            Span::raw("hello "),
+            Span::raw("world"),
+        ])]);
+        assert_eq!(wrapped_row_count(&text, 4), 3);
+    }
+
+    #[test]
+    fn wrapped_row_count_width_zero_falls_back_to_line_count() {
+        let text = Text::from(vec![line_of("anything"), line_of("here")]);
+        assert_eq!(wrapped_row_count(&text, 0), 2);
+    }
+
+    #[test]
+    fn max_scroll_accounts_for_line_wrapping() {
+        let text = Text::from(vec![line_of(&"a".repeat(150))]);
+        let app = App {
+            text,
+            scroll: 0,
+            viewport_height: 2,
+            render_width: 50,
+        };
+        assert_eq!(app.max_scroll(), 1);
+    }
+
+    #[test]
+    fn max_scroll_is_zero_when_content_fits() {
+        let text = Text::from(vec![line_of("hello")]);
+        let app = App {
+            text,
+            scroll: 0,
+            viewport_height: 10,
+            render_width: 80,
+        };
+        assert_eq!(app.max_scroll(), 0);
+    }
+}