feat(terminal): port Screen, ScreenSet, Tabstops and Selection

Ports ZIG/src/terminal/{Screen,ScreenSet,Tabstops,Selection}.zig on top
of the page/PageList layer. The cursor holds a TrackedPin; Zig's cached
page_row/page_cell pointers become accessor methods. Selection methods
take the PageList explicitly because tracked bounds are handles.

Screen tests use minimal plain-text dump/selection-string helpers that
follow the formatter's semantics; they will delegate to the real
formatter once formatter.zig is ported.

Gaps found in the PageList layer are recorded for the parity pass in
docs/rewrite/notes/ghostty-terminal-pagelist-requests.md; three resize
tests are #[ignore]d pending those fixes (PageList::resize keeps
trailing blank rows Zig drops). Kitty image storage and StringMap are
placeholders.

Test Plan:
- cargo test -p ghostty-terminal (443 passed, 3 ignored; Screen 183/184,
  Selection 18/18, Tabstops 4/5 - skipped tests use allocator failure
  injection)

crates/ghostty-terminal/Cargo.toml

@@ -5,7 +5,10 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
+ghostty-datastruct.workspace = true
+ghostty-unicode.workspace = true
 ghostty-vt.workspace = true
+log = "0.4.34"
 
 [lints]
 workspace = true

crates/ghostty-terminal/src/cursor.rs

@@ -0,0 +1,22 @@
+//! Cursor visual style (ZIG/src/terminal/cursor.zig).
+
+/// The visual style of the cursor. Whether or not it blinks
+/// is determined by mode 12 (modes.zig). This mode is synchronized
+/// with CSI q, the same as xterm.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum Style {
+    /// DECSCUSR 5, 6
+    Bar,
+    /// DECSCUSR 1, 2
+    #[default]
+    Block,
+    /// DECSCUSR 3, 4
+    Underline,
+
+    /// The cursor styles below aren't known by DESCUSR and are custom
+    /// implemented in Ghostty. They are reported as some standard style
+    /// if requested, though.
+    /// Hollow block cursor. This is a block cursor with the center empty.
+    /// Reported as DECSCUSR 1 or 2 (block).
+    BlockHollow,
+}

crates/ghostty-terminal/src/lib.rs

@@ -1,9 +1,15 @@
 //! Safe page-based terminal memory model.
 #![cfg_attr(test, allow(clippy::unwrap_used))]
+pub mod cursor;
 pub mod hyperlink;
 pub mod page;
 pub mod page_list;
+pub mod pin_iter;
 pub mod point;
 pub mod ref_counted_set;
+pub mod screen;
+pub mod screen_set;
+pub mod selection;
 pub mod size;
 pub mod style;
+pub mod tabstops;

crates/ghostty-terminal/src/pin_iter.rs

@@ -0,0 +1,148 @@
+//! Pin-based iterators.
+//!
+//! Zig's `PageList.Pin` has `rowIterator`, `cellIterator` and
+//! `promptIterator` methods that start from a pin and use an inclusive limit
+//! *pin* (the Rust `PageList` iterators are point-based). These are local
+//! equivalents used by `Screen` and `Selection`.
+//!
+//! TODO(integration): replace with `Pin` methods in `page_list.rs` once
+//! available (see docs/rewrite/notes/ghostty-terminal-pagelist-requests.md).
+use crate::{
+    page_list::{Direction, PageList, Pin, PromptIterator},
+    point::{Coordinate, Point, Tag},
+};
+
+fn same_row(a: Pin, b: Pin) -> bool {
+    a.node == b.node && a.y == b.y
+}
+
+/// Iterates the rows (x = 0) from `start` toward `limit` (inclusive).
+pub struct RowIter<'a> {
+    list: &'a PageList,
+    current: Option<Pin>,
+    limit: Option<Pin>,
+    direction: Direction,
+}
+
+impl Iterator for RowIter<'_> {
+    type Item = Pin;
+
+    fn next(&mut self) -> Option<Pin> {
+        let cur = self.current?;
+        let result = Pin { x: 0, ..cur };
+        if self.limit.is_some_and(|l| same_row(l, cur)) {
+            self.current = None;
+        } else {
+            self.current = match self.direction {
+                Direction::RightDown => cur.down(self.list, 1),
+                Direction::LeftUp => cur.up(self.list, 1),
+            };
+        }
+        Some(result)
+    }
+}
+
+/// Equivalent of `Pin.rowIterator(direction, limit)`. The limit is inclusive.
+pub fn row_iterator(
+    list: &PageList,
+    start: Pin,
+    direction: Direction,
+    limit: Option<Pin>,
+) -> RowIter<'_> {
+    RowIter {
+        list,
+        current: Some(start),
+        limit,
+        direction,
+    }
+}
+
+/// Iterates cells from `start` toward the end of the `limit` row.
+///
+/// Note that, as in Zig, the limit only applies at row granularity: iteration
+/// continues to the end (or start, for `LeftUp`) of the limit row.
+pub struct CellIter<'a> {
+    list: &'a PageList,
+    cell: Option<Pin>,
+    limit: Option<Pin>,
+    direction: Direction,
+}
+
+impl Iterator for CellIter<'_> {
+    type Item = Pin;
+
+    fn next(&mut self) -> Option<Pin> {
+        let cell = self.cell?;
+        let cols = self
+            .list
+            .node(cell.node)
+            .map_or(self.list.cols, |n| n.data.size.cols);
+        let at_limit = self.limit.is_some_and(|l| same_row(l, cell));
+        self.cell = match self.direction {
+            Direction::RightDown => {
+                if cell.x + 1 < cols {
+                    Some(Pin {
+                        x: cell.x + 1,
+                        ..cell
+                    })
+                } else if at_limit {
+                    None
+                } else {
+                    cell.down(self.list, 1).map(|p| Pin { x: 0, ..p })
+                }
+            }
+            Direction::LeftUp => {
+                if cell.x > 0 {
+                    Some(Pin {
+                        x: cell.x - 1,
+                        ..cell
+                    })
+                } else if at_limit {
+                    None
+                } else {
+                    cell.up(self.list, 1).map(|p| {
+                        let cols = self.list.node(p.node).map_or(cols, |n| n.data.size.cols);
+                        Pin { x: cols - 1, ..p }
+                    })
+                }
+            }
+        };
+        Some(cell)
+    }
+}
+
+/// Equivalent of `Pin.cellIterator(direction, limit)`.
+pub fn cell_iterator(
+    list: &PageList,
+    start: Pin,
+    direction: Direction,
+    limit: Option<Pin>,
+) -> CellIter<'_> {
+    CellIter {
+        list,
+        cell: Some(start),
+        limit,
+        direction,
+    }
+}
+
+/// Equivalent of `Pin.promptIterator(direction, limit)`.
+pub fn prompt_iterator(
+    list: &PageList,
+    start: Pin,
+    direction: Direction,
+    limit: Option<Pin>,
+) -> PromptIterator<'_> {
+    let pt = |p: Pin| {
+        list.point_from_pin(Tag::Screen, p)
+            .unwrap_or(Point::Screen(Coordinate::default()))
+    };
+    match direction {
+        Direction::RightDown => list.prompt_iterator(direction, pt(start), limit.map(pt)),
+        Direction::LeftUp => list.prompt_iterator(
+            direction,
+            limit.map_or(Point::Screen(Coordinate::default()), pt),
+            Some(pt(start)),
+        ),
+    }
+}

crates/ghostty-terminal/src/screen.rs

@@ -0,0 +1,3811 @@
+//! A single terminal screen: a page list plus the cursor, saved cursor,
+//! selection, charset state, kitty keyboard flags and semantic prompt state.
+//!
+//! Port of `ZIG/src/terminal/Screen.zig`.
+//!
+//! # Differences from the Zig API
+//!
+//! * The cursor's `page_pin` is a [`TrackedPin`] handle into `screen.pages`;
+//!   the cached `page_row` / `page_cell` pointers are replaced by on-demand
+//!   accessors ([`Screen::cursor_row`], [`Screen::cursor_cell`], ...).
+//! * Errors use [`page::Error`] (which covers Zig's `Allocator.Error`,
+//!   `IncreaseCapacityError`, `SplitError` and the page insertion errors).
+//! * Selection helpers take the screen's [`PageList`] explicitly (see
+//!   `selection.rs`).
+#![allow(
+    clippy::manual_assert_eq,
+    clippy::single_match_else,
+    clippy::doc_overindented_list_items,
+    clippy::items_after_statements
+)]
+use crate::{
+    cursor::Style as CursorStyle,
+    hyperlink::{self, Hyperlink, HyperlinkId},
+    page::{Cell, ContentTag, Page, Row, SemanticContent, SemanticPrompt as RowPrompt, Wide},
+    page_list::{
+        CellSubset, Chunk, Direction, IncreaseCapacity, NodeId, PageList, Pin,
+        Scroll as ListScroll, TrackedPin, Viewport,
+    },
+    pin_iter,
+    point::{Coordinate, Point, Tag},
+    selection::{Bounds, Order, Selection},
+    size,
+    style::{self, Style},
+};
+use ghostty_vt::{
+    ansi::ProtectedMode,
+    charsets::{Charset, Slots},
+    kitty::key::FlagStack,
+    osc::semantic_prompt::{Click, PromptKind, Redraw},
+    sgr,
+};
+
+pub use crate::page::Error;
+
+/// The Unicode codepoint used by the Kitty graphics protocol for virtual
+/// placements (`kitty.graphics.unicode.placeholder`).
+const KITTY_PLACEHOLDER: u32 = 0x10EEEE;
+
+/// See Terminal.Dirty. This behaves the same way.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub struct Dirty {
+    /// Set when the selection is set or unset, regardless of if the
+    /// selection is changed or not.
+    pub selection: bool,
+
+    /// When an OSC8 hyperlink is hovered, we set the full screen as dirty
+    /// because links can span multiple lines.
+    pub hyperlink_hover: bool,
+}
+
+/// How click handling in a prompt is handled.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SemanticClick {
+    None,
+    ClickEvents,
+    Cl(Click),
+}
+
+/// Semantic prompt (OSC133) state.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct SemanticPrompt {
+    /// This is flipped to true when any sort of semantic content is
+    /// seen. In particular, this is set to true only when a `prompt` type
+    /// is ever set on our cursor.
+    ///
+    /// This is used to optimize away semantic content operations if we know
+    /// we've never seen them.
+    pub seen: bool,
+
+    /// This is set on any `cl` or `click_events` option set on the
+    /// most recent OSC 133 commands to specify how click handling in a
+    /// prompt is handling.
+    pub click: SemanticClick,
+}
+
+impl SemanticPrompt {
+    pub const DISABLED: SemanticPrompt = SemanticPrompt {
+        seen: false,
+        click: SemanticClick::None,
+    };
+}
+
+/// Kitty graphics protocol state.
+///
+/// TODO(integration): replace with `kitty::graphics_image::ImageStorage`
+/// once the kitty graphics modules are ported. Only the dirty flag that
+/// `Screen` touches is represented here.
+#[derive(Debug, Clone, Default)]
+pub struct KittyImages {
+    /// Dirty flag for the renderer.
+    pub dirty: bool,
+}
+
+/// The cursor position and style.
+#[derive(Debug, Clone)]
+pub struct Cursor {
+    /// The x position within the active area.
+    pub x: size::CellCountInt,
+    /// The y position within the active area.
+    pub y: size::CellCountInt,
+
+    /// The visual style of the cursor. This defaults to block because
+    /// it has to default to something, but users of this struct are
+    /// encouraged to set their own default.
+    pub cursor_style: CursorStyle,
+
+    /// The "last column flag (LCF)" as its called. If this is set then the
+    /// next character print will force a soft-wrap.
+    pub pending_wrap: bool,
+
+    /// The protected mode state of the cursor. If this is true then
+    /// all new characters printed will have the protected state set.
+    pub protected: bool,
+
+    /// The currently active style. This is the concrete style value
+    /// that should be kept up to date. The style ID to use for cell writing
+    /// is below.
+    pub style: Style,
+
+    /// The currently active style ID. The style is page-specific so when
+    /// we change pages we need to ensure that we update that page with
+    /// our style when used.
+    pub style_id: style::Id,
+
+    /// The hyperlink ID that is currently active for the cursor. A value
+    /// of zero means no hyperlink is active. (Implements OSC8, saying that
+    /// so code search can find it.).
+    pub hyperlink_id: hyperlink::Id,
+
+    /// This is the implicit ID to use for hyperlinks that don't specify
+    /// an ID. We do an overflowing add to this so repeats can technically
+    /// happen with carefully crafted inputs but for real workloads its
+    /// highly unlikely -- and the fix is for the TUI program to use explicit
+    /// IDs.
+    pub hyperlink_implicit_id: size::OffsetInt,
+
+    /// Heap-allocated hyperlink state so that we can recreate it when
+    /// the cursor page pin changes. We can't get it from the old screen
+    /// state because the page may be cleared.
+    pub hyperlink: Option<Box<Hyperlink>>,
+
+    /// The current semantic content type for the cursor that will be
+    /// applied to any newly written cells.
+    pub semantic_content: SemanticContent,
+    pub semantic_content_clear_eol: bool,
+
+    /// The tracked pin into the page list where the cursor is currently
+    /// located. This makes it faster to move the cursor. Read it with
+    /// [`Screen::cursor_pin`].
+    pub page_pin: TrackedPin,
+}
+
+impl Cursor {
+    fn new(page_pin: TrackedPin) -> Self {
+        Self {
+            x: 0,
+            y: 0,
+            cursor_style: CursorStyle::Block,
+            pending_wrap: false,
+            protected: false,
+            style: Style::default(),
+            style_id: style::DEFAULT_ID,
+            hyperlink_id: 0,
+            hyperlink_implicit_id: 0,
+            hyperlink: None,
+            semantic_content: SemanticContent::Output,
+            semantic_content_clear_eol: false,
+            page_pin,
+        }
+    }
+}
+
+/// The set of 4 charsets (G0-G3).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct CharsetArray {
+    pub g0: Charset,
+    pub g1: Charset,
+    pub g2: Charset,
+    pub g3: Charset,
+}
+
+impl Default for CharsetArray {
+    fn default() -> Self {
+        Self {
+            g0: Charset::Utf8,
+            g1: Charset::Utf8,
+            g2: Charset::Utf8,
+            g3: Charset::Utf8,
+        }
+    }
+}
+
+impl CharsetArray {
+    #[inline]
+    pub fn get(&self, slot: Slots) -> Charset {
+        match slot {
+            Slots::G0 => self.g0,
+            Slots::G1 => self.g1,
+            Slots::G2 => self.g2,
+            Slots::G3 => self.g3,
+        }
+    }
+
+    #[inline]
+    pub fn set(&mut self, slot: Slots, charset: Charset) {
+        match slot {
+            Slots::G0 => self.g0 = charset,
+            Slots::G1 => self.g1 = charset,
+            Slots::G2 => self.g2 = charset,
+            Slots::G3 => self.g3 = charset,
+        }
+    }
+}
+
+/// State required for all charset operations.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct CharsetState {
+    /// The list of graphical charsets by slot
+    pub charsets: CharsetArray,
+
+    /// GL is the slot to use when using a 7-bit printable char (up to 127)
+    /// GR used for 8-bit printable chars.
+    pub gl: Slots,
+    pub gr: Slots,
+
+    /// Single shift where a slot is used for exactly one char.
+    pub single_shift: Option<Slots>,
+}
+
+impl Default for CharsetState {
+    fn default() -> Self {
+        Self {
+            charsets: CharsetArray::default(),
+            gl: Slots::G0,
+            gr: Slots::G2,
+            single_shift: None,
+        }
+    }
+}
+
+/// Saved cursor state.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct SavedCursor {
+    pub x: size::CellCountInt,
+    pub y: size::CellCountInt,
+    pub style: Style,
+    pub protected: bool,
+    pub pending_wrap: bool,
+    pub origin: bool,
+    pub charset: CharsetState,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Options {
+    pub cols: size::CellCountInt,
+    pub rows: size::CellCountInt,
+
+    /// The maximum size of scrollback in bytes. Zero means no scrollback.
+    /// Any other value will be clamped to support a minimum of the active
+    /// area.
+    pub max_scrollback: usize,
+
+    /// The total storage limit for Kitty images in bytes for this
+    /// screen. Kitty image storage is per-screen.
+    pub kitty_image_storage_limit: usize,
+}
+
+impl Options {
+    /// A simple, default terminal. If you rely on specific dimensions or
+    /// scrollback (or lack of) then do not use this directly. This is just
+    /// for callers that need some defaults.
+    pub const DEFAULT: Options = Options {
+        cols: 80,
+        rows: 24,
+        max_scrollback: 0,
+        kitty_image_storage_limit: 320 * 1000 * 1000, // 320MB
+    };
+
+    pub fn new(cols: size::CellCountInt, rows: size::CellCountInt, max_scrollback: usize) -> Self {
+        Self {
+            cols,
+            rows,
+            max_scrollback,
+            ..Self::DEFAULT
+        }
+    }
+}
+
+impl Default for Options {
+    fn default() -> Self {
+        Self::DEFAULT
+    }
+}
+
+/// Options for scrolling the viewport of the terminal grid. The reason
+/// we have this in addition to PageList.Scroll is because we have additional
+/// scroll behaviors that are not part of the PageList.Scroll enum.
+#[derive(Debug, Clone, Copy)]
+pub enum Scroll {
+    /// For all of these, see PageList.Scroll.
+    Active,
+    Top,
+    Pin(Pin),
+    Row(usize),
+    DeltaRow(isize),
+    DeltaPrompt(isize),
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Resize {
+    /// The new size to resize to
+    pub cols: size::CellCountInt,
+    pub rows: size::CellCountInt,
+
+    /// Whether to reflow soft-wrapped text.
+    ///
+    /// This will reflow soft-wrapped text. If the screen size is getting
+    /// smaller and the maximum scrollback size is exceeded, data will be
+    /// lost from the top of the scrollback.
+    pub reflow: bool,
+
+    /// Set this to enable prompt redraw on resize. This signals
+    /// that the running program can redraw the prompt if the cursor is
+    /// currently at a prompt. This detects OSC133 prompts lines and clears
+    /// them. If set to `Last`, only the most recent prompt line is cleared.
+    pub prompt_redraw: Redraw,
+}
+
+impl Resize {
+    pub fn new(cols: size::CellCountInt, rows: size::CellCountInt) -> Self {
+        Self {
+            cols,
+            rows,
+            reflow: true,
+            prompt_redraw: Redraw::False,
+        }
+    }
+}
+
+/// The semantic content setting for `cursor_set_semantic_content`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum InputClear {
+    ClearExplicit,
+    ClearEol,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SemanticContentSet {
+    Prompt(PromptKind),
+    Output,
+    Input(InputClear),
+}
+
+/// A string and a map from each byte of the string to the pin it came from.
+///
+/// TODO(integration): replace with `string_map::StringMap` once ported.
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct StringMap {
+    pub string: String,
+    pub map: Vec<Pin>,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct SelectionString {
+    /// The selection to convert to a string.
+    pub sel: Selection,
+
+    /// If true, trim whitespace around the selection.
+    pub trim: bool,
+}
+
+impl SelectionString {
+    pub fn new(sel: Selection) -> Self {
+        Self { sel, trim: true }
+    }
+}
+
+/// The default whitespace set for line/all selection: NUL, space and tab.
+pub const DEFAULT_SELECT_WHITESPACE: &[u32] = &[0, ' ' as u32, '\t' as u32];
+
+#[derive(Debug, Clone, Copy)]
+pub struct SelectLine<'a> {
+    /// The pin of some part of the line to select.
+    pub pin: Pin,
+
+    /// These are the codepoints to consider whitespace to trim
+    /// from the ends of the selection.
+    pub whitespace: Option<&'a [u32]>,
+
+    /// If true, line selection will consider semantic prompt
+    /// state changing a boundary. State changing is ANY state
+    /// change.
+    pub semantic_prompt_boundary: bool,
+}
+
+impl SelectLine<'_> {
+    pub fn new(pin: Pin) -> SelectLine<'static> {
+        SelectLine {
+            pin,
+            whitespace: Some(DEFAULT_SELECT_WHITESPACE),
+            semantic_prompt_boundary: true,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub struct PromptClickMove {
+    pub left: usize,
+    pub right: usize,
+}
+
+impl PromptClickMove {
+    pub const ZERO: PromptClickMove = PromptClickMove { left: 0, right: 0 };
+}
+
+/// Options for [`Screen::dump_string`].
+#[derive(Debug, Clone, Copy)]
+pub struct DumpString {
+    /// The start and end points of the dump, both inclusive. The x will
+    /// be ignored and the full row will always be dumped.
+    pub tl: Pin,
+    pub br: Option<Pin>,
+
+    /// If true, this will unwrap soft-wrapped lines. If false, this will
+    /// dump the screen as it is visually seen in a rendered window.
+    pub unwrap: bool,
+}
+
+impl DumpString {
+    pub fn new(tl: Pin) -> Self {
+        Self {
+            tl,
+            br: None,
+            unwrap: true,
+        }
+    }
+}
+
+/// A screen is a single terminal grid with its own cursor and scrollback.
+#[derive(Debug)]
+pub struct Screen {
+    /// The list of pages in the screen.
+    pub pages: PageList,
+
+    /// Special-case where we want no scrollback whatsoever. We have to flag
+    /// this because max_size 0 in PageList gets rounded up to two pages so
+    /// we can always have an active screen.
+    pub no_scrollback: bool,
+
+    /// The current cursor position
+    pub cursor: Cursor,
+
+    /// The saved cursor
+    pub saved_cursor: Option<SavedCursor>,
+
+    /// The selection for this screen (if any). This MUST be a tracked
+    /// selection otherwise the selection will become invalid. Instead of
+    /// accessing this directly to set it, use [`Screen::select`] which will
+    /// automatically setup tracking.
+    pub selection: Option<Selection>,
+
+    /// The charset state
+    pub charset: CharsetState,
+
+    /// The current or most recent protected mode. Once a protection mode is
+    /// set, this will never become "off" again until the screen is reset.
+    /// The current state of whether protection attributes should be set is
+    /// set on the Cell pen; this is only used to determine the most recent
+    /// protection mode since some sequences such as ECH depend on this.
+    pub protected_mode: ProtectedMode,
+
+    /// The kitty keyboard settings.
+    pub kitty_keyboard: FlagStack,
+
+    /// Kitty graphics protocol state.
+    pub kitty_images: KittyImages,
+
+    /// Semantic prompt (OSC133) state.
+    pub semantic_prompt: SemanticPrompt,
+
+    /// Dirty flags for the renderer.
+    pub dirty: Dirty,
+}
+
+impl Screen {
+    /// Initialize a new screen.
+    ///
+    /// max_scrollback is the amount of scrollback to keep in bytes. This
+    /// will be rounded UP to the nearest page size because our minimum
+    /// allocation size is that anyways.
+    ///
+    /// If max scrollback is 0, then no scrollback is kept at all.
+    pub fn new(opts: Options) -> Result<Screen, Error> {
+        // Initialize our backing pages.
+        let mut pages = PageList::init(opts.cols, opts.rows, Some(opts.max_scrollback))?;
+
+        // Create our tracked pin for the cursor.
+        let first = pages.first.ok_or(Error::InvalidId)?;
+        let page_pin = pages.track_pin(Pin {
+            node: first,
+            y: 0,
+            x: 0,
+            garbage: false,
+        })?;
+
+        Ok(Screen {
+            pages,
+            no_scrollback: opts.max_scrollback == 0,
+            cursor: Cursor::new(page_pin),
+            saved_cursor: None,
+            selection: None,
+            charset: CharsetState::default(),
+            protected_mode: ProtectedMode::Off,
+            kitty_keyboard: FlagStack::default(),
+            kitty_images: KittyImages::default(),
+            semantic_prompt: SemanticPrompt::DISABLED,
+            dirty: Dirty::default(),
+        })
+    }
+
+    /// The page for a node (panics if the node is stale).
+    pub fn page(&self, node: NodeId) -> &Page {
+        &self.pages.node(node).expect("live page node").data
+    }
+
+    /// The mutable page for a node (panics if the node is stale).
+    pub fn page_mut(&mut self, node: NodeId) -> &mut Page {
+        &mut self.pages.node_mut(node).expect("live page node").data
+    }
+
+    /// The current location of the cursor in the page list.
+    pub fn cursor_pin(&self) -> Pin {
+        self.pages
+            .tracked_pin(self.cursor.page_pin)
+            .expect("cursor pin is always tracked")
+    }
+
+    fn set_cursor_pin(&mut self, p: Pin) {
+        self.pages
+            .set_tracked_pin(self.cursor.page_pin, p)
+            .expect("cursor pin must be valid");
+    }
+
+    /// The page the cursor is currently on.
+    pub fn cursor_page(&self) -> &Page {
+        self.page(self.cursor_pin().node)
+    }
+
+    /// The page the cursor is currently on.
+    pub fn cursor_page_mut(&mut self) -> &mut Page {
+        let node = self.cursor_pin().node;
+        self.page_mut(node)
+    }
+
+    /// The row the cursor is on (Zig: `cursor.page_row`).
+    pub fn cursor_row(&self) -> Row {
+        let p = self.cursor_pin();
+        *self
+            .page(p.node)
+            .get_row(usize::from(p.y))
+            .expect("cursor row")
+    }
+
+    pub fn cursor_row_mut(&mut self) -> &mut Row {
+        let p = self.cursor_pin();
+        self.page_mut(p.node)
+            .get_row_mut(usize::from(p.y))
+            .expect("cursor row")
+    }
+
+    /// The cell under the cursor (Zig: `cursor.page_cell`).
+    pub fn cursor_cell(&self) -> Cell {
+        let p = self.cursor_pin();
+        *self
+            .page(p.node)
+            .get_row_and_cell(usize::from(p.x), usize::from(p.y))
+            .expect("cursor cell")
+            .1
+    }
+
+    pub fn cursor_cell_mut(&mut self) -> &mut Cell {
+        let p = self.cursor_pin();
+        let page = self.page_mut(p.node);
+        let i = page
+            .cell_index(usize::from(p.x), usize::from(p.y))
+            .expect("cursor cell");
+        &mut page.cells[i]
+    }
+
+    /// The cells of the cursor's row.
+    pub fn cursor_row_cells(&self) -> &[Cell] {
+        let p = self.cursor_pin();
+        self.page(p.node)
+            .get_cells(usize::from(p.y))
+            .expect("cursor row")
+    }
+
+    /// Assert that the screen is in a consistent state. This doesn't check
+    /// all pages in the page list because that is SO SLOW even just for
+    /// tests. This only asserts the screen specific data so callers should
+    /// ensure they're also calling page integrity checks if necessary.
+    pub fn assert_integrity(&self) {
+        if cfg!(debug_assertions) {
+            assert!(self.cursor.x < self.pages.cols);
+            assert!(self.cursor.y < self.pages.rows);
+
+            // Our cursor x/y should always match the pin. If this doesn't
+            // match then it indicates that the tracked pin moved and we
+            // didn't account for it by either calling cursor_reload or
+            // manually adjusting.
+            let pt = self
+                .pages
+                .point_from_pin(Tag::Active, self.cursor_pin())
+                .expect("cursor pin must be in the active area");
+            assert_eq!(self.cursor.x, pt.coord().x);
+            assert_eq!(u32::from(self.cursor.y), pt.coord().y);
+        }
+    }
+
+    /// Reset the screen according to the logic of a DEC RIS sequence.
+    ///
+    /// - Clears the screen and attempts to reclaim memory.
+    /// - Moves the cursor to the top-left.
+    /// - Clears any cursor state: style, hyperlink, etc.
+    /// - Resets the charset
+    /// - Clears the selection
+    /// - Deletes all Kitty graphics
+    /// - Resets Kitty Keyboard settings
+    /// - Disables protection mode
+    pub fn reset(&mut self) -> Result<(), Error> {
+        // Reset our pages
+        self.pages.reset()?;
+
+        // The above reset preserves tracked pins so we can still use
+        // our cursor pin, which should be at the top-left already.
+        let first = self.pages.first.ok_or(Error::InvalidId)?;
+        let pin = self.cursor_pin();
+        assert!(pin.node == first);
+        assert!(pin.x == 0);
+        assert!(pin.y == 0);
+        self.set_cursor_pin(Pin {
+            garbage: false,
+            ..pin
+        });
+        self.cursor = Cursor::new(self.cursor.page_pin);
+
+        // Reset kitty graphics storage
+        self.kitty_images = KittyImages { dirty: true };
+
+        // Reset our basic state
+        self.saved_cursor = None;
+        self.charset = CharsetState::default();
+        self.kitty_keyboard = FlagStack::default();
+        self.protected_mode = ProtectedMode::Off;
+        self.semantic_prompt = SemanticPrompt::DISABLED;
+        self.clear_selection();
+        Ok(())
+    }
+
+    /// Clone the screen.
+    ///
+    /// This will copy:
+    ///
+    ///   - Screen dimensions
+    ///   - Screen data (cell state, etc.) for the region
+    ///
+    /// Anything not mentioned above is NOT copied. Some of this is for
+    /// very good reason:
+    ///
+    ///   - Kitty images have a LOT of data. This is not efficient to copy.
+    ///     Use a lock and access the image data. The dirty bit is there for
+    ///     a reason.
+    ///   - Cursor location can be expensive to calculate with respect to the
+    ///     specified region. It is faster to grab the cursor from the old
+    ///     screen and then move it to the new screen.
+    ///   - Current hyperlink cursor state has heap allocations. Since clone
+    ///     is only for read-only operations, it is better to not have any
+    ///     hyperlink state. Note that already-written hyperlinks are cloned.
+    ///
+    /// If not mentioned above, then there isn't a specific reason right now
+    /// to not copy some data other than we probably didn't need it and it
+    /// isn't necessary for screen coherency.
+    ///
+    /// Other notes:
+    ///
+    ///   - The viewport will always be set to the active area of the new
+    ///     screen. This is the bottom "rows" rows.
+    ///   - If the clone region is smaller than a viewport area, blanks will
+    ///     be filled in at the bottom.
+    pub fn clone_screen(&self, top: Point, bot: Option<Point>) -> Result<Screen, Error> {
+        // Create a tracked pin remapper for our selection and cursor.
+        let (mut pages, pin_remap) = self.pages.clone_range(top, bot)?;
+
+        // Find our cursor. If the cursor isn't in the cloned area, we move it
+        // to the top-left arbitrarily because a screen must have SOME cursor.
+        let mut cursor_xy = None;
+        if let Some(&handle) = pin_remap.get(&self.cursor.page_pin)
+            && let Some(p) = pages.tracked_pin(handle)
+            && let Some(pt) = pages.point_from_pin(Tag::Active, p)
+        {
+            cursor_xy = Some((handle, pt.coord().x, pt.coord().y as u16));
+        }
+        let (page_pin, cx, cy) = match cursor_xy {
+            Some(v) => v,
+            None => {
+                let first = pages.first.ok_or(Error::InvalidId)?;
+                let h = pages.track_pin(Pin {
+                    node: first,
+                    y: 0,
+                    x: 0,
+                    garbage: false,
+                })?;
+                (h, 0, 0)
+            }
+        };
+        let mut cursor = Cursor::new(page_pin);
+        cursor.x = cx;
+        cursor.y = cy;
+
+        // Preserve our selection if we have one.
+        let sel: Option<Selection> = if let Some(sel) = self.selection {
+            assert!(sel.tracked());
+            let Bounds::Tracked { start, end } = sel.bounds else {
+                unreachable!()
+            };
+
+            let (tl, br) = match sel.order(&self.pages) {
+                Order::Forward | Order::MirroredForward => (start, end),
+                Order::Reverse | Order::MirroredReverse => (end, start),
+            };
+            let tl_pin = self.pages.tracked_pin(tl).expect("selection pin");
+            let br_pin = self.pages.tracked_pin(br).expect("selection pin");
+
+            let start_handle = match pin_remap.get(&tl).copied() {
+                Some(h) => Some(h),
+                None => 'start: {
+                    // No start means it is outside the cloned area.
+
+                    // If we have no end pin then either
+                    // (1) our whole selection is outside the cloned area or
+                    // (2) our cloned area is within the selection
+                    if !pin_remap.contains_key(&br) {
+                        // We check if the selection bottom right pin is above
+                        // the cloned area or if the top left pin is below the
+                        // cloned area, in either of these cases it means that
+                        // the selection is fully out of bounds, so we have no
+                        // selection in the cloned area and break out now.
+                        let Some(clone_top) = self.pages.pin(top) else {
+                            break 'start None;
+                        };
+                        let clone_top_y = self
+                            .pages
+                            .point_from_pin(Tag::Screen, clone_top)
+                            .expect("pin in screen")
+                            .coord()
+                            .y;
+                        if self
+                            .pages
+                            .point_from_pin(Tag::Screen, br_pin)
+                            .expect("pin in screen")
+                            .coord()
+                            .y
+                            < clone_top_y
+                        {
+                            break 'start None;
+                        }
+                        if self
+                            .pages
+                            .point_from_pin(Tag::Screen, tl_pin)
+                            .expect("pin in screen")
+                            .coord()
+                            .y
+                            > clone_top_y
+                        {
+                            break 'start None;
+                        }
+                    }
+
+                    // We move the top pin back in bounds to the top row.
+                    let first = pages.first.ok_or(Error::InvalidId)?;
+                    Some(pages.track_pin(Pin {
+                        node: first,
+                        y: 0,
+                        x: if sel.rectangle { tl_pin.x } else { 0 },
+                        garbage: false,
+                    })?)
+                }
+            };
+
+            match start_handle {
+                None => None,
+                Some(start_handle) => {
+                    // If we got to this point it means that the selection is
+                    // not fully out of bounds, so we move the bottom right pin
+                    // back in bounds if it isn't already.
+                    let end_handle = match pin_remap.get(&br).copied() {
+                        Some(h) => h,
+                        None => {
+                            let last = pages.last.ok_or(Error::InvalidId)?;
+                            let rows = pages.node(last).expect("pin in screen").data.size.rows;
+                            pages.track_pin(Pin {
+                                node: last,
+                                x: if sel.rectangle {
+                                    br_pin.x
+                                } else {
+                                    pages.cols - 1
+                                },
+                                y: rows - 1,
+                                garbage: false,
+                            })?
+                        }
+                    };
+                    Some(Selection {
+                        bounds: Bounds::Tracked {
+                            start: start_handle,
+                            end: end_handle,
+                        },
+                        rectangle: sel.rectangle,
+                    })
+                }
+            }
+        } else {
+            None
+        };
+
+        let result = Screen {
+            pages,
+            no_scrollback: self.no_scrollback,
+            cursor,
+            saved_cursor: None,
+            selection: sel,
+            charset: CharsetState::default(),
+            protected_mode: ProtectedMode::Off,
+            kitty_keyboard: FlagStack::default(),
+            kitty_images: KittyImages::default(),
+            semantic_prompt: SemanticPrompt::DISABLED,
+            dirty: self.dirty,
+        };
+        result.assert_integrity();
+        Ok(result)
+    }
+
+    /// Increase the capacity of a page, keeping our cursor state (style and
+    /// hyperlink reference counts) consistent when it is the cursor page.
+    pub fn increase_capacity(
+        &mut self,
+        node: NodeId,
+        adjustment: Option<IncreaseCapacity>,
+    ) -> Result<NodeId, Error> {
+        // If the page being modified isn't our cursor page then
+        // this is a quick operation because we have no additional
+        // accounting. We have to do this check here BEFORE calling
+        // increase_capacity because increase_capacity will update all
+        // our tracked pins (including our cursor).
+        if node != self.cursor_pin().node {
+            return self.pages.increase_capacity(node, adjustment);
+        }
+
+        // We're modifying the cursor page. When we increase the
+        // capacity below it will be short the ref count on our
+        // current style and hyperlink, so we need to init those.
+        let new_node = self.pages.increase_capacity(node, adjustment)?;
+
+        // Re-add the style, if the page somehow doesn't have enough
+        // memory to add it, we emit a warning and gracefully degrade
+        // to the default style for the cursor.
+        if self.cursor.style_id != style::DEFAULT_ID {
+            let st = self.cursor.style;
+            self.cursor.style_id = match self.page_mut(new_node).styles.add(st) {
+                Ok(id) => id,
+                Err(err) => {
+                    // TODO: Should we increase the capacity further in this case?
+                    log::warn!(
+                        "(Screen.increaseCapacity) Failed to add cursor style back to page, err={err:?}"
+                    );
+
+                    // Reset the cursor style.
+                    self.cursor.style = Style::default();
+                    style::DEFAULT_ID
+                }
+            };
+        }
+
+        // Re-add the hyperlink, if the page somehow doesn't have enough
+        // memory to add it, we emit a warning and gracefully degrade to
+        // no hyperlink.
+        if let Some(link) = self.cursor.hyperlink.take() {
+            // So we don't attempt to free any memory in the replaced page.
+            self.cursor.hyperlink_id = 0;
+
+            // Re-add
+            if let Err(err) = self.start_hyperlink_once(&link) {
+                // TODO: Should we increase the capacity further in this case?
+                log::warn!(
+                    "(Screen.increaseCapacity) Failed to add cursor hyperlink back to page, err={err:?}"
+                );
+            }
+        }
+
+        // Reload the cursor information because the pin changed.
+        // So our page row/cell and so on are all off.
+        self.cursor_reload();
+
+        Ok(new_node)
+    }
+
+    /// The cell `n` columns right of the cursor.
+    pub fn cursor_cell_right(&self, n: size::CellCountInt) -> Cell {
+        assert!(self.cursor.x + n < self.pages.cols);
+        self.cursor_row_cells()[usize::from(self.cursor.x + n)]
+    }
+
+    pub fn cursor_cell_right_mut(&mut self, n: size::CellCountInt) -> &mut Cell {
+        assert!(self.cursor.x + n < self.pages.cols);
+        let p = self.cursor_pin();
+        let page = self.page_mut(p.node);
+        let i = page
+            .cell_index(usize::from(p.x + n), usize::from(p.y))
+            .expect("cursor cell");
+        &mut page.cells[i]
+    }
+
+    /// The cell `n` columns left of the cursor.
+    pub fn cursor_cell_left(&self, n: size::CellCountInt) -> Cell {
+        assert!(self.cursor.x >= n);
+        self.cursor_row_cells()[usize::from(self.cursor.x - n)]
+    }
+
+    pub fn cursor_cell_left_mut(&mut self, n: size::CellCountInt) -> &mut Cell {
+        assert!(self.cursor.x >= n);
+        let p = self.cursor_pin();
+        let page = self.page_mut(p.node);
+        let i = page
+            .cell_index(usize::from(p.x - n), usize::from(p.y))
+            .expect("cursor cell");
+        &mut page.cells[i]
+    }
+
+    /// The last cell of the row above the cursor row.
+    pub fn cursor_cell_end_of_prev(&self) -> Cell {
+        assert!(self.cursor.y > 0);
+
+        let mut page_pin = self
+            .cursor_pin()
+            .up(&self.pages, 1)
+            .expect("row above cursor");
+        page_pin.x = self.pages.cols - 1;
+        *page_pin
+            .row_and_cell(&self.pages)
+            .expect("end of prev cell")
+            .1
+    }
+
+    /// Move the cursor right. This is a specialized function that is very fast
+    /// if the caller can guarantee we have space to move right (no wrapping).
+    pub fn cursor_right(&mut self, n: size::CellCountInt) {
+        assert!(self.cursor.x + n < self.pages.cols);
+
+        let mut p = self.cursor_pin();
+        p.x += n;
+        self.set_cursor_pin(p);
+        self.cursor.x += n;
+        self.assert_integrity();
+    }
+
+    /// Move the cursor left.
+    pub fn cursor_left(&mut self, n: size::CellCountInt) {
+        assert!(self.cursor.x >= n);
+
+        let mut p = self.cursor_pin();
+        p.x -= n;
+        self.set_cursor_pin(p);
+        self.cursor.x -= n;
+        self.assert_integrity();
+    }
+
+    /// Move the cursor up.
+    ///
+    /// Precondition: The cursor is not at the top of the screen.
+    pub fn cursor_up(&mut self, n: size::CellCountInt) {
+        assert!(self.cursor.y >= n);
+
+        self.cursor.y -= n; // Must be set before cursor_change_pin
+        let new = self
+            .cursor_pin()
+            .up(&self.pages, usize::from(n))
+            .expect("row above cursor");
+        self.cursor_change_pin(new);
+        self.assert_integrity();
+    }
+
+    /// The row `n` rows above the cursor row.
+    pub fn cursor_row_up(&self, n: size::CellCountInt) -> Row {
+        assert!(self.cursor.y >= n);
+
+        let page_pin = self
+            .cursor_pin()
+            .up(&self.pages, usize::from(n))
+            .expect("row above cursor");
+        *page_pin.row_and_cell(&self.pages).expect("row").0
+    }
+
+    /// Move the cursor down.
+    ///
+    /// Precondition: The cursor is not at the bottom of the screen.
+    pub fn cursor_down(&mut self, n: size::CellCountInt) {
+        assert!(u32::from(self.cursor.y) + u32::from(n) < u32::from(self.pages.rows));
+
+        self.cursor.y += n; // Must be set before cursor_change_pin
+
+        // We move the offset into our page list to the next row and then
+        // get the pointers to the row/cell and set all the cursor state up.
+        let new = self
+            .cursor_pin()
+            .down(&self.pages, usize::from(n))
+            .expect("row below cursor");
+        self.cursor_change_pin(new);
+        self.assert_integrity();
+    }
+
+    /// Move the cursor to some absolute horizontal position.
+    pub fn cursor_horizontal_absolute(&mut self, x: size::CellCountInt) {
+        assert!(x < self.pages.cols);
+
+        let mut p = self.cursor_pin();
+        p.x = x;
+        self.set_cursor_pin(p);
+        self.cursor.x = x;
+        self.assert_integrity();
+    }
+
+    /// Move the cursor to some absolute position.
+    pub fn cursor_absolute(&mut self, x: size::CellCountInt, y: size::CellCountInt) {
+        assert!(x < self.pages.cols);
+        assert!(y < self.pages.rows);
+
+        let cur = self.cursor_pin();
+        let mut page_pin = match y.cmp(&self.cursor.y) {
+            std::cmp::Ordering::Less => cur
+                .up(&self.pages, usize::from(self.cursor.y - y))
+                .expect("row above cursor"),
+            std::cmp::Ordering::Greater => cur
+                .down(&self.pages, usize::from(y - self.cursor.y))
+                .expect("row below cursor"),
+            std::cmp::Ordering::Equal => cur,
+        };
+        page_pin.x = x;
+        self.cursor.x = x; // Must be set before cursor_change_pin
+        self.cursor.y = y;
+        self.cursor_change_pin(page_pin);
+        self.assert_integrity();
+    }
+
+    /// Reloads the cursor information into the screen. This is expensive
+    /// so it should only be done in cases where the pointers are invalidated
+    /// in such a way that its difficult to recover otherwise.
+    pub fn cursor_reload(&mut self) {
+        // Our tracked pin is ALWAYS accurate, so we derive the active
+        // point from the pin. If this returns None it means our pin
+        // points outside the active area. In that case, we update the
+        // pin to be the top-left.
+        let pt = match self.pages.point_from_pin(Tag::Active, self.cursor_pin()) {
+            Some(pt) => pt,
+            None => {
+                let pin = self
+                    .pages
+                    .pin(Point::Active(Coordinate::default()))
+                    .expect("active area exists");
+                self.set_cursor_pin(pin);
+                self.pages
+                    .point_from_pin(Tag::Active, pin)
+                    .expect("active area")
+            }
+        };
+
+        self.cursor.x = pt.coord().x;
+        self.cursor.y = pt.coord().y as size::CellCountInt;
+
+        // If we have a style, we need to ensure it is in the page because this
+        // method may also be called after a page change.
+        if self.cursor.style_id != style::DEFAULT_ID
+            && let Err(err) = self.manual_style_update()
+        {
+            // This failure should not happen because manual_style_update
+            // handles page splitting, overflow, and more. This should only
+            // happen if we're out of RAM. In this case, we'll just degrade
+            // gracefully back to the default style.
+            log::error!("failed to update style on cursor reload err={err:?}");
+            self.cursor.style = Style::default();
+            self.cursor.style_id = 0;
+        }
+        self.assert_integrity();
+    }
+
+    /// Scroll the active area and keep the cursor at the bottom of the screen.
+    /// This is a very specialized function but it keeps it fast.
+    pub fn cursor_down_scroll(&mut self) -> Result<(), Error> {
+        assert!(self.cursor.y == self.pages.rows - 1);
+
+        // Scrolling dirties the images because it updates their placements pins.
+        self.kitty_images.dirty = true;
+
+        // If we have no scrollback, then we shift all our rows instead.
+        if self.no_scrollback {
+            // If we have a single-row screen, we have no rows to shift
+            // so our cursor is in the correct place we just have to clear
+            // the cells.
+            if self.pages.rows == 1 {
+                let p = self.cursor_pin();
+                let cols = usize::from(self.pages.cols);
+                self.clear_cells(p.node, p.y, 0, cols);
+                self.cursor_mark_dirty();
+            } else {
+                // The call to `erase_row` will move the tracked cursor pin up
+                // by one row, but we don't actually want that, so we keep the
+                // old pin and put it back after calling `erase_row`.
+                let old_pin = self.cursor_pin();
+
+                // erase_row will shift everything below it up.
+                self.pages.erase_row(Point::Active(Coordinate::default()))?;
+
+                // Note we don't need to mark anything dirty in this branch
+                // because erase_row will mark all the rotated rows as dirty
+                // in the entire page.
+
+                // We don't use `cursor_change_pin` here because we aren't
+                // actually changing the pin, we're keeping it the same.
+                self.set_cursor_pin(old_pin);
+            }
+        } else {
+            let old_pin = self.cursor_pin();
+
+            // Grow our pages by one row. The PageList will handle if we need to
+            // allocate, prune scrollback, whatever.
+            self.pages.grow()?;
+
+            let new_pin = {
+                // If our pin page change it means that the page that the pin
+                // was on was pruned. In this case, grow() moves the pin to
+                // the top-left of the new page. This effectively moves it by
+                // one already, we just need to fix up the x value.
+                let cur = self.cursor_pin();
+                let page_pin = if old_pin.node == cur.node {
+                    cur.down(&self.pages, 1).expect("row below cursor")
+                } else {
+                    let mut pin = cur;
+                    pin.x = self.cursor.x;
+                    pin
+                };
+
+                // These assertions help catch some pagelist math errors. Our
+                // x/y should be unchanged after the grow.
+                if cfg!(debug_assertions) {
+                    let active = self
+                        .pages
+                        .point_from_pin(Tag::Active, page_pin)
+                        .expect("active")
+                        .coord();
+                    assert_eq!(active.x, self.cursor.x);
+                    assert_eq!(active.y, u32::from(self.cursor.y));
+                }
+
+                page_pin
+            };
+            self.cursor_change_pin(new_pin);
+
+            // Our new row is always dirty
+            self.cursor_mark_dirty();
+
+            // Clear the new row so it gets our bg color. We only do this
+            // if we have a bg color at all.
+            if self.cursor.style.bg_color != style::Color::None {
+                let p = self.cursor_pin();
+                let cols = usize::from(self.pages.cols);
+                self.clear_cells(p.node, p.y, 0, cols);
+            }
+        }
+
+        if self.cursor.style_id != style::DEFAULT_ID {
+            // The newly created line needs to be styled according to
+            // the bg color if it is set.
+            self.fill_cursor_row_bg();
+        }
+        self.assert_integrity();
+        Ok(())
+    }
+
+    /// If the cursor style has a background, fill the whole cursor row with
+    /// the blank background cell.
+    fn fill_cursor_row_bg(&mut self) {
+        if let Some(blank_cell) = self.cursor.style.bg_cell() {
+            self.cursor_page_row_cells_mut().fill(blank_cell);
+        }
+    }
+
+    fn cursor_page_row_cells_mut(&mut self) -> &mut [Cell] {
+        let p = self.cursor_pin();
+        self.page_mut(p.node)
+            .get_cells_mut(usize::from(p.y))
+            .expect("cursor row")
+    }
+
+    /// This scrolls the active area at and above the cursor.
+    /// The lines below the cursor are not scrolled.
+    pub fn cursor_scroll_above(&mut self) -> Result<(), Error> {
+        // We unconditionally mark the cursor row as dirty here because
+        // the cursor always changes page rows inside this function, and
+        // when that happens it can mean the text in the old row needs to
+        // be re-shaped because the cursor splits runs to break ligatures.
+        self.cursor_mark_dirty();
+
+        // If the cursor is on the bottom of the screen, its faster to use
+        // our specialized function for that case.
+        if self.cursor.y == self.pages.rows - 1 {
+            return self.cursor_down_scroll();
+        }
+
+        // Logic below assumes we always have at least one row that isn't moving
+        assert!(self.cursor.y < self.pages.rows - 1);
+
+        // Explanation:
+        //  We don't actually move everything that's at or above the cursor row,
+        //  since this would require us to shift up our ENTIRE scrollback, which
+        //  would be ridiculously expensive. Instead, we insert a new row at the
+        //  end of the pagelist (`grow()`), and move everything BELOW the cursor
+        //  DOWN by one row. This has the same practical result but it's a whole
+        //  lot cheaper in 99% of cases.
+
+        let old_pin = self.cursor_pin();
+        if self.pages.grow()?.is_some() {
+            self.cursor_scroll_above_rotate()?;
+        } else {
+            // In this case, it means grow() didn't allocate a new page.
+
+            if Some(self.cursor_pin().node) == self.pages.last {
+                // If we're on the last page we can do a very fast path because
+                // all the rows we need to move around are within a single page.
+
+                // Note: we don't need to call cursor_change_pin here because
+                // the pin page is the same so there is no accounting to do
+                // for styles or any of that.
+                assert!(old_pin.node == self.cursor_pin().node);
+                let down = self
+                    .cursor_pin()
+                    .down(&self.pages, 1)
+                    .expect("row below cursor");
+                self.set_cursor_pin(down);
+
+                let page = self.page_mut(down.node);
+
+                // Rotate the rows so that the newly created empty row is at the
+                // beginning. e.g. [ 0 1 2 3 ] in to [ 3 0 1 2 ].
+                let n = usize::from(page.size.rows);
+                page.rows[usize::from(down.y)..n].rotate_right(1);
+
+                // Mark the whole page as dirty.
+                //
+                // Technically we only need to mark from the cursor row to the
+                // end but this is a hot function, so we want to minimize work.
+                page.dirty = true;
+            } else {
+                // We didn't grow pages but our cursor isn't on the last page.
+                // In this case we need to do more work because we need to copy
+                // elements between pages.
+                self.cursor_scroll_above_rotate()?;
+            }
+        }
+
+        if self.cursor.style_id != style::DEFAULT_ID {
+            // The newly created line needs to be styled according to
+            // the bg color if it is set.
+            self.fill_cursor_row_bg();
+        }
+        self.assert_integrity();
+        Ok(())
+    }
+
+    fn cursor_scroll_above_rotate(&mut self) -> Result<(), Error> {
+        let down = self
+            .cursor_pin()
+            .down(&self.pages, 1)
+            .expect("row below cursor");
+        self.cursor_change_pin(down);
+        let cursor_pin = self.cursor_pin();
+
+        // Go through each of the pages following our pin, shift all rows
+        // down by one, and copy the last row of the previous page.
+        let mut current = self.pages.last.expect("last page");
+        while current != cursor_pin.node {
+            let prev = self
+                .pages
+                .node(current)
+                .and_then(|n| n.prev)
+                .expect("prev page");
+            let prev_rows = self.page(prev).size.rows;
+
+            // Rotate the pages down: [ 0 1 2 3 ] => [ 3 0 1 2 ]
+            let cur_page = self.page_mut(current);
+            let n = usize::from(cur_page.size.rows);
+            cur_page.rows[..n].rotate_right(1);
+
+            // Copy the last row of the previous page to the top of current.
+            self.clone_row_between(prev, prev_rows - 1, current, 0)?;
+
+            // Mark dirty on the page, since we are dirtying all rows with this.
+            self.page_mut(current).dirty = true;
+            current = prev;
+        }
+
+        // Our current is our cursor page, we need to rotate down from
+        // our cursor and clear our row.
+        assert!(current == cursor_pin.node);
+        let cols = usize::from(self.pages.cols);
+        let cur_page = self.page_mut(current);
+        let n = usize::from(cur_page.size.rows);
+        cur_page.rows[usize::from(cursor_pin.y)..n].rotate_right(1);
+        self.clear_cells(current, cursor_pin.y, 0, cols);
+
+        // Mark the whole page as dirty.
+        //
+        // Technically we only need to mark from the cursor row to the
+        // end but this is a hot function, so we want to minimize work.
+        self.page_mut(current).dirty = true;
+        Ok(())
+    }
+
+    /// Clone a row from one page to another (Zig: `Page.cloneRowFrom`).
+    fn clone_row_between(
+        &mut self,
+        src: NodeId,
+        src_y: u16,
+        dst: NodeId,
+        dst_y: u16,
+    ) -> Result<(), Error> {
+        let (row, cells) = {
+            let sp = self.page(src);
+            let row = *sp
+                .get_row(usize::from(src_y))
+                .ok_or(Error::InvalidCoordinate)?;
+            let cells: Vec<_> = (0..usize::from(sp.size.cols))
+                .map(|x| sp.export_cell(row.cells() + x))
+                .collect();
+            (row, cells)
+        };
+        let dp = self.page_mut(dst);
+        let cols = usize::from(dp.size.cols);
+        dp.clear_cells(usize::from(dst_y), 0, cols, false)?;
+        for (x, c) in cells.iter().enumerate().take(cols) {
+            dp.import_cell(x, usize::from(dst_y), c)?;
+        }
+        let start = dp.rows[usize::from(dst_y)].cells();
+        dp.rows[usize::from(dst_y)] = row;
+        dp.rows[usize::from(dst_y)].set_cells(start);
+        Ok(())
+    }
+
+    /// Move the cursor down if we're not at the bottom of the screen. Otherwise
+    /// scroll. Currently only used for testing.
+    pub fn cursor_down_or_scroll(&mut self) -> Result<(), Error> {
+        if self.cursor.y + 1 < self.pages.rows {
+            self.cursor_down(1);
+            Ok(())
+        } else {
+            self.cursor_down_scroll()
+        }
+    }
+
+    /// Copy another cursor. The cursor can be on any screen but the x/y
+    /// must be within our screen bounds.
+    ///
+    /// `hyperlink`: Copy the hyperlink from the other cursor. If not set,
+    /// this will clear our current hyperlink.
+    pub fn cursor_copy(&mut self, other: &Cursor, hyperlink: bool) -> Result<(), Error> {
+        assert!(other.x < self.pages.cols);
+        assert!(other.y < self.pages.rows);
+
+        // End any currently active hyperlink on our cursor.
+        self.end_hyperlink();
+
+        let old = self.cursor.clone();
+        let mut new = other.clone();
+
+        // Keep our old style ID so it can be properly cleaned up below.
+        new.style_id = old.style_id;
+
+        // Hyperlinks will be managed separately below.
+        new.hyperlink_id = 0;
+        new.hyperlink = None;
+
+        // Keep our old page pin and X/Y because:
+        // 1. The old style will need to be cleaned up from the page it's from.
+        // 2. The new position navigated to by `cursor_absolute` needs to be in our
+        //    own screen.
+        new.page_pin = old.page_pin;
+        new.x = old.x;
+        new.y = old.y;
+        self.cursor = new;
+
+        // Call manual style update in order to clean up our old style, if we have
+        // one, and also to load the style from the other cursor, if it had one.
+        if let Err(e) = self.manual_style_update() {
+            self.cursor = old;
+            return Err(e);
+        }
+
+        // Move to the correct location to match the other cursor.
+        self.cursor_absolute(other.x, other.y);
+
+        // If the other cursor had a hyperlink, add it to ours.
+        if hyperlink
+            && other.hyperlink_id != 0
+            && let Some(other_link) = &other.hyperlink
+        {
+            // And it to our cursor.
+            let id = match &other_link.id {
+                HyperlinkId::Explicit(id) => Some(id.clone()),
+                HyperlinkId::Implicit(_) => None,
+            };
+            if let Err(err) = self.start_hyperlink(&other_link.uri, id.as_deref()) {
+                // This shouldn't happen because start_hyperlink should handle
+                // resizing. This only happens if we're truly out of RAM. Degrade
+                // to forgetting the hyperlink.
+                log::error!("failed to update hyperlink on cursor change err={err:?}");
+            }
+        }
+        Ok(())
+    }
+
+    /// Always use this to write to the cursor pin.
+    ///
+    /// This specifically handles the case when the new pin is on a different
+    /// page than the old AND we have a style or hyperlink set. In that case,
+    /// we must release our old one and insert the new one, since styles are
+    /// stored per-page.
+    ///
+    /// Note that this can change the cursor pin AGAIN if the process of
+    /// setting up our cursor forces a capacity adjustment of the underlying
+    /// cursor page, so any references to the page pin should be re-read
+    /// from `cursor_pin()` after calling this.
+    fn cursor_change_pin(&mut self, new: Pin) {
+        let cur = self.cursor_pin();
+
+        // Moving the cursor affects text run splitting (ligatures) so
+        // we must mark the old and new page dirty. We do this as long
+        // as the pins are not equal
+        if !cur.eql(new) {
+            self.cursor_mark_dirty();
+            new.mark_dirty(&mut self.pages);
+        }
+
+        // If our pin is on the same page, then we can just update the pin.
+        // We don't need to migrate any state.
+        if cur.node == new.node {
+            self.set_cursor_pin(new);
+            return;
+        }
+
+        // If we have an old style then we need to release it from the old page.
+        let old_style: Option<Style> = if self.cursor.style_id == style::DEFAULT_ID {
+            None
+        } else {
+            Some(self.cursor.style)
+        };
+        if old_style.is_some() {
+            // Release the style directly from the old page instead of going through
+            // manual_style_update, because the cursor position may have already been
+            // updated but the pin has not, which would fail integrity checks.
+            let id = self.cursor.style_id;
+            let _ = self.page_mut(cur.node).styles.release(id);
+            self.cursor.style = Style::default();
+            self.cursor.style_id = style::DEFAULT_ID;
+        }
+
+        // If we have a hyperlink then we need to release it from the old page.
+        if self.cursor.hyperlink.is_some() {
+            let id = self.cursor.hyperlink_id;
+            let _ = self.page_mut(cur.node).hyperlink_set.release(id);
+        }
+
+        // Update our pin to the new page
+        self.set_cursor_pin(new);
+
+        // On the new page, we need to migrate our style
+        if let Some(old_style) = old_style {
+            self.cursor.style = old_style;
+            if let Err(err) = self.manual_style_update() {
+                // This failure should not happen because manual_style_update
+                // handles page splitting, overflow, and more. This should only
+                // happen if we're out of RAM. In this case, we'll just degrade
+                // gracefully back to the default style.
+                log::error!("failed to update style on cursor change err={err:?}");
+                self.cursor.style = Style::default();
+                self.cursor.style_id = 0;
+            }
+        }
+
+        // On the new page, we need to migrate our hyperlink
+        if let Some(link) = self.cursor.hyperlink.take() {
+            // So we don't attempt to free any memory in the replaced page.
+            self.cursor.hyperlink_id = 0;
+
+            // Re-add
+            let id = match &link.id {
+                HyperlinkId::Explicit(v) => Some(v.as_slice()),
+                HyperlinkId::Implicit(_) => None,
+            };
+            if let Err(err) = self.start_hyperlink(&link.uri, id) {
+                // This shouldn't happen because start_hyperlink should handle
+                // resizing. This only happens if we're truly out of RAM. Degrade
+                // to forgetting the hyperlink.
+                log::error!("failed to update hyperlink on cursor change err={err:?}");
+            }
+        }
+    }
+
+    /// Mark the cursor position as dirty.
+    pub fn cursor_mark_dirty(&mut self) {
+        self.cursor_row_mut().set_dirty(true);
+    }
+
+    /// Reset the cursor row's soft-wrap state and the cursor's pending wrap.
+    /// Also handles clearing the spacer head on the cursor row and resetting
+    /// the wrap_continuation flag on the next row if necessary.
+    ///
+    /// NOTE(qwerasd): This method is not scrolling region aware, and cannot be
+    /// since it's on Screen not Terminal. This needs to be addressed down the
+    /// line. Not an extremely urgent issue since it's an edge case of an edge
+    /// case, but not ideal.
+    pub fn cursor_reset_wrap(&mut self) {
+        // Reset the cursor's pending wrap state
+        self.cursor.pending_wrap = false;
+
+        if !self.cursor_row().wrap() {
+            return;
+        }
+
+        // This row does not wrap and the next row is not wrapped to
+        self.cursor_row_mut().set_wrap(false);
+
+        let pin = self.cursor_pin();
+        if let Some(next_row) = pin.down(&self.pages, 1) {
+            self.page_mut(next_row.node)
+                .get_row_mut(usize::from(next_row.y))
+                .expect("next row")
+                .set_wrap_continuation(false);
+        }
+
+        // If the last cell in the row is a spacer head we need to clear it.
+        let cols = usize::from(self.page(pin.node).size.cols);
+        let cell = self.cursor_row_cells()[cols - 1];
+        if cell.wide() == Wide::SpacerHead {
+            self.clear_cells(pin.node, pin.y, cols - 1, cols);
+        }
+    }
+
+    /// Scroll the viewport of the terminal grid.
+    pub fn scroll(&mut self, behavior: Scroll) {
+        // No matter what, scrolling marks our image state as dirty since
+        // it could move placements. If there are no placements or no images
+        // this is still a very cheap operation.
+        self.kitty_images.dirty = true;
+
+        self.pages.scroll(match behavior {
+            Scroll::Active => ListScroll::Active,
+            Scroll::Top => ListScroll::Top,
+            Scroll::Pin(p) => ListScroll::Pin(p),
+            Scroll::Row(v) => ListScroll::Row(v),
+            Scroll::DeltaRow(v) => ListScroll::DeltaRow(v),
+            Scroll::DeltaPrompt(v) => ListScroll::DeltaPrompt(v),
+        });
+        self.assert_integrity();
+    }
+
+    /// See PageList.scroll_clear. In addition to that, we reset the cursor
+    /// to be on top.
+    pub fn scroll_clear(&mut self) -> Result<(), Error> {
+        self.pages.scroll_clear()?;
+        self.cursor_reload();
+
+        // No matter what, scrolling marks our image state as dirty since
+        // it could move placements. If there are no placements or no images
+        // this is still a very cheap operation.
+        self.kitty_images.dirty = true;
+        self.assert_integrity();
+        Ok(())
+    }
+
+    /// Returns true if the viewport is scrolled to the bottom of the screen.
+    pub fn viewport_is_bottom(&self) -> bool {
+        self.pages.viewport == Viewport::Active
+    }
+
+    /// Erase the region specified by tl and br, inclusive. This will physically
+    /// erase the rows meaning the memory will be reclaimed (if the underlying
+    /// page is empty) and other rows will be shifted up.
+    ///
+    /// Like Zig's `PageList.eraseRows` this requires that `tl` is valid.
+    pub fn erase_rows(&mut self, tl: Point, bl: Option<Point>) {
+        // Erase the rows
+        if let Err(err) = self.pages.erase_rows(tl, bl) {
+            log::warn!("erase_rows failed err={err:?}");
+        }
+
+        // Workaround for PageList::fixup_viewport not handling `Viewport::Top`
+        // (Zig: a top viewport returns to active when the first page is in
+        // the active area after erasing).
+        // TODO(integration): remove once page_list.rs handles this.
+        if self.pages.viewport == Viewport::Top
+            && self.pages.total_rows <= usize::from(self.pages.rows)
+        {
+            self.pages.viewport = Viewport::Active;
+        }
+
+        // Just to be safe, reset our cursor since it is possible depending
+        // on the points that our active area shifted so our pointers are
+        // invalid.
+        self.cursor_reload();
+        self.assert_integrity();
+    }
+
+    /// Clear the region specified by tl and bl, inclusive. Cleared cells are
+    /// colored with the current style background color. This will clear all
+    /// cells in the rows.
+    ///
+    /// If protected is true, the protected flag will be respected and only
+    /// unprotected cells will be cleared. Otherwise, all cells will be cleared.
+    pub fn clear_rows(&mut self, tl: Point, bl: Option<Point>, protected: bool) {
+        let chunks: Vec<Chunk> = self
+            .pages
+            .page_iterator(Direction::RightDown, tl, bl)
+            .collect();
+        let cols = usize::from(self.pages.cols);
+        for chunk in chunks {
+            for y in chunk.start..chunk.end {
+                let cells_offset = self.page(chunk.node).rows[usize::from(y)].cells();
+
+                // Clear all cells
+                if protected {
+                    self.clear_unprotected_cells(chunk.node, y, 0, cols);
+                    // We need to preserve other row attributes since we only
+                    // cleared unprotected cells.
+                    self.page_mut(chunk.node).rows[usize::from(y)].set_cells(cells_offset);
+                } else {
+                    self.clear_cells(chunk.node, y, 0, cols);
+                    let mut row = Row::default();
+                    row.set_cells(cells_offset);
+                    self.page_mut(chunk.node).rows[usize::from(y)] = row;
+                }
+
+                self.page_mut(chunk.node).rows[usize::from(y)].set_dirty(true);
+            }
+        }
+        self.assert_integrity();
+    }
+
+    /// Clear the cells `[x0, x1)` of row `y` of the given page with the blank
+    /// cell.
+    ///
+    /// This takes care to handle cleaning up graphemes and styles.
+    pub fn clear_cells(&mut self, node: NodeId, y: u16, x0: usize, x1: usize) {
+        let blank = self.blank_cell();
+        let full_row = x1 - x0 == usize::from(self.pages.cols);
+        let page = self.page_mut(node);
+        let y = usize::from(y);
+        let base = page.rows[y].cells();
+        assert!(x0 <= x1 && x1 <= usize::from(page.size.cols));
+        let row = page.rows[y];
+
+        // If we have managed memory (styles, graphemes, or hyperlinks)
+        // in this row then we go cell by cell and clear them if present.
+        if row.grapheme() {
+            for i in base + x0..base + x1 {
+                if page.cells[i].has_grapheme() {
+                    page.clear_grapheme(i);
+                }
+            }
+
+            // If we have no left/right scroll region we can be sure
+            // that we've cleared all the graphemes, so we clear the
+            // flag, otherwise we ask the page to update the flag.
+            if full_row {
+                page.rows[y].set_grapheme(false);
+            } else {
+                page.update_row_grapheme_flag(y);
+            }
+        }
+
+        if row.hyperlink() {
+            for i in base + x0..base + x1 {
+                if page.cells[i].hyperlink() {
+                    let _ = page.clear_hyperlink(i);
+                }
+            }
+
+            if full_row {
+                page.rows[y].set_hyperlink(false);
+            } else {
+                page.update_row_hyperlink_flag(y);
+            }
+        }
+
+        if row.styled() {
+            for i in base + x0..base + x1 {
+                if page.cells[i].has_styling() {
+                    let id = page.cells[i].style_id();
+                    let _ = page.styles.release(id);
+                }
+            }
+
+            if full_row {
+                page.rows[y].set_styled(false);
+            } else {
+                page.update_row_styled_flag(y);
+            }
+        }
+
+        if row.kitty_virtual_placeholder()
+            && full_row
+            && !page.cells[base + x0..base + x1]
+                .iter()
+                .any(|c| c.codepoint() == KITTY_PLACEHOLDER)
+        {
+            page.rows[y].set_kitty_virtual_placeholder(false);
+        }
+
+        page.cells[base + x0..base + x1].fill(blank);
+    }
+
+    /// Clear cells but only if they are not protected.
+    pub fn clear_unprotected_cells(&mut self, node: NodeId, y: u16, x0: usize, x1: usize) {
+        let base = self.page(node).rows[usize::from(y)].cells();
+        let mut i = x0;
+
+        while i < x1 {
+            while self.page(node).cells[base + i].protected() {
+                i += 1;
+                if i >= x1 {
+                    self.assert_integrity();
+                    return;
+                }
+            }
+            let mut j = i + 1;
+            while j < x1 && !self.page(node).cells[base + j].protected() {
+                j += 1;
+            }
+            self.clear_cells(node, y, i, j);
+            i = j;
+        }
+
+        self.assert_integrity();
+    }
+
+    /// Clean up boundary conditions where a cell will become discontiguous with
+    /// a neighboring cell because either one of them will be moved and/or cleared.
+    ///
+    /// For performance reasons this is specialized to operate on the cursor row.
+    ///
+    /// Handles the boundary between the cell at `x` and the cell at `x - 1`.
+    ///
+    /// So, for example, when moving a region of cells [a, b] (inclusive), call this
+    /// function with `x = a` and `x = b + 1`. It is okay if `x` is out of bounds by
+    /// 1, this will be interpreted correctly.
+    ///
+    /// DOES NOT MODIFY ROW WRAP STATE! See `cursor_reset_wrap` for that.
+    ///
+    /// The following boundary conditions are handled:
+    ///
+    /// - `x - 1` is a wide character and `x` is a spacer tail:
+    ///   o Both cells will be cleared.
+    ///   o If `x - 1` is the start of the row and was wrapped from a previous row
+    ///     then the previous row is checked for a spacer head, which is cleared if
+    ///     present.
+    ///
+    /// - `x == 0` and is a wide character:
+    ///   o If the row is a wrap continuation then the previous row will be checked
+    ///     for a spacer head, which is cleared if present.
+    ///
+    /// - `x == cols` and `x - 1` is a spacer head:
+    ///   o `x - 1` will be cleared.
+    ///
+    /// NOTE(qwerasd): This method is not scrolling region aware, and cannot be
+    /// since it's on Screen not Terminal. This needs to be addressed down the
+    /// line. Not an extremely urgent issue since it's an edge case of an edge
+    /// case, but not ideal.
+    pub fn split_cell_boundary(&mut self, x: size::CellCountInt) {
+        let pin = self.cursor_pin();
+        let cols = self.page(pin.node).size.cols;
+
+        // `x` may be up to an INCLUDING `cols`, since that signifies splitting
+        // the boundary to the right of the final cell in the row.
+        assert!(x <= cols);
+
+        // [ A B C D E F|]
+        //              ^ Boundary between final cell and row end.
+        if x == cols {
+            if !self.cursor_row().wrap() {
+                return;
+            }
+
+            // Spacer head at end of wrapped row.
+            if self.cursor_row_cells()[usize::from(cols - 1)].wide() == Wide::SpacerHead {
+                self.clear_cells(pin.node, pin.y, usize::from(cols - 1), usize::from(cols));
+            }
+
+            return;
+        }
+
+        // [|A B C D E F ]
+        //  ^ Boundary between first cell and row start.
+        //
+        //  OR
+        //
+        // [ A|B C D E F ]
+        //    ^ Boundary between first cell and second cell.
+        //
+        // First cell may be a wrapped wide cell with a spacer
+        // head on the previous row that needs to be cleared.
+        if (x == 0 || x == 1) && self.cursor_row().wrap_continuation() {
+            // If the first cell in a row is wide the previous row
+            // may have a spacer head which needs to be cleared.
+            if self.cursor_row_cells()[0].wide() == Wide::Wide
+                && let Some(p_row) = pin.up(&self.pages, 1)
+            {
+                let p_cols = self.page(p_row.node).size.cols;
+                let p_cell = self
+                    .page(p_row.node)
+                    .get_cells(usize::from(p_row.y))
+                    .expect("row")[usize::from(p_cols - 1)];
+                if p_cell.wide() == Wide::SpacerHead {
+                    self.clear_cells(
+                        p_row.node,
+                        p_row.y,
+                        usize::from(p_cols - 1),
+                        usize::from(p_cols),
+                    );
+                }
+            }
+        }
+
+        // If x is 0 then we're done.
+        if x == 0 {
+            return;
+        }
+
+        // [ ... X|Y ... ]
+        //        ^ Boundary between two cells in the middle of the row.
+        {
+            assert!(x > 0);
+            assert!(x < cols);
+
+            let left = self.cursor_row_cells()[usize::from(x - 1)];
+            match left.wide() {
+                // There should not be spacer heads in the middle of the row.
+                Wide::SpacerHead => unreachable!("spacer head in the middle of a row"),
+
+                // We don't need to do anything for narrow cells or spacer tails.
+                Wide::Narrow | Wide::SpacerTail => {}
+
+                // A wide char would be split, so must be cleared.
+                Wide::Wide => {
+                    self.clear_cells(pin.node, pin.y, usize::from(x - 1), usize::from(x + 1));
+                }
+            }
+        }
+    }
+
+    /// Returns the blank cell to use when doing terminal operations that
+    /// require preserving the bg color.
+    #[inline]
+    pub fn blank_cell(&self) -> Cell {
+        if self.cursor.style_id == style::DEFAULT_ID {
+            return Cell::default();
+        }
+        self.cursor.style.bg_cell().unwrap_or_default()
+    }
+}
+
+impl Screen {
+    /// Resize the screen. The rows or cols can be bigger or smaller.
+    ///
+    /// If this returns an error, the screen is left in a likely garbage state.
+    /// It is very hard to undo this operation without blowing up our memory
+    /// usage. The only way to recover is to reset the screen. The only way
+    /// this really fails is if page allocation is required and fails, which
+    /// probably means the system is in trouble anyways. I'd like to improve this
+    /// in the future but it is not a priority particularly because this scenario
+    /// (resize) is difficult.
+    pub fn resize(&mut self, opts: Resize) -> Result<(), Error> {
+        // No matter what we mark our image state as dirty
+        self.kitty_images.dirty = true;
+
+        // Release the cursor style while resizing just
+        // in case the cursor ends up on a different page.
+        let cursor_style = self.cursor.style;
+        self.cursor.style = Style::default();
+        self.manual_style_update()
+            .expect("releasing to the default style cannot fail");
+
+        // We need to insert a tracked pin for our saved cursor so we can
+        // modify its X/Y for reflow.
+        let saved_cursor_pin = match self.saved_cursor {
+            Some(sc) => match self.pages.pin(Point::Active(Coordinate {
+                x: sc.x,
+                y: u32::from(sc.y),
+            })) {
+                Some(pin) => match self.pages.track_pin(pin) {
+                    Ok(h) => Some(h),
+                    Err(e) => {
+                        self.restore_cursor_style(cursor_style);
+                        self.assert_integrity();
+                        return Err(e);
+                    }
+                },
+                None => None,
+            },
+            None => None,
+        };
+
+        let result = self.resize_inner(opts, saved_cursor_pin);
+        if let Some(p) = saved_cursor_pin {
+            self.pages.untrack_pin(p);
+        }
+
+        // Restore the cursor style.
+        self.restore_cursor_style(cursor_style);
+        self.assert_integrity();
+        result
+    }
+
+    fn restore_cursor_style(&mut self, cursor_style: Style) {
+        self.cursor.style = cursor_style;
+        if let Err(err) = self.manual_style_update() {
+            // This failure should not happen because manual_style_update
+            // handles page splitting, overflow, and more. This should only
+            // happen if we're out of RAM. In this case, we'll just degrade
+            // gracefully back to the default style.
+            log::error!("failed to update style on cursor reload err={err:?}");
+            self.cursor.style = Style::default();
+            self.cursor.style_id = 0;
+        }
+    }
+
+    fn resize_inner(
+        &mut self,
+        opts: Resize,
+        saved_cursor_pin: Option<TrackedPin>,
+    ) -> Result<(), Error> {
+        // If we have a hyperlink, release it from the old page
+        // and then we need to re-add it to the new page. This needs
+        // to happen because resize below typically reallocates a
+        // new page so the old hyperlink is invalid.
+        let hyperlink_ = self.cursor.hyperlink.take();
+        if self.cursor.hyperlink_id != 0 {
+            // Note we do NOT use end_hyperlink because we want to keep
+            // our allocated hyperlink valid.
+            let id = self.cursor.hyperlink_id;
+            let node = self.cursor_pin().node;
+            let _ = self.page_mut(node).hyperlink_set.release(id);
+            self.cursor.hyperlink_id = 0;
+        }
+
+        // If our cursor is on a prompt or input line, clear it so the shell can
+        // redraw it. This works with OSC 133 semantic prompts.
+        //
+        // We check cursor.semantic_content rather than page_row.semantic_prompt
+        // because some shells (e.g., Nu) mark input areas with OSC 133 B but don't
+        // mark continuation lines with k=s. If the input spans multiple lines and
+        // continuation lines are unmarked, checking only page_row.semantic_prompt
+        // would miss them. By checking semantic_content, we assume that if the
+        // cursor is on anything other than command output, we're at a prompt/input
+        // line and should clear from there.
+        if opts.prompt_redraw != Redraw::False
+            && self.cursor.semantic_content != SemanticContent::Output
+        {
+            let cols = usize::from(self.pages.cols);
+            match opts.prompt_redraw {
+                Redraw::False => unreachable!(),
+
+                // For `Last`, only clear the current line where the cursor is.
+                // For `True`, clear all prompt lines starting from the beginning.
+                Redraw::Last => {
+                    let p = self.cursor_pin();
+                    self.clear_cells(p.node, p.y, 0, cols);
+                }
+
+                Redraw::True => {
+                    let start = pin_iter::prompt_iterator(
+                        &self.pages,
+                        self.cursor_pin(),
+                        Direction::LeftUp,
+                        None,
+                    )
+                    .next();
+                    if let Some(start) = start {
+                        // Clear cells from our start down. We replace it with spaces,
+                        // and do not physically erase the rows (erase_rows) because the
+                        // shell is going to expect this space to be available.
+                        let rows: Vec<Pin> =
+                            pin_iter::row_iterator(&self.pages, start, Direction::RightDown, None)
+                                .collect();
+                        for pin in rows {
+                            self.clear_cells(pin.node, pin.y, 0, cols);
+                        }
+                    } else {
+                        // This should never happen because prompt_iterator should always
+                        // find a prompt if we already verified our row is some kind of
+                        // prompt.
+                        log::warn!("cursor on prompt line but promptIterator found no prompt");
+                    }
+                }
+            }
+        }
+
+        // Perform the resize operation.
+        self.pages.resize(crate::page_list::Resize {
+            rows: Some(opts.rows),
+            cols: Some(opts.cols),
+            reflow: opts.reflow,
+            cursor: Some(crate::page_list::Cursor {
+                x: self.cursor.x,
+                y: self.cursor.y,
+            }),
+        })?;
+
+        // If we have no scrollback and we shrunk our rows, we must explicitly
+        // erase our history. This is because PageList always keeps at least
+        // a page size of history.
+        if self.no_scrollback
+            && self.pages.get_top_left(Tag::History).is_some()
+            && let Err(err) = self
+                .pages
+                .erase_rows(Point::History(Coordinate::default()), None)
+        {
+            log::warn!("failed to erase history on resize err={err:?}");
+        }
+
+        // If our cursor was updated, we do a full reload so all our cursor
+        // state is correct.
+        self.cursor_reload();
+
+        // If we reflowed a saved cursor, update it.
+        if let Some(p) = saved_cursor_pin {
+            // This should never fail because a non-null saved_cursor_pin
+            // implies a non-null saved_cursor.
+            let pin = self.pages.tracked_pin(p);
+            let pt = pin.and_then(|pin| self.pages.point_from_pin(Tag::Active, pin));
+            if let Some(sc) = self.saved_cursor.as_mut() {
+                if let Some(pt) = pt {
+                    sc.x = pt.coord().x;
+                    sc.y = pt.coord().y as size::CellCountInt;
+
+                    // If we had pending wrap set and we're no longer at the end of
+                    // the line, we unset the pending wrap and move the cursor to
+                    // reflect the correct next position.
+                    if sc.pending_wrap && sc.x != opts.cols - 1 {
+                        sc.pending_wrap = false;
+                        sc.x += 1;
+                    }
+                } else {
+                    // I think this can happen if the screen is resized to be
+                    // less rows or less cols and our saved cursor moves outside
+                    // the active area. In this case, there isn't anything really
+                    // reasonable we can do so we just move the cursor to the
+                    // top-left. It may be reasonable to also move the cursor to
+                    // match the primary cursor. Any behavior is fine since this is
+                    // totally unspecified.
+                    sc.x = 0;
+                    sc.y = 0;
+                    sc.pending_wrap = false;
+                }
+            }
+        }
+
+        // Fix up our hyperlink if we had one.
+        if let Some(link) = hyperlink_ {
+            let id = match &link.id {
+                HyperlinkId::Explicit(v) => Some(v.as_slice()),
+                HyperlinkId::Implicit(_) => None,
+            };
+            if let Err(err) = self.start_hyperlink(&link.uri, id) {
+                // This shouldn't happen because start_hyperlink should handle
+                // resizing. This only happens if we're truly out of RAM. Degrade
+                // to forgetting the hyperlink.
+                log::error!("failed to update hyperlink on resize err={err:?}");
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Set a style attribute for the current cursor.
+    ///
+    /// If the style can't be set due to any internal errors (memory-related),
+    /// then this will revert back to the existing style and return an error.
+    pub fn set_attribute(&mut self, attr: sgr::Attribute<'_>) -> Result<(), Error> {
+        // If we fail to set our style for any reason, we should revert
+        // back to the old style. If we fail to do that, we revert back to
+        // the default style.
+        let old_style = self.cursor.style;
+
+        use sgr::Attribute as A;
+        let st = &mut self.cursor.style;
+        match attr {
+            A::Unset => *st = Style::default(),
+            A::Bold => st.flags.bold = true,
+            A::ResetBold => {
+                // Bold and faint share the same SGR code for this
+                st.flags.bold = false;
+                st.flags.faint = false;
+            }
+            A::Italic => st.flags.italic = true,
+            A::ResetItalic => st.flags.italic = false,
+            A::Faint => st.flags.faint = true,
+            A::Underline(v) => st.flags.underline = v,
+            A::UnderlineColor(rgb) => st.underline_color = style::Color::Rgb(rgb),
+            A::UnderlineColor256(idx) => st.underline_color = style::Color::Palette(idx),
+            A::ResetUnderlineColor => st.underline_color = style::Color::None,
+            A::Overline => st.flags.overline = true,
+            A::ResetOverline => st.flags.overline = false,
+            A::Blink => st.flags.blink = true,
+            A::ResetBlink => st.flags.blink = false,
+            A::Inverse => st.flags.inverse = true,
+            A::ResetInverse => st.flags.inverse = false,
+            A::Invisible => st.flags.invisible = true,
+            A::ResetInvisible => st.flags.invisible = false,
+            A::Strikethrough => st.flags.strikethrough = true,
+            A::ResetStrikethrough => st.flags.strikethrough = false,
+            A::DirectColorFg(rgb) => st.fg_color = style::Color::Rgb(rgb),
+            A::DirectColorBg(rgb) => st.bg_color = style::Color::Rgb(rgb),
+            A::Fg8(n) => st.fg_color = style::Color::Palette(n.0),
+            A::Bg8(n) => st.bg_color = style::Color::Palette(n.0),
+            A::ResetFg => st.fg_color = style::Color::None,
+            A::ResetBg => st.bg_color = style::Color::None,
+            A::Fg8Bright(n) => st.fg_color = style::Color::Palette(n.0),
+            A::Bg8Bright(n) => st.bg_color = style::Color::Palette(n.0),
+            A::Fg256(idx) => st.fg_color = style::Color::Palette(idx),
+            A::Bg256(idx) => st.bg_color = style::Color::Palette(idx),
+            A::Unknown(_) => return Ok(()),
+        }
+
+        if let Err(e) = self.manual_style_update() {
+            self.cursor.style = old_style;
+            if let Err(err) = self.manual_style_update() {
+                log::warn!("setAttribute error restoring old style after failure err={err:?}");
+                self.cursor.style = Style::default();
+                let _ = self.manual_style_update();
+            }
+            return Err(e);
+        }
+        Ok(())
+    }
+
+    /// Call this whenever you manually change the cursor style.
+    ///
+    /// This function can NOT fail if the cursor style is changing to the
+    /// default style.
+    ///
+    /// If this returns an error, the style change did not take effect and
+    /// the cursor style is reverted back to the default. The only scenario
+    /// this returns an error is if there is a physical memory allocation failure
+    /// or if there is no possible way to increase style capacity to store
+    /// the style.
+    ///
+    /// This function WILL split pages as necessary to accommodate the new style.
+    /// So if OutOfSpace is returned, it means that even after splitting the page
+    /// there was still no room for the new style.
+    pub fn manual_style_update(&mut self) -> Result<(), Error> {
+        let result = self.manual_style_update_inner();
+        self.assert_integrity();
+        result
+    }
+
+    fn manual_style_update_inner(&mut self) -> Result<(), Error> {
+        let node = self.cursor_pin().node;
+
+        // Release our previous style if it was not default.
+        if self.cursor.style_id != style::DEFAULT_ID {
+            let id = self.cursor.style_id;
+            let _ = self.page_mut(node).styles.release(id);
+        }
+
+        // If our new style is the default, just reset to that
+        if self.cursor.style.is_default() {
+            self.cursor.style_id = style::DEFAULT_ID;
+            return Ok(());
+        }
+
+        // Clear the cursor style ID to prevent weird things from happening
+        // if the page capacity has to be adjusted which would end up calling
+        // manual_style_update again.
+        //
+        // This also ensures that if anything fails below, we fall back to
+        // clearing our style.
+        self.cursor.style_id = style::DEFAULT_ID;
+
+        // After setting the style, we need to update our style map.
+        // Note that we COULD lazily do this in print. We should look into
+        // if that makes a meaningful difference. Our priority is to keep print
+        // fast because setting a ton of styles that do nothing is uncommon
+        // and weird.
+        let st = self.cursor.style;
+        let id = match self.page_mut(node).styles.add(st) {
+            Ok(id) => id,
+            Err(err) => {
+                // Our style map is full or needs to be rehashed, so we need to
+                // increase style capacity (or rehash).
+                let adjustment = match err {
+                    crate::ref_counted_set::AddError::OutOfMemory => Some(IncreaseCapacity::Styles),
+                    crate::ref_counted_set::AddError::NeedsRehash => None,
+                    other => return Err(other.into()),
+                };
+                let node = match self.increase_capacity(self.cursor_pin().node, adjustment) {
+                    Ok(n) => n,
+                    Err(Error::OutOfSpace) => {
+                        // Out of space, we need to split the page. Split wherever
+                        // is using less capacity and hope that works. If it doesn't
+                        // work, we tried.
+                        self.split_for_capacity(self.cursor_pin())?;
+                        self.cursor_pin().node
+                    }
+                    Err(e) => return Err(e),
+                };
+
+                match self.page_mut(node).styles.add(st) {
+                    Ok(id) => id,
+                    Err(crate::ref_counted_set::AddError::NeedsRehash) => {
+                        // This should be impossible because we rehash above
+                        // and rehashing should never result in a duplicate. But
+                        // we don't want to simply hard crash so log it and
+                        // clear our style.
+                        log::error!("style rehash resulted in needs rehash");
+                        return Ok(());
+                    }
+                    Err(crate::ref_counted_set::AddError::OutOfMemory) => {
+                        // This shouldn't happen because increase_capacity is
+                        // guaranteed to increase our capacity by at least one and
+                        // we only need one space, but again, I don't want to crash
+                        // here so let's log loudly and reset.
+                        log::error!("style addition failed after capacity increase");
+                        return Err(Error::OutOfMemory);
+                    }
+                    Err(e) => return Err(e.into()),
+                }
+            }
+        };
+
+        self.cursor.style_id = id;
+        Ok(())
+    }
+
+    /// Split at the given pin so that the pinned row moves to the page
+    /// with less used capacity after the split.
+    ///
+    /// The primary use case for this is to handle IncreaseCapacityError
+    /// OutOfSpace conditions where we need to split the page in order
+    /// to make room for more managed memory.
+    ///
+    /// If the caller cares about where the pin moves to, they should
+    /// setup a tracked pin before calling this and then check that.
+    /// In many calling cases, the input pin is tracked (e.g. the cursor
+    /// pin).
+    ///
+    /// If this returns OOM then its a system OOM. If this returns OutOfSpace
+    /// then it means the page can't be split further.
+    fn split_for_capacity(&mut self, pin: Pin) -> Result<(), Error> {
+        // Get our capacities. We include our target row because its
+        // capacity will be preserved.
+        let (bytes_above, bytes_below) = {
+            let page = self.page(pin.node);
+            let above =
+                Page::layout(page.exact_row_capacity(0, usize::from(pin.y) + 1)?).total_size;
+            let below = Page::layout(
+                page.exact_row_capacity(usize::from(pin.y), usize::from(page.size.rows))?,
+            )
+            .total_size;
+            (above, below)
+        };
+
+        // We need to track the old cursor pin because if our split
+        // moves the cursor pin we need to update our accounting.
+        let old_cursor = self.cursor_pin();
+
+        // If our bytes above are less than bytes below, we move the pin
+        // to split down one since splitting includes the pinned row in
+        // the new node.
+        self.pages.split(if bytes_above < bytes_below {
+            pin.down(&self.pages, 1).unwrap_or(pin)
+        } else {
+            pin
+        })?;
+
+        // Cursor didn't change nodes, we're done.
+        if self.cursor_pin().node == old_cursor.node {
+            return Ok(());
+        }
+
+        // Cursor changed, we need to restore the old pin then use
+        // cursor_change_pin to move to the new pin. The old node is guaranteed
+        // to still exist, just not the row.
+        //
+        // The page list validates tracked pins, so the stand-in for the old
+        // location is clamped into the old node's remaining rows (only the
+        // node matters to cursor_change_pin).
+        let new_cursor = self.cursor_pin();
+        let old_rows = self.page(old_cursor.node).size.rows;
+        self.set_cursor_pin(Pin {
+            y: old_cursor.y.min(old_rows - 1),
+            ..old_cursor
+        });
+        self.cursor_change_pin(new_cursor);
+        Ok(())
+    }
+
+    /// Append a grapheme to the given cell (column `x`) within the current
+    /// cursor row.
+    pub fn append_grapheme(&mut self, x: size::CellCountInt, cp: u32) -> Result<(), Error> {
+        let result = {
+            let p = self.cursor_pin();
+            self.page_mut(p.node)
+                .append_grapheme(usize::from(x), usize::from(p.y), cp)
+        };
+        match result {
+            Err(Error::GraphemeAllocOutOfMemory | Error::GraphemeMapOutOfMemory) => {
+                // Adjust our capacity. This will update our cursor page pin and
+                // force us to reload. The cell is addressed by column so it stays
+                // valid.
+                let node = self.cursor_pin().node;
+                self.increase_capacity(node, Some(IncreaseCapacity::GraphemeBytes))?;
+
+                let p = self.cursor_pin();
+                self.page_mut(p.node)
+                    .append_grapheme(usize::from(x), usize::from(p.y), cp)
+                    .inspect_err(|_| {
+                        // This should never happen because we just increased capacity.
+                        // Log loudly but still return an error so we don't just
+                        // crash.
+                        log::error!("grapheme append failed after capacity increase");
+                    })
+            }
+            other => other,
+        }
+    }
+
+    /// Start the hyperlink state. Future cells will be marked as hyperlinks with
+    /// this state. Note that various terminal operations may clear the hyperlink
+    /// state, such as switching screens (alt screen).
+    pub fn start_hyperlink(&mut self, uri: &[u8], id: Option<&[u8]>) -> Result<(), Error> {
+        // Create our pending entry.
+        let implicit = id.is_none();
+        let link = Hyperlink {
+            uri: uri.to_vec(),
+            id: match id {
+                Some(id) => HyperlinkId::Explicit(id.to_vec()),
+                None => {
+                    let v = self.cursor.hyperlink_implicit_id;
+                    self.cursor.hyperlink_implicit_id = v.wrapping_add(1);
+                    HyperlinkId::Implicit(v)
+                }
+            },
+        };
+
+        // Loop until we have enough page memory to add the hyperlink
+        loop {
+            let adjustment = match self.start_hyperlink_once(&link) {
+                Ok(()) => return Ok(()),
+                // strings table is out of memory, adjust it up
+                Err(Error::StringsOutOfMemory) => Some(IncreaseCapacity::StringBytes),
+                // hyperlink set is out of memory, adjust it up
+                Err(Error::SetOutOfMemory) => Some(IncreaseCapacity::HyperlinkBytes),
+                // hyperlink set is too full, rehash it
+                Err(Error::SetNeedsRehash) => None,
+                Err(e) => {
+                    if implicit {
+                        self.cursor.hyperlink_implicit_id =
+                            self.cursor.hyperlink_implicit_id.wrapping_sub(1);
+                    }
+                    return Err(e);
+                }
+            };
+
+            let node = self.cursor_pin().node;
+            if let Err(e) = self.increase_capacity(node, adjustment) {
+                if implicit {
+                    self.cursor.hyperlink_implicit_id =
+                        self.cursor.hyperlink_implicit_id.wrapping_sub(1);
+                }
+                return Err(e);
+            }
+
+            self.assert_integrity();
+        }
+    }
+
+    /// This is like start_hyperlink but if we have to adjust page capacities
+    /// this returns an error. This is useful so that we unwind all the
+    /// previous state and try again.
+    fn start_hyperlink_once(&mut self, source: &Hyperlink) -> Result<(), Error> {
+        // End any prior hyperlink
+        self.end_hyperlink();
+
+        // Allocate our new Hyperlink entry in non-page memory. This
+        // lets us quickly get access to URI, ID.
+        let link = Box::new(source.dupe());
+
+        // Insert the hyperlink into page memory
+        let node = self.cursor_pin().node;
+        let id: hyperlink::Id = self.page_mut(node).insert_hyperlink((*link).clone())?;
+
+        // Save it all
+        self.cursor.hyperlink = Some(link);
+        self.cursor.hyperlink_id = id;
+        Ok(())
+    }
+
+    /// End the hyperlink state so that future cells aren't part of the
+    /// current hyperlink (if any). This is safe to call multiple times.
+    pub fn end_hyperlink(&mut self) {
+        // If we have no hyperlink state then do nothing
+        if self.cursor.hyperlink_id == 0 {
+            assert!(self.cursor.hyperlink.is_none());
+            return;
+        }
+
+        // Release the old hyperlink state. If there are cells using the
+        // hyperlink this will work because the creation creates a reference
+        // and all additional cells create a new reference. This release will
+        // just release our initial reference.
+        //
+        // If the ref count reaches zero the set will not delete the item
+        // immediately; it is kept around in case it is used again (this is
+        // how RefCountedSet works). This causes some memory fragmentation but
+        // is fine because if it is ever pruned the context deleted callback
+        // will be called.
+        let id = self.cursor.hyperlink_id;
+        let node = self.cursor_pin().node;
+        let _ = self.page_mut(node).hyperlink_set.release(id);
+        self.cursor.hyperlink_id = 0;
+        self.cursor.hyperlink = None;
+    }
+
+    /// Set the current hyperlink state on the current cell.
+    pub fn cursor_set_hyperlink(&mut self) -> Result<(), Error> {
+        assert!(self.cursor.hyperlink_id != 0);
+
+        loop {
+            let p = self.cursor_pin();
+            let id = self.cursor.hyperlink_id;
+            let page = self.page_mut(p.node);
+            match page.set_hyperlink(usize::from(p.x), usize::from(p.y), id) {
+                Ok(()) => {
+                    // Success, increase the refcount for the hyperlink.
+                    let _ = page.hyperlink_set.r#use(id);
+                    return Ok(());
+                }
+
+                // hyperlink_map is out of space, realloc the page to be larger
+                Err(Error::HyperlinkMapOutOfMemory) => {
+                    // Note: Zig first probes the string allocator to decide whether
+                    // string bytes must grow too (because its increaseCapacity
+                    // always adds an extra copy of the URI). The Rust page rebuild
+                    // deduplicates hyperlinks, so only the hyperlink capacity needs
+                    // to grow.
+                    let saved_link = self.cursor.hyperlink.clone();
+                    self.increase_capacity(p.node, Some(IncreaseCapacity::HyperlinkBytes))?;
+
+                    // The page rebuild re-adds the cursor hyperlink, but that can
+                    // fail when the string allocator has no room for the extra
+                    // copy of the URI (Zig grows string_bytes up front for this).
+                    // Re-add it here, growing as needed.
+                    if self.cursor.hyperlink_id == 0
+                        && let Some(link) = saved_link
+                    {
+                        loop {
+                            let adjustment = match self.start_hyperlink_once(&link) {
+                                Ok(()) => break,
+                                Err(Error::StringsOutOfMemory) => IncreaseCapacity::StringBytes,
+                                Err(Error::SetOutOfMemory) => IncreaseCapacity::HyperlinkBytes,
+                                Err(e) => return Err(e),
+                            };
+                            let node = self.cursor_pin().node;
+                            self.increase_capacity(node, Some(adjustment))?;
+                        }
+                    }
+
+                    // Retry
+                    //
+                    // We check that the cursor hyperlink hasn't been destroyed
+                    // by the capacity adjustment first though- since despite the
+                    // terrible code above, that can still apparently happen ._.
+                    if self.cursor.hyperlink_id > 0 {
+                        continue;
+                    }
+                    return Ok(());
+                }
+
+                Err(e) => return Err(e),
+            }
+        }
+    }
+
+    /// Modify the semantic content type of the cursor. This should
+    /// be preferred over setting it manually since it handles all the
+    /// proper accounting.
+    pub fn cursor_set_semantic_content(&mut self, t: SemanticContentSet) {
+        match t {
+            SemanticContentSet::Output => {
+                self.cursor.semantic_content = SemanticContent::Output;
+                self.cursor.semantic_content_clear_eol = false;
+            }
+
+            SemanticContentSet::Input(clear) => {
+                self.cursor.semantic_content = SemanticContent::Input;
+                self.cursor.semantic_content_clear_eol = match clear {
+                    InputClear::ClearExplicit => false,
+                    InputClear::ClearEol => true,
+                };
+            }
+
+            SemanticContentSet::Prompt(kind) => {
+                self.semantic_prompt.seen = true;
+                self.cursor.semantic_content = SemanticContent::Prompt;
+                self.cursor.semantic_content_clear_eol = false;
+                self.cursor_row_mut().set_semantic_prompt(match kind {
+                    PromptKind::Initial | PromptKind::Right => RowPrompt::Prompt,
+                    PromptKind::Continuation | PromptKind::Secondary => {
+                        RowPrompt::PromptContinuation
+                    }
+                });
+            }
+        }
+    }
+
+    /// Set the selection to the given selection. If this is a tracked selection
+    /// then the screen will take ownership of the selection. If this is untracked
+    /// then the screen will convert it to tracked internally. This will automatically
+    /// untrack the prior selection (if any).
+    ///
+    /// Set the selection to None to clear any previous selection.
+    ///
+    /// This is always recommended over setting `selection` directly. Beyond
+    /// managing memory for you, it also performs safety checks that the selection
+    /// is always tracked.
+    pub fn select(&mut self, sel: Option<Selection>) -> Result<(), Error> {
+        let Some(sel) = sel else {
+            self.clear_selection();
+            return Ok(());
+        };
+
+        // If this selection is untracked then we track it.
+        let tracked_sel = if sel.tracked() {
+            sel
+        } else {
+            sel.track(&mut self.pages)?
+        };
+
+        // Untrack prior selection
+        if let Some(old) = self.selection {
+            old.deinit(&mut self.pages);
+        }
+        self.selection = Some(tracked_sel);
+        self.dirty.selection = true;
+        Ok(())
+    }
+
+    /// Same as select(None) but can't fail.
+    pub fn clear_selection(&mut self) {
+        if let Some(sel) = self.selection {
+            sel.deinit(&mut self.pages);
+            self.dirty.selection = true;
+        }
+        self.selection = None;
+    }
+}
+
+fn is_ws(whitespace: &[u32], cp: u32) -> bool {
+    whitespace.contains(&cp)
+}
+
+impl Screen {
+    fn pin_cell(&self, p: Pin) -> Cell {
+        *p.row_and_cell(&self.pages).expect("valid pin").1
+    }
+
+    fn pin_row(&self, p: Pin) -> Row {
+        *p.row_and_cell(&self.pages).expect("valid pin").0
+    }
+
+    fn pin_row_cells(&self, p: Pin) -> &[Cell] {
+        p.cells(&self.pages, CellSubset::All).expect("valid pin")
+    }
+
+    fn pin_cols(&self, p: Pin) -> u16 {
+        self.page(p.node).size.cols
+    }
+
+    /// Returns the raw text associated with a selection. This will unwrap
+    /// soft-wrapped edges.
+    ///
+    /// For more flexibility, use a ScreenFormatter directly.
+    pub fn selection_string(&self, opts: SelectionString) -> String {
+        self.selection_string_impl(opts, None)
+    }
+
+    /// Same as `selection_string` but also returns a map from every byte of
+    /// the string to the pin it came from (Zig: `SelectionString.map`).
+    pub fn selection_string_map(&self, opts: SelectionString) -> StringMap {
+        let mut pins = Vec::new();
+        let string = self.selection_string_impl(opts, Some(&mut pins));
+        StringMap { string, map: pins }
+    }
+
+    fn selection_string_impl(
+        &self,
+        opts: SelectionString,
+        pin_map: Option<&mut Vec<Pin>>,
+    ) -> String {
+        // TODO(integration): delegate to formatter::ScreenFormatter (plain,
+        // unwrap = true, trim = opts.trim, content = selection).
+        let tl = opts.sel.top_left(&self.pages);
+        let br = opts.sel.bottom_right(&self.pages);
+        plain_format(
+            &self.pages,
+            tl,
+            br,
+            opts.sel.rectangle,
+            true,
+            opts.trim,
+            pin_map,
+        )
+    }
+
+    /// Select the line under the given point. This will select across soft-wrapped
+    /// lines and will omit the leading and trailing whitespace. If the point is
+    /// over whitespace but the line has non-whitespace characters elsewhere, the
+    /// line will be selected.
+    pub fn select_line(&self, opts: SelectLine<'_>) -> Option<Selection> {
+        let list = &self.pages;
+
+        // Get the current point semantic prompt state since that determines
+        // boundary conditions too. This makes it so that line selection can
+        // only happen within the same prompt state. For example, if you triple
+        // click output, but the shell uses spaces to soft-wrap to the prompt
+        // then the selection will stop prior to the prompt. See issue #1329.
+        let semantic_prompt_state: Option<SemanticContent> = if opts.semantic_prompt_boundary {
+            Some(self.pin_cell(opts.pin).semantic_content())
+        } else {
+            None
+        };
+
+        // The real start of the row is the first row in the soft-wrap.
+        let start_pin: Pin = 'start_pin: {
+            let mut it = pin_iter::row_iterator(list, opts.pin, Direction::LeftUp, None);
+            let mut it_prev: Pin = it.next().expect("self row"); // skip self
+
+            // First, check the current row for semantic boundaries before the clicked position.
+            if let Some(v) = semantic_prompt_state {
+                let cells = self.pin_row_cells(it_prev);
+                // Scan backwards from clicked position to find where our content starts
+                for i in 0..=usize::from(opts.pin.x) {
+                    let x_rev = usize::from(opts.pin.x) - i;
+                    if cells[x_rev].semantic_content() != v {
+                        let mut copy = it_prev;
+                        copy.x = (x_rev + 1) as u16;
+                        break 'start_pin copy;
+                    }
+                }
+
+                // No boundary found before clicked position on current row.
+                // If row doesn't wrap from above, start is at column 0.
+                // Otherwise, continue checking previous rows.
+            }
+
+            for p in it {
+                let row = self.pin_row(p);
+
+                if !row.wrap() {
+                    let mut copy = it_prev;
+                    copy.x = 0;
+                    break 'start_pin copy;
+                }
+
+                if let Some(v) = semantic_prompt_state {
+                    // We need to check every cell in this row in reverse
+                    // order since we're going up and back.
+                    let cells = self.pin_row_cells(p);
+                    for x in 0..cells.len() {
+                        let x_rev = cells.len() - 1 - x;
+                        let cell = cells[x_rev];
+                        if cell.semantic_content() != v {
+                            break 'start_pin it_prev;
+                        }
+                        it_prev = p;
+                        it_prev.x = x_rev as u16;
+                    }
+
+                    continue;
+                }
+
+                it_prev = p;
+            }
+
+            let mut copy = it_prev;
+            copy.x = 0;
+            copy
+        };
+
+        // The real end of the row is the final row in the soft-wrap.
+        let end_pin: Pin = 'end_pin: {
+            for p in pin_iter::row_iterator(list, opts.pin, Direction::RightDown, None) {
+                let row = self.pin_row(p);
+                let cols = self.pin_cols(p);
+
+                if let Some(v) = semantic_prompt_state {
+                    // We need to check every cell in this row
+                    let cells = self.pin_row_cells(p);
+
+                    // If this is our pin row we can start from our x because
+                    // the start_pin logic already found the real start.
+                    let start_offset = if p.node == opts.pin.node && p.y == opts.pin.y {
+                        usize::from(opts.pin.x)
+                    } else {
+                        0
+                    };
+
+                    // Handle the zero case specially because if the first
+                    // col doesn't match then we end at the end of the prior
+                    // row. But if this is the first row, we can't go back,
+                    // so we scan forward to find where our content ends.
+                    if start_offset == 0 && cells[0].semantic_content() != v {
+                        let mut prev = p.up(list, 1)?;
+                        prev.x = cols - 1;
+                        break 'end_pin prev;
+                    }
+
+                    // For every other case, we end at the prior cell.
+                    for (x, cell) in cells.iter().enumerate().skip(start_offset) {
+                        if cell.semantic_content() != v {
+                            let mut copy = p;
+                            copy.x = (x - 1) as u16;
+                            break 'end_pin copy;
+                        }
+                    }
+                }
+
+                if !row.wrap() {
+                    let mut copy = p;
+                    copy.x = cols - 1;
+                    break 'end_pin copy;
+                }
+            }
+
+            return None;
+        };
+
+        // Go forward from the start to find the first non-whitespace character.
+        let start: Pin = 'start: {
+            let Some(whitespace) = opts.whitespace else {
+                break 'start start_pin;
+            };
+            for p in pin_iter::cell_iterator(list, start_pin, Direction::RightDown, Some(end_pin)) {
+                let cell = self.pin_cell(p);
+                if !cell.has_text() {
+                    continue;
+                }
+
+                // Non-empty means we found it.
+                if is_ws(whitespace, cell.codepoint()) {
+                    continue;
+                }
+
+                break 'start p;
+            }
+
+            return None;
+        };
+
+        // Go backward from the end to find the first non-whitespace character.
+        let end: Pin = 'end: {
+            let Some(whitespace) = opts.whitespace else {
+                break 'end end_pin;
+            };
+            for p in pin_iter::cell_iterator(list, end_pin, Direction::LeftUp, Some(start_pin)) {
+                let cell = self.pin_cell(p);
+                if !cell.has_text() {
+                    continue;
+                }
+
+                // Non-empty means we found it.
+                if is_ws(whitespace, cell.codepoint()) {
+                    continue;
+                }
+
+                break 'end p;
+            }
+
+            return None;
+        };
+
+        Some(Selection::new(start, end, false))
+    }
+
+    /// Return the selection for all contents on the screen. Surrounding
+    /// whitespace is omitted. If there is no selection, this returns None.
+    pub fn select_all(&self) -> Option<Selection> {
+        let whitespace = DEFAULT_SELECT_WHITESPACE;
+        let screen = Point::Screen(Coordinate::default());
+
+        let start = self
+            .pages
+            .cell_iterator(Direction::RightDown, screen, None)
+            .find(|p| {
+                let cell = self.pin_cell(*p);
+                cell.has_text() && !is_ws(whitespace, cell.codepoint())
+            })?;
+
+        let end = self
+            .pages
+            .cell_iterator(Direction::LeftUp, screen, None)
+            .find(|p| {
+                let cell = self.pin_cell(*p);
+                cell.has_text() && !is_ws(whitespace, cell.codepoint())
+            })?;
+
+        Some(Selection::new(start, end, false))
+    }
+
+    /// Select the nearest word to start point that is between start_pt and
+    /// end_pt (inclusive). Because it selects "nearest" to start point, start
+    /// point can be before or after end point.
+    ///
+    /// The boundary_codepoints parameter should be a slice of codepoints that
+    /// mark word boundaries, passed through to select_word.
+    ///
+    /// TODO: test this
+    pub fn select_word_between(
+        &self,
+        start: Pin,
+        end: Pin,
+        boundary_codepoints: &[u32],
+    ) -> Option<Selection> {
+        let list = &self.pages;
+        let dir = if start.before(list, end) {
+            Direction::RightDown
+        } else {
+            Direction::LeftUp
+        };
+        for pin in pin_iter::cell_iterator(list, start, dir, Some(end)) {
+            // Boundary conditions
+            match dir {
+                Direction::RightDown => {
+                    if end.before(list, pin) {
+                        return None;
+                    }
+                }
+                Direction::LeftUp => {
+                    if pin.before(list, end) {
+                        return None;
+                    }
+                }
+            }
+
+            // If we found a word, then return it
+            if let Some(sel) = self.select_word(pin, boundary_codepoints) {
+                return Some(sel);
+            }
+        }
+
+        None
+    }
+
+    /// Select the word under the given point. A word is any consecutive series
+    /// of characters that are exclusively whitespace or exclusively non-whitespace.
+    /// A selection can span multiple physical lines if they are soft-wrapped.
+    ///
+    /// This will return None if a selection is impossible. The only scenario
+    /// this happens is if the point pt is outside of the written screen space.
+    ///
+    /// The boundary_codepoints parameter should be a slice of codepoints that
+    /// mark word boundaries. This is expected to be pre-parsed from the config.
+    pub fn select_word(&self, pin: Pin, boundary_codepoints: &[u32]) -> Option<Selection> {
+        let list = &self.pages;
+
+        // If our cell is empty we can't select a word, because we can't select
+        // areas where the screen is not yet written.
+        let start_cell = self.pin_cell(pin);
+        if !start_cell.has_text() {
+            return None;
+        }
+
+        // Determine if we are a boundary or not to determine what our boundary is.
+        let expect_boundary = is_ws(boundary_codepoints, start_cell.codepoint());
+
+        // Go forwards to find our end boundary
+        let end: Pin = 'end: {
+            let mut it = pin_iter::cell_iterator(list, pin, Direction::RightDown, None);
+            let mut prev = it.next().expect("start cell"); // Consume one, our start
+            for p in it {
+                let (row, cell) = {
+                    let (r, c) = p.row_and_cell(list).expect("valid pin");
+                    (*r, *c)
+                };
+
+                // If we reached an empty cell its always a boundary
+                if !cell.has_text() {
+                    break 'end prev;
+                }
+
+                // If we do not match our expected set, we hit a boundary
+                let this_boundary = is_ws(boundary_codepoints, cell.codepoint());
+                if this_boundary != expect_boundary {
+                    break 'end prev;
+                }
+
+                // If we are going to the next row and it isn't wrapped, we
+                // return the previous.
+                if p.x == self.pin_cols(p) - 1 && !row.wrap() {
+                    break 'end p;
+                }
+
+                prev = p;
+            }
+
+            prev
+        };
+
+        // Go backwards to find our start boundary
+        let start: Pin = 'start: {
+            let mut it = pin_iter::cell_iterator(list, pin, Direction::LeftUp, None);
+            let mut prev = it.next().expect("start cell"); // Consume one, our start
+            for p in it {
+                let (row, cell) = {
+                    let (r, c) = p.row_and_cell(list).expect("valid pin");
+                    (*r, *c)
+                };
+
+                // If we are going to the next row and it isn't wrapped, we
+                // return the previous.
+                if p.x == self.pin_cols(p) - 1 && !row.wrap() {
+                    break 'start prev;
+                }
+
+                // If we reached an empty cell its always a boundary
+                if !cell.has_text() {
+                    break 'start prev;
+                }
+
+                // If we do not match our expected set, we hit a boundary
+                let this_boundary = is_ws(boundary_codepoints, cell.codepoint());
+                if this_boundary != expect_boundary {
+                    break 'start prev;
+                }
+
+                prev = p;
+            }
+
+            prev
+        };
+
+        Some(Selection::new(start, end, false))
+    }
+
+    /// Select the command output under the given point. The limits of the output
+    /// are determined by semantic prompt information provided by shell integration.
+    /// A selection can span multiple physical lines if they are soft-wrapped.
+    ///
+    /// This will return None if a selection is impossible:
+    ///  - the point pt is outside of the written screen space.
+    ///  - the point pt is on a prompt / input line.
+    pub fn select_output(&self, pin: Pin) -> Option<Selection> {
+        let list = &self.pages;
+
+        // If our pin right now is not on output, then we return nothing.
+        if self.pin_cell(pin).semantic_content() != SemanticContent::Output {
+            return None;
+        }
+
+        // Get the post prior prompt from this pin. This is the prompt whose
+        // output we'll be capturing.
+        let prompt_pin: Pin = 'prompt: {
+            // If we have a prompt above this point (including this point),
+            // then thats the prompt we want to capture output from.
+            if let Some(p) = pin_iter::prompt_iterator(list, pin, Direction::LeftUp, None).next() {
+                break 'prompt p;
+            }
+
+            // If we don't have a prompt, then we assume that we're
+            // capturing all the output up to the next prompt.
+            let next = pin_iter::prompt_iterator(list, pin, Direction::RightDown, None).next()?;
+
+            // We'll capture from the start of the screen to just above
+            // the prompt and will trim the trailing whitespace.
+            let start_pin = self.pages.get_top_left(Tag::Screen)?;
+            let mut end_pin = next.up(list, 1)?;
+            end_pin.x = self.pin_cols(end_pin) - 1;
+            for p in pin_iter::cell_iterator(list, end_pin, Direction::LeftUp, Some(start_pin)) {
+                end_pin = p;
+                if self.pin_cell(p).has_text() {
+                    break;
+                }
+            }
+
+            return Some(Selection::new(start_pin, end_pin, false));
+        };
+
+        // Grab our content
+        let (hl_start, mut hl_end) = self
+            .pages
+            .highlight_semantic_content(prompt_pin, SemanticContent::Output)?;
+
+        // Trim our trailing whitespace
+        for p in pin_iter::cell_iterator(list, hl_end, Direction::LeftUp, Some(hl_start)) {
+            hl_end = p;
+            if self.pin_cell(p).has_text() {
+                break;
+            }
+        }
+
+        Some(Selection::new(hl_start, hl_end, false))
+    }
+
+    /// Returns an iterator to move through the soft-wrapped lines starting
+    /// from pin.
+    pub fn line_iterator(&self, start: Pin) -> LineIterator<'_> {
+        LineIterator {
+            screen: self,
+            current: Some(start),
+        }
+    }
+
+    /// Determine the inputs necessary to move the cursor to the given
+    /// click location within a prompt input area.
+    ///
+    /// If the cursor isn't currently at a prompt input location, this
+    /// returns no movement.
+    ///
+    /// This feature depends on well-behaved OSC133 shell integration. Specifically,
+    /// this only moves over designated input areas (OSC 133 B). It is assumed
+    /// that the shell will only move the cursor to input cells, so prompt cells
+    /// and other blank cells are ignored as part of the movement calculation.
+    pub fn prompt_click_move(&self, click_pin: Pin) -> PromptClickMove {
+        // If we're not at an input cell with our cursor, no movement will
+        // ever be possible.
+        if self.cursor.semantic_content != SemanticContent::Input
+            && self.cursor_cell().semantic_content() != SemanticContent::Input
+        {
+            return PromptClickMove::ZERO;
+        }
+
+        match self.semantic_prompt.click {
+            // None doesn't support movement and click_events must use a
+            // different mechanism (SGR mouse events) that callers must handle.
+            SemanticClick::None | SemanticClick::ClickEvents => PromptClickMove::ZERO,
+            SemanticClick::Cl(cl) => match cl {
+                // All of these currently use dumb line-based navigation.
+                // But eventually we'll support more.
+                Click::Line
+                | Click::Multiple
+                | Click::ConservativeVertical
+                | Click::SmartVertical => self.prompt_click_line(click_pin),
+            },
+        }
+    }
+
+    /// Determine the inputs required to move from the cursor to the given
+    /// click location. If the cursor isn't currently at a prompt input
+    /// location, this will return zero.
+    ///
+    /// This currently only supports moving a single line.
+    fn prompt_click_line(&self, click_pin: Pin) -> PromptClickMove {
+        let list = &self.pages;
+
+        // If our click pin is our cursor pin, no movement is needed.
+        // Do this early so we can assume later that they are different.
+        let cursor_pin = self.cursor_pin();
+        if cursor_pin.eql(click_pin) {
+            return PromptClickMove::ZERO;
+        }
+
+        // If our cursor is before our click, we're only emitting right inputs.
+        if cursor_pin.before(list, click_pin) {
+            let mut count: usize = 0;
+
+            // We go row-by-row because soft-wrapped rows are still a single
+            // line to a shell, so we can't just look at our page row.
+            'row_it: for row_pin in
+                pin_iter::row_iterator(list, cursor_pin, Direction::RightDown, Some(click_pin))
+            {
+                let row = self.pin_row(row_pin);
+                let cells = self.pin_row_cells(row_pin);
+
+                // Determine if this row is our cursor.
+                let is_cursor_row = row_pin.node == cursor_pin.node && row_pin.y == cursor_pin.y;
+
+                // If this is not the cursor row, verify it's still part of the
+                // continuation of our starting prompt.
+                if !is_cursor_row && row.semantic_prompt() != RowPrompt::PromptContinuation {
+                    break;
+                }
+
+                // Determine where our input starts.
+                let start_x: usize = 'start_x: {
+                    // If this is our cursor row then we start after the cursor.
+                    if is_cursor_row {
+                        break 'start_x usize::from(cursor_pin.x) + 1;
+                    }
+
+                    // Otherwise, we start at the first input cell, because
+                    // we expect the shell to properly translate arrows across
+                    // lines to the start of the input. Some shells indent
+                    // where input starts on subsequent lines so we must do
+                    // this.
+                    for (x, cell) in cells.iter().enumerate() {
+                        if cell.semantic_content() == SemanticContent::Input {
+                            break 'start_x x;
+                        }
+                    }
+
+                    // We never found an input cell, so we need to move to the
+                    // next row.
+                    cells.len()
+                };
+
+                // Iterate over the input cells and assume arrow keys only
+                // jump to input cells.
+                for (x, cell) in cells.iter().enumerate().skip(start_x) {
+                    // Ignore non-input cells, but allow breaks. We assume
+                    // the shell will translate arrow keys to only input
+                    // areas.
+                    if cell.semantic_content() != SemanticContent::Input {
+                        continue;
+                    }
+
+                    // Increment our input count
+                    count += 1;
+
+                    // If this is our target, we're done.
+                    if row_pin.node == click_pin.node
+                        && row_pin.y == click_pin.y
+                        && x == usize::from(click_pin.x)
+                    {
+                        break 'row_it;
+                    }
+                }
+
+                // If this row isn't soft-wrapped, we need to break out
+                // because line based moving only handles single lines.
+                // We're done!
+                if !row.wrap() {
+                    // If we never found our pin, that means we clicked further
+                    // right/beyond it. If we're already on a non-empty input cell
+                    // then we add one so we can move to the newest, empty cell
+                    // at the end, matching typical editor behavior.
+                    if self.cursor_cell().semantic_content() == SemanticContent::Input {
+                        count += 1;
+                    }
+
+                    break;
+                }
+            }
+
+            return PromptClickMove {
+                left: 0,
+                right: count,
+            };
+        }
+
+        // Otherwise, cursor is after click, so we're emitting left inputs.
+        let mut count: usize = 0;
+
+        // We go row-by-row because soft-wrapped rows are still a single
+        // line to a shell, so we can't just look at our page row.
+        'row_it: for row_pin in
+            pin_iter::row_iterator(list, cursor_pin, Direction::LeftUp, Some(click_pin))
+        {
+            let row = self.pin_row(row_pin);
+            let cells = self.pin_row_cells(row_pin);
+
+            // Determine the length of the cells we look at in this row.
+            let end_len: usize =
+                // If this is our cursor row then we end before the cursor.
+                if row_pin.node == cursor_pin.node && row_pin.y == cursor_pin.y {
+                    usize::from(cursor_pin.x)
+                } else {
+                    // Otherwise, we end at the last cell in the row.
+                    cells.len()
+                };
+
+            // Iterate backwards over the input cells.
+            for rev_x in 0..end_len {
+                let x = end_len - 1 - rev_x;
+                let cell = cells[x];
+
+                // Ignore non-input cells.
+                if cell.semantic_content() != SemanticContent::Input {
+                    continue;
+                }
+
+                // Increment our input count
+                count += 1;
+
+                // If this is our target, we're done.
+                if row_pin.node == click_pin.node
+                    && row_pin.y == click_pin.y
+                    && x == usize::from(click_pin.x)
+                {
+                    break 'row_it;
+                }
+            }
+
+            // If this row is not a wrap continuation, then break out
+            if !row.wrap_continuation() {
+                break;
+            }
+        }
+
+        PromptClickMove {
+            left: count,
+            right: 0,
+        }
+    }
+
+    /// Dump the screen to a string.
+    pub fn dump_string(&self, out: &mut String, opts: DumpString) {
+        // TODO(integration): delegate to formatter::ScreenFormatter (plain,
+        // unwrap = opts.unwrap, trim = false, content = selection(tl, br)).
+        let br = opts
+            .br
+            .unwrap_or_else(|| self.pages.get_bottom_right(Tag::Screen).expect("screen"));
+        let sel = Selection::new(opts.tl, br, false);
+        let tl = sel.top_left(&self.pages);
+        let br = sel.bottom_right(&self.pages);
+        out.push_str(&plain_format(
+            &self.pages,
+            tl,
+            br,
+            false,
+            opts.unwrap,
+            false,
+            None,
+        ));
+    }
+
+    /// You should use dump_string, this is a restricted version mostly for
+    /// legacy and convenience reasons for unit tests.
+    pub fn dump_string_alloc(&self, tl: Point) -> Result<String, Error> {
+        let mut out = String::new();
+        self.dump_string(
+            &mut out,
+            DumpString {
+                tl: self
+                    .pages
+                    .get_top_left(tl.tag())
+                    .ok_or(Error::InvalidCoordinate)?,
+                br: Some(
+                    self.pages
+                        .get_bottom_right(tl.tag())
+                        .ok_or(Error::InvalidCoordinate)?,
+                ),
+                unwrap: false,
+            },
+        );
+        Ok(out)
+    }
+
+    /// You should use dump_string, this is a restricted version mostly for
+    /// legacy and convenience reasons for unit tests.
+    pub fn dump_string_alloc_unwrapped(&self, tl: Point) -> Result<String, Error> {
+        let mut out = String::new();
+        self.dump_string(
+            &mut out,
+            DumpString {
+                tl: self
+                    .pages
+                    .get_top_left(tl.tag())
+                    .ok_or(Error::InvalidCoordinate)?,
+                br: Some(
+                    self.pages
+                        .get_bottom_right(tl.tag())
+                        .ok_or(Error::InvalidCoordinate)?,
+                ),
+                unwrap: true,
+            },
+        );
+        Ok(out)
+    }
+
+    /// This is basically a really jank version of Terminal.printString. We
+    /// have to reimplement it here because we want a way to print to the screen
+    /// to test it but don't want all the features of Terminal.
+    pub fn test_write_string(&mut self, text: &str) -> Result<(), Error> {
+        for c in text.chars() {
+            let c = c as u32;
+
+            // Explicit newline forces a new row
+            if c == u32::from('\n') {
+                self.cursor_down_or_scroll()?;
+                self.cursor_horizontal_absolute(0);
+                self.cursor.pending_wrap = false;
+                if self.cursor.semantic_content_clear_eol {
+                    self.cursor_set_semantic_content(SemanticContentSet::Output);
+                } else {
+                    match self.cursor.semantic_content {
+                        SemanticContent::Output => {}
+                        SemanticContent::Prompt | SemanticContent::Input => {
+                            self.cursor_row_mut()
+                                .set_semantic_prompt(RowPrompt::PromptContinuation);
+                        }
+                    }
+                }
+                continue;
+            }
+
+            let width: usize = if c <= 0xFF {
+                1
+            } else {
+                usize::from(ghostty_unicode::table().get(c).width)
+            };
+            if width == 0 {
+                let mut x = self.cursor.x - 1;
+                match self.cursor_cell_left(1).wide() {
+                    Wide::Narrow | Wide::Wide => {}
+                    Wide::SpacerHead => unreachable!(),
+                    Wide::SpacerTail => x = self.cursor.x - 2,
+                }
+
+                let p = self.cursor_pin();
+                self.page_mut(p.node)
+                    .append_grapheme(usize::from(x), usize::from(p.y), c)?;
+                continue;
+            }
+
+            if self.cursor.pending_wrap {
+                assert!(self.cursor.x == self.pages.cols - 1);
+                self.cursor.pending_wrap = false;
+                self.cursor_row_mut().set_wrap(true);
+                self.cursor_down_or_scroll()?;
+                self.cursor_horizontal_absolute(0);
+                self.cursor_row_mut().set_wrap_continuation(true);
+                match self.cursor.semantic_content {
+                    SemanticContent::Output => {}
+                    SemanticContent::Input | SemanticContent::Prompt => {
+                        self.cursor_row_mut()
+                            .set_semantic_prompt(RowPrompt::PromptContinuation);
+                    }
+                }
+            }
+
+            assert!(width == 1 || width == 2);
+            match width {
+                1 => {
+                    let mut cell = Cell::default();
+                    cell.set_content_tag(ContentTag::Codepoint);
+                    cell.set_codepoint(c);
+                    cell.set_style_id(self.cursor.style_id);
+                    cell.set_protected(self.cursor.protected);
+                    cell.set_semantic_content(self.cursor.semantic_content);
+                    *self.cursor_cell_mut() = cell;
+
+                    // If we have a ref-counted style, increase.
+                    if self.cursor.style_id != style::DEFAULT_ID {
+                        let id = self.cursor.style_id;
+                        let _ = self.cursor_page_mut().styles.r#use(id);
+                        self.cursor_row_mut().set_styled(true);
+                    }
+
+                    // If we have a hyperlink, add it to the cell.
+                    if self.cursor.hyperlink_id > 0 {
+                        self.cursor_set_hyperlink()?;
+                    }
+                }
+
+                2 => {
+                    // Need a wide spacer head
+                    if self.cursor.x == self.pages.cols - 1 {
+                        let mut cell = Cell::default();
+                        cell.set_content_tag(ContentTag::Codepoint);
+                        cell.set_codepoint(0);
+                        cell.set_wide(Wide::SpacerHead);
+                        cell.set_protected(self.cursor.protected);
+                        cell.set_semantic_content(self.cursor.semantic_content);
+                        *self.cursor_cell_mut() = cell;
+
+                        // If we have a hyperlink, add it to the cell.
+                        if self.cursor.hyperlink_id > 0 {
+                            self.cursor_set_hyperlink()?;
+                        }
+
+                        self.cursor_row_mut().set_wrap(true);
+                        self.cursor_down_or_scroll()?;
+                        self.cursor_horizontal_absolute(0);
+                        self.cursor_row_mut().set_wrap_continuation(true);
+                    }
+
+                    // Write our wide char
+                    let mut cell = Cell::default();
+                    cell.set_content_tag(ContentTag::Codepoint);
+                    cell.set_codepoint(c);
+                    cell.set_style_id(self.cursor.style_id);
+                    cell.set_wide(Wide::Wide);
+                    cell.set_protected(self.cursor.protected);
+                    cell.set_semantic_content(self.cursor.semantic_content);
+                    *self.cursor_cell_mut() = cell;
+
+                    // If we have a hyperlink, add it to the cell.
+                    if self.cursor.hyperlink_id > 0 {
+                        self.cursor_set_hyperlink()?;
+                    }
+
+                    // Write our tail
+                    self.cursor_right(1);
+                    let mut cell = Cell::default();
+                    cell.set_content_tag(ContentTag::Codepoint);
+                    cell.set_codepoint(0);
+                    cell.set_wide(Wide::SpacerTail);
+                    cell.set_protected(self.cursor.protected);
+                    cell.set_semantic_content(self.cursor.semantic_content);
+                    *self.cursor_cell_mut() = cell;
+
+                    // If we have a hyperlink, add it to the cell.
+                    if self.cursor.hyperlink_id > 0 {
+                        self.cursor_set_hyperlink()?;
+                    }
+
+                    // If we have a ref-counted style, increase twice.
+                    if self.cursor.style_id != style::DEFAULT_ID {
+                        let id = self.cursor.style_id;
+                        let _ = self.cursor_page_mut().styles.r#use(id);
+                        let _ = self.cursor_page_mut().styles.r#use(id);
+                        self.cursor_row_mut().set_styled(true);
+                    }
+                }
+
+                _ => unreachable!(),
+            }
+
+            if self.cursor.x + 1 < self.pages.cols {
+                self.cursor_right(1);
+            } else {
+                self.cursor.pending_wrap = true;
+            }
+        }
+        Ok(())
+    }
+}
+
+/// An iterator over the soft-wrapped lines of a screen.
+pub struct LineIterator<'a> {
+    screen: &'a Screen,
+    current: Option<Pin>,
+}
+
+impl Iterator for LineIterator<'_> {
+    type Item = Selection;
+
+    fn next(&mut self) -> Option<Selection> {
+        let current = self.current?;
+        let Some(result) = self.screen.select_line(SelectLine {
+            pin: current,
+            whitespace: None,
+            semantic_prompt_boundary: false,
+        }) else {
+            self.current = None;
+            return None;
+        };
+
+        self.current = result.end(&self.screen.pages).down(&self.screen.pages, 1);
+        Some(result)
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Minimal plain-text formatter.
+//
+// TODO(integration): this is a minimal port of the `emit = .plain` paths of
+// formatter.zig's PageListFormatter/PageFormatter (unwrapping soft-wrapped
+// lines, trimming trailing whitespace, trailing blank lines are dropped).
+// Replace with the real formatter once ported.
+// ---------------------------------------------------------------------------
+
+/// Trailing state carried between pages (formatter.zig `TrailingState`).
+#[derive(Clone, Copy, Default)]
+struct TrailingState {
+    rows: usize,
+    cells: usize,
+}
+
+fn write_codepoint(
+    out: &mut String,
+    cp: u32,
+    map: &mut Option<&mut Vec<(u16, u16)>>,
+    x: u16,
+    y: u16,
+) {
+    let ch = char::from_u32(cp).unwrap_or(char::REPLACEMENT_CHARACTER);
+    let before = out.len();
+    out.push(ch);
+    if let Some(map) = map {
+        for _ in before..out.len() {
+            map.push((x, y));
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn plain_format_page(
+    page: &Page,
+    out: &mut String,
+    start_x: u16,
+    start_y: u16,
+    end_x: Option<u16>,
+    end_y: Option<u16>,
+    rectangle: bool,
+    unwrap: bool,
+    trim: bool,
+    trailing_state: Option<TrailingState>,
+    mut point_map: Option<&mut Vec<(u16, u16)>>,
+) -> TrailingState {
+    let mut blank_rows: usize = 0;
+    let mut blank_cells: usize = 0;
+
+    // Continue our prior trailing state if we have it, but only if we're
+    // starting from the beginning (start_y and start_x are both 0).
+    // If a non-zero start position is specified, ignore trailing state.
+    if let Some(state) = trailing_state
+        && start_y == 0
+        && start_x == 0
+    {
+        blank_rows = state.rows;
+        blank_cells = state.cells;
+    }
+    let ret = |blank_rows, blank_cells| TrailingState {
+        rows: blank_rows,
+        cells: blank_cells,
+    };
+
+    // Setup our starting column and perform some validation for overflows.
+    if start_x >= page.size.cols {
+        return ret(blank_rows, blank_cells);
+    }
+    let end_x_unclamped = end_x.unwrap_or(page.size.cols - 1);
+    let mut end_x = end_x_unclamped.min(page.size.cols - 1);
+
+    // Setup our starting row and perform some validation for overflows.
+    if start_y >= page.size.rows {
+        return ret(blank_rows, blank_cells);
+    }
+    let end_y_unclamped = end_y.unwrap_or(page.size.rows - 1);
+    if start_y > end_y_unclamped {
+        return ret(blank_rows, blank_cells);
+    }
+    let mut end_y = end_y_unclamped.min(page.size.rows - 1);
+
+    // Edge case: if our end x/y falls on a spacer head AND we're unwrapping,
+    // then we move the x/y to the start of the next row (if available).
+    if unwrap && !rectangle {
+        let cells = page.get_cells(usize::from(end_y)).expect("row");
+        if cells[usize::from(end_x)].wide() == Wide::SpacerHead && end_y < page.size.rows - 1 {
+            end_y += 1;
+            end_x = 0;
+        }
+    }
+
+    // If we only have a single row, validate that start_x <= end_x
+    if start_y == end_y && start_x > end_x {
+        return ret(blank_rows, blank_cells);
+    }
+
+    for y in start_y..=end_y {
+        let row = *page.get_row(usize::from(y)).expect("row");
+        let cells = page.get_cells(usize::from(y)).expect("row cells");
+        let base = row.cells();
+
+        // Determine the x range for this row
+        // - First row: start_x to end of row (or end_x if single row)
+        // - Last row: start of row to end_x
+        // - Middle rows: full width
+        let row_end_x: u16 = if rectangle || y == end_y {
+            end_x + 1
+        } else {
+            page.size.cols
+        };
+
+        // The first we have to check if our start X falls on the
+        // tail of a wide character.
+        let row_start_x: u16 = if start_x > 0 && (rectangle || y == start_y) {
+            match cells[usize::from(start_x)].wide() {
+                // Include the prior cell to get the full wide char
+                Wide::SpacerTail => start_x - 1,
+
+                // If we're a spacer head on our first row then we
+                // skip this whole row.
+                Wide::SpacerHead => continue,
+
+                Wide::Narrow | Wide::Wide => start_x,
+            }
+        } else {
+            0
+        };
+
+        let subset = &cells[usize::from(row_start_x)..usize::from(row_end_x)];
+
+        // If this row is blank, accumulate to avoid a bunch of extra
+        // work later. If it isn't blank, make sure we dump all our
+        // blanks.
+        if !Cell::has_text_any(subset) {
+            blank_rows += 1;
+            continue;
+        }
+
+        if blank_rows > 0 {
+            for _ in 0..blank_rows {
+                out.push('\n');
+            }
+
+            // \r and \n map to the row that ends with this newline.
+            // If we're continuing (trailing state) then this will be
+            // in a prior page, so we just map to the first row of this
+            // page.
+            if let Some(map) = point_map.as_deref_mut() {
+                let start = map.last().copied().unwrap_or((0, 0));
+
+                // The first one inherits the x value.
+                map.push(start);
+
+                // All others have x = 0 since they reference their prior
+                // blank line.
+                for y_offset in 1..blank_rows {
+                    map.push((0, start.1 + y_offset as u16));
+                }
+            }
+
+            blank_rows = 0;
+        }
+
+        // If we're not wrapped, we always add a newline so after
+        // the row is printed we can add a newline.
+        if !row.wrap() || !unwrap {
+            blank_rows += 1;
+        }
+
+        // If the row doesn't continue a wrap then we need to reset
+        // our blank cell count.
+        if !row.wrap_continuation() || !unwrap {
+            blank_cells = 0;
+        }
+
+        // Go through each cell and print it
+        for (offset, cell) in subset.iter().enumerate() {
+            let x = row_start_x + offset as u16;
+
+            // Skip spacers. These happen naturally when wide characters
+            // are printed again on the screen (for well-behaved terminals!)
+            match cell.wide() {
+                Wide::Narrow | Wide::Wide => {}
+                Wide::SpacerHead | Wide::SpacerTail => continue,
+            }
+
+            // If we have a zero value, then we accumulate a counter. We
+            // only want to turn zero values into spaces if we have a non-zero
+            // char sometime later.
+            // Cells with no text are blank
+            if !cell.has_text() {
+                blank_cells += 1;
+                continue;
+            }
+
+            // Trailing spaces are blank. We know it is trailing
+            // because if we get a non-empty cell later we'll
+            // fill the blanks.
+            if cell.codepoint() == u32::from(' ') && trim {
+                blank_cells += 1;
+                continue;
+            }
+
+            // This cell is not blank. If we have accumulated blank cells
+            // then we want to emit them now.
+            if blank_cells > 0 {
+                for _ in 0..blank_cells {
+                    out.push(' ');
+                }
+
+                if let Some(map) = point_map.as_deref_mut() {
+                    // Map each blank cell to its coordinate. Blank cells can span
+                    // multiple rows if they carry over from wrap continuation.
+                    let mut remaining_blanks = blank_cells;
+                    let mut blank_x = x;
+                    let mut blank_y = y;
+                    while remaining_blanks > 0 {
+                        if blank_x > 0 {
+                            // We have space in this row
+                            blank_x -= 1;
+                        } else if blank_y > 0 {
+                            // Wrap to previous row
+                            blank_y -= 1;
+                            blank_x = page.size.cols - 1;
+                        } else {
+                            // Can't go back further, just use (0, 0)
+                            blank_x = 0;
+                            blank_y = 0;
+                        }
+
+                        map.push((blank_x, blank_y));
+                        remaining_blanks -= 1;
+                    }
+                }
+
+                blank_cells = 0;
+            }
+
+            write_codepoint(out, cell.codepoint(), &mut point_map, x, y);
+            if cell.content_tag() == ContentTag::CodepointGrapheme
+                && let Some(extra) = page.lookup_grapheme(base + usize::from(x))
+            {
+                for &cp in extra {
+                    write_codepoint(out, cp, &mut point_map, x, y);
+                }
+            }
+        }
+    }
+
+    ret(blank_rows, blank_cells)
+}
+
+/// Plain-text format of the pages between `tl` and `br` (both inclusive,
+/// properly ordered).
+fn plain_format(
+    list: &PageList,
+    tl: Pin,
+    br: Pin,
+    rectangle: bool,
+    unwrap: bool,
+    trim: bool,
+    mut pin_map: Option<&mut Vec<Pin>>,
+) -> String {
+    let mut out = String::new();
+    let mut page_state: Option<TrailingState> = None;
+    let mut point_map: Vec<(u16, u16)> = Vec::new();
+
+    let mut node = Some(tl.node);
+    while let Some(id) = node {
+        let n = list.node(id).expect("live node");
+        let chunk_start = if id == tl.node { tl.y } else { 0 };
+        let chunk_end = if id == br.node {
+            br.y + 1
+        } else {
+            n.data.size.rows
+        };
+        debug_assert!(chunk_start < chunk_end);
+
+        let (start_x, end_x) = if rectangle {
+            // For rectangle selection, apply start_x and end_x to all chunks
+            (tl.x, Some(br.x))
+        } else {
+            // Otherwise only on the first/last, respectively.
+            (
+                if id == tl.node { tl.x } else { 0 },
+                if id == br.node { Some(br.x) } else { None },
+            )
+        };
+
+        point_map.clear();
+        page_state = Some(plain_format_page(
+            &n.data,
+            &mut out,
+            start_x,
+            chunk_start,
+            end_x,
+            Some(chunk_end - 1),
+            rectangle,
+            unwrap,
+            trim,
+            page_state,
+            if pin_map.is_some() {
+                Some(&mut point_map)
+            } else {
+                None
+            },
+        ));
+
+        if let Some(m) = pin_map.as_deref_mut() {
+            for &(x, y) in &point_map {
+                m.push(Pin {
+                    node: id,
+                    x,
+                    y,
+                    garbage: false,
+                });
+            }
+        }
+
+        if id == br.node {
+            break;
+        }
+        node = n.next;
+    }
+
+    out
+}
+
+#[cfg(test)]
+mod tests;

crates/ghostty-terminal/src/screen/tests/mod.rs

@@ -0,0 +1,61 @@
+//! Ported Screen.zig tests. Shared helpers live here; the tests themselves
+//! are split over `p*.rs` files in the order they appear in Screen.zig.
+#![allow(
+    clippy::manual_assert_eq,
+    clippy::unwrap_used,
+    clippy::too_many_lines,
+    dead_code
+)]
+
+pub(super) use super::*;
+pub(super) use crate::point::Coordinate;
+
+mod p1;
+mod p2;
+mod p3;
+mod p4;
+mod p5;
+
+/// `Screen.init(alloc, .{ .cols, .rows, .max_scrollback })`
+pub(super) fn init(cols: u16, rows: u16, max_scrollback: usize) -> Screen {
+    Screen::new(Options::new(cols, rows, max_scrollback)).unwrap()
+}
+
+/// Point constructors with the Zig `.{ .tag = .{ .x, .y } }` shape.
+pub(super) fn active(x: u16, y: u32) -> Point {
+    Point::Active(Coordinate { x, y })
+}
+pub(super) fn screen_pt(x: u16, y: u32) -> Point {
+    Point::Screen(Coordinate { x, y })
+}
+pub(super) fn history(x: u16, y: u32) -> Point {
+    Point::History(Coordinate { x, y })
+}
+pub(super) fn viewport(x: u16, y: u32) -> Point {
+    Point::Viewport(Coordinate { x, y })
+}
+
+/// `s.dumpStringAlloc(alloc, tl)`
+pub(super) fn dump(s: &Screen, tl: Point) -> String {
+    s.dump_string_alloc(tl).unwrap()
+}
+
+/// `s.dumpStringAllocUnwrapped(alloc, tl)`
+pub(super) fn dump_unwrapped(s: &Screen, tl: Point) -> String {
+    s.dump_string_alloc_unwrapped(tl).unwrap()
+}
+
+/// `s.pages.pin(pt).?`
+pub(super) fn pin(s: &Screen, pt: Point) -> Pin {
+    s.pages.pin(pt).unwrap()
+}
+
+/// `s.pages.pointFromPin(tag, pin).?`
+pub(super) fn pt_from_pin(s: &Screen, tag: Tag, p: Pin) -> Point {
+    s.pages.point_from_pin(tag, p).unwrap()
+}
+
+/// The page at the cursor.
+pub(super) fn cursor_page(s: &Screen) -> &Page {
+    s.cursor_page()
+}

crates/ghostty-terminal/src/screen/tests/p1.rs

@@ -0,0 +1,438 @@
+use super::*;
+use ghostty_vt::sgr::Attribute as A;
+
+#[test]
+fn screen_read_and_write() {
+    let mut s = init(80, 24, 1000);
+    assert_eq!(0, s.cursor.style_id);
+
+    s.test_write_string("hello, world").unwrap();
+    let str = dump(&s, screen_pt(0, 0));
+    assert_eq!("hello, world", str);
+}
+
+#[test]
+fn screen_read_and_write_newline() {
+    let mut s = init(80, 24, 1000);
+    assert_eq!(0, s.cursor.style_id);
+
+    s.test_write_string("hello\nworld").unwrap();
+    let str = dump(&s, screen_pt(0, 0));
+    assert_eq!("hello\nworld", str);
+}
+
+#[test]
+fn screen_read_and_write_scrollback() {
+    let mut s = init(80, 2, 1000);
+
+    s.test_write_string("hello\nworld\ntest").unwrap();
+    assert_eq!("hello\nworld\ntest", dump(&s, screen_pt(0, 0)));
+    assert_eq!("world\ntest", dump(&s, active(0, 0)));
+}
+
+#[test]
+fn screen_read_and_write_no_scrollback_small() {
+    let mut s = init(80, 2, 0);
+
+    s.test_write_string("hello\nworld\ntest").unwrap();
+    assert_eq!("world\ntest", dump(&s, screen_pt(0, 0)));
+    assert_eq!("world\ntest", dump(&s, active(0, 0)));
+}
+
+#[test]
+fn screen_read_and_write_no_scrollback_large() {
+    let mut s = init(80, 2, 0);
+
+    for i in 0..1_000 {
+        s.test_write_string(&format!("{i}\n")).unwrap();
+    }
+    s.test_write_string("1000").unwrap();
+
+    assert_eq!("999\n1000", dump(&s, screen_pt(0, 0)));
+}
+
+#[test]
+fn screen_cursor_copy_x_y() {
+    let mut s = init(10, 10, 0);
+    s.cursor_absolute(2, 3);
+    assert!(s.cursor.x == 2);
+    assert!(s.cursor.y == 3);
+
+    let mut s2 = init(10, 10, 0);
+    s2.cursor_copy(&s.cursor, true).unwrap();
+    assert!(s2.cursor.x == 2);
+    assert!(s2.cursor.y == 3);
+    s2.test_write_string("Hello").unwrap();
+
+    assert_eq!("\n\n\n  Hello", dump(&s2, screen_pt(0, 0)));
+}
+
+#[test]
+fn screen_cursor_copy_style_deref() {
+    let s = init(10, 10, 0);
+
+    let mut s2 = init(10, 10, 0);
+    let page = s2.cursor_pin().node;
+
+    // Bold should create our style
+    s2.set_attribute(A::Bold).unwrap();
+    assert_eq!(1, s2.page(page).styles.count());
+    assert!(s2.cursor.style.flags.bold);
+
+    // Copy default style, should release our style
+    s2.cursor_copy(&s.cursor, true).unwrap();
+    assert!(!s2.cursor.style.flags.bold);
+    assert_eq!(0, s2.page(page).styles.count());
+}
+
+/// Builds the two-page setup shared by the "new page" cursorCopy tests.
+fn cursor_on_second_page() -> Screen {
+    let mut s2 = init(10, 10, 2048);
+
+    // We need to get the cursor on a new page.
+    let first = s2.pages.first.unwrap();
+    let first_page_size = s2.page(first).capacity.rows;
+
+    // Fill the scrollback with blank lines until
+    // there are only 5 rows left on the first page.
+    s2.page_mut(first).pause_integrity_checks(true);
+    for _ in 0..first_page_size - 5 {
+        s2.test_write_string("\n").unwrap();
+    }
+    s2.page_mut(first).pause_integrity_checks(false);
+
+    s2.test_write_string("1\n2\n3\n4\n5\n6\n7\n8\n9\n10")
+        .unwrap();
+
+    // s2.pages.diagram(...):
+    //
+    //      +----------+ = PAGE 0
+    //  ... :          :
+    //     +-------------+ ACTIVE
+    // 4300 |1         | | 0
+    // 4301 |2         | | 1
+    // 4302 |3         | | 2
+    // 4303 |4         | | 3
+    // 4304 |5         | | 4
+    //      +----------+ :
+    //      +----------+ : = PAGE 1
+    //    0 |6         | | 5
+    //    1 |7         | | 6
+    //    2 |8         | | 7
+    //    3 |9         | | 8
+    //    4 |10        | | 9
+    //      :  ^       : : = PIN 0
+    //      +----------+ :
+    //     +-------------+
+    s2
+}
+
+#[test]
+fn screen_cursor_copy_style_deref_new_page() {
+    let s = init(10, 10, 0);
+    let mut s2 = cursor_on_second_page();
+
+    // This should be PAGE 1
+    let page = s2.cursor_pin().node;
+
+    // It should be the last page in the list.
+    assert_eq!(Some(page), s2.pages.last);
+    // It should have a previous page.
+    assert!(s2.pages.node(page).unwrap().prev.is_some());
+
+    // The cursor should be at 2, 9
+    assert!(s2.cursor.x == 2);
+    assert!(s2.cursor.y == 9);
+
+    // Bold should create our style in page 1.
+    s2.set_attribute(A::Bold).unwrap();
+    assert_eq!(1, s2.page(page).styles.count());
+    assert!(s2.cursor.style.flags.bold);
+
+    // Copy the cursor for the first screen. This should release
+    // the style from page 1 and move the cursor back to page 0.
+    s2.cursor_copy(&s.cursor, true).unwrap();
+    assert!(!s2.cursor.style.flags.bold);
+    assert_eq!(0, s2.page(page).styles.count());
+    // The page after the page the cursor is now in should be page 1.
+    assert_eq!(
+        Some(page),
+        s2.pages.node(s2.cursor_pin().node).unwrap().next
+    );
+    // The cursor should be at 0, 0
+    assert!(s2.cursor.x == 0);
+    assert!(s2.cursor.y == 0);
+}
+
+#[test]
+fn screen_cursor_copy_style_copy() {
+    let mut s = init(10, 10, 0);
+    s.set_attribute(A::Bold).unwrap();
+
+    let mut s2 = init(10, 10, 0);
+    let page = s2.cursor_pin().node;
+    s2.cursor_copy(&s.cursor, true).unwrap();
+    assert!(s2.cursor.style.flags.bold);
+    assert_eq!(1, s2.page(page).styles.count());
+}
+
+#[test]
+fn screen_cursor_copy_hyperlink_deref() {
+    let s = init(10, 10, 0);
+
+    let mut s2 = init(10, 10, 0);
+    let page = s2.cursor_pin().node;
+
+    // Create a hyperlink for the cursor.
+    s2.start_hyperlink(b"https://example.com/", None).unwrap();
+    assert_eq!(1, s2.page(page).hyperlink_set.count());
+    assert!(s2.cursor.hyperlink_id != 0);
+
+    // Copy a cursor with no hyperlink, should release our hyperlink.
+    s2.cursor_copy(&s.cursor, true).unwrap();
+    assert_eq!(0, s2.page(page).hyperlink_set.count());
+    assert!(s2.cursor.hyperlink_id == 0);
+}
+
+#[test]
+fn screen_cursor_copy_hyperlink_deref_new_page() {
+    let s = init(10, 10, 0);
+    let mut s2 = cursor_on_second_page();
+
+    // This should be PAGE 1
+    let page = s2.cursor_pin().node;
+
+    // It should be the last page in the list.
+    assert_eq!(Some(page), s2.pages.last);
+    // It should have a previous page.
+    assert!(s2.pages.node(page).unwrap().prev.is_some());
+
+    // The cursor should be at 2, 9
+    assert!(s2.cursor.x == 2);
+    assert!(s2.cursor.y == 9);
+
+    // Create a hyperlink for the cursor, should be in page 1.
+    s2.start_hyperlink(b"https://example.com/", None).unwrap();
+    assert_eq!(1, s2.page(page).hyperlink_set.count());
+    assert!(s2.cursor.hyperlink_id != 0);
+
+    // Copy the cursor for the first screen. This should release
+    // the hyperlink from page 1 and move the cursor back to page 0.
+    s2.cursor_copy(&s.cursor, true).unwrap();
+    assert_eq!(0, s2.page(page).hyperlink_set.count());
+    assert!(s2.cursor.hyperlink_id == 0);
+    // The page after the page the cursor is now in should be page 1.
+    assert_eq!(
+        Some(page),
+        s2.pages.node(s2.cursor_pin().node).unwrap().next
+    );
+    // The cursor should be at 0, 0
+    assert!(s2.cursor.x == 0);
+    assert!(s2.cursor.y == 0);
+}
+
+#[test]
+fn screen_cursor_copy_hyperlink_copy() {
+    let mut s = init(10, 10, 0);
+
+    // Create a hyperlink for the cursor.
+    s.start_hyperlink(b"https://example.com/", None).unwrap();
+    assert_eq!(1, s.cursor_page().hyperlink_set.count());
+    assert!(s.cursor.hyperlink_id != 0);
+
+    let mut s2 = init(10, 10, 0);
+    let page = s2.cursor_pin().node;
+
+    assert_eq!(0, s2.page(page).hyperlink_set.count());
+    assert!(s2.cursor.hyperlink_id == 0);
+
+    // Copy the cursor with the hyperlink.
+    s2.cursor_copy(&s.cursor, true).unwrap();
+    assert_eq!(1, s2.page(page).hyperlink_set.count());
+    assert!(s2.cursor.hyperlink_id != 0);
+}
+
+#[test]
+fn screen_cursor_copy_hyperlink_copy_disabled() {
+    let mut s = init(10, 10, 0);
+
+    // Create a hyperlink for the cursor.
+    s.start_hyperlink(b"https://example.com/", None).unwrap();
+    assert_eq!(1, s.cursor_page().hyperlink_set.count());
+    assert!(s.cursor.hyperlink_id != 0);
+
+    let mut s2 = init(10, 10, 0);
+    let page = s2.cursor_pin().node;
+
+    assert_eq!(0, s2.page(page).hyperlink_set.count());
+    assert!(s2.cursor.hyperlink_id == 0);
+
+    // Copy the cursor with the hyperlink.
+    s2.cursor_copy(&s.cursor, false).unwrap();
+    assert_eq!(0, s2.page(page).hyperlink_set.count());
+    assert!(s2.cursor.hyperlink_id == 0);
+}
+
+#[test]
+fn screen_style_basics() {
+    let mut s = init(80, 24, 1000);
+    let page = s.cursor_pin().node;
+    assert_eq!(0, s.page(page).styles.count());
+
+    // Set a new style
+    s.set_attribute(A::Bold).unwrap();
+    assert!(s.cursor.style_id != 0);
+    assert_eq!(1, s.page(page).styles.count());
+    assert!(s.cursor.style.flags.bold);
+
+    // Set another style, we should still only have one since it was unused
+    s.set_attribute(A::Italic).unwrap();
+    assert!(s.cursor.style_id != 0);
+    assert_eq!(1, s.page(page).styles.count());
+    assert!(s.cursor.style.flags.italic);
+}
+
+#[test]
+fn screen_style_reset_to_default() {
+    let mut s = init(80, 24, 1000);
+    let page = s.cursor_pin().node;
+    assert_eq!(0, s.page(page).styles.count());
+
+    // Set a new style
+    s.set_attribute(A::Bold).unwrap();
+    assert!(s.cursor.style_id != 0);
+    assert_eq!(1, s.page(page).styles.count());
+
+    // Reset to default
+    s.set_attribute(A::ResetBold).unwrap();
+    assert!(s.cursor.style_id == 0);
+    assert_eq!(0, s.page(page).styles.count());
+}
+
+#[test]
+fn screen_style_reset_with_unset() {
+    let mut s = init(80, 24, 1000);
+    let page = s.cursor_pin().node;
+    assert_eq!(0, s.page(page).styles.count());
+
+    // Set a new style
+    s.set_attribute(A::Bold).unwrap();
+    assert!(s.cursor.style_id != 0);
+    assert_eq!(1, s.page(page).styles.count());
+
+    // Reset to default
+    s.set_attribute(A::Unset).unwrap();
+    assert!(s.cursor.style_id == 0);
+    assert_eq!(0, s.page(page).styles.count());
+}
+
+#[test]
+fn screen_clear_rows_active_one_line() {
+    let mut s = init(80, 24, 1000);
+
+    s.test_write_string("hello, world").unwrap();
+    s.clear_rows(active(0, 0), None, false);
+    assert!(s.pages.is_dirty(active(0, 0)));
+    assert_eq!("", dump(&s, screen_pt(0, 0)));
+}
+
+#[test]
+fn screen_clear_rows_active_multi_line() {
+    let mut s = init(80, 24, 1000);
+
+    s.test_write_string("hello\nworld").unwrap();
+    s.clear_rows(active(0, 0), None, false);
+    assert!(s.pages.is_dirty(active(0, 0)));
+    assert!(s.pages.is_dirty(active(0, 1)));
+    assert_eq!("", dump(&s, screen_pt(0, 0)));
+}
+
+#[test]
+fn screen_clear_rows_active_styled_line() {
+    let mut s = init(80, 24, 1000);
+
+    s.set_attribute(A::Bold).unwrap();
+    s.test_write_string("hello world").unwrap();
+    s.set_attribute(A::Unset).unwrap();
+
+    // We should have one style
+    let page = s.cursor_pin().node;
+    assert_eq!(1, s.page(page).styles.count());
+
+    s.clear_rows(active(0, 0), None, false);
+
+    // We should have none because active cleared it
+    assert_eq!(0, s.page(page).styles.count());
+
+    assert_eq!("", dump(&s, screen_pt(0, 0)));
+}
+
+#[test]
+fn screen_clear_rows_protected() {
+    let mut s = init(80, 24, 1000);
+
+    s.test_write_string("UNPROTECTED").unwrap();
+    s.cursor.protected = true;
+    s.test_write_string("PROTECTED").unwrap();
+    s.cursor.protected = false;
+    s.test_write_string("UNPROTECTED").unwrap();
+    s.test_write_string("\n").unwrap();
+    s.cursor.protected = true;
+    s.test_write_string("PROTECTED").unwrap();
+    s.cursor.protected = false;
+    s.test_write_string("UNPROTECTED").unwrap();
+    s.cursor.protected = true;
+    s.test_write_string("PROTECTED").unwrap();
+    s.cursor.protected = false;
+
+    s.clear_rows(active(0, 0), None, true);
+
+    assert_eq!(
+        "           PROTECTED\nPROTECTED           PROTECTED",
+        dump(&s, screen_pt(0, 0))
+    );
+}
+
+#[test]
+fn screen_erase_rows_history() {
+    let mut s = init(5, 5, 1000);
+
+    s.test_write_string("1\n2\n3\n4\n5\n6").unwrap();
+
+    assert_eq!("2\n3\n4\n5\n6", dump(&s, active(0, 0)));
+    assert_eq!("1\n2\n3\n4\n5\n6", dump(&s, screen_pt(0, 0)));
+
+    s.erase_rows(history(0, 0), None);
+
+    assert_eq!("2\n3\n4\n5\n6", dump(&s, active(0, 0)));
+    assert_eq!("2\n3\n4\n5\n6", dump(&s, screen_pt(0, 0)));
+}
+
+#[test]
+fn screen_erase_rows_history_with_more_lines() {
+    let mut s = init(5, 5, 1000);
+
+    s.test_write_string("A\nB\nC\n1\n2\n3\n4\n5\n6").unwrap();
+
+    assert_eq!("2\n3\n4\n5\n6", dump(&s, active(0, 0)));
+    assert_eq!("A\nB\nC\n1\n2\n3\n4\n5\n6", dump(&s, screen_pt(0, 0)));
+
+    s.erase_rows(history(0, 0), None);
+
+    assert_eq!("2\n3\n4\n5\n6", dump(&s, active(0, 0)));
+    assert_eq!("2\n3\n4\n5\n6", dump(&s, screen_pt(0, 0)));
+}
+
+#[test]
+fn screen_erase_rows_active_partial() {
+    let mut s = init(5, 5, 0);
+
+    s.test_write_string("1\n2\n3").unwrap();
+
+    assert_eq!("1\n2\n3", dump(&s, active(0, 0)));
+
+    s.erase_rows(active(0, 0), Some(active(0, 1)));
+
+    assert_eq!("3", dump(&s, active(0, 0)));
+    assert_eq!("3", dump(&s, screen_pt(0, 0)));
+}

crates/ghostty-terminal/src/screen/tests/p2.rs

@@ -0,0 +1,1080 @@
+use super::*;
+use ghostty_vt::{color::Rgb, sgr::Attribute as A};
+
+fn bg155() -> A<'static> {
+    A::DirectColorBg(Rgb { r: 155, g: 0, b: 0 })
+}
+
+fn assert_bg155(s: &Screen, x: u16, y: u32) {
+    let cell = s.pages.get_cell(active(x, y)).unwrap();
+    assert!(cell.content_tag() == ContentTag::BgColorRgb);
+    assert_eq!(Rgb { r: 155, g: 0, b: 0 }, cell.color_rgb());
+}
+
+fn bold_style(s: &Screen) -> bool {
+    let page = s.cursor_page();
+    page.styles.get(s.cursor.style_id).unwrap().flags.bold
+}
+
+/// Scroll down enough to go to another page. Returns the start page.
+fn scroll_to_new_page(s: &mut Screen) -> NodeId {
+    let start_page = s.pages.last.unwrap();
+    let rem = s.page(start_page).capacity.rows;
+    s.page_mut(start_page).pause_integrity_checks(true);
+    for _ in 0..rem {
+        s.cursor_down_or_scroll().unwrap();
+    }
+    s.page_mut(start_page).pause_integrity_checks(false);
+    start_page
+}
+
+#[test]
+fn screen_cursor_down_across_pages_preserves_style() {
+    let mut s = init(10, 3, 1);
+
+    // Scroll down enough to go to another page
+    let start_page = scroll_to_new_page(&mut s);
+
+    // We need our page to change for this test o make sense. If this
+    // assertion fails then the bug is in the test: we should be scrolling
+    // above enough for a new page to show up.
+    assert!(start_page != s.cursor_pin().node);
+
+    // Scroll back to the previous page
+    s.cursor_up(1);
+    assert!(start_page == s.cursor_pin().node);
+
+    // Go back up, set a style
+    s.set_attribute(A::Bold).unwrap();
+    assert!(bold_style(&s));
+
+    // Go back down into the next page and we should have that style
+    s.cursor_down(1);
+    assert!(bold_style(&s));
+}
+
+#[test]
+fn screen_cursor_up_across_pages_preserves_style() {
+    let mut s = init(10, 3, 1);
+
+    let start_page = scroll_to_new_page(&mut s);
+    assert!(start_page != s.cursor_pin().node);
+
+    // Go back up, set a style
+    s.set_attribute(A::Bold).unwrap();
+    assert!(bold_style(&s));
+
+    // Go back down into the prev page and we should have that style
+    s.cursor_up(1);
+    assert!(start_page == s.cursor_pin().node);
+    assert!(bold_style(&s));
+}
+
+#[test]
+fn screen_cursor_absolute_across_pages_preserves_style() {
+    let mut s = init(10, 3, 1);
+
+    let start_page = scroll_to_new_page(&mut s);
+    assert!(start_page != s.cursor_pin().node);
+
+    // Go back up, set a style
+    s.set_attribute(A::Bold).unwrap();
+    assert!(bold_style(&s));
+
+    // Go back down into the prev page and we should have that style
+    s.cursor_absolute(1, 1);
+    assert!(start_page == s.cursor_pin().node);
+    assert!(bold_style(&s));
+}
+
+#[test]
+fn screen_cursor_absolute_to_page_with_insufficient_capacity() {
+    // This test checks for a very specific edge case
+    // which previously resulted in memory corruption.
+    //
+    // The conditions for this edge case are as such:
+    // - The cursor has an associated style or other managed memory.
+    // - The cursor moves to a different page.
+    // - The new page is at capacity and must have its capacity adjusted.
+    let mut s = init(10, 3, 1);
+
+    let start_page = scroll_to_new_page(&mut s);
+    let new_page = s.cursor_pin().node;
+
+    // We need our page to change for this test to make sense. If this
+    // assertion fails then the bug is in the test: we should be scrolling
+    // above enough for a new page to show up.
+    assert!(start_page != new_page);
+
+    // Add styles to the start page until it reaches capacity.
+    {
+        // Pause integrity checks because they're slow and
+        // we're not testing this, this is just setup.
+        s.page_mut(start_page).pause_integrity_checks(true);
+
+        let mut n: u32 = 1;
+        while s
+            .page_mut(start_page)
+            .styles
+            .add(Style {
+                bg_color: style::Color::Rgb(Rgb {
+                    r: (n & 0xff) as u8,
+                    g: ((n >> 8) & 0xff) as u8,
+                    b: ((n >> 16) & 0xff) as u8,
+                }),
+                ..Style::default()
+            })
+            .is_ok()
+        {
+            n += 1;
+        }
+
+        s.page_mut(start_page).pause_integrity_checks(false);
+        s.page(start_page).assert_integrity();
+    }
+
+    // Set a style on the cursor.
+    s.set_attribute(A::Bold).unwrap();
+    {
+        let styleval = s.page(new_page).styles.get(s.cursor.style_id).unwrap();
+        assert!(styleval.flags.bold);
+    }
+
+    // Go back up into the start page and we should still have that style.
+    s.cursor_absolute(1, 1);
+    {
+        let cur_page = s.cursor_pin().node;
+        // The page we're on now should NOT equal start_page, since its
+        // capacity should have been adjusted, which invalidates our ptr.
+        assert!(start_page != cur_page);
+        // To make sure we DID change pages we check we're not on new_page.
+        assert!(new_page != cur_page);
+
+        let styleval = s.page(cur_page).styles.get(s.cursor.style_id).unwrap();
+        assert!(styleval.flags.bold);
+    }
+
+    s.cursor_page().assert_integrity();
+    s.page(new_page).assert_integrity();
+}
+
+#[test]
+fn screen_scrolling() {
+    let mut s = init(10, 3, 0);
+    s.set_attribute(bg155()).unwrap();
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL").unwrap();
+
+    // Scroll down, should still be bottom
+    s.cursor_down_scroll().unwrap();
+    assert_eq!("2EFGH\n3IJKL", dump(&s, viewport(0, 0)));
+    assert_bg155(&s, 0, 2);
+
+    // Everything is dirty because we have no scrollback
+    assert!(s.pages.is_dirty(active(0, 0)));
+    assert!(s.pages.is_dirty(active(0, 1)));
+    assert!(s.pages.is_dirty(active(0, 2)));
+
+    // Scrolling to the bottom does nothing
+    s.scroll(Scroll::Active);
+
+    assert_eq!("2EFGH\n3IJKL", dump(&s, viewport(0, 0)));
+}
+
+#[test]
+fn screen_scrolling_with_a_single_row_screen_no_scrollback() {
+    let mut s = init(10, 1, 0);
+    s.test_write_string("1ABCD").unwrap();
+
+    // Scroll down, should still be bottom
+    s.cursor_down_scroll().unwrap();
+    assert_eq!("", dump(&s, viewport(0, 0)));
+
+    // Screen should be dirty
+    assert!(s.pages.is_dirty(active(0, 0)));
+}
+
+#[test]
+fn screen_scrolling_with_a_single_row_screen_with_scrollback() {
+    let mut s = init(10, 1, 1);
+    s.test_write_string("1ABCD").unwrap();
+
+    // Scroll down, should still be bottom
+    s.cursor_down_scroll().unwrap();
+    assert_eq!("", dump(&s, viewport(0, 0)));
+
+    // Active should be dirty
+    assert!(s.pages.is_dirty(active(0, 0)));
+
+    // Scrollback also dirty because cursor moved from there
+    assert!(s.pages.is_dirty(screen_pt(0, 0)));
+
+    s.scroll(Scroll::DeltaRow(-1));
+    assert_eq!("1ABCD", dump(&s, viewport(0, 0)));
+}
+
+#[test]
+fn screen_scrolling_across_pages_preserves_style() {
+    let mut s = init(10, 3, 1);
+    s.set_attribute(A::Bold).unwrap();
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL").unwrap();
+    let start_page = s.pages.last.unwrap();
+
+    // Scroll down enough to go to another page
+    let rem = {
+        let p = s.page(start_page);
+        p.capacity.rows - p.size.rows + 1
+    };
+    s.page_mut(start_page).pause_integrity_checks(true);
+    for _ in 0..rem {
+        s.cursor_down_or_scroll().unwrap();
+    }
+    s.page_mut(start_page).pause_integrity_checks(false);
+
+    // We need our page to change for this test o make sense. If this
+    // assertion fails then the bug is in the test: we should be scrolling
+    // above enough for a new page to show up.
+    let page = s.pages.last.unwrap();
+    assert!(start_page != page);
+
+    let styleval = s.page(page).styles.get(s.cursor.style_id).unwrap();
+    assert!(styleval.flags.bold);
+}
+
+#[test]
+fn screen_scroll_down_from_0() {
+    let mut s = init(10, 3, 0);
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL").unwrap();
+
+    // Scrolling up does nothing, but allows it
+    s.scroll(Scroll::DeltaRow(-1));
+    assert!(s.pages.viewport == Viewport::Active);
+
+    assert_eq!("1ABCD\n2EFGH\n3IJKL", dump(&s, viewport(0, 0)));
+}
+
+#[test]
+fn screen_scrollback_various_cases() {
+    let mut s = init(10, 3, 1);
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL").unwrap();
+    s.cursor_down_scroll().unwrap();
+
+    assert_eq!("2EFGH\n3IJKL", dump(&s, viewport(0, 0)));
+
+    // Scrolling to the bottom
+    s.scroll(Scroll::Active);
+    assert_eq!("2EFGH\n3IJKL", dump(&s, viewport(0, 0)));
+
+    // Scrolling back should make it visible again
+    s.scroll(Scroll::DeltaRow(-1));
+    assert!(s.pages.viewport != Viewport::Active);
+    assert_eq!("1ABCD\n2EFGH\n3IJKL", dump(&s, viewport(0, 0)));
+
+    // Scrolling back again should do nothing
+    s.scroll(Scroll::DeltaRow(-1));
+    assert_eq!("1ABCD\n2EFGH\n3IJKL", dump(&s, viewport(0, 0)));
+
+    // Scrolling to the bottom
+    s.scroll(Scroll::Active);
+    assert_eq!("2EFGH\n3IJKL", dump(&s, viewport(0, 0)));
+
+    // Scrolling forward with no grow should do nothing
+    s.scroll(Scroll::DeltaRow(1));
+    assert_eq!("2EFGH\n3IJKL", dump(&s, viewport(0, 0)));
+
+    // Scrolling to the top should work
+    s.scroll(Scroll::Top);
+    assert_eq!("1ABCD\n2EFGH\n3IJKL", dump(&s, viewport(0, 0)));
+
+    // Should be able to easily clear active area only
+    s.clear_rows(active(0, 0), None, false);
+    assert_eq!("1ABCD", dump(&s, viewport(0, 0)));
+
+    // Scrolling to the bottom
+    s.scroll(Scroll::Active);
+    assert_eq!("", dump(&s, viewport(0, 0)));
+}
+
+#[test]
+fn screen_scrollback_with_multi_row_delta() {
+    let mut s = init(10, 3, 3);
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL\n4ABCD\n5EFGH\n6IJKL")
+        .unwrap();
+
+    // Scroll to top
+    s.scroll(Scroll::Top);
+    assert_eq!("1ABCD\n2EFGH\n3IJKL", dump(&s, viewport(0, 0)));
+
+    // Scroll down multiple
+    s.scroll(Scroll::DeltaRow(5));
+    assert!(s.pages.viewport == Viewport::Active);
+    assert_eq!("4ABCD\n5EFGH\n6IJKL", dump(&s, viewport(0, 0)));
+}
+
+#[test]
+fn screen_scrollback_empty() {
+    let mut s = init(10, 3, 50);
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL").unwrap();
+    s.scroll(Scroll::DeltaRow(1));
+    assert_eq!("1ABCD\n2EFGH\n3IJKL", dump(&s, viewport(0, 0)));
+}
+
+#[test]
+fn screen_scrollback_doesnt_move_viewport_if_not_at_bottom() {
+    let mut s = init(10, 3, 3);
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL\n4ABCD\n5EFGH")
+        .unwrap();
+
+    // First test: we scroll up by 1, so we're not at the bottom anymore.
+    s.scroll(Scroll::DeltaRow(-1));
+    assert_eq!("2EFGH\n3IJKL\n4ABCD", dump(&s, viewport(0, 0)));
+
+    // Next, we scroll back down by 1, this grows the scrollback but we
+    // shouldn't move.
+    s.cursor_down_scroll().unwrap();
+    assert_eq!("2EFGH\n3IJKL\n4ABCD", dump(&s, viewport(0, 0)));
+
+    // Scroll again, this clears scrollback so we should move viewports
+    // but still see the same thing since our original view fits.
+    s.cursor_down_scroll().unwrap();
+    assert_eq!("2EFGH\n3IJKL\n4ABCD", dump(&s, viewport(0, 0)));
+}
+
+#[test]
+fn screen_scrolling_moves_selection() {
+    let mut s = init(5, 3, 1);
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL").unwrap();
+
+    // Select a single line
+    let sel = Selection::new(
+        pin(&s, active(0, 1)),
+        pin(&s, active(s.pages.cols - 1, 1)),
+        false,
+    );
+    s.select(Some(sel)).unwrap();
+
+    // Scroll down, should still be bottom
+    s.cursor_down_scroll().unwrap();
+
+    // Our selection should've moved up
+    {
+        let sel = s.selection.unwrap();
+        assert_eq!(
+            active(0, 0),
+            pt_from_pin(&s, Tag::Active, sel.start(&s.pages))
+        );
+        assert_eq!(
+            active(s.pages.cols - 1, 0),
+            pt_from_pin(&s, Tag::Active, sel.end(&s.pages))
+        );
+    }
+
+    // Test our contents rotated
+    assert_eq!("2EFGH\n3IJKL", dump(&s, viewport(0, 0)));
+
+    // Scrolling to the bottom does nothing
+    s.scroll(Scroll::Active);
+
+    // Our selection should've stayed the same
+    {
+        let sel = s.selection.unwrap();
+        assert_eq!(
+            active(0, 0),
+            pt_from_pin(&s, Tag::Active, sel.start(&s.pages))
+        );
+        assert_eq!(
+            active(s.pages.cols - 1, 0),
+            pt_from_pin(&s, Tag::Active, sel.end(&s.pages))
+        );
+    }
+
+    // Test our contents rotated
+    assert_eq!("2EFGH\n3IJKL", dump(&s, viewport(0, 0)));
+
+    // Scroll up again
+    s.cursor_down_scroll().unwrap();
+
+    // Test our contents rotated
+    assert_eq!("3IJKL", dump(&s, viewport(0, 0)));
+
+    // Our selection should be null because it left the screen.
+    {
+        let sel = s.selection.unwrap();
+        assert!(
+            s.pages
+                .point_from_pin(Tag::Active, sel.start(&s.pages))
+                .is_none()
+        );
+        assert!(
+            s.pages
+                .point_from_pin(Tag::Active, sel.end(&s.pages))
+                .is_none()
+        );
+    }
+}
+
+#[test]
+fn screen_scrolling_moves_viewport() {
+    let mut s = init(10, 3, 1);
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL\n").unwrap();
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL").unwrap();
+    s.scroll(Scroll::DeltaRow(-2));
+
+    // Test our contents rotated
+    assert_eq!("2EFGH\n3IJKL\n1ABCD", dump(&s, viewport(0, 0)));
+
+    let tl = s.pages.get_top_left(Tag::Viewport).unwrap();
+    assert_eq!(screen_pt(0, 1), pt_from_pin(&s, Tag::Screen, tl));
+}
+
+#[test]
+fn screen_scrolling_when_viewport_is_pruned() {
+    let mut s = init(215, 3, 1);
+
+    // Write some to create scrollback and move back into our scrollback.
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL\n").unwrap();
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL").unwrap();
+    s.scroll(Scroll::DeltaRow(-2));
+
+    // Our viewport is now somewhere pinned. Create so much scrollback
+    // that we prune it.
+    s.test_write_string("\n").unwrap();
+    for _ in 0..1000 {
+        s.test_write_string("1ABCD\n2EFGH\n3IJKL\n").unwrap();
+    }
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL").unwrap();
+
+    let tl = s.pages.get_top_left(Tag::Viewport).unwrap();
+    assert_eq!(screen_pt(0, 0), pt_from_pin(&s, Tag::Screen, tl));
+}
+
+#[test]
+fn screen_scroll_and_clear_full_screen() {
+    let mut s = init(10, 3, 5);
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL").unwrap();
+
+    assert_eq!("1ABCD\n2EFGH\n3IJKL", dump(&s, viewport(0, 0)));
+
+    s.scroll_clear().unwrap();
+    assert_eq!("", dump(&s, viewport(0, 0)));
+    assert_eq!("1ABCD\n2EFGH\n3IJKL", dump(&s, screen_pt(0, 0)));
+}
+
+#[test]
+fn screen_scroll_and_clear_partial_screen() {
+    let mut s = init(10, 3, 5);
+    s.test_write_string("1ABCD\n2EFGH").unwrap();
+
+    assert_eq!("1ABCD\n2EFGH", dump(&s, viewport(0, 0)));
+
+    s.scroll_clear().unwrap();
+    assert_eq!("", dump(&s, viewport(0, 0)));
+    assert_eq!("1ABCD\n2EFGH", dump(&s, screen_pt(0, 0)));
+}
+
+#[test]
+fn screen_scroll_and_clear_empty_screen() {
+    let mut s = init(10, 3, 5);
+    s.scroll_clear().unwrap();
+    assert_eq!("", dump(&s, viewport(0, 0)));
+    assert_eq!("", dump(&s, screen_pt(0, 0)));
+}
+
+#[test]
+fn screen_scroll_and_clear_ignore_blank_lines() {
+    let mut s = init(10, 3, 10);
+    s.test_write_string("1ABCD\n2EFGH").unwrap();
+    s.scroll_clear().unwrap();
+    assert_eq!("", dump(&s, viewport(0, 0)));
+
+    // Move back to top-left
+    s.cursor_absolute(0, 0);
+
+    // Write and clear
+    s.test_write_string("3ABCD\n").unwrap();
+    assert_eq!("3ABCD", dump(&s, active(0, 0)));
+
+    s.scroll_clear().unwrap();
+    assert_eq!("", dump(&s, viewport(0, 0)));
+
+    // Move back to top-left
+    s.cursor_absolute(0, 0);
+    s.test_write_string("X").unwrap();
+
+    assert_eq!("1ABCD\n2EFGH\n3ABCD\nX", dump(&s, screen_pt(0, 0)));
+}
+
+#[test]
+fn screen_scroll_above_same_page() {
+    let mut s = init(10, 3, 10);
+    s.set_attribute(bg155()).unwrap();
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL").unwrap();
+    s.cursor_absolute(0, 1);
+    s.pages.clear_dirty();
+
+    // At this point:
+    //  +-------------+ ACTIVE
+    //   +----------+ : = PAGE 0
+    // 0 |1ABCD00000| | 0
+    // 1 |2EFGH00000| | 1
+    //   :^         : : = PIN 0
+    // 2 |3IJKL00000| | 2
+    //   +----------+ :
+    //  +-------------+
+
+    s.cursor_scroll_above().unwrap();
+
+    //   +----------+ = PAGE 0
+    // 0 |1ABCD00000|
+    //  +-------------+ ACTIVE
+    // 1 |2EFGH00000| | 0
+    // 2 |          | | 1
+    //   :^         : : = PIN 0
+    // 3 |3IJKL00000| | 2
+    //   +----------+ :
+    //  +-------------+
+
+    assert_eq!("2EFGH\n\n3IJKL", dump(&s, viewport(0, 0)));
+    assert_bg155(&s, 0, 1);
+
+    // Page 0 row 1 (active row 0) is dirty because the cursor moved off of it.
+    assert!(s.pages.is_dirty(active(0, 0)));
+    // Page 0 row 2 (active row 1) is dirty because it was cleared.
+    assert!(s.pages.is_dirty(active(0, 1)));
+    // Page 0 row 3 (active row 2) is dirty because it's new.
+    assert!(s.pages.is_dirty(active(0, 2)));
+}
+
+#[test]
+fn screen_scroll_above_same_page_but_cursor_on_previous_page() {
+    let mut s = init(10, 5, 10);
+
+    // We need to get the cursor to a new page
+    let first = s.pages.first.unwrap();
+    let first_page_size = s.page(first).capacity.rows;
+    s.page_mut(first).pause_integrity_checks(true);
+    for _ in 0..first_page_size - 3 {
+        s.test_write_string("\n").unwrap();
+    }
+    s.page_mut(first).pause_integrity_checks(false);
+
+    s.set_attribute(bg155()).unwrap();
+    s.test_write_string("1A\n2B\n3C\n4D\n5E").unwrap();
+    s.cursor_absolute(0, 1);
+    s.pages.clear_dirty();
+
+    // Ensure we're still on the first page and have a second
+    assert!(s.cursor_pin().node == s.pages.first.unwrap());
+    assert!(s.pages.node(s.pages.first.unwrap()).unwrap().next.is_some());
+
+    // At this point:
+    //      +----------+ = PAGE 0
+    //  ... :          :
+    //     +-------------+ ACTIVE
+    // 4305 |1A00000000| | 0
+    // 4306 |2B00000000| | 1
+    //      :^         : : = PIN 0
+    // 4307 |3C00000000| | 2
+    //      +----------+ :
+    //      +----------+ : = PAGE 1
+    //    0 |4D00000000| | 3
+    //    1 |5E00000000| | 4
+    //      +----------+ :
+    //     +-------------+
+
+    s.cursor_scroll_above().unwrap();
+
+    //      +----------+ = PAGE 0
+    //  ... :          :
+    // 4305 |1A00000000|
+    //     +-------------+ ACTIVE
+    // 4306 |2B00000000| | 0
+    // 4307 |          | | 1
+    //      :^         : : = PIN 0
+    //      +----------+ :
+    //      +----------+ : = PAGE 1
+    //    0 |3C00000000| | 2
+    //    1 |4D00000000| | 3
+    //    2 |5E00000000| | 4
+    //      +----------+ :
+    //     +-------------+
+
+    assert_eq!("2B\n\n3C\n4D\n5E", dump(&s, viewport(0, 0)));
+    assert_bg155(&s, 0, 1);
+
+    // Page 0's penultimate row is dirty because the cursor moved off of it.
+    assert!(s.pages.is_dirty(active(0, 0)));
+    // The rest of the rows are dirty because they've been modified or are new.
+    assert!(s.pages.is_dirty(active(0, 1)));
+    assert!(s.pages.is_dirty(active(0, 2)));
+    assert!(s.pages.is_dirty(active(0, 3)));
+    assert!(s.pages.is_dirty(active(0, 4)));
+}
+
+#[test]
+fn screen_scroll_above_same_page_but_cursor_on_previous_page_last_row() {
+    let mut s = init(10, 5, 10);
+
+    // We need to get the cursor to a new page
+    let first = s.pages.first.unwrap();
+    let first_page_size = s.page(first).capacity.rows;
+    s.page_mut(first).pause_integrity_checks(true);
+    for _ in 0..first_page_size - 2 {
+        s.test_write_string("\n").unwrap();
+    }
+    s.page_mut(first).pause_integrity_checks(false);
+
+    s.set_attribute(bg155()).unwrap();
+    s.test_write_string("1A\n2B\n3C\n4D\n5E").unwrap();
+    s.cursor_absolute(0, 1);
+    s.pages.clear_dirty();
+
+    // Ensure we're still on the first page and have a second
+    assert!(s.cursor_pin().node == s.pages.first.unwrap());
+    assert!(s.pages.node(s.pages.first.unwrap()).unwrap().next.is_some());
+
+    // At this point:
+    //      +----------+ = PAGE 0
+    //  ... :          :
+    //     +-------------+ ACTIVE
+    // 4306 |1A00000000| | 0
+    // 4307 |2B00000000| | 1
+    //      :^         : : = PIN 0
+    //      +----------+ :
+    //      +----------+ : = PAGE 1
+    //    0 |3C00000000| | 2
+    //    1 |4D00000000| | 3
+    //    2 |5E00000000| | 4
+    //      +----------+ :
+    //     +-------------+
+
+    s.cursor_scroll_above().unwrap();
+
+    //      +----------+ = PAGE 0
+    //  ... :          :
+    // 4306 |1A00000000|
+    //     +-------------+ ACTIVE
+    // 4307 |2B00000000| | 0
+    //      +----------+ :
+    //      +----------+ : = PAGE 1
+    //    0 |          | | 1
+    //      :^         : : = PIN 0
+    //    1 |3C00000000| | 2
+    //    2 |4D00000000| | 3
+    //    3 |5E00000000| | 4
+    //      +----------+ :
+    //     +-------------+
+
+    assert_eq!("2B\n\n3C\n4D\n5E", dump(&s, viewport(0, 0)));
+    assert_bg155(&s, 0, 1);
+
+    // Page 0's final row is dirty because the cursor moved off of it.
+    assert!(s.pages.is_dirty(active(0, 0)));
+    // Page 1's rows are all dirty because every row was moved.
+    assert!(s.pages.is_dirty(active(0, 1)));
+    assert!(s.pages.is_dirty(active(0, 2)));
+    assert!(s.pages.is_dirty(active(0, 3)));
+    assert!(s.pages.is_dirty(active(0, 4)));
+
+    // Attempt to clear the style from the cursor and
+    // then assert the integrity of both of our pages.
+    //
+    // This catches a case of memory corruption where the cursor
+    // is moved between pages without accounting for style refs.
+    s.set_attribute(A::ResetBg).unwrap();
+    s.page(s.pages.first.unwrap()).assert_integrity();
+    s.page(s.pages.last.unwrap()).assert_integrity();
+}
+
+#[test]
+fn screen_scroll_above_creates_new_page() {
+    let mut s = init(10, 3, 10);
+
+    // We need to get the cursor to a new page
+    let first = s.pages.first.unwrap();
+    let first_page_size = s.page(first).capacity.rows;
+    s.page_mut(first).pause_integrity_checks(true);
+    for _ in 0..first_page_size - 3 {
+        s.test_write_string("\n").unwrap();
+    }
+    s.page_mut(first).pause_integrity_checks(false);
+
+    s.set_attribute(bg155()).unwrap();
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL").unwrap();
+    s.cursor_absolute(0, 1);
+    s.pages.clear_dirty();
+
+    // Ensure we're still on the first page
+    assert!(s.cursor_pin().node == s.pages.first.unwrap());
+
+    // At this point:
+    //      +----------+ = PAGE 0
+    //  ... :          :
+    //     +-------------+ ACTIVE
+    // 4305 |1ABCD00000| | 0
+    // 4306 |2EFGH00000| | 1
+    //      :^         : : = PIN 0
+    // 4307 |3IJKL00000| | 2
+    //      +----------+ :
+    //     +-------------+
+    s.cursor_scroll_above().unwrap();
+
+    //      +----------+ = PAGE 0
+    //  ... :          :
+    // 4305 |1ABCD00000|
+    //     +-------------+ ACTIVE
+    // 4306 |2EFGH00000| | 0
+    // 4307 |          | | 1
+    //      :^         : : = PIN 0
+    //      +----------+ :
+    //      +----------+ : = PAGE 1
+    //    0 |3IJKL00000| | 2
+    //      +----------+ :
+    //     +-------------+
+
+    assert_eq!("2EFGH\n\n3IJKL", dump(&s, viewport(0, 0)));
+    assert_bg155(&s, 0, 1);
+
+    // Page 0's penultimate row is dirty because the cursor moved off of it.
+    assert!(s.pages.is_dirty(active(0, 0)));
+    // Page 0's final row is dirty because it was cleared.
+    assert!(s.pages.is_dirty(active(0, 1)));
+    // Page 1's row is dirty because it's new.
+    assert!(s.pages.is_dirty(active(0, 2)));
+}
+
+#[test]
+fn screen_scroll_above_with_cursor_on_non_final_row() {
+    let mut s = init(10, 4, 10);
+
+    // Get the cursor to be 2 rows above a new page
+    let first = s.pages.first.unwrap();
+    let first_page_size = s.page(first).capacity.rows;
+    s.page_mut(first).pause_integrity_checks(true);
+    for _ in 0..first_page_size - 3 {
+        s.test_write_string("\n").unwrap();
+    }
+    s.page_mut(first).pause_integrity_checks(false);
+
+    // Write 3 lines of text, forcing the last line into the first
+    // row of a new page. Move our cursor onto the previous page.
+    s.set_attribute(bg155()).unwrap();
+    s.test_write_string("1AB\n2BC\n3DE\n4FG").unwrap();
+    s.cursor_absolute(0, 1);
+    s.pages.clear_dirty();
+
+    // Ensure we're still on the first page. So our cursor is on the first
+    // page but we have two pages of data.
+    assert!(s.cursor_pin().node == s.pages.first.unwrap());
+
+    //      +----------+ = PAGE 0
+    //  ... :          :
+    //     +-------------+ ACTIVE
+    // 4305 |1AB0000000| | 0
+    // 4306 |2BC0000000| | 1
+    //      :^         : : = PIN 0
+    // 4307 |3DE0000000| | 2
+    //      +----------+ :
+    //      +----------+ : = PAGE 1
+    //    0 |4FG0000000| | 3
+    //      +----------+ :
+    //     +-------------+
+    s.cursor_scroll_above().unwrap();
+
+    //     +----------+ = PAGE 0
+    //  ... :          :
+    // 4305 |1AB0000000|
+    //     +-------------+ ACTIVE
+    // 4306 |2BC0000000| | 0
+    // 4307 |          | | 1
+    //      :^         : : = PIN 0
+    //      +----------+ :
+    //      +----------+ : = PAGE 1
+    //    0 |3DE0000000| | 2
+    //    1 |4FG0000000| | 3
+    //      +----------+ :
+    //     +-------------+
+
+    assert_eq!("2BC\n\n3DE\n4FG", dump(&s, viewport(0, 0)));
+    assert_bg155(&s, 0, 1);
+
+    // Page 0's penultimate row is dirty because the cursor moved off of it.
+    assert!(s.pages.is_dirty(active(0, 0)));
+    // Page 0's final row is dirty because it was cleared.
+    assert!(s.pages.is_dirty(active(0, 1)));
+    // Page 1's row is dirty because it's new.
+    assert!(s.pages.is_dirty(active(0, 2)));
+}
+
+#[test]
+fn screen_scroll_above_no_scrollback_bottom_of_page() {
+    let mut s = init(10, 3, 0);
+
+    let first = s.pages.first.unwrap();
+    let first_page_size = s.page(first).capacity.rows;
+    s.page_mut(first).pause_integrity_checks(true);
+    for _ in 0..first_page_size - 3 {
+        s.test_write_string("\n").unwrap();
+    }
+    s.page_mut(first).pause_integrity_checks(false);
+
+    s.set_attribute(bg155()).unwrap();
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL").unwrap();
+    s.cursor_absolute(0, 1);
+    s.pages.clear_dirty();
+
+    // At this point:
+    //  +-------------+ ACTIVE
+    //   +----------+ : = PAGE 0
+    // 0 |1ABCD00000| | 0
+    // 1 |2EFGH00000| | 1
+    //   :^         : : = PIN 0
+    // 2 |3IJKL00000| | 2
+    //   +----------+ :
+    //  +-------------+
+
+    s.cursor_scroll_above().unwrap();
+
+    //   +----------+ = PAGE 0
+    // 0 |1ABCD00000|
+    //  +-------------+ ACTIVE
+    // 1 |2EFGH00000| | 0
+    // 2 |          | | 1
+    //   :^         : : = PIN 0
+    // 3 |3IJKL00000| | 2
+    //   +----------+ :
+    //  +-------------+
+
+    assert_eq!("2EFGH\n\n3IJKL", dump(&s, viewport(0, 0)));
+    assert_bg155(&s, 0, 1);
+
+    // Page 0 row 1 (active row 0) is dirty because the cursor moved off of it.
+    assert!(s.pages.is_dirty(active(0, 0)));
+    // Page 0 row 2 (active row 1) is dirty because it was cleared.
+    assert!(s.pages.is_dirty(active(0, 1)));
+    // Page 0 row 3 (active row 2) is dirty because it is new.
+    assert!(s.pages.is_dirty(active(0, 2)));
+}
+
+#[test]
+fn screen_clone() {
+    let mut s = init(10, 3, 10);
+    s.test_write_string("1ABCD\n2EFGH").unwrap();
+    assert_eq!("1ABCD\n2EFGH", dump(&s, active(0, 0)));
+    assert_eq!(5, s.cursor.x);
+    assert_eq!(1, s.cursor.y);
+
+    // Clone
+    let s2 = s.clone_screen(active(0, 0), None).unwrap();
+    assert_eq!("1ABCD\n2EFGH", dump(&s2, active(0, 0)));
+    assert_eq!(5, s2.cursor.x);
+    assert_eq!(1, s2.cursor.y);
+
+    // Write to s1, should not be in s2
+    s.test_write_string("\n34567").unwrap();
+    assert_eq!("1ABCD\n2EFGH\n34567", dump(&s, active(0, 0)));
+    assert_eq!("1ABCD\n2EFGH", dump(&s2, active(0, 0)));
+    assert_eq!(5, s2.cursor.x);
+    assert_eq!(1, s2.cursor.y);
+}
+
+#[test]
+fn screen_clone_partial() {
+    let mut s = init(10, 3, 10);
+    s.test_write_string("1ABCD\n2EFGH").unwrap();
+    assert_eq!("1ABCD\n2EFGH", dump(&s, active(0, 0)));
+    assert_eq!(5, s.cursor.x);
+    assert_eq!(1, s.cursor.y);
+
+    // Clone
+    let s2 = s.clone_screen(active(0, 1), None).unwrap();
+    assert_eq!("2EFGH", dump(&s2, active(0, 0)));
+
+    // Cursor is shifted since we cloned partial
+    assert_eq!(5, s2.cursor.x);
+    assert_eq!(0, s2.cursor.y);
+}
+
+#[test]
+fn screen_clone_partial_cursor_out_of_bounds() {
+    let mut s = init(10, 3, 10);
+    s.test_write_string("1ABCD\n2EFGH").unwrap();
+    assert_eq!("1ABCD\n2EFGH", dump(&s, active(0, 0)));
+    assert_eq!(5, s.cursor.x);
+    assert_eq!(1, s.cursor.y);
+
+    // Clone
+    let s2 = s.clone_screen(active(0, 0), Some(active(0, 0))).unwrap();
+    assert_eq!("1ABCD", dump(&s2, active(0, 0)));
+
+    // Cursor is shifted since we cloned partial
+    assert_eq!(0, s2.cursor.x);
+    assert_eq!(0, s2.cursor.y);
+}
+
+/// Common setup: 5x3 with scrollback 1 containing three lines.
+fn sel_screen() -> Screen {
+    let mut s = init(5, 3, 1);
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL").unwrap();
+    s
+}
+
+fn sel_points(s: &Screen) -> (Point, Point) {
+    let sel = s.selection.unwrap();
+    (
+        pt_from_pin(s, Tag::Active, sel.start(&s.pages)),
+        pt_from_pin(s, Tag::Active, sel.end(&s.pages)),
+    )
+}
+
+#[test]
+fn screen_clone_contains_full_selection() {
+    let mut s = sel_screen();
+
+    // Select a single line
+    let sel = Selection::new(
+        pin(&s, active(0, 1)),
+        pin(&s, active(s.pages.cols - 1, 1)),
+        false,
+    );
+    s.select(Some(sel)).unwrap();
+
+    // Clone
+    let s2 = s.clone_screen(active(0, 0), None).unwrap();
+
+    // Our selection should remain valid
+    let (a, b) = sel_points(&s2);
+    assert_eq!(active(0, 1), a);
+    assert_eq!(active(s2.pages.cols - 1, 1), b);
+}
+
+#[test]
+fn screen_clone_contains_none_of_selection() {
+    let mut s = sel_screen();
+
+    // Select a single line
+    let sel = Selection::new(
+        pin(&s, active(0, 0)),
+        pin(&s, active(s.pages.cols - 1, 0)),
+        false,
+    );
+    s.select(Some(sel)).unwrap();
+
+    // Clone
+    let s2 = s.clone_screen(active(0, 1), None).unwrap();
+
+    // Our selection should be null
+    assert!(s2.selection.is_none());
+}
+
+#[test]
+fn screen_clone_contains_selection_start_cutoff() {
+    let mut s = sel_screen();
+
+    // Select a single line
+    let sel = Selection::new(
+        pin(&s, active(0, 0)),
+        pin(&s, active(s.pages.cols - 1, 1)),
+        false,
+    );
+    s.select(Some(sel)).unwrap();
+
+    // Clone
+    let s2 = s.clone_screen(active(0, 1), None).unwrap();
+
+    // Our selection should remain valid
+    let (a, b) = sel_points(&s2);
+    assert_eq!(active(0, 0), a);
+    assert_eq!(active(s2.pages.cols - 1, 0), b);
+}
+
+#[test]
+fn screen_clone_contains_selection_end_cutoff() {
+    let mut s = sel_screen();
+
+    // Select a single line
+    let sel = Selection::new(pin(&s, active(0, 1)), pin(&s, active(2, 2)), false);
+    s.select(Some(sel)).unwrap();
+
+    // Clone
+    let s2 = s.clone_screen(active(0, 0), Some(active(0, 1))).unwrap();
+
+    // Our selection should remain valid
+    let (a, b) = sel_points(&s2);
+    assert_eq!(active(0, 1), a);
+    assert_eq!(active(s2.pages.cols - 1, 2), b);
+}
+
+#[test]
+fn screen_clone_contains_selection_end_cutoff_reversed() {
+    let mut s = sel_screen();
+
+    // Select a single line
+    let sel = Selection::new(pin(&s, active(2, 2)), pin(&s, active(0, 1)), false);
+    s.select(Some(sel)).unwrap();
+
+    // Clone
+    let s2 = s.clone_screen(active(0, 0), Some(active(0, 1))).unwrap();
+
+    // Our selection should remain valid
+    let (a, b) = sel_points(&s2);
+    assert_eq!(active(0, 1), a);
+    assert_eq!(active(s2.pages.cols - 1, 2), b);
+}
+
+#[test]
+fn screen_clone_contains_subset_of_selection() {
+    let mut s = init(5, 4, 1);
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL\n4ABCD").unwrap();
+
+    // Select the full screen
+    let sel = Selection::new(pin(&s, active(0, 0)), pin(&s, active(0, 3)), false);
+    s.select(Some(sel)).unwrap();
+
+    // Clone
+    let s2 = s.clone_screen(active(0, 1), Some(active(0, 2))).unwrap();
+
+    // Our selection should remain valid
+    let (a, b) = sel_points(&s2);
+    assert_eq!(active(0, 0), a);
+    assert_eq!(active(s2.pages.cols - 1, 3), b);
+}
+
+#[test]
+fn screen_clone_contains_subset_of_rectangle_selection() {
+    let mut s = init(5, 4, 1);
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL\n4ABCD").unwrap();
+
+    // Select the full screen from x=1 to x=3
+    let sel = Selection::new(pin(&s, active(1, 0)), pin(&s, active(3, 3)), true);
+    s.select(Some(sel)).unwrap();
+
+    // Clone
+    let s2 = s.clone_screen(active(0, 1), Some(active(0, 2))).unwrap();
+
+    // Our selection should remain valid and be properly clipped
+    // preserving the columns of the start and end points of the
+    // selection.
+    let (a, b) = sel_points(&s2);
+    assert_eq!(active(1, 0), a);
+    assert_eq!(active(3, 3), b);
+}
+
+#[test]
+fn screen_clone_basic() {
+    let mut s = init(10, 3, 0);
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL").unwrap();
+
+    {
+        let s2 = s.clone_screen(active(0, 1), Some(active(0, 1))).unwrap();
+
+        // Test our contents rotated
+        assert_eq!("2EFGH", dump(&s2, active(0, 0)));
+    }
+
+    {
+        let s2 = s.clone_screen(active(0, 1), Some(active(0, 2))).unwrap();
+
+        // Test our contents rotated
+        assert_eq!("2EFGH\n3IJKL", dump(&s2, active(0, 0)));
+    }
+}

crates/ghostty-terminal/src/screen/tests/p3.rs

@@ -0,0 +1,1236 @@
+use super::*;
+use crate::page::Wide;
+use crate::screen::{PromptKind, SemanticContentSet};
+
+fn cell_at(s: &Screen, pt: Point) -> Cell {
+    s.pages.get_cell(pt).unwrap()
+}
+
+fn row_at(s: &Screen, pt: Point) -> Row {
+    *pin(s, pt).row_and_cell(&s.pages).unwrap().0
+}
+
+fn resize(s: &mut Screen, cols: u16, rows: u16) {
+    s.resize(Resize::new(cols, rows)).unwrap();
+}
+
+fn resize_no_reflow(s: &mut Screen, cols: u16, rows: u16) {
+    s.resize(Resize {
+        reflow: false,
+        ..Resize::new(cols, rows)
+    })
+    .unwrap();
+}
+
+fn cursor_cell_cp(s: &Screen) -> u32 {
+    cell_at(s, active(s.cursor.x, u32::from(s.cursor.y))).codepoint()
+}
+
+#[test]
+fn screen_clone_empty_viewport() {
+    let s = init(10, 3, 0);
+
+    {
+        let s2 = s
+            .clone_screen(viewport(0, 0), Some(viewport(0, 0)))
+            .unwrap();
+
+        // Test our contents rotated
+        assert_eq!("", dump(&s2, viewport(0, 0)));
+    }
+}
+
+#[test]
+fn screen_clone_one_line_viewport() {
+    let mut s = init(10, 3, 0);
+    s.test_write_string("1ABC").unwrap();
+
+    {
+        let s2 = s
+            .clone_screen(viewport(0, 0), Some(viewport(0, 0)))
+            .unwrap();
+
+        // Test our contents
+        assert_eq!("1ABC", dump(&s2, viewport(0, 0)));
+    }
+}
+
+#[test]
+fn screen_clone_empty_active() {
+    let s = init(10, 3, 0);
+
+    {
+        let s2 = s.clone_screen(active(0, 0), Some(active(0, 0))).unwrap();
+
+        // Test our contents rotated
+        assert_eq!("", dump(&s2, active(0, 0)));
+    }
+}
+
+#[test]
+fn screen_clone_one_line_active_with_extra_space() {
+    let mut s = init(10, 3, 0);
+    s.test_write_string("1ABC").unwrap();
+
+    {
+        let s2 = s.clone_screen(active(0, 0), None).unwrap();
+
+        // Test our contents rotated
+        assert_eq!("1ABC", dump(&s2, active(0, 0)));
+    }
+}
+
+#[test]
+fn screen_clear_history_with_no_history() {
+    let mut s = init(10, 3, 3);
+    s.test_write_string("4ABCD\n5EFGH\n6IJKL").unwrap();
+    assert!(s.pages.viewport == Viewport::Active);
+    s.erase_rows(history(0, 0), None);
+    assert!(s.pages.viewport == Viewport::Active);
+    {
+        // Test our contents rotated
+        assert_eq!("4ABCD\n5EFGH\n6IJKL", dump(&s, viewport(0, 0)));
+    }
+    {
+        // Test our contents rotated
+        assert_eq!("4ABCD\n5EFGH\n6IJKL", dump(&s, screen_pt(0, 0)));
+    }
+}
+
+#[test]
+fn screen_clear_history() {
+    let mut s = init(10, 3, 3);
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL\n4ABCD\n5EFGH\n6IJKL")
+        .unwrap();
+    assert!(s.pages.viewport == Viewport::Active);
+
+    // Scroll to top
+    s.scroll(Scroll::Top);
+    {
+        // Test our contents rotated
+        assert_eq!("1ABCD\n2EFGH\n3IJKL", dump(&s, viewport(0, 0)));
+    }
+
+    s.erase_rows(history(0, 0), None);
+    assert!(s.pages.viewport == Viewport::Active);
+    {
+        // Test our contents rotated
+        assert_eq!("4ABCD\n5EFGH\n6IJKL", dump(&s, viewport(0, 0)));
+    }
+    {
+        // Test our contents rotated
+        assert_eq!("4ABCD\n5EFGH\n6IJKL", dump(&s, screen_pt(0, 0)));
+    }
+}
+
+#[test]
+fn screen_clear_above_cursor() {
+    let mut s = init(10, 10, 3);
+    s.test_write_string("4ABCD\n5EFGH\n6IJKL").unwrap();
+    s.clear_rows(
+        active(0, 0),
+        Some(active(0, u32::from(s.cursor.y) - 1)),
+        false,
+    );
+    {
+        assert_eq!("\n\n6IJKL", dump(&s, viewport(0, 0)));
+    }
+    {
+        assert_eq!("\n\n6IJKL", dump(&s, screen_pt(0, 0)));
+    }
+
+    assert_eq!(5, s.cursor.x);
+    assert_eq!(2, s.cursor.y);
+}
+
+#[test]
+fn screen_clear_above_cursor_with_history() {
+    let mut s = init(10, 3, 3);
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL\n").unwrap();
+    s.test_write_string("4ABCD\n5EFGH\n6IJKL").unwrap();
+    s.clear_rows(
+        active(0, 0),
+        Some(active(0, u32::from(s.cursor.y) - 1)),
+        false,
+    );
+    {
+        assert_eq!("\n\n6IJKL", dump(&s, viewport(0, 0)));
+    }
+    {
+        assert_eq!("1ABCD\n2EFGH\n3IJKL\n\n\n6IJKL", dump(&s, screen_pt(0, 0)));
+    }
+
+    assert_eq!(5, s.cursor.x);
+    assert_eq!(2, s.cursor.y);
+}
+
+#[test]
+fn screen_resize_no_reflow_more_rows() {
+    let mut s = init(10, 3, 0);
+    let str = "1ABCD\n2EFGH\n3IJKL";
+    s.test_write_string(str).unwrap();
+
+    // Resize
+    resize_no_reflow(&mut s, 10, 10);
+    {
+        assert_eq!(str, dump(&s, viewport(0, 0)));
+    }
+}
+
+#[test]
+fn screen_resize_no_reflow_less_rows() {
+    let mut s = init(10, 3, 0);
+    let str = "1ABCD\n2EFGH\n3IJKL";
+    s.test_write_string(str).unwrap();
+    assert_eq!(5, s.cursor.x);
+    assert_eq!(2, s.cursor.y);
+    resize_no_reflow(&mut s, 10, 2);
+
+    // Since we shrunk, we should adjust our cursor
+    assert_eq!(5, s.cursor.x);
+    assert_eq!(1, s.cursor.y);
+
+    {
+        assert_eq!("2EFGH\n3IJKL", dump(&s, viewport(0, 0)));
+    }
+}
+
+fn bg_fill_rows(s: &mut Screen) {
+    // Write only a background color into the remaining rows
+    for y in 1..s.pages.rows {
+        let c = s.pages.get_cell_mut(active(0, u32::from(y))).unwrap();
+        let mut cell = Cell::default();
+        cell.set_content_tag(ContentTag::BgColorRgb);
+        cell.set_color_rgb(ghostty_vt::color::Rgb {
+            r: 0xFF,
+            g: 0,
+            b: 0,
+        });
+        *c = cell;
+    }
+}
+
+#[test]
+#[ignore = "pagelist: PageList::resize (no reflow, fewer rows) does not trim trailing rows that only contain background-color cells; the content row is pushed to history instead"]
+fn screen_resize_no_reflow_less_rows_trims_blank_lines() {
+    let mut s = init(10, 3, 0);
+    let str = "1ABCD";
+    s.test_write_string(str).unwrap();
+
+    bg_fill_rows(&mut s);
+
+    let (cx, cy) = (s.cursor.x, s.cursor.y);
+    resize_no_reflow(&mut s, 6, 2);
+
+    // Cursor should not move
+    assert_eq!(cx, s.cursor.x);
+    assert_eq!(cy, s.cursor.y);
+
+    {
+        assert_eq!("1ABCD", dump(&s, viewport(0, 0)));
+    }
+}
+
+#[test]
+fn screen_resize_no_reflow_more_rows_trims_blank_lines() {
+    let mut s = init(10, 3, 0);
+    let str = "1ABCD";
+    s.test_write_string(str).unwrap();
+
+    bg_fill_rows(&mut s);
+
+    let (cx, cy) = (s.cursor.x, s.cursor.y);
+    resize_no_reflow(&mut s, 10, 7);
+
+    // Cursor should not move
+    assert_eq!(cx, s.cursor.x);
+    assert_eq!(cy, s.cursor.y);
+
+    {
+        assert_eq!("1ABCD", dump(&s, viewport(0, 0)));
+    }
+}
+
+#[test]
+fn screen_resize_no_reflow_more_cols() {
+    let mut s = init(10, 3, 0);
+    let str = "1ABCD\n2EFGH\n3IJKL";
+    s.test_write_string(str).unwrap();
+    resize_no_reflow(&mut s, 20, 3);
+
+    {
+        assert_eq!(str, dump(&s, viewport(0, 0)));
+    }
+}
+
+#[test]
+fn screen_resize_no_reflow_less_cols() {
+    let mut s = init(10, 3, 0);
+    let str = "1ABCD\n2EFGH\n3IJKL";
+    s.test_write_string(str).unwrap();
+    resize_no_reflow(&mut s, 4, 3);
+
+    {
+        let expected = "1ABC\n2EFG\n3IJK";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+}
+
+#[test]
+fn screen_resize_no_reflow_more_rows_with_scrollback_cursor_end() {
+    let mut s = init(7, 3, 2);
+    let str = "1ABCD\n2EFGH\n3IJKL\n4ABCD\n5EFGH";
+    s.test_write_string(str).unwrap();
+    resize_no_reflow(&mut s, 7, 10);
+
+    {
+        assert_eq!(str, dump(&s, viewport(0, 0)));
+    }
+}
+
+#[test]
+fn screen_resize_no_reflow_less_rows_with_scrollback() {
+    let mut s = init(7, 3, 2);
+    let str = "1ABCD\n2EFGH\n3IJKL\n4ABCD\n5EFGH";
+    s.test_write_string(str).unwrap();
+    resize_no_reflow(&mut s, 7, 2);
+
+    {
+        let expected = "4ABCD\n5EFGH";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+}
+
+// https://github.com/mitchellh/ghostty/issues/1030
+#[test]
+fn screen_resize_no_reflow_less_rows_with_empty_trailing() {
+    let mut s = init(5, 3, 5);
+    let str = "1\n2\n3\n4\n5\n6\n7\n8";
+    s.test_write_string(str).unwrap();
+    s.scroll_clear().unwrap();
+    s.cursor_absolute(0, 0);
+    s.test_write_string("A\nB").unwrap();
+
+    let (cx, cy) = (s.cursor.x, s.cursor.y);
+    resize_no_reflow(&mut s, 5, 2);
+    assert_eq!(cx, s.cursor.x);
+    assert_eq!(cy, s.cursor.y);
+
+    {
+        assert_eq!("A\nB", dump(&s, viewport(0, 0)));
+    }
+}
+
+#[test]
+fn screen_resize_no_reflow_more_rows_with_soft_wrapping() {
+    let mut s = init(2, 3, 3);
+    let str = "1A2B\n3C4E\n5F6G";
+    s.test_write_string(str).unwrap();
+
+    // Every second row should be wrapped
+    for y in 0..6u32 {
+        let row = row_at(&s, screen_pt(0, y));
+        let wrapped = y % 2 == 0;
+        assert_eq!(wrapped, row.wrap());
+    }
+
+    // Resize
+    resize_no_reflow(&mut s, 2, 10);
+    {
+        let expected = "1A\n2B\n3C\n4E\n5F\n6G";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+
+    // Every second row should be wrapped
+    for y in 0..6u32 {
+        let row = row_at(&s, screen_pt(0, y));
+        let wrapped = y % 2 == 0;
+        assert_eq!(wrapped, row.wrap());
+    }
+}
+
+#[test]
+fn screen_resize_more_rows_no_scrollback() {
+    let mut s = init(5, 3, 0);
+    let str = "1ABCD\n2EFGH\n3IJKL";
+    s.test_write_string(str).unwrap();
+    let (cx, cy) = (s.cursor.x, s.cursor.y);
+    resize(&mut s, 5, 10);
+
+    // Cursor should not move
+    assert_eq!(cx, s.cursor.x);
+    assert_eq!(cy, s.cursor.y);
+
+    {
+        assert_eq!(str, dump(&s, viewport(0, 0)));
+    }
+    {
+        assert_eq!(str, dump(&s, screen_pt(0, 0)));
+    }
+}
+
+#[test]
+fn screen_resize_more_rows_with_empty_scrollback() {
+    let mut s = init(5, 3, 10);
+    let str = "1ABCD\n2EFGH\n3IJKL";
+    s.test_write_string(str).unwrap();
+    let (cx, cy) = (s.cursor.x, s.cursor.y);
+    resize(&mut s, 5, 10);
+
+    // Cursor should not move
+    assert_eq!(cx, s.cursor.x);
+    assert_eq!(cy, s.cursor.y);
+
+    {
+        assert_eq!(str, dump(&s, viewport(0, 0)));
+    }
+    {
+        assert_eq!(str, dump(&s, screen_pt(0, 0)));
+    }
+}
+
+#[test]
+fn screen_resize_more_rows_with_populated_scrollback() {
+    let mut s = init(5, 3, 5);
+    let str = "1ABCD\n2EFGH\n3IJKL\n4ABCD\n5EFGH";
+    s.test_write_string(str).unwrap();
+    {
+        let expected = "3IJKL\n4ABCD\n5EFGH";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+
+    // Set our cursor to be on the "4"
+    s.cursor_absolute(0, 1);
+    {
+        assert_eq!(u32::from('4'), cursor_cell_cp(&s));
+    }
+
+    // Resize
+    resize(&mut s, 5, 10);
+
+    // Cursor should still be on the "4"
+    {
+        assert_eq!(u32::from('4'), cursor_cell_cp(&s));
+    }
+
+    {
+        let expected = "3IJKL\n4ABCD\n5EFGH";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+}
+
+#[test]
+fn screen_resize_more_cols_no_reflow() {
+    let mut s = init(5, 3, 0);
+    let str = "1ABCD\n2EFGH\n3IJKL";
+    s.test_write_string(str).unwrap();
+
+    let (cx, cy) = (s.cursor.x, s.cursor.y);
+    resize(&mut s, 10, 3);
+
+    // Cursor should not move
+    assert_eq!(cx, s.cursor.x);
+    assert_eq!(cy, s.cursor.y);
+
+    {
+        assert_eq!(str, dump(&s, viewport(0, 0)));
+    }
+    {
+        assert_eq!(str, dump(&s, screen_pt(0, 0)));
+    }
+}
+
+// https://github.com/mitchellh/ghostty/issues/272#issuecomment-1676038963
+#[test]
+fn screen_resize_more_cols_perfect_split() {
+    let mut s = init(5, 3, 0);
+    let str = "1ABCD2EFGH3IJKL";
+    s.test_write_string(str).unwrap();
+    resize(&mut s, 10, 3);
+
+    {
+        assert_eq!("1ABCD2EFGH\n3IJKL", dump(&s, screen_pt(0, 0)));
+    }
+}
+
+// https://github.com/mitchellh/ghostty/issues/1159
+#[test]
+fn screen_resize_no_reflow_more_cols_with_scrollback_scrolled_up() {
+    let mut s = init(5, 3, 5);
+    let str = "1\n2\n3\n4\n5\n6\n7\n8";
+    s.test_write_string(str).unwrap();
+
+    // Cursor at bottom
+    assert_eq!(1, s.cursor.x);
+    assert_eq!(2, s.cursor.y);
+
+    s.scroll(Scroll::DeltaRow(-4));
+    {
+        assert_eq!("2\n3\n4", dump(&s, viewport(0, 0)));
+    }
+
+    resize(&mut s, 8, 3);
+    {
+        assert_eq!(str, dump(&s, screen_pt(0, 0)));
+    }
+
+    // Cursor remains at bottom
+    assert_eq!(1, s.cursor.x);
+    assert_eq!(2, s.cursor.y);
+}
+
+// https://github.com/mitchellh/ghostty/issues/1159
+#[test]
+fn screen_resize_no_reflow_less_cols_with_scrollback_scrolled_up() {
+    let mut s = init(5, 3, 5);
+    let str = "1\n2\n3\n4\n5\n6\n7\n8";
+    s.test_write_string(str).unwrap();
+
+    // Cursor at bottom
+    assert_eq!(1, s.cursor.x);
+    assert_eq!(2, s.cursor.y);
+
+    s.scroll(Scroll::DeltaRow(-4));
+    {
+        assert_eq!("2\n3\n4", dump(&s, viewport(0, 0)));
+    }
+
+    resize(&mut s, 4, 3);
+    {
+        assert_eq!(str, dump(&s, screen_pt(0, 0)));
+    }
+    {
+        assert_eq!("6\n7\n8", dump(&s, active(0, 0)));
+    }
+
+    // Cursor remains at bottom
+    assert_eq!(1, s.cursor.x);
+    assert_eq!(2, s.cursor.y);
+
+    // Old implementation doesn't do this but it makes sense to me:
+    // {
+    //     assert_eq!("2\n3\n4", dump(&s, viewport(0, 0)));
+    // }
+}
+
+#[test]
+fn screen_resize_more_cols_no_reflow_preserves_semantic_prompt() {
+    let mut s = init(5, 3, 0);
+
+    // Set one of the rows to be a prompt
+    s.cursor_set_semantic_content(SemanticContentSet::Output);
+    s.test_write_string("1ABCD\n").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Prompt(PromptKind::Initial));
+    s.test_write_string("2EFGH").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Output);
+    s.test_write_string("\n3IJKL").unwrap();
+
+    s.resize(Resize {
+        reflow: false,
+        ..Resize::new(10, 3)
+    })
+    .unwrap();
+
+    let expected = "1ABCD\n2EFGH\n3IJKL";
+    {
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+    {
+        assert_eq!(expected, dump(&s, screen_pt(0, 0)));
+    }
+
+    // Our one row should still be a semantic prompt, the others should not.
+    assert!(row_at(&s, active(0, 0)).semantic_prompt() == RowPrompt::None);
+    assert!(row_at(&s, active(0, 1)).semantic_prompt() == RowPrompt::Prompt);
+    assert!(row_at(&s, active(0, 2)).semantic_prompt() == RowPrompt::None);
+}
+
+#[test]
+fn screen_resize_more_cols_with_reflow_that_fits_full_width() {
+    let mut s = init(5, 3, 0);
+    let str = "1ABCD2EFGH\n3IJKL";
+    s.test_write_string(str).unwrap();
+
+    // Verify we soft wrapped
+    {
+        let expected = "1ABCD\n2EFGH\n3IJKL";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+
+    // Let's put our cursor on row 2, where the soft wrap is
+    s.cursor_absolute(0, 1);
+    {
+        assert_eq!(u32::from('2'), cursor_cell_cp(&s));
+    }
+
+    // Resize and verify we undid the soft wrap because we have space now
+    resize(&mut s, 10, 3);
+    {
+        assert_eq!(str, dump(&s, viewport(0, 0)));
+    }
+
+    // Our cursor should've moved
+    assert_eq!(5, s.cursor.x);
+    assert_eq!(0, s.cursor.y);
+}
+
+#[test]
+fn screen_resize_more_cols_with_reflow_that_ends_in_newline() {
+    let mut s = init(6, 3, 0);
+    let str = "1ABCD2EFGH\n3IJKL";
+    s.test_write_string(str).unwrap();
+
+    // Verify we soft wrapped
+    {
+        let expected = "1ABCD2\nEFGH\n3IJKL";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+
+    // Let's put our cursor on the last row
+    s.cursor_absolute(0, 2);
+    {
+        assert_eq!(u32::from('3'), cursor_cell_cp(&s));
+    }
+
+    // Resize and verify we undid the soft wrap because we have space now
+    resize(&mut s, 10, 3);
+    {
+        assert_eq!(str, dump(&s, viewport(0, 0)));
+    }
+
+    // Our cursor should still be on the 3
+    {
+        assert_eq!(u32::from('3'), cursor_cell_cp(&s));
+    }
+}
+
+#[test]
+fn screen_resize_more_cols_with_reflow_that_forces_more_wrapping() {
+    let mut s = init(5, 3, 0);
+    let str = "1ABCD2EFGH\n3IJKL";
+    s.test_write_string(str).unwrap();
+
+    // Let's put our cursor on row 2, where the soft wrap is
+    s.cursor_absolute(0, 1);
+    {
+        assert_eq!(u32::from('2'), cursor_cell_cp(&s));
+    }
+
+    // Verify we soft wrapped
+    {
+        let expected = "1ABCD\n2EFGH\n3IJKL";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+
+    // Resize and verify we undid the soft wrap because we have space now
+    resize(&mut s, 7, 3);
+    {
+        let expected = "1ABCD2E\nFGH\n3IJKL";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+
+    // Our cursor should've moved
+    assert_eq!(5, s.cursor.x);
+    assert_eq!(0, s.cursor.y);
+}
+
+#[test]
+fn screen_resize_more_cols_with_reflow_that_unwraps_multiple_times() {
+    let mut s = init(5, 3, 0);
+    let str = "1ABCD2EFGH3IJKL";
+    s.test_write_string(str).unwrap();
+
+    // Let's put our cursor on row 2, where the soft wrap is
+    s.cursor_absolute(0, 2);
+    {
+        assert_eq!(u32::from('3'), cursor_cell_cp(&s));
+    }
+
+    // Verify we soft wrapped
+    {
+        let expected = "1ABCD\n2EFGH\n3IJKL";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+
+    // Resize and verify we undid the soft wrap because we have space now
+    resize(&mut s, 15, 3);
+    {
+        let expected = "1ABCD2EFGH3IJKL";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+
+    // Our cursor should've moved
+    assert_eq!(10, s.cursor.x);
+    assert_eq!(0, s.cursor.y);
+}
+
+#[test]
+fn screen_resize_more_cols_with_populated_scrollback() {
+    let mut s = init(5, 3, 5);
+    let str = "1ABCD\n2EFGH\n3IJKL\n4ABCD5EFGH";
+    s.test_write_string(str).unwrap();
+    {
+        let expected = "3IJKL\n4ABCD\n5EFGH";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+
+    // // Set our cursor to be on the "5"
+    s.cursor_absolute(0, 2);
+    {
+        assert_eq!(u32::from('5'), cursor_cell_cp(&s));
+    }
+
+    // Resize
+    resize(&mut s, 10, 3);
+    {
+        let expected = "2EFGH\n3IJKL\n4ABCD5EFGH";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+
+    // Cursor should still be on the "5"
+    {
+        assert_eq!(u32::from('5'), cursor_cell_cp(&s));
+    }
+}
+
+#[test]
+fn screen_resize_more_cols_with_reflow() {
+    let mut s = init(2, 3, 5);
+    let str = "1ABC\n2DEF\n3ABC\n4DEF";
+    s.test_write_string(str).unwrap();
+
+    // Let's put our cursor on row 2, where the soft wrap is
+    s.cursor_absolute(0, 2);
+    {
+        assert_eq!(u32::from('E'), cursor_cell_cp(&s));
+    }
+
+    // Verify we soft wrapped
+    {
+        let expected = "BC\n4D\nEF";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+
+    // Resize and verify we undid the soft wrap because we have space now
+    resize(&mut s, 7, 3);
+    {
+        let expected = "1ABC\n2DEF\n3ABC\n4DEF";
+        assert_eq!(expected, dump(&s, screen_pt(0, 0)));
+    }
+
+    // Our cursor should've moved
+    assert_eq!(2, s.cursor.x);
+    assert_eq!(2, s.cursor.y);
+}
+
+#[test]
+fn screen_resize_more_rows_and_cols_with_wrapping() {
+    let mut s = init(2, 4, 0);
+    let str = "1A2B\n3C4D";
+    s.test_write_string(str).unwrap();
+    {
+        let expected = "1A\n2B\n3C\n4D";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+
+    resize(&mut s, 5, 10);
+
+    // Cursor should move due to wrapping
+    assert_eq!(3, s.cursor.x);
+    assert_eq!(1, s.cursor.y);
+
+    {
+        assert_eq!(str, dump(&s, viewport(0, 0)));
+    }
+    {
+        assert_eq!(str, dump(&s, screen_pt(0, 0)));
+    }
+}
+
+#[test]
+fn screen_resize_less_rows_no_scrollback() {
+    let mut s = init(5, 3, 0);
+    let str = "1ABCD\n2EFGH\n3IJKL";
+    s.test_write_string(str).unwrap();
+
+    s.cursor_absolute(0, 0);
+    let (cx, cy) = (s.cursor.x, s.cursor.y);
+    resize(&mut s, 5, 1);
+
+    // Cursor should not move
+    assert_eq!(cx, s.cursor.x);
+    assert_eq!(cy, s.cursor.y);
+
+    {
+        assert_eq!("3IJKL", dump(&s, viewport(0, 0)));
+    }
+    {
+        assert_eq!("3IJKL", dump(&s, screen_pt(0, 0)));
+    }
+}
+
+#[test]
+fn screen_resize_less_rows_moving_cursor() {
+    let mut s = init(5, 3, 0);
+    let str = "1ABCD\n2EFGH\n3IJKL";
+    s.test_write_string(str).unwrap();
+
+    // Put our cursor on the last line
+    s.cursor_absolute(1, 2);
+    {
+        assert_eq!(u32::from('I'), cursor_cell_cp(&s));
+    }
+
+    // Resize
+    resize(&mut s, 5, 1);
+
+    {
+        assert_eq!("3IJKL", dump(&s, viewport(0, 0)));
+    }
+    {
+        assert_eq!("3IJKL", dump(&s, screen_pt(0, 0)));
+    }
+
+    // Cursor should be on the last line
+    assert_eq!(1, s.cursor.x);
+    assert_eq!(0, s.cursor.y);
+}
+
+#[test]
+fn screen_resize_less_rows_with_empty_scrollback() {
+    let mut s = init(5, 3, 10);
+    let str = "1ABCD\n2EFGH\n3IJKL";
+    s.test_write_string(str).unwrap();
+    resize(&mut s, 5, 1);
+
+    {
+        assert_eq!(str, dump(&s, screen_pt(0, 0)));
+    }
+    {
+        assert_eq!("3IJKL", dump(&s, viewport(0, 0)));
+    }
+}
+
+#[test]
+fn screen_resize_less_rows_with_populated_scrollback() {
+    let mut s = init(5, 3, 5);
+    let str = "1ABCD\n2EFGH\n3IJKL\n4ABCD\n5EFGH";
+    s.test_write_string(str).unwrap();
+    {
+        let expected = "3IJKL\n4ABCD\n5EFGH";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+
+    // Resize
+    resize(&mut s, 5, 1);
+
+    {
+        assert_eq!(str, dump(&s, screen_pt(0, 0)));
+    }
+    {
+        assert_eq!("5EFGH", dump(&s, viewport(0, 0)));
+    }
+}
+
+#[test]
+fn screen_resize_less_rows_with_full_scrollback() {
+    let mut s = init(5, 3, 3);
+    let str = "00000\n1ABCD\n2EFGH\n3IJKL\n4ABCD\n5EFGH";
+    s.test_write_string(str).unwrap();
+    {
+        let expected = "3IJKL\n4ABCD\n5EFGH";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+
+    assert_eq!(4, s.cursor.x);
+    assert_eq!(2, s.cursor.y);
+
+    // Resize
+    resize(&mut s, 5, 2);
+
+    // Cursor should stay in the same relative place (bottom of the
+    // screen, same character).
+    assert_eq!(4, s.cursor.x);
+    assert_eq!(1, s.cursor.y);
+
+    {
+        let expected = "00000\n1ABCD\n2EFGH\n3IJKL\n4ABCD\n5EFGH";
+        assert_eq!(expected, dump(&s, screen_pt(0, 0)));
+    }
+    {
+        let expected = "4ABCD\n5EFGH";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+}
+
+#[test]
+fn screen_resize_less_cols_no_reflow() {
+    let mut s = init(5, 3, 0);
+    let str = "1AB\n2EF\n3IJ";
+    s.test_write_string(str).unwrap();
+
+    s.cursor_absolute(0, 0);
+    let (cx, cy) = (s.cursor.x, s.cursor.y);
+    resize(&mut s, 3, 3);
+
+    // Cursor should not move
+    assert_eq!(cx, s.cursor.x);
+    assert_eq!(cy, s.cursor.y);
+
+    {
+        assert_eq!(str, dump(&s, viewport(0, 0)));
+    }
+    {
+        assert_eq!(str, dump(&s, screen_pt(0, 0)));
+    }
+}
+
+#[test]
+#[ignore = "pagelist: reflow keeps trailing blank rows (total_rows 4 > 3) instead of trimming them like Zig, pushing the first row into history"]
+fn screen_resize_less_cols_with_reflow_but_row_space() {
+    let mut s = init(5, 3, 1);
+    let str = "1ABCD";
+    s.test_write_string(str).unwrap();
+
+    // Put our cursor on the end
+    s.cursor_absolute(4, 0);
+    {
+        assert_eq!(u32::from('D'), cursor_cell_cp(&s));
+    }
+
+    resize(&mut s, 3, 3);
+    {
+        assert_eq!("1AB\nCD", dump(&s, viewport(0, 0)));
+    }
+    {
+        assert_eq!("1AB\nCD", dump(&s, screen_pt(0, 0)));
+    }
+
+    // Cursor should be on the last line
+    assert_eq!(1, s.cursor.x);
+    assert_eq!(1, s.cursor.y);
+}
+
+#[test]
+fn screen_resize_less_cols_with_reflow_with_trimmed_rows() {
+    let mut s = init(5, 3, 0);
+    let str = "3IJKL\n4ABCD\n5EFGH";
+    s.test_write_string(str).unwrap();
+    resize(&mut s, 3, 3);
+
+    {
+        assert_eq!("CD\n5EF\nGH", dump(&s, viewport(0, 0)));
+    }
+    {
+        assert_eq!("CD\n5EF\nGH", dump(&s, screen_pt(0, 0)));
+    }
+}
+
+#[test]
+fn screen_resize_less_cols_with_reflow_with_trimmed_rows_and_scrollback() {
+    let mut s = init(5, 3, 1);
+    let str = "3IJKL\n4ABCD\n5EFGH";
+    s.test_write_string(str).unwrap();
+    resize(&mut s, 3, 3);
+
+    {
+        assert_eq!("CD\n5EF\nGH", dump(&s, viewport(0, 0)));
+    }
+    {
+        let expected = "3IJ\nKL\n4AB\nCD\n5EF\nGH";
+        assert_eq!(expected, dump(&s, screen_pt(0, 0)));
+    }
+}
+
+#[test]
+fn screen_resize_less_cols_with_reflow_previously_wrapped() {
+    let mut s = init(5, 3, 0);
+    let str = "3IJKL4ABCD5EFGH";
+    s.test_write_string(str).unwrap();
+
+    // Check
+    {
+        let expected = "3IJKL\n4ABCD\n5EFGH";
+        assert_eq!(expected, dump(&s, screen_pt(0, 0)));
+    }
+
+    resize(&mut s, 3, 3);
+
+    // {
+    //     const contents = try s.testString(alloc, .viewport);
+    //     const expected = "CD\n5EF\nGH";
+    // }
+    {
+        let expected = "ABC\nD5E\nFGH";
+        assert_eq!(expected, dump(&s, screen_pt(0, 0)));
+    }
+}
+
+#[test]
+fn screen_resize_less_cols_with_reflow_and_scrollback() {
+    let mut s = init(5, 3, 5);
+    let str = "1A\n2B\n3C\n4D\n5E";
+    s.test_write_string(str).unwrap();
+
+    // Put our cursor on the end
+    s.cursor_absolute(1, s.pages.rows - 1);
+    {
+        assert_eq!(u32::from('E'), cursor_cell_cp(&s));
+    }
+
+    resize(&mut s, 3, 3);
+
+    {
+        let expected = "3C\n4D\n5E";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+
+    // Cursor should be on the last line
+    assert_eq!(1, s.cursor.x);
+    assert_eq!(2, s.cursor.y);
+}
+
+#[test]
+fn screen_resize_less_cols_with_reflow_previously_wrapped_and_scrollback() {
+    let mut s = init(5, 3, 2);
+    let str = "1ABCD2EFGH3IJKL4ABCD5EFGH";
+    s.test_write_string(str).unwrap();
+
+    // Check
+    {
+        let expected = "3IJKL\n4ABCD\n5EFGH";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+
+    // Put our cursor on the end
+    s.cursor_absolute(s.pages.cols - 1, s.pages.rows - 1);
+    {
+        assert_eq!(u32::from('H'), cursor_cell_cp(&s));
+    }
+
+    resize(&mut s, 3, 3);
+
+    {
+        let expected = "CD5\nEFG\nH";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+    {
+        let expected = "1AB\nCD2\nEFG\nH3I\nJKL\n4AB\nCD5\nEFG\nH";
+        assert_eq!(expected, dump(&s, screen_pt(0, 0)));
+    }
+
+    // Cursor should be on the last line
+    assert_eq!(0, s.cursor.x);
+    assert_eq!(2, s.cursor.y);
+    {
+        assert_eq!(u32::from('H'), cursor_cell_cp(&s));
+    }
+}
+
+#[test]
+fn screen_resize_less_cols_with_scrollback_keeps_cursor_row() {
+    let mut s = init(5, 3, 5);
+    let str = "1A\n2B\n3C\n4D\n5E";
+    s.test_write_string(str).unwrap();
+
+    // Lets do a scroll and clear operation
+    s.scroll_clear().unwrap();
+
+    // Move our cursor to the beginning
+    s.cursor_absolute(0, 0);
+
+    resize(&mut s, 3, 3);
+
+    {
+        assert_eq!("", dump(&s, viewport(0, 0)));
+    }
+
+    // Cursor should be on the last line
+    assert_eq!(0, s.cursor.x);
+    assert_eq!(0, s.cursor.y);
+}
+
+#[test]
+fn screen_resize_more_rows_less_cols_with_reflow_with_scrollback() {
+    let mut s = init(5, 3, 3);
+    let str = "1ABCD\n2EFGH3IJKL\n4MNOP";
+    s.test_write_string(str).unwrap();
+
+    {
+        let expected = "1ABCD\n2EFGH\n3IJKL\n4MNOP";
+        assert_eq!(expected, dump(&s, screen_pt(0, 0)));
+    }
+    {
+        let expected = "2EFGH\n3IJKL\n4MNOP";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+
+    resize(&mut s, 2, 10);
+
+    {
+        let expected = "BC\nD\n2E\nFG\nH3\nIJ\nKL\n4M\nNO\nP";
+        assert_eq!(expected, dump(&s, viewport(0, 0)));
+    }
+    {
+        let expected = "1A\nBC\nD\n2E\nFG\nH3\nIJ\nKL\n4M\nNO\nP";
+        assert_eq!(expected, dump(&s, screen_pt(0, 0)));
+    }
+}
+
+// This seems like it should work fine but for some reason in practice
+// in the initial implementation I found this bug! This is a regression
+// test for that.
+#[test]
+fn screen_resize_more_rows_then_shrink_again() {
+    let mut s = init(5, 3, 10);
+    let str = "1ABC";
+    s.test_write_string(str).unwrap();
+
+    // Grow
+    resize(&mut s, 5, 10);
+    {
+        assert_eq!(str, dump(&s, viewport(0, 0)));
+    }
+    {
+        assert_eq!(str, dump(&s, screen_pt(0, 0)));
+    }
+
+    // Shrink
+    resize(&mut s, 5, 3);
+    {
+        assert_eq!(str, dump(&s, screen_pt(0, 0)));
+    }
+    {
+        assert_eq!(str, dump(&s, viewport(0, 0)));
+    }
+
+    // Grow again
+    resize(&mut s, 5, 10);
+    {
+        assert_eq!(str, dump(&s, viewport(0, 0)));
+    }
+    {
+        assert_eq!(str, dump(&s, screen_pt(0, 0)));
+    }
+}
+
+#[test]
+fn screen_resize_less_cols_to_eliminate_wide_char() {
+    let mut s = init(2, 1, 0);
+    let str = "😀";
+    s.test_write_string(str).unwrap();
+    {
+        assert_eq!(str, dump(&s, screen_pt(0, 0)));
+    }
+    {
+        let cell = cell_at(&s, screen_pt(0, 0));
+        assert_eq!(Wide::Wide, cell.wide());
+        assert_eq!(u32::from('😀'), cell.codepoint());
+    }
+
+    // Resize to 1 column can't fit a wide char. So it should be deleted.
+    resize(&mut s, 1, 1);
+    {
+        assert_eq!("", dump(&s, screen_pt(0, 0)));
+    }
+    {
+        let cell = cell_at(&s, screen_pt(0, 0));
+        assert_eq!(0, cell.codepoint());
+        assert_eq!(Wide::Narrow, cell.wide());
+    }
+}
+
+#[test]
+#[ignore = "pagelist: reflow keeps trailing blank rows, pushing the wrapped first row into history (erased by no_scrollback)"]
+fn screen_resize_less_cols_to_wrap_wide_char() {
+    let mut s = init(3, 3, 0);
+    let str = "x😀";
+    s.test_write_string(str).unwrap();
+    {
+        assert_eq!(str, dump(&s, screen_pt(0, 0)));
+    }
+    {
+        let cell = cell_at(&s, screen_pt(1, 0));
+        assert_eq!(Wide::Wide, cell.wide());
+        assert_eq!(u32::from('😀'), cell.codepoint());
+    }
+    {
+        let cell = cell_at(&s, screen_pt(2, 0));
+        assert_eq!(Wide::SpacerTail, cell.wide());
+    }
+
+    resize(&mut s, 2, 3);
+    {
+        assert_eq!("x\n😀", dump(&s, screen_pt(0, 0)));
+    }
+    {
+        let cell = cell_at(&s, screen_pt(1, 0));
+        assert_eq!(Wide::SpacerHead, cell.wide());
+        assert!(row_at(&s, screen_pt(0, 0)).wrap());
+    }
+}
+
+#[test]
+fn screen_resize_less_cols_to_eliminate_wide_char_with_row_space() {
+    let mut s = init(2, 2, 0);
+    let str = "😀";
+    s.test_write_string(str).unwrap();
+    {
+        assert_eq!(str, dump(&s, screen_pt(0, 0)));
+    }
+    {
+        let cell = cell_at(&s, screen_pt(0, 0));
+        assert_eq!(Wide::Wide, cell.wide());
+        assert_eq!(u32::from('😀'), cell.codepoint());
+    }
+    {
+        let cell = cell_at(&s, screen_pt(1, 0));
+        assert_eq!(Wide::SpacerTail, cell.wide());
+    }
+
+    resize(&mut s, 1, 2);
+    {
+        assert_eq!("", dump(&s, screen_pt(0, 0)));
+    }
+}
+
+#[test]
+fn screen_resize_more_cols_with_wide_spacer_head() {
+    let mut s = init(3, 2, 0);
+    let str = "  😀";
+    s.test_write_string(str).unwrap();
+    {
+        assert_eq!("  \n😀", dump(&s, screen_pt(0, 0)));
+    }
+
+    // So this is the key point: we end up with a wide spacer head at
+    // the end of row 1, then the emoji, then a wide spacer tail on row 2.
+    // We should expect that if we resize to more cols, the wide spacer
+    // head is replaced with the emoji.
+    {
+        let cell = cell_at(&s, screen_pt(2, 0));
+        assert_eq!(Wide::SpacerHead, cell.wide());
+    }
+    {
+        let cell = cell_at(&s, screen_pt(0, 1));
+        assert_eq!(Wide::Wide, cell.wide());
+    }
+    {
+        let cell = cell_at(&s, screen_pt(1, 1));
+        assert_eq!(Wide::SpacerTail, cell.wide());
+    }
+
+    resize(&mut s, 4, 2);
+    {
+        assert_eq!(str, dump(&s, screen_pt(0, 0)));
+    }
+    {
+        let cell = cell_at(&s, screen_pt(2, 0));
+        assert_eq!(Wide::Wide, cell.wide());
+        assert_eq!(u32::from('😀'), cell.codepoint());
+    }
+    {
+        let cell = cell_at(&s, screen_pt(3, 0));
+        assert_eq!(Wide::SpacerTail, cell.wide());
+    }
+}

crates/ghostty-terminal/src/screen/tests/p4.rs

@@ -0,0 +1,751 @@
+use super::*;
+
+/// Asserts the selection start/end map to the expected points in `tag`.
+fn expect_sel(s: &Screen, sel: &Selection, tag: Tag, start: (u16, u32), end: (u16, u32)) {
+    let mk = |(x, y): (u16, u32)| Point::new(tag, Coordinate { x, y });
+    assert_eq!(
+        mk(start),
+        s.pages.point_from_pin(tag, sel.start(&s.pages)).unwrap()
+    );
+    assert_eq!(
+        mk(end),
+        s.pages.point_from_pin(tag, sel.end(&s.pages)).unwrap()
+    );
+}
+
+fn line(s: &Screen, x: u16, y: u32) -> Selection {
+    s.select_line(SelectLine::new(pin(s, active(x, y))))
+        .unwrap()
+}
+
+fn sel_str(s: &Screen, sel: Selection, trim: bool) -> String {
+    s.selection_string(SelectionString { sel, trim })
+}
+
+const BOUNDARY: &[u32] = &[
+    0,
+    ' ' as u32,
+    '\t' as u32,
+    '\'' as u32,
+    '"' as u32,
+    '│' as u32,
+    '`' as u32,
+    '|' as u32,
+    ':' as u32,
+    ';' as u32,
+    ',' as u32,
+    '(' as u32,
+    ')' as u32,
+    '[' as u32,
+    ']' as u32,
+    '{' as u32,
+    '}' as u32,
+    '<' as u32,
+    '>' as u32,
+    '$' as u32,
+];
+
+fn word(s: &Screen, x: u16, y: u32) -> Selection {
+    s.select_word(pin(s, active(x, y)), BOUNDARY).unwrap()
+}
+
+#[test]
+fn screen_resize_more_cols_with_wide_spacer_head_multiple_lines() {
+    let mut s = init(3, 3, 0);
+    let str = "xxxyy😀";
+    s.test_write_string(str).unwrap();
+    assert_eq!("xxx\nyy\n😀", dump(&s, screen_pt(0, 0)));
+
+    // Similar to the "wide spacer head" test, but this time we'er going
+    // to increase our columns such that multiple rows are unwrapped.
+    assert_eq!(
+        Wide::SpacerHead,
+        s.pages.get_cell(screen_pt(2, 1)).unwrap().wide()
+    );
+    assert_eq!(
+        Wide::Wide,
+        s.pages.get_cell(screen_pt(0, 2)).unwrap().wide()
+    );
+    assert_eq!(
+        Wide::SpacerTail,
+        s.pages.get_cell(screen_pt(1, 2)).unwrap().wide()
+    );
+
+    s.resize(Resize::new(8, 2)).unwrap();
+    assert_eq!(str, dump(&s, screen_pt(0, 0)));
+    {
+        let cell = s.pages.get_cell(screen_pt(5, 0)).unwrap();
+        assert_eq!(Wide::Wide, cell.wide());
+        assert_eq!('😀' as u32, cell.codepoint());
+    }
+    assert_eq!(
+        Wide::SpacerTail,
+        s.pages.get_cell(screen_pt(6, 0)).unwrap().wide()
+    );
+}
+
+#[test]
+fn screen_resize_more_cols_requiring_a_wide_spacer_head() {
+    let mut s = init(2, 2, 0);
+    let str = "xx😀";
+    s.test_write_string(str).unwrap();
+    assert_eq!("xx\n😀", dump(&s, screen_pt(0, 0)));
+    assert_eq!(
+        Wide::Wide,
+        s.pages.get_cell(screen_pt(0, 1)).unwrap().wide()
+    );
+    assert_eq!(
+        Wide::SpacerTail,
+        s.pages.get_cell(screen_pt(1, 1)).unwrap().wide()
+    );
+
+    // This resizes to 3 columns, which isn't enough space for our wide
+    // char to enter row 1. But we need to mark the wide spacer head on the
+    // end of the first row since we're wrapping to the next row.
+    s.resize(Resize::new(3, 2)).unwrap();
+    assert_eq!("xx\n😀", dump(&s, screen_pt(0, 0)));
+    assert_eq!(
+        Wide::SpacerHead,
+        s.pages.get_cell(screen_pt(2, 0)).unwrap().wide()
+    );
+    {
+        let cell = s.pages.get_cell(screen_pt(0, 1)).unwrap();
+        assert_eq!(Wide::Wide, cell.wide());
+        assert_eq!('😀' as u32, cell.codepoint());
+    }
+    assert_eq!(
+        Wide::SpacerTail,
+        s.pages.get_cell(screen_pt(1, 1)).unwrap().wide()
+    );
+}
+
+#[test]
+fn screen_resize_more_cols_with_cursor_at_prompt() {
+    let mut s = init(10, 3, 5);
+
+    s.test_write_string("ABCDE\n").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Prompt(PromptKind::Initial));
+    s.test_write_string("> ").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Input(InputClear::ClearEol));
+    s.test_write_string("echo").unwrap();
+
+    assert_eq!("ABCDE\n> echo", dump(&s, viewport(0, 0)));
+
+    s.resize(Resize {
+        prompt_redraw: Redraw::True,
+        ..Resize::new(20, 3)
+    })
+    .unwrap();
+
+    // Cursor should not move
+    assert_eq!(6, s.cursor.x);
+    assert_eq!(1, s.cursor.y);
+
+    assert_eq!("ABCDE", dump(&s, viewport(0, 0)));
+}
+
+#[test]
+fn screen_resize_more_cols_with_cursor_not_at_prompt() {
+    let mut s = init(10, 3, 5);
+
+    s.test_write_string("ABCDE\n").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Prompt(PromptKind::Initial));
+    s.test_write_string("> ").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Input(InputClear::ClearEol));
+    s.test_write_string("echo\n").unwrap();
+    s.test_write_string("output").unwrap();
+
+    assert_eq!("ABCDE\n> echo\noutput", dump(&s, viewport(0, 0)));
+
+    s.resize(Resize {
+        prompt_redraw: Redraw::True,
+        ..Resize::new(20, 3)
+    })
+    .unwrap();
+
+    // Cursor should not move
+    assert_eq!(6, s.cursor.x);
+    assert_eq!(2, s.cursor.y);
+
+    assert_eq!("ABCDE\n> echo\noutput", dump(&s, viewport(0, 0)));
+}
+
+#[test]
+fn screen_resize_with_prompt_redraw_last_clears_only_one_line() {
+    let mut s = init(10, 4, 5);
+
+    s.test_write_string("ABCDE\n").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Prompt(PromptKind::Initial));
+    s.test_write_string("> ").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Input(InputClear::ClearExplicit));
+    s.test_write_string("hello\n").unwrap();
+    s.test_write_string("world").unwrap();
+
+    assert_eq!("ABCDE\n> hello\nworld", dump(&s, viewport(0, 0)));
+
+    // Cursor is at end of "world" line with semantic_content = .input
+    s.resize(Resize {
+        prompt_redraw: Redraw::Last,
+        ..Resize::new(20, 4)
+    })
+    .unwrap();
+
+    // With .last, only the current line where cursor is should be cleared
+    assert_eq!("ABCDE\n> hello", dump(&s, viewport(0, 0)));
+}
+
+#[test]
+fn screen_resize_with_prompt_redraw_last_multiline_prompt_clears_only_last_line() {
+    let mut s = init(20, 5, 5);
+
+    // Create a 3-line prompt: 1 initial + 2 continuation lines
+    s.cursor_set_semantic_content(SemanticContentSet::Prompt(PromptKind::Initial));
+    s.test_write_string("line1\n").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Prompt(PromptKind::Continuation));
+    s.test_write_string("line2\n").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Prompt(PromptKind::Continuation));
+    s.test_write_string("line3").unwrap();
+
+    assert_eq!("line1\nline2\nline3", dump(&s, viewport(0, 0)));
+
+    // Cursor is at end of line3 (the last continuation line)
+    s.resize(Resize {
+        prompt_redraw: Redraw::Last,
+        ..Resize::new(30, 5)
+    })
+    .unwrap();
+
+    // With .last, only line3 (where cursor is) should be cleared
+    assert_eq!("line1\nline2", dump(&s, viewport(0, 0)));
+}
+
+#[test]
+fn screen_select_untracked() {
+    let mut s = init(10, 10, 0);
+    s.test_write_string("ABC  DEF\n 123\n456").unwrap();
+
+    assert!(s.selection.is_none());
+    let tracked = s.pages.count_tracked_pins();
+    let sel = Selection::new(pin(&s, active(0, 0)), pin(&s, active(3, 0)), false);
+    s.select(Some(sel)).unwrap();
+    assert_eq!(tracked + 2, s.pages.count_tracked_pins());
+    s.select(None).unwrap();
+    assert_eq!(tracked, s.pages.count_tracked_pins());
+}
+
+#[test]
+fn screen_select_all() {
+    let mut s = init(10, 10, 0);
+
+    {
+        s.test_write_string("ABC  DEF\n 123\n456").unwrap();
+        let sel = s.select_all().unwrap();
+        expect_sel(&s, &sel, Tag::Screen, (0, 0), (2, 2));
+    }
+
+    {
+        s.test_write_string("\nFOO\n BAR\n BAZ\n QWERTY\n 12345678")
+            .unwrap();
+        let sel = s.select_all().unwrap();
+        expect_sel(&s, &sel, Tag::Screen, (0, 0), (8, 7));
+    }
+}
+
+#[test]
+fn screen_select_line() {
+    let mut s = init(10, 10, 0);
+    s.test_write_string("ABC  DEF\n 123\n456").unwrap();
+
+    // Going forward
+    let sel = line(&s, 0, 0);
+    expect_sel(&s, &sel, Tag::Screen, (0, 0), (7, 0));
+
+    // Going backward
+    let sel = line(&s, 7, 0);
+    expect_sel(&s, &sel, Tag::Screen, (0, 0), (7, 0));
+
+    // Going forward and backward
+    let sel = line(&s, 3, 0);
+    expect_sel(&s, &sel, Tag::Screen, (0, 0), (7, 0));
+
+    // Outside active area
+    let sel = line(&s, 9, 0);
+    expect_sel(&s, &sel, Tag::Screen, (0, 0), (7, 0));
+}
+
+#[test]
+fn screen_select_line_across_soft_wrap() {
+    let mut s = init(5, 10, 0);
+    s.test_write_string(" 12 34012   \n 123").unwrap();
+
+    // Going forward
+    let sel = line(&s, 1, 0);
+    expect_sel(&s, &sel, Tag::Screen, (1, 0), (3, 1));
+}
+
+#[test]
+fn screen_select_line_across_full_soft_wrap() {
+    let mut s = init(5, 5, 0);
+    s.test_write_string("1ABCD2EFGH\n3IJKL").unwrap();
+
+    let sel = line(&s, 2, 1);
+    expect_sel(&s, &sel, Tag::Screen, (0, 0), (4, 1));
+}
+
+#[test]
+fn screen_select_line_across_soft_wrap_ignores_blank_lines() {
+    let mut s = init(5, 10, 0);
+    s.test_write_string(" 12 34012             \n 123").unwrap();
+
+    // Going forward
+    let sel = line(&s, 1, 0);
+    expect_sel(&s, &sel, Tag::Screen, (1, 0), (3, 1));
+
+    // Going backward
+    let sel = line(&s, 1, 1);
+    expect_sel(&s, &sel, Tag::Screen, (1, 0), (3, 1));
+
+    // Going forward and backward
+    let sel = line(&s, 3, 0);
+    expect_sel(&s, &sel, Tag::Screen, (1, 0), (3, 1));
+}
+
+#[test]
+fn screen_select_line_disabled_whitespace_trimming() {
+    let mut s = init(5, 10, 0);
+    s.test_write_string(" 12 34012   \n 123").unwrap();
+
+    // Going forward
+    let sel = s
+        .select_line(SelectLine {
+            whitespace: None,
+            ..SelectLine::new(pin(&s, active(1, 0)))
+        })
+        .unwrap();
+    expect_sel(&s, &sel, Tag::Screen, (0, 0), (4, 2));
+
+    // Non-wrapped
+    let sel = s
+        .select_line(SelectLine {
+            whitespace: None,
+            ..SelectLine::new(pin(&s, active(1, 3)))
+        })
+        .unwrap();
+    expect_sel(&s, &sel, Tag::Screen, (0, 3), (4, 3));
+}
+
+#[test]
+fn screen_select_line_with_scrollback() {
+    let mut s = init(2, 3, 5);
+    s.test_write_string("1A\n2B\n3C\n4D\n5E").unwrap();
+
+    // Selecting first line
+    let sel = line(&s, 0, 0);
+    expect_sel(&s, &sel, Tag::Active, (0, 0), (1, 0));
+
+    // Selecting last line
+    let sel = line(&s, 0, 2);
+    expect_sel(&s, &sel, Tag::Active, (0, 2), (1, 2));
+}
+
+// https://github.com/mitchellh/ghostty/issues/1329
+#[test]
+fn screen_select_line_semantic_prompt_boundary() {
+    let mut s = init(5, 10, 0);
+    s.test_write_string("ABCDE\n").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Prompt(PromptKind::Initial));
+    s.test_write_string("A    ").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Output);
+    s.test_write_string("> ").unwrap();
+
+    assert_eq!("ABCDE\nA    \n> ", dump(&s, screen_pt(0, 0)));
+
+    // Selecting output stops at the prompt even if soft-wrapped
+    {
+        let sel = line(&s, 1, 1);
+        assert_eq!("A", sel_str(&s, sel, false));
+    }
+    {
+        let sel = line(&s, 1, 2);
+        expect_sel(&s, &sel, Tag::Active, (0, 2), (0, 2));
+    }
+}
+
+#[test]
+fn screen_select_line_semantic_prompt_to_input_boundary() {
+    let mut s = init(10, 5, 0);
+
+    // Write prompt followed by user input on same row: "$>command"
+    // Using non-whitespace to avoid whitespace trimming affecting the test
+    s.cursor_set_semantic_content(SemanticContentSet::Prompt(PromptKind::Initial));
+    s.test_write_string("$>").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Input(InputClear::ClearExplicit));
+    s.test_write_string("command").unwrap();
+
+    // Selecting from prompt should only select prompt
+    let sel = line(&s, 0, 0);
+    expect_sel(&s, &sel, Tag::Active, (0, 0), (1, 0));
+
+    // Selecting from input should only select input
+    let sel = line(&s, 5, 0);
+    expect_sel(&s, &sel, Tag::Active, (2, 0), (8, 0));
+}
+
+#[test]
+fn screen_select_line_semantic_input_to_output_boundary() {
+    let mut s = init(10, 5, 0);
+
+    // Row 0: user input
+    s.cursor_set_semantic_content(SemanticContentSet::Input(InputClear::ClearExplicit));
+    s.test_write_string("ls -la\n").unwrap();
+    // Row 1: command output
+    s.cursor_set_semantic_content(SemanticContentSet::Output);
+    s.test_write_string("file.txt").unwrap();
+
+    // Selecting from input should only select input
+    let sel = line(&s, 2, 0);
+    assert_eq!("ls -la", sel_str(&s, sel, false));
+
+    // Selecting from output should only select output
+    let sel = line(&s, 2, 1);
+    assert_eq!("file.txt", sel_str(&s, sel, false));
+}
+
+#[test]
+fn screen_select_line_semantic_mid_row_boundary() {
+    let mut s = init(10, 5, 0);
+
+    // Single row with output then prompt then input: "out$>cmd"
+    // Using non-whitespace to avoid whitespace trimming affecting the test
+    s.cursor_set_semantic_content(SemanticContentSet::Output);
+    s.test_write_string("out").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Prompt(PromptKind::Initial));
+    s.test_write_string("$>").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Input(InputClear::ClearExplicit));
+    s.test_write_string("cmd").unwrap();
+
+    // Selecting from output should stop at prompt
+    let sel = line(&s, 1, 0);
+    expect_sel(&s, &sel, Tag::Active, (0, 0), (2, 0));
+
+    // Selecting from prompt should only select prompt
+    let sel = line(&s, 3, 0);
+    expect_sel(&s, &sel, Tag::Active, (3, 0), (4, 0));
+
+    // Selecting from input should only select input
+    let sel = line(&s, 6, 0);
+    expect_sel(&s, &sel, Tag::Active, (5, 0), (7, 0));
+}
+
+#[test]
+fn screen_select_line_semantic_boundary_soft_wrap_with_mid_row_transition() {
+    let mut s = init(5, 5, 0);
+
+    // Row 0: prompt "$ " + input "cmd" (soft-wraps)
+    // Row 1: input continues "12" + output "out"
+    s.cursor_set_semantic_content(SemanticContentSet::Prompt(PromptKind::Initial));
+    s.test_write_string("$ ").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Input(InputClear::ClearExplicit));
+    s.test_write_string("cmd12").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Output);
+    s.test_write_string("out").unwrap();
+
+    // Verify layout
+    assert_eq!("$ cmd\n12out", dump(&s, screen_pt(0, 0)));
+
+    // Selecting from input on row 0 should get all input across soft-wrap
+    let sel = line(&s, 3, 0);
+    assert_eq!("cmd12", sel_str(&s, sel, false));
+
+    // Selecting from input on row 1 should get all input across soft-wrap
+    let sel = line(&s, 0, 1);
+    assert_eq!("cmd12", sel_str(&s, sel, false));
+
+    // Selecting from output should only get output
+    let sel = line(&s, 3, 1);
+    assert_eq!("out", sel_str(&s, sel, false));
+}
+
+#[test]
+fn screen_select_line_semantic_boundary_disabled() {
+    let mut s = init(10, 5, 0);
+
+    // Write prompt followed by input
+    s.cursor_set_semantic_content(SemanticContentSet::Prompt(PromptKind::Initial));
+    s.test_write_string("$ ").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Input(InputClear::ClearExplicit));
+    s.test_write_string("command").unwrap();
+
+    // With semantic_prompt_boundary = false, should select entire line
+    let sel = s
+        .select_line(SelectLine {
+            semantic_prompt_boundary: false,
+            ..SelectLine::new(pin(&s, active(0, 0)))
+        })
+        .unwrap();
+    assert_eq!("$ command", sel_str(&s, sel, false));
+}
+
+#[test]
+fn screen_select_line_semantic_boundary_first_cell_of_row() {
+    let mut s = init(5, 5, 0);
+
+    // Row 0: input that soft-wraps
+    // Row 1: output starts at first cell
+    s.cursor_set_semantic_content(SemanticContentSet::Input(InputClear::ClearExplicit));
+    s.test_write_string("12345").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Output);
+    s.test_write_string("ABCDE").unwrap();
+
+    // Verify soft-wrap happened
+    {
+        let p = pin(&s, active(0, 0));
+        let (row, _) = p.row_and_cell(&s.pages).unwrap();
+        assert!(row.wrap());
+    }
+
+    // Selecting from input should stop before output on row 1
+    let sel = line(&s, 2, 0);
+    expect_sel(&s, &sel, Tag::Active, (0, 0), (4, 0));
+
+    // Selecting from output should only get output
+    let sel = line(&s, 2, 1);
+    expect_sel(&s, &sel, Tag::Active, (0, 1), (4, 1));
+}
+
+#[test]
+fn screen_select_line_semantic_all_same_content() {
+    let mut s = init(5, 5, 0);
+
+    // All prompt content that soft-wraps
+    s.cursor_set_semantic_content(SemanticContentSet::Prompt(PromptKind::Initial));
+    s.test_write_string("prompt text").unwrap();
+
+    // Verify soft-wrap
+    assert_eq!("promp\nt tex\nt", dump(&s, screen_pt(0, 0)));
+
+    // Should select all prompt content across soft-wraps
+    let sel = line(&s, 2, 1);
+    assert_eq!("prompt text", sel_str(&s, sel, false));
+}
+
+#[test]
+fn screen_select_word() {
+    let mut s = init(10, 10, 0);
+    s.test_write_string("ABC  DEF\n 123\n456").unwrap();
+
+    // Going forward
+    let sel = word(&s, 0, 0);
+    expect_sel(&s, &sel, Tag::Screen, (0, 0), (2, 0));
+
+    // Going backward
+    let sel = word(&s, 2, 0);
+    expect_sel(&s, &sel, Tag::Screen, (0, 0), (2, 0));
+
+    // Going forward and backward
+    let sel = word(&s, 1, 0);
+    expect_sel(&s, &sel, Tag::Screen, (0, 0), (2, 0));
+
+    // Whitespace
+    let sel = word(&s, 3, 0);
+    expect_sel(&s, &sel, Tag::Screen, (3, 0), (4, 0));
+
+    // Whitespace single char
+    let sel = word(&s, 0, 1);
+    expect_sel(&s, &sel, Tag::Screen, (0, 1), (0, 1));
+
+    // End of screen
+    let sel = word(&s, 1, 2);
+    expect_sel(&s, &sel, Tag::Screen, (0, 2), (2, 2));
+}
+
+#[test]
+fn screen_select_word_across_soft_wrap() {
+    let mut s = init(5, 10, 0);
+    s.test_write_string(" 1234012\n 123").unwrap();
+
+    assert_eq!(" 1234\n012\n 123", dump(&s, screen_pt(0, 0)));
+
+    // Going forward
+    let sel = word(&s, 1, 0);
+    expect_sel(&s, &sel, Tag::Screen, (1, 0), (2, 1));
+
+    // Going backward
+    let sel = word(&s, 1, 1);
+    expect_sel(&s, &sel, Tag::Screen, (1, 0), (2, 1));
+
+    // Going forward and backward
+    let sel = word(&s, 3, 0);
+    expect_sel(&s, &sel, Tag::Screen, (1, 0), (2, 1));
+}
+
+#[test]
+fn screen_select_word_whitespace_across_soft_wrap() {
+    let mut s = init(5, 10, 0);
+    s.test_write_string("1       1\n 123").unwrap();
+
+    // Going forward
+    let sel = word(&s, 1, 0);
+    expect_sel(&s, &sel, Tag::Screen, (1, 0), (2, 1));
+
+    // Going backward
+    let sel = word(&s, 1, 1);
+    expect_sel(&s, &sel, Tag::Screen, (1, 0), (2, 1));
+
+    // Going forward and backward
+    let sel = word(&s, 3, 0);
+    expect_sel(&s, &sel, Tag::Screen, (1, 0), (2, 1));
+}
+
+#[test]
+fn screen_select_word_with_character_boundary() {
+    let cases = [
+        " 'abc' \n123",
+        " \"abc\" \n123",
+        " │abc│ \n123",
+        " `abc` \n123",
+        " |abc| \n123",
+        " :abc: \n123",
+        " ;abc; \n123",
+        " ,abc, \n123",
+        " (abc( \n123",
+        " )abc) \n123",
+        " [abc[ \n123",
+        " ]abc] \n123",
+        " {abc{ \n123",
+        " }abc} \n123",
+        " <abc< \n123",
+        " >abc> \n123",
+        " $abc$ \n123",
+    ];
+
+    for case in cases {
+        let mut s = init(20, 10, 0);
+        s.test_write_string(case).unwrap();
+
+        // Inside character forward
+        let sel = word(&s, 2, 0);
+        expect_sel(&s, &sel, Tag::Screen, (2, 0), (4, 0));
+
+        // Inside character backward
+        let sel = word(&s, 4, 0);
+        expect_sel(&s, &sel, Tag::Screen, (2, 0), (4, 0));
+
+        // Inside character bidirectional
+        let sel = word(&s, 3, 0);
+        expect_sel(&s, &sel, Tag::Screen, (2, 0), (4, 0));
+
+        // On quote
+        // NOTE: this behavior is not ideal, so we can change this one day,
+        // but I think its also not that important compared to the above.
+        let sel = word(&s, 1, 0);
+        expect_sel(&s, &sel, Tag::Screen, (0, 0), (1, 0));
+    }
+}
+
+#[test]
+fn screen_select_output() {
+    let mut s = init(10, 15, 0);
+
+    // Build content with cell-level semantic content:
+    // Row 0-1: output1 (output)
+    // Row 2: prompt2 (prompt)
+    // Row 3: input2 (input)
+    // Row 4-7: output2 (output, with overflow causing wrap)
+    // Row 8: "$ " (prompt) + "input3" (input)
+    // Row 9-11: output3 (output)
+    s.cursor_set_semantic_content(SemanticContentSet::Output);
+    s.test_write_string("output1\n").unwrap();
+    s.test_write_string("output1\n").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Prompt(PromptKind::Initial));
+    s.test_write_string("prompt2\n").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Input(InputClear::ClearExplicit));
+    s.test_write_string("input2\n").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Output);
+    s.test_write_string("output2output2output2output2\n")
+        .unwrap();
+    s.test_write_string("output2\n").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Prompt(PromptKind::Initial));
+    s.test_write_string("$ ").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Input(InputClear::ClearExplicit));
+    s.test_write_string("input3\n").unwrap();
+    s.cursor_set_semantic_content(SemanticContentSet::Output);
+    s.test_write_string("output3\n").unwrap();
+    s.test_write_string("output3\n").unwrap();
+    s.test_write_string("output3").unwrap();
+
+    // First output block (rows 0-1), should select those rows
+    {
+        let sel = s.select_output(pin(&s, active(1, 1))).unwrap();
+        assert_eq!("output1\noutput1", sel_str(&s, sel, false));
+    }
+
+    // Second output block (rows 4-7)
+    {
+        let sel = s.select_output(pin(&s, active(3, 7))).unwrap();
+        assert_eq!(
+            "output2output2output2output2\noutput2",
+            sel_str(&s, sel, false)
+        );
+    }
+
+    // Third output block (rows 9-11)
+    {
+        let sel = s.select_output(pin(&s, active(2, 10))).unwrap();
+        expect_sel(&s, &sel, Tag::Active, (0, 9), (6, 11));
+    }
+
+    // Click on prompt should return null
+    assert!(s.select_output(pin(&s, active(1, 8))).is_none());
+
+    // Click on input should return null
+    assert!(s.select_output(pin(&s, active(5, 8))).is_none());
+}
+
+#[test]
+fn screen_selection_string_basic() {
+    let mut s = init(5, 3, 0);
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL").unwrap();
+    let sel = Selection::new(pin(&s, screen_pt(0, 1)), pin(&s, screen_pt(2, 2)), false);
+    assert_eq!("2EFGH\n3IJ", sel_str(&s, sel, true));
+}
+
+#[test]
+fn screen_selection_string_start_outside_of_written_area() {
+    let mut s = init(5, 10, 0);
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL").unwrap();
+    let sel = Selection::new(pin(&s, screen_pt(0, 5)), pin(&s, screen_pt(2, 6)), false);
+    assert_eq!("", sel_str(&s, sel, true));
+}
+
+#[test]
+fn screen_selection_string_end_outside_of_written_area() {
+    let mut s = init(5, 10, 0);
+    s.test_write_string("1ABCD\n2EFGH\n3IJKL").unwrap();
+    let sel = Selection::new(pin(&s, screen_pt(0, 2)), pin(&s, screen_pt(2, 6)), false);
+    assert_eq!("3IJKL", sel_str(&s, sel, true));
+}
+
+#[test]
+fn screen_selection_string_trim_space() {
+    let mut s = init(5, 3, 0);
+    s.test_write_string("1AB  \n2EFGH\n3IJKL").unwrap();
+    let sel = Selection::new(pin(&s, screen_pt(0, 0)), pin(&s, screen_pt(2, 1)), false);
+    assert_eq!("1AB\n2EF", sel_str(&s, sel, true));
+
+    // No trim
+    assert_eq!("1AB  \n2EF", sel_str(&s, sel, false));
+}
+
+#[test]
+fn screen_selection_string_trim_empty_line() {
+    let mut s = init(5, 5, 0);
+    s.test_write_string("1AB  \n\n2EFGH\n3IJKL").unwrap();
+
+    let sel = Selection::new(pin(&s, screen_pt(0, 0)), pin(&s, screen_pt(2, 2)), false);
+
+    assert_eq!("1AB\n\n2EF", sel_str(&s, sel, true));
+
+    // No trim
+    assert_eq!("1AB  \n\n2EF", sel_str(&s, sel, false));
+}

crates/ghostty-terminal/src/screen/tests/p5.rs

@@ -0,0 +1,1076 @@
+use super::*;
+use crate::page::STD_CAPACITY;
+use crate::style::Color;
+use ghostty_vt::color::Rgb;
+use ghostty_vt::sgr::Attribute as A;
+
+fn sel_str(s: &Screen, sel: Selection, trim: bool) -> String {
+    s.selection_string(SelectionString { sel, trim })
+}
+
+fn sel_active(s: &Screen, a: (u16, u32), b: (u16, u32), rect: bool) -> Selection {
+    Selection::new(pin(s, active(a.0, a.1)), pin(s, active(b.0, b.1)), rect)
+}
+
+fn sel_screen(s: &Screen, a: (u16, u32), b: (u16, u32), rect: bool) -> Selection {
+    Selection::new(
+        pin(s, screen_pt(a.0, a.1)),
+        pin(s, screen_pt(b.0, b.1)),
+        rect,
+    )
+}
+
+#[test]
+fn screen_selection_string_trim_empty_line() {
+    let mut s = init(5, 5, 0);
+    s.test_write_string("1AB  \n\n2EFGH\n3IJKL").unwrap();
+
+    let sel = sel_screen(&s, (0, 0), (2, 2), false);
+
+    assert_eq!("1AB\n\n2EF", sel_str(&s, sel, true));
+
+    // No trim
+    assert_eq!("1AB  \n\n2EF", sel_str(&s, sel, false));
+}
+
+#[test]
+fn screen_selection_string_soft_wrap() {
+    let mut s = init(5, 3, 0);
+    s.test_write_string("1ABCD2EFGH3IJKL").unwrap();
+
+    let sel = sel_screen(&s, (0, 1), (2, 2), false);
+    assert_eq!("2EFGH3IJ", sel_str(&s, sel, true));
+}
+
+#[test]
+fn screen_selection_string_wide_char() {
+    let mut s = init(5, 3, 0);
+    let str = "1A\u{26A1}";
+    s.test_write_string(str).unwrap();
+
+    {
+        let sel = sel_screen(&s, (0, 0), (3, 0), false);
+        assert_eq!(str, sel_str(&s, sel, true));
+    }
+
+    {
+        let sel = sel_screen(&s, (0, 0), (2, 0), false);
+        assert_eq!(str, sel_str(&s, sel, true));
+    }
+
+    {
+        let sel = sel_screen(&s, (3, 0), (3, 0), false);
+        assert_eq!("\u{26A1}", sel_str(&s, sel, true));
+    }
+}
+
+#[test]
+fn screen_selection_string_wide_char_with_header() {
+    let mut s = init(5, 3, 0);
+    let str = "1ABC\u{26A1}";
+    s.test_write_string(str).unwrap();
+
+    let sel = sel_screen(&s, (0, 0), (4, 0), false);
+    assert_eq!(str, sel_str(&s, sel, true));
+}
+
+// https://github.com/mitchellh/ghostty/issues/289
+#[test]
+fn screen_selection_string_empty_with_soft_wrap() {
+    let mut s = init(5, 2, 0);
+
+    // Let me describe the situation that caused this because this
+    // test is not obvious. By writing an emoji below, we introduce
+    // one cell with the emoji and one cell as a "wide char spacer".
+    // We then soft wrap the line by writing spaces.
+    //
+    // By selecting only the tail, we'd select nothing and we had
+    // a logic error that would cause a crash.
+    s.test_write_string("\u{1F468}").unwrap();
+    s.test_write_string("      ").unwrap();
+
+    let sel = sel_screen(&s, (1, 0), (2, 0), false);
+    assert_eq!("\u{1F468}", sel_str(&s, sel, true));
+}
+
+#[test]
+fn screen_selection_string_with_zero_width_joiner() {
+    let mut s = init(10, 1, 0);
+    let str = "\u{1F468}\u{200D}"; // this has a ZWJ
+    s.test_write_string(str).unwrap();
+
+    // Integrity check
+    {
+        let p = pin(&s, screen_pt(0, 0));
+        let cell = s.pin_cell(p);
+        assert_eq!(0x1F468, cell.codepoint());
+        assert_eq!(Wide::Wide, cell.wide());
+        let cps = p.grapheme(&s.pages).unwrap();
+        assert_eq!(1, cps.len());
+    }
+
+    // The real test
+    {
+        let sel = sel_screen(&s, (0, 0), (1, 0), false);
+        assert_eq!("\u{1F468}\u{200D}", sel_str(&s, sel, true));
+    }
+}
+
+const LOREM: &str = "Lorem ipsum dolor\nsit amet, consectetur\nadipiscing elit, sed do\neiusmod tempor incididunt\nut labore et dolore";
+
+#[test]
+fn screen_selection_string_rectangle_basic() {
+    let mut s = init(30, 5, 0);
+    let sel = sel_screen(&s, (2, 1), (6, 3), true);
+    let expected = "t ame\nipisc\nusmod";
+    s.test_write_string(LOREM).unwrap();
+
+    assert_eq!(expected, sel_str(&s, sel, true));
+}
+
+#[test]
+fn screen_selection_string_rectangle_w_eol() {
+    let mut s = init(30, 5, 0);
+    let sel = sel_screen(&s, (12, 0), (26, 4), true);
+    let expected = "dolor\nnsectetur\nlit, sed do\nor incididunt\n dolore";
+    s.test_write_string(LOREM).unwrap();
+
+    assert_eq!(expected, sel_str(&s, sel, true));
+}
+
+#[test]
+fn screen_selection_string_rectangle_more_complex_w_breaks() {
+    let mut s = init(30, 8, 0);
+    let str = "Lorem ipsum dolor\nsit amet, consectetur\nadipiscing elit, sed do\neiusmod tempor incididunt\nut labore et dolore\n\nmagna aliqua. Ut enim\nad minim veniam, quis";
+    let sel = sel_screen(&s, (11, 2), (26, 7), true);
+    let expected = "elit, sed do\npor incididunt\nt dolore\n\na. Ut enim\nniam, quis";
+    s.test_write_string(str).unwrap();
+
+    assert_eq!(expected, sel_str(&s, sel, true));
+}
+
+#[test]
+fn screen_selection_string_multi_page() {
+    let mut s = init(10, 3, 2048);
+
+    let first = s.pages.first.unwrap();
+    let first_page_size = s.page(first).capacity.rows;
+
+    // Lazy way to seek to the first page boundary.
+    s.page_mut(first).pause_integrity_checks(true);
+    for _ in 0..first_page_size - 1 {
+        s.test_write_string("\n").unwrap();
+    }
+    s.page_mut(first).pause_integrity_checks(false);
+
+    s.test_write_string("123456789\n!@#$%^&*(\n123456789")
+        .unwrap();
+
+    {
+        let sel = sel_active(&s, (0, 0), (2, 2), false);
+        assert_eq!("123456789\n!@#$%^&*(\n123", sel_str(&s, sel, true));
+    }
+}
+
+#[test]
+fn screen_line_iterator() {
+    let mut s = init(5, 5, 0);
+    s.test_write_string("1ABCD\n2EFGH").unwrap();
+
+    // Test the line iterator
+    let mut iter = s.line_iterator(pin(&s, viewport(0, 0)));
+    {
+        let sel = iter.next().unwrap();
+        assert_eq!("1ABCD", sel_str(&s, sel, false));
+    }
+    {
+        let sel = iter.next().unwrap();
+        assert_eq!("2EFGH", sel_str(&s, sel, false));
+    }
+}
+
+#[test]
+fn screen_line_iterator_soft_wrap() {
+    let mut s = init(5, 5, 0);
+    s.test_write_string("1ABCD2EFGH\n3ABCD").unwrap();
+
+    // Test the line iterator
+    let mut iter = s.line_iterator(pin(&s, viewport(0, 0)));
+    {
+        let sel = iter.next().unwrap();
+        assert_eq!("1ABCD2EFGH", sel_str(&s, sel, false));
+    }
+    {
+        let sel = iter.next().unwrap();
+        assert_eq!("3ABCD", sel_str(&s, sel, false));
+    }
+    // assert!(iter.next().is_none());
+}
+
+#[test]
+fn screen_hyperlink_start_end() {
+    let mut s = init(5, 5, 0);
+    assert!(s.cursor.hyperlink_id == 0);
+    assert_eq!(0, s.cursor_page().hyperlink_set.count());
+
+    s.start_hyperlink(b"http://example.com", None).unwrap();
+    assert!(s.cursor.hyperlink_id != 0);
+    assert_eq!(1, s.cursor_page().hyperlink_set.count());
+
+    s.end_hyperlink();
+    assert!(s.cursor.hyperlink_id == 0);
+    assert_eq!(0, s.cursor_page().hyperlink_set.count());
+}
+
+#[test]
+fn screen_hyperlink_reuse() {
+    let mut s = init(5, 5, 0);
+
+    assert!(s.cursor.hyperlink_id == 0);
+    assert_eq!(0, s.cursor_page().hyperlink_set.count());
+
+    // Use it for the first time
+    s.start_hyperlink(b"http://example.com", None).unwrap();
+    assert!(s.cursor.hyperlink_id != 0);
+    let id = s.cursor.hyperlink_id;
+
+    // Reuse the same hyperlink, expect we have the same ID
+    s.start_hyperlink(b"http://example.com", None).unwrap();
+    assert_eq!(id, s.cursor.hyperlink_id);
+    assert_eq!(1, s.cursor_page().hyperlink_set.count());
+
+    s.end_hyperlink();
+    assert!(s.cursor.hyperlink_id == 0);
+    assert_eq!(0, s.cursor_page().hyperlink_set.count());
+}
+
+#[test]
+fn screen_hyperlink_cursor_state_on_resize() {
+    // This test depends on underlying PageList implementation so
+    // it may be invalid one day. It's here to document/verify the
+    // current behavior.
+
+    let mut s = init(5, 10, 0);
+
+    // Start a hyperlink
+    s.start_hyperlink(b"http://example.com", None).unwrap();
+    assert!(s.cursor.hyperlink_id != 0);
+    assert_eq!(1, s.cursor_page().hyperlink_set.count());
+
+    // Resize. Any column growth will trigger a page to be reallocated.
+    s.resize(Resize::new(10, 10)).unwrap();
+    assert!(s.cursor.hyperlink_id != 0);
+    assert_eq!(1, s.cursor_page().hyperlink_set.count());
+
+    s.end_hyperlink();
+    assert!(s.cursor.hyperlink_id == 0);
+    assert_eq!(0, s.cursor_page().hyperlink_set.count());
+}
+
+#[test]
+fn screen_cursor_set_hyperlink_oom_uri_too_large_for_string_alloc() {
+    let mut s = init(80, 24, 0);
+
+    // Start a hyperlink with a URI that just barely fits in the string alloc.
+    // This will ensure that additional string alloc space is needed for the
+    // redundant copy of the URI when the page is re-alloced.
+    let uri = vec![b'a'; STD_CAPACITY.string_bytes as usize - 8];
+    s.start_hyperlink(&uri, None).unwrap();
+
+    // Figure out how many cells should can have hyperlinks in this page,
+    // and write twice that number, to guarantee the capacity needs to be
+    // increased at some point.
+    let base_capacity = s.cursor_page().hyperlink_capacity();
+    let base_string_bytes = s.cursor_page().capacity.string_bytes;
+    for _ in 0..base_capacity * 2 {
+        s.cursor_set_hyperlink().unwrap();
+        if s.cursor.x >= s.pages.cols - 1 {
+            s.cursor_down_or_scroll().unwrap();
+            s.cursor_horizontal_absolute(0);
+        } else {
+            s.cursor_right(1);
+        }
+    }
+
+    // Make sure the capacity really did increase.
+    assert!(base_capacity < s.cursor_page().hyperlink_capacity());
+    // And that our string_bytes increased as well.
+    assert!(base_string_bytes < s.cursor_page().capacity.string_bytes);
+}
+
+#[test]
+fn screen_increase_capacity_cursor_style_ref_count_preserved() {
+    let mut s = init(5, 5, 0);
+    s.set_attribute(A::Bold).unwrap();
+    s.test_write_string("1ABCD").unwrap();
+
+    // We should have one page and it should be our cursor page
+    assert!(s.pages.first == s.pages.last);
+    assert!(s.pages.first == Some(s.cursor_pin().node));
+
+    let old_style = s.cursor.style;
+
+    {
+        let page = s.page(s.pages.last.unwrap());
+        // 5 chars + cursor = 6 refs
+        assert_eq!(6, page.styles.ref_count(s.cursor.style_id));
+    }
+
+    // This forces the page to change via increase_capacity.
+    let new_node = s
+        .increase_capacity(s.cursor_pin().node, Some(IncreaseCapacity::GraphemeBytes))
+        .unwrap();
+
+    // Cursor's page_pin should now point to the new node
+    assert!(s.cursor_pin().node == new_node);
+
+    // Cursor row/cell are derived from the pin; verify they resolve.
+    let cp = s.cursor_pin();
+    let (row, cell) = cp.row_and_cell(&s.pages).unwrap();
+    assert_eq!(s.cursor_row(), *row);
+    assert_eq!(s.cursor_cell(), *cell);
+
+    // Style should be preserved
+    assert_eq!(old_style, s.cursor.style);
+    assert!(s.cursor.style_id != style::DEFAULT_ID);
+
+    // After increase_capacity, the 5 chars are cloned (5 refs) and
+    // the cursor's style is re-added (1 ref) = 6 total.
+    {
+        let page = s.page(s.pages.last.unwrap());
+        let ref_count = page.styles.ref_count(s.cursor.style_id);
+        assert_eq!(6, ref_count);
+    }
+}
+
+#[test]
+fn screen_increase_capacity_cursor_hyperlink_ref_count_preserved() {
+    let mut s = init(5, 5, 0);
+    s.start_hyperlink(b"https://example.com/", None).unwrap();
+    s.test_write_string("1ABCD").unwrap();
+
+    // We should have one page and it should be our cursor page
+    assert!(s.pages.first == s.pages.last);
+    assert!(s.pages.first == Some(s.cursor_pin().node));
+
+    {
+        let page = s.page(s.pages.last.unwrap());
+        // Cursor has the hyperlink active = 1 count in hyperlink_set
+        assert_eq!(1, page.hyperlink_set.count());
+        assert!(s.cursor.hyperlink_id != 0);
+        assert!(s.cursor.hyperlink.is_some());
+    }
+
+    // This forces the page to change via increase_capacity.
+    s.increase_capacity(s.cursor_pin().node, Some(IncreaseCapacity::GraphemeBytes))
+        .unwrap();
+
+    // Hyperlink should be preserved with correct URI
+    assert!(s.cursor.hyperlink.is_some());
+    assert!(s.cursor.hyperlink_id != 0);
+    assert_eq!(
+        b"https://example.com/".as_slice(),
+        s.cursor.hyperlink.as_ref().unwrap().uri.as_slice()
+    );
+
+    // After increase_capacity, the hyperlink is re-added to the new page.
+    {
+        let page = s.page(s.pages.last.unwrap());
+        assert_eq!(1, page.hyperlink_set.count());
+    }
+}
+
+#[test]
+fn screen_increase_capacity_cursor_with_both_style_and_hyperlink_preserved() {
+    let mut s = init(5, 5, 0);
+
+    // Set both a non-default style AND an active hyperlink.
+    // Write one character first with bold to mark the row as styled,
+    // then start the hyperlink and write more characters.
+    s.set_attribute(A::Bold).unwrap();
+    s.start_hyperlink(b"https://example.com/", None).unwrap();
+    s.test_write_string("1ABCD").unwrap();
+
+    // We should have one page and it should be our cursor page
+    assert!(s.pages.first == s.pages.last);
+    assert!(s.pages.first == Some(s.cursor_pin().node));
+
+    let old_style = s.cursor.style;
+
+    {
+        let page = s.page(s.pages.last.unwrap());
+        // 5 chars + cursor = 6 refs for bold style
+        assert_eq!(6, page.styles.ref_count(s.cursor.style_id));
+        // Cursor has the hyperlink active = 1 count in hyperlink_set
+        assert_eq!(1, page.hyperlink_set.count());
+        assert!(s.cursor.style_id != style::DEFAULT_ID);
+        assert!(s.cursor.hyperlink_id != 0);
+        assert!(s.cursor.hyperlink.is_some());
+    }
+
+    // This forces the page to change via increase_capacity.
+    s.increase_capacity(s.cursor_pin().node, Some(IncreaseCapacity::GraphemeBytes))
+        .unwrap();
+
+    // Style should be preserved
+    assert_eq!(old_style, s.cursor.style);
+    assert!(s.cursor.style_id != style::DEFAULT_ID);
+
+    // Hyperlink should be preserved with correct URI
+    assert!(s.cursor.hyperlink.is_some());
+    assert!(s.cursor.hyperlink_id != 0);
+    assert_eq!(
+        b"https://example.com/".as_slice(),
+        s.cursor.hyperlink.as_ref().unwrap().uri.as_slice()
+    );
+
+    // After increase_capacity, both style and hyperlink are re-added to the new page.
+    {
+        let page = s.page(s.pages.last.unwrap());
+        let ref_count = page.styles.ref_count(s.cursor.style_id);
+        assert_eq!(6, ref_count);
+        assert_eq!(1, page.hyperlink_set.count());
+    }
+}
+
+#[test]
+fn screen_increase_capacity_non_cursor_page_returns_early() {
+    // Test that calling increase_capacity on a page that is NOT the cursor's
+    // page properly delegates to pages.increase_capacity without doing the
+    // extra cursor accounting (style/hyperlink re-adding).
+    let mut s = init(80, 24, 10000);
+
+    // Set up a custom style and hyperlink on the cursor
+    s.set_attribute(A::Bold).unwrap();
+    s.start_hyperlink(b"https://example.com/", None).unwrap();
+    s.test_write_string("Hello").unwrap();
+
+    // Store cursor state before growing pages
+    let old_style = s.cursor.style;
+    let old_style_id = s.cursor.style_id;
+    let old_hyperlink = s.cursor.hyperlink.clone();
+    let old_hyperlink_id = s.cursor.hyperlink_id;
+
+    // The cursor is on the first (and only) page
+    assert!(s.pages.first == s.pages.last);
+    assert!(Some(s.cursor_pin().node) == s.pages.first);
+
+    // Grow pages until we have multiple pages. The cursor's pin stays on
+    // the first page since we're just adding rows.
+    let first_page_node = s.pages.first.unwrap();
+    s.page_mut(first_page_node).pause_integrity_checks(true);
+    let remaining = {
+        let p = s.page(first_page_node);
+        p.capacity.rows - p.size.rows
+    };
+    for _ in 0..remaining {
+        s.pages.grow().unwrap();
+    }
+    s.page_mut(first_page_node).pause_integrity_checks(false);
+    s.pages.grow().unwrap();
+
+    // Now we have two pages
+    assert!(s.pages.first != s.pages.last);
+    let second_page = s.pages.last.unwrap();
+
+    // Cursor should still be on the first page (where it was created)
+    assert!(Some(s.cursor_pin().node) == s.pages.first);
+    assert!(s.cursor_pin().node != second_page);
+
+    let second_page_styles_cap = s.page(second_page).capacity.styles;
+    let cursor_page_styles_cap = s.cursor_page().capacity.styles;
+
+    // Call increase_capacity on the second page (NOT the cursor's page)
+    let new_second_page = s
+        .increase_capacity(second_page, Some(IncreaseCapacity::Styles))
+        .unwrap();
+
+    // The second page should have increased capacity
+    assert_eq!(
+        second_page_styles_cap * 2,
+        s.page(new_second_page).capacity.styles
+    );
+
+    // The cursor's page (first page) should be unchanged
+    assert_eq!(cursor_page_styles_cap, s.cursor_page().capacity.styles);
+
+    // Cursor state should be completely unchanged since we didn't touch its page
+    assert_eq!(old_style, s.cursor.style);
+    assert_eq!(old_style_id, s.cursor.style_id);
+    assert_eq!(old_hyperlink, s.cursor.hyperlink);
+    assert_eq!(old_hyperlink_id, s.cursor.hyperlink_id);
+
+    // Verify hyperlink is still valid
+    assert!(s.cursor.hyperlink.is_some());
+    assert_eq!(
+        b"https://example.com/".as_slice(),
+        s.cursor.hyperlink.as_ref().unwrap().uri.as_slice()
+    );
+}
+
+/// Fill a page's style set until `add` fails, with unique bg colors.
+fn fill_styles(page: &mut Page) {
+    page.pause_integrity_checks(true);
+    let mut n: u32 = 1;
+    while page
+        .styles
+        .add(Style {
+            bg_color: Color::Rgb(Rgb {
+                r: (n >> 16) as u8,
+                g: (n >> 8) as u8,
+                b: n as u8,
+            }),
+            ..Style::default()
+        })
+        .is_ok()
+    {
+        n += 1;
+    }
+    page.pause_integrity_checks(false);
+    page.assert_integrity();
+}
+
+#[test]
+fn screen_cursor_down_to_page_with_insufficient_capacity() {
+    // Regression test for https://github.com/ghostty-org/ghostty/issues/10282
+    //
+    // This test exposes a use-after-realloc bug in cursorDown (and similar
+    // cursor movement functions). The bug pattern:
+    //
+    // 1. cursorDown creates a by-value copy of the pin via page_pin.down(n)
+    // 2. cursorChangePin is called, which may trigger adjustCapacity
+    //    if the target page's style map is full
+    // 3. adjustCapacity frees the old page and creates a new one
+    // 4. The local pin copy still points to the freed page
+    // 5. rowAndCell() on the stale pin accesses freed memory
+
+    // Small screen to make page boundary crossing easy to set up
+    let mut s = init(10, 3, 1);
+
+    // Scroll down enough to create a second page
+    let start_page = s.pages.last.unwrap();
+    let rem = s.page(start_page).capacity.rows;
+    s.page_mut(start_page).pause_integrity_checks(true);
+    for _ in 0..rem {
+        s.cursor_down_or_scroll().unwrap();
+    }
+    s.page_mut(start_page).pause_integrity_checks(false);
+
+    // Cursor should now be on a new page
+    let new_page = s.cursor_pin().node;
+    assert!(start_page != new_page);
+
+    // Fill new_page's style map to capacity. When we move INTO this page
+    // with a style set, adjustCapacity will be triggered.
+    fill_styles(s.page_mut(new_page));
+
+    // Move cursor to start of active area and set a style
+    s.cursor_absolute(0, 0);
+    s.set_attribute(A::Bold).unwrap();
+    assert!(s.cursor.style.flags.bold);
+    assert!(s.cursor.style_id != style::DEFAULT_ID);
+
+    // Find the row just before the page boundary
+    let mut found = false;
+    for row in 0..s.pages.rows - 1 {
+        s.cursor_absolute(0, row);
+        let cur_node = s.cursor_pin().node;
+        if let Some(next_pin) = s.cursor_pin().down(&s.pages, 1)
+            && next_pin.node != cur_node
+        {
+            // Cursor is at 'row', moving down crosses to new_page
+            assert!(next_pin.node == new_page);
+
+            // This cursorDown triggers the bug: the local page_pin copy
+            // becomes stale after adjustCapacity, causing rowAndCell()
+            // to access freed memory.
+            s.cursor_down(1);
+
+            // If the fix is applied, verify correct state
+            assert!(s.cursor.y == row + 1);
+            assert!(s.cursor.style.flags.bold);
+
+            found = true;
+            break;
+        }
+    }
+    // Didn't find boundary
+    assert!(found);
+}
+
+#[test]
+fn screen_set_attribute_increases_capacity_when_style_map_is_full() {
+    // Tests that setAttribute succeeds when the style map is full by
+    // increasing page capacity. When capacity is at max and increaseCapacity
+    // returns OutOfSpace, manualStyleUpdate will split the page instead.
+
+    // Use a small screen with multiple rows
+    let mut s = init(10, 5, 10);
+
+    // Write content to multiple rows
+    s.test_write_string("line1\nline2\nline3\nline4\nline5")
+        .unwrap();
+
+    // Get the page and fill its style map to capacity
+    let page = s.cursor_pin().node;
+    let original_styles_capacity = s.page(page).capacity.styles;
+
+    // Fill the style map to capacity
+    fill_styles(s.page_mut(page));
+
+    // Now try to set a new unique attribute that would require a new style slot
+    // This should succeed by increasing capacity (or splitting if at max capacity)
+    s.set_attribute(A::Bold).unwrap();
+
+    // The style should have been applied (bold flag set)
+    assert!(s.cursor.style.flags.bold);
+
+    // The cursor should have a valid non-default style_id
+    assert!(s.cursor.style_id != style::DEFAULT_ID);
+
+    // Either the capacity increased or the page was split/changed
+    let current_page = s.cursor_pin().node;
+    let capacity_increased = s.page(current_page).capacity.styles > original_styles_capacity;
+    let page_changed = current_page != page;
+    assert!(capacity_increased || page_changed);
+}
+
+#[test]
+fn screen_set_attribute_splits_page_on_out_of_space_at_max_styles() {
+    let mut s = init(10, 10, 0);
+
+    // Write content to multiple rows so we have something to split
+    s.test_write_string("line1\nline2\nline3\nline4\nline5")
+        .unwrap();
+
+    // Remember the original node
+    let original_node = s.cursor_pin().node;
+
+    // Increase the page's style capacity to max by repeatedly calling increase_capacity
+    // Use Screen.increase_capacity to properly maintain cursor state
+    let max_styles = size::CellCountInt::MAX;
+    while s.cursor_page().capacity.styles < max_styles {
+        if s.increase_capacity(s.cursor_pin().node, Some(IncreaseCapacity::Styles))
+            .is_err()
+        {
+            break;
+        }
+    }
+
+    // Get the page reference after increase_capacity - cursor may have moved
+    let node = s.cursor_pin().node;
+    assert_eq!(max_styles, s.page(node).capacity.styles);
+
+    // Fill the style map to capacity
+    fill_styles(s.page_mut(node));
+
+    // Track the node before setAttribute
+    let node_before_set = s.cursor_pin().node;
+
+    // Now try to set a new unique attribute that would require a new style slot
+    // At max capacity, increase_capacity will return OutOfSpace, triggering page split
+    s.set_attribute(A::Bold).unwrap();
+
+    // The style should have been applied (bold flag set)
+    assert!(s.cursor.style.flags.bold);
+
+    // The cursor should have a valid non-default style_id
+    assert!(s.cursor.style_id != style::DEFAULT_ID);
+
+    // The page should have been split
+    let nb = s.pages.node(node_before_set);
+    let page_was_split = s.cursor_pin().node != node_before_set
+        || nb.is_some_and(|n| n.next.is_some())
+        || nb.is_some_and(|n| n.prev.is_some())
+        || s.cursor_pin().node != original_node;
+    assert!(page_was_split);
+}
+
+// "selectionString map allocation failure cleanup" is skipped: it relies on
+// Zig tripwire allocation-failure injection (selectionString_tw), which has
+// no Rust counterpart.
+
+fn setup_prompt(cols: u16, click: Click) -> Screen {
+    let mut s = init(cols, 5, 0);
+    // Enable line click mode
+    s.semantic_prompt.click = SemanticClick::Cl(click);
+    s
+}
+
+fn prompt(s: &mut Screen) {
+    s.cursor_set_semantic_content(SemanticContentSet::Prompt(PromptKind::Initial));
+}
+fn input(s: &mut Screen) {
+    s.cursor_set_semantic_content(SemanticContentSet::Input(InputClear::ClearExplicit));
+}
+fn output(s: &mut Screen) {
+    s.cursor_set_semantic_content(SemanticContentSet::Output);
+}
+fn click_at(s: &Screen, x: u16, y: u32) -> PromptClickMove {
+    let p = pin(s, active(x, y));
+    s.prompt_click_move(p)
+}
+
+#[test]
+fn screen_prompt_click_move_line_right_basic() {
+    let mut s = setup_prompt(20, Click::Line);
+    prompt(&mut s);
+    s.test_write_string("> ").unwrap();
+    input(&mut s);
+    s.test_write_string("hello").unwrap();
+
+    // Move cursor back to start of input (column 2, the 'h')
+    s.cursor_absolute(2, 0);
+
+    // Click on first 'l' (column 4), should require 2 right movements (h->e->l)
+    let result = click_at(&s, 4, 0);
+
+    assert_eq!(2, result.right);
+    assert_eq!(0, result.left);
+}
+
+#[test]
+fn screen_prompt_click_move_line_right_cursor_not_on_input() {
+    let mut s = setup_prompt(20, Click::Line);
+    prompt(&mut s);
+    s.test_write_string("> ").unwrap();
+    input(&mut s);
+    s.test_write_string("hello").unwrap();
+    output(&mut s);
+
+    // Move cursor back to prompt area (column 0, the '>')
+    s.cursor_absolute(0, 0);
+
+    // Cursor is on prompt, not input - should return zero
+    let result = click_at(&s, 4, 0);
+
+    assert_eq!(PromptClickMove::ZERO, result);
+}
+
+#[test]
+fn screen_prompt_click_move_line_right_click_on_same_position() {
+    let mut s = setup_prompt(20, Click::Line);
+    prompt(&mut s);
+    s.test_write_string("> ").unwrap();
+    input(&mut s);
+    s.test_write_string("hello").unwrap();
+
+    // Move cursor to column 4
+    s.cursor_absolute(4, 0);
+
+    // Click on same position - no movement needed
+    let result = click_at(&s, 4, 0);
+
+    assert_eq!(PromptClickMove::ZERO, result);
+}
+
+#[test]
+fn screen_prompt_click_move_line_right_skips_non_input_cells() {
+    let mut s = setup_prompt(20, Click::Line);
+    // Write: "> h" then output "X" then input "llo"
+    prompt(&mut s);
+    s.test_write_string("> ").unwrap();
+    input(&mut s);
+    s.test_write_string("h").unwrap();
+    output(&mut s);
+    s.test_write_string("X").unwrap();
+    input(&mut s);
+    s.test_write_string("llo").unwrap();
+
+    // Move cursor to column 2 (the 'h')
+    s.cursor_absolute(2, 0);
+
+    // Click on 'l' at column 5 - should skip the 'X' output cell
+    // Movement: h (start) -> l (col 4) -> l (col 5) = 2 right movements
+    let result = click_at(&s, 5, 0);
+
+    assert_eq!(2, result.right);
+    assert_eq!(0, result.left);
+}
+
+#[test]
+fn screen_prompt_click_move_line_right_soft_wrapped_line() {
+    let mut s = setup_prompt(10, Click::Line);
+    // Write a prompt and input that wraps
+    prompt(&mut s);
+    s.test_write_string("> ").unwrap();
+    input(&mut s);
+    // Write 8 chars of input, first row has 2 for prompt + 8 input = 10 cols
+    s.test_write_string("abcdefgh").unwrap();
+    // Continue on next row (soft-wrapped)
+    s.test_write_string("ij").unwrap();
+
+    // Verify soft wrap occurred
+    assert_eq!("> abcdefgh\nij", dump(&s, viewport(0, 0)));
+
+    // Move cursor to column 2 (the 'a')
+    s.cursor_absolute(2, 0);
+
+    // Click on 'j' at column 1, row 1 - should count all input cells
+    // Movement: a->b->c->d->e->f->g->h->i->j = 9 right movements
+    let result = click_at(&s, 1, 1);
+
+    assert_eq!(9, result.right);
+    assert_eq!(0, result.left);
+}
+
+#[test]
+fn screen_prompt_click_move_disabled_when_click_is_none() {
+    let mut s = setup_prompt(20, Click::Line);
+    // Click mode is .none by default (disabled)
+    s.semantic_prompt.click = SemanticClick::None;
+    assert_eq!(SemanticClick::None, s.semantic_prompt.click);
+
+    prompt(&mut s);
+    s.test_write_string("> ").unwrap();
+    input(&mut s);
+    s.test_write_string("hello").unwrap();
+
+    // Move cursor to start of input
+    s.cursor_absolute(2, 0);
+
+    // Click should return zero since click mode is disabled
+    let result = click_at(&s, 4, 0);
+
+    assert_eq!(PromptClickMove::ZERO, result);
+}
+
+#[test]
+fn screen_prompt_click_move_line_right_stops_at_hard_wrap() {
+    let mut s = setup_prompt(20, Click::Line);
+    prompt(&mut s);
+    s.test_write_string("> ").unwrap();
+    input(&mut s);
+    s.test_write_string("hello").unwrap();
+    // Hard wrap (newline)
+    s.test_write_string("\n").unwrap();
+    s.test_write_string("world").unwrap();
+
+    // Move cursor to column 2 (the 'h')
+    s.cursor_absolute(2, 0);
+
+    // Click on 'w' at column 0, row 1 - but line mode stops at hard wrap
+    // Should only move to end of first line: h->e->l->l->o = 4 movements
+    let result = click_at(&s, 0, 1);
+
+    // Should stop at end of first line, not cross hard wrap
+    assert_eq!(5, result.right);
+    assert_eq!(0, result.left);
+}
+
+#[test]
+fn screen_prompt_click_move_line_right_stops_at_non_continuation_row() {
+    let mut s = setup_prompt(20, Click::Line);
+    // Row 0: PROMPT "> hello"
+    prompt(&mut s);
+    s.test_write_string("> ").unwrap();
+    input(&mut s);
+    s.test_write_string("hello\n").unwrap();
+
+    // Row 1: CONTINUATION "world"
+    s.cursor_set_semantic_content(SemanticContentSet::Prompt(PromptKind::Continuation));
+    input(&mut s);
+    s.test_write_string("world\n").unwrap();
+
+    // Row 2: NEW PROMPT "> again"
+    prompt(&mut s);
+    s.test_write_string("> ").unwrap();
+    input(&mut s);
+    s.test_write_string("again").unwrap();
+
+    // Verify content
+    assert_eq!("> hello\nworld\n> again", dump(&s, viewport(0, 0)));
+
+    // Move cursor to 'w' at column 0, row 1
+    s.cursor_absolute(0, 1);
+
+    // Click on 'a' at column 2, row 2 - but row 2 is a new prompt
+    // Should stop at end of "world": w->o->r->l->d = 4 movements
+    let result = click_at(&s, 2, 2);
+
+    // Should stop at 'd' (end of world), not cross to new prompt
+    assert_eq!(5, result.right);
+    assert_eq!(0, result.left);
+}
+
+#[test]
+fn screen_prompt_click_move_line_left_basic() {
+    let mut s = setup_prompt(20, Click::Line);
+    prompt(&mut s);
+    s.test_write_string("> ").unwrap();
+    input(&mut s);
+    s.test_write_string("hello").unwrap();
+
+    // Cursor is at column 7 (after 'o'), move it to column 6 (the 'o')
+    s.cursor_absolute(6, 0);
+
+    // Click on 'h' (column 2), should require 4 left movements (o->l->l->e->h)
+    let result = click_at(&s, 2, 0);
+
+    assert_eq!(0, result.right);
+    assert_eq!(4, result.left);
+}
+
+#[test]
+fn screen_prompt_click_move_line_left_skips_non_input_cells() {
+    let mut s = setup_prompt(20, Click::Line);
+    // Write: "> h" then output "X" then input "llo"
+    prompt(&mut s);
+    s.test_write_string("> ").unwrap();
+    input(&mut s);
+    s.test_write_string("h").unwrap();
+    output(&mut s);
+    s.test_write_string("X").unwrap();
+    input(&mut s);
+    s.test_write_string("llo").unwrap();
+
+    // Move cursor to column 6 (the 'o')
+    s.cursor_absolute(6, 0);
+
+    // Click on 'h' at column 2 - should skip the 'X' output cell
+    // Movement: o->l->l->h = 3 left movements (skipping X)
+    let result = click_at(&s, 2, 0);
+
+    assert_eq!(0, result.right);
+    assert_eq!(3, result.left);
+}
+
+#[test]
+fn screen_prompt_click_move_line_left_soft_wrapped_line() {
+    let mut s = setup_prompt(10, Click::Line);
+    // Write a prompt and input that wraps
+    prompt(&mut s);
+    s.test_write_string("> ").unwrap();
+    input(&mut s);
+    // Write 8 chars of input, first row has 2 for prompt + 8 input = 10 cols
+    s.test_write_string("abcdefgh").unwrap();
+    // Continue on next row (soft-wrapped)
+    s.test_write_string("ij").unwrap();
+
+    // Verify soft wrap occurred
+    assert_eq!("> abcdefgh\nij", dump(&s, viewport(0, 0)));
+
+    // Cursor is at column 2, row 1 (after 'j'). Move to 'j' at column 1.
+    s.cursor_absolute(1, 1);
+
+    // Click on 'a' at column 2, row 0 - should count all input cells backwards
+    // Movement: j->i->h->g->f->e->d->c->b->a = 9 left movements
+    let result = click_at(&s, 2, 0);
+
+    assert_eq!(0, result.right);
+    assert_eq!(9, result.left);
+}
+
+#[test]
+fn screen_prompt_click_move_line_left_stops_at_hard_wrap() {
+    let mut s = setup_prompt(20, Click::Line);
+    prompt(&mut s);
+    s.test_write_string("> ").unwrap();
+    input(&mut s);
+    s.test_write_string("hello").unwrap();
+    // Hard wrap (newline)
+    s.test_write_string("\n").unwrap();
+    s.test_write_string("world").unwrap();
+
+    // Move cursor to 'd' at column 4, row 1 (an actual input cell)
+    s.cursor_absolute(4, 1);
+
+    // Click on 'h' at column 2, row 0 - but line mode stops at hard wrap
+    // Should only move to start of second line, not cross to row 0
+    let result = click_at(&s, 2, 0);
+
+    // Should stop at start of second line: d->l->r->o->w = 4 movements
+    assert_eq!(0, result.right);
+    assert_eq!(4, result.left);
+}
+
+#[test]
+fn screen_prompt_click_move_click_right_of_input_same_line() {
+    let mut s = setup_prompt(20, Click::Line);
+    // Set up: "> hello" where "> " is prompt and "hello" is input
+    // Clicking to the right of the 'o' should move cursor past the input
+    prompt(&mut s);
+    s.test_write_string("> ").unwrap();
+    input(&mut s);
+    s.test_write_string("hello").unwrap();
+
+    // Move cursor to start of input (column 2, the 'h')
+    s.cursor_absolute(2, 0);
+
+    // Click beyond the input (column 15) - should move to one past the 'o'
+    let result = click_at(&s, 15, 0);
+
+    assert_eq!(5, result.right);
+    assert_eq!(0, result.left);
+}
+
+#[test]
+fn screen_prompt_click_move_click_right_of_input_cursor_at_end() {
+    let mut s = setup_prompt(20, Click::Line);
+    prompt(&mut s);
+    s.test_write_string("> ").unwrap();
+    input(&mut s);
+    s.test_write_string("hello").unwrap();
+
+    // Cursor is already at column 7 (one past 'o') after writing
+    // Click beyond the input (column 15) - no movement needed since
+    // cursor is already at the end position
+    let result = click_at(&s, 15, 0);
+
+    assert_eq!(0, result.right);
+    assert_eq!(0, result.left);
+}
+
+#[test]
+fn screen_prompt_click_move_click_right_of_input_on_lower_line() {
+    let mut s = setup_prompt(20, Click::Line);
+    prompt(&mut s);
+    s.test_write_string("> ").unwrap();
+    input(&mut s);
+    s.test_write_string("hello").unwrap();
+
+    // Move cursor to start of input (column 2, the 'h')
+    s.cursor_absolute(2, 0);
+
+    // Click on a lower line (row 1) - should move to end of input
+    // This is outside the prompt area so should clamp to end
+    let result = click_at(&s, 5, 1);
+
+    // From 'h', we need to pass e, l, l, o (4 cells) + 1 past end = 5
+    assert_eq!(5, result.right);
+    assert_eq!(0, result.left);
+}
+
+#[test]
+fn screen_prompt_click_move_click_right_of_input_cursor_at_end_lower_line() {
+    let mut s = setup_prompt(20, Click::Line);
+    prompt(&mut s);
+    s.test_write_string("> ").unwrap();
+    input(&mut s);
+    s.test_write_string("hello").unwrap();
+
+    // Cursor is at column 7 after writing (one past 'o')
+    // Click on a lower line (row 1) - cursor already at end, no movement needed
+    let result = click_at(&s, 5, 1);
+
+    assert_eq!(0, result.right);
+    assert_eq!(0, result.left);
+}
+
+#[test]
+fn screen_prompt_click_move_click_right_of_input_cursor_on_last_char() {
+    let mut s = setup_prompt(20, Click::Line);
+    prompt(&mut s);
+    s.test_write_string("> ").unwrap();
+    input(&mut s);
+    s.test_write_string("hello").unwrap();
+
+    // Move cursor to last input char (column 6, the 'o')
+    s.cursor_absolute(6, 0);
+
+    // Click beyond the input (column 15)
+    let result = click_at(&s, 15, 0);
+
+    assert_eq!(1, result.right);
+    assert_eq!(0, result.left);
+}

crates/ghostty-terminal/src/screen_set.rs

@@ -0,0 +1,108 @@
+//! A ScreenSet holds multiple terminal screens. This is initially created
+//! to handle simple primary vs alternate screens, but could be extended
+//! in the future to handle N screens.
+//!
+//! One of the goals of this is to allow lazy initialization of screens
+//! as needed. The primary screen is always initialized, but the alternate
+//! screen may not be until first used.
+use crate::screen::{Error, Options, Screen};
+
+/// The possible keys for screens in the screen set.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Key {
+    Primary,
+    Alternate,
+}
+
+impl Key {
+    fn index(self) -> usize {
+        match self {
+            Key::Primary => 0,
+            Key::Alternate => 1,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ScreenSet {
+    /// The key value of the currently active screen. Useful for simple
+    /// comparisons, e.g. "is this screen the primary screen".
+    pub active_key: Key,
+
+    /// All screens that are initialized. The active screen is always
+    /// initialized.
+    all: [Option<Box<Screen>>; 2],
+}
+
+impl ScreenSet {
+    pub fn new(opts: Options) -> Result<ScreenSet, Error> {
+        // We need to initialize our initial primary screen
+        let screen = Box::new(Screen::new(opts)?);
+        Ok(ScreenSet {
+            active_key: Key::Primary,
+            all: [Some(screen), None],
+        })
+    }
+
+    /// The active screen.
+    pub fn active(&self) -> &Screen {
+        self.all[self.active_key.index()]
+            .as_deref()
+            .expect("active screen is initialized")
+    }
+
+    /// The active screen.
+    pub fn active_mut(&mut self) -> &mut Screen {
+        self.all[self.active_key.index()]
+            .as_deref_mut()
+            .expect("active screen is initialized")
+    }
+
+    /// Get the screen for the given key, if it is initialized.
+    pub fn get(&self, key: Key) -> Option<&Screen> {
+        self.all[key.index()].as_deref()
+    }
+
+    /// Get the screen for the given key, if it is initialized.
+    pub fn get_mut(&mut self, key: Key) -> Option<&mut Screen> {
+        self.all[key.index()].as_deref_mut()
+    }
+
+    /// Get the screen for the given key, initializing it if necessary.
+    pub fn get_init(&mut self, key: Key, opts: Options) -> Result<&mut Screen, Error> {
+        let slot = &mut self.all[key.index()];
+        if slot.is_none() {
+            *slot = Some(Box::new(Screen::new(opts)?));
+        }
+        Ok(slot.as_deref_mut().expect("just initialized"))
+    }
+
+    /// Remove a key from the set. The primary screen cannot be removed (asserted).
+    pub fn remove(&mut self, key: Key) {
+        assert_ne!(key, Key::Primary);
+        self.all[key.index()] = None;
+    }
+
+    /// Switch the active screen to the given key. Requires that the
+    /// screen is initialized.
+    pub fn switch_to(&mut self, key: Key) {
+        assert!(self.all[key.index()].is_some());
+        self.active_key = key;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn screen_set() {
+        let mut set = ScreenSet::new(Options::DEFAULT).unwrap();
+        assert_eq!(Key::Primary, set.active_key);
+
+        // Initialize a secondary screen
+        set.get_init(Key::Alternate, Options::DEFAULT).unwrap();
+        set.switch_to(Key::Alternate);
+        assert_eq!(Key::Alternate, set.active_key);
+    }
+}

crates/ghostty-terminal/src/selection.rs

@@ -0,0 +1,1041 @@
+//! Represents a single selection within the terminal (i.e. a highlight region).
+//!
+//! Unlike Zig, tracked bounds hold [`TrackedPin`] handles into the owning
+//! [`PageList`], so every method that must read (or move) the pins takes the
+//! screen's page list explicitly (`&screen.pages`).
+#![allow(clippy::manual_assert_eq)]
+use crate::{
+    page::{Cell, Error},
+    page_list::{Direction, PageList, Pin, TrackedPin},
+    pin_iter,
+    point::{Coordinate, Point, Tag},
+};
+
+// NOTE(mitchellh): I'm not very happy with how this is implemented, because
+// the ordering operations which are used frequently require using
+// pointFromPin which -- at the time of writing this -- is slow. The overall
+// style of this struct is due to porting it from the previous implementation
+// which had an efficient ordering operation.
+//
+// While reimplementing this, there were too many callers that already
+// depended on this behavior so I kept it despite the inefficiency. In the
+// future, we should take a look at this again!
+
+/// The bounds of the selection. A selection bounds can be either tracked
+/// or untracked. Untracked bounds are unsafe beyond the point the terminal
+/// screen may be modified, since they may point to invalid memory. Tracked
+/// bounds are always valid and will be updated as the screen changes, but
+/// are more expensive to exist.
+///
+/// In all cases, start and end can be in any order. There is no guarantee that
+/// start is before end or vice versa. If a user selects backwards,
+/// start will be after end, and vice versa. Use the struct functions
+/// to not have to worry about this.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Bounds {
+    Untracked { start: Pin, end: Pin },
+    Tracked { start: TrackedPin, end: TrackedPin },
+}
+
+/// Represents a single selection within the terminal (i.e. a highlight region).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Selection {
+    /// The bounds of the selection.
+    pub bounds: Bounds,
+
+    /// Whether or not this selection refers to a rectangle, rather than whole
+    /// lines of a buffer. In this mode, start and end refer to the top left and
+    /// bottom right of the rectangle, or vice versa if the selection is backwards.
+    pub rectangle: bool,
+}
+
+/// The order of the selection:
+///
+///  * forward: start(x, y) is before end(x, y) (top-left to bottom-right).
+///  * reverse: end(x, y) is before start(x, y) (bottom-right to top-left).
+///  * mirrored_[forward|reverse]: special, rectangle selections only (see below).
+///
+///  For regular selections, the above also holds for top-right to bottom-left
+///  (forward) and bottom-left to top-right (reverse). However, for rectangle
+///  selections, both of these selections are *mirrored* as orientation
+///  operations only flip the x or y axis, not both. Depending on the y axis
+///  direction, this is either mirrored_forward or mirrored_reverse.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Order {
+    Forward,
+    Reverse,
+    MirroredForward,
+    MirroredReverse,
+}
+
+/// Possible adjustments to the selection.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Adjustment {
+    Left,
+    Right,
+    Up,
+    Down,
+    Home,
+    End,
+    PageUp,
+    PageDown,
+    BeginningOfLine,
+    EndOfLine,
+}
+
+fn screen_coord(list: &PageList, p: Pin) -> Coordinate {
+    list.point_from_pin(Tag::Screen, p)
+        .expect("selection pin must be in the screen")
+        .coord()
+}
+
+impl Selection {
+    /// Initialize a new (untracked) selection with the given start and end
+    /// pins on the screen.
+    pub fn new(start_pin: Pin, end_pin: Pin, rect: bool) -> Self {
+        Self {
+            bounds: Bounds::Untracked {
+                start: start_pin,
+                end: end_pin,
+            },
+            rectangle: rect,
+        }
+    }
+
+    /// Release the tracked pins (if any).
+    pub fn deinit(self, list: &mut PageList) {
+        if let Bounds::Tracked { start, end } = self.bounds {
+            list.untrack_pin(start);
+            list.untrack_pin(end);
+        }
+    }
+
+    /// Returns true if this selection is equal to another selection.
+    pub fn eql(&self, list: &PageList, other: &Selection) -> bool {
+        self.start(list).eql(other.start(list))
+            && self.end(list).eql(other.end(list))
+            && self.rectangle == other.rectangle
+    }
+
+    /// The starting pin of the selection. This is NOT ordered.
+    pub fn start(&self, list: &PageList) -> Pin {
+        match self.bounds {
+            Bounds::Untracked { start, .. } => start,
+            Bounds::Tracked { start, .. } => list
+                .tracked_pin(start)
+                .expect("tracked selection pin must be live"),
+        }
+    }
+
+    /// The ending pin of the selection. This is NOT ordered.
+    pub fn end(&self, list: &PageList) -> Pin {
+        match self.bounds {
+            Bounds::Untracked { end, .. } => end,
+            Bounds::Tracked { end, .. } => list
+                .tracked_pin(end)
+                .expect("tracked selection pin must be live"),
+        }
+    }
+
+    /// Set the starting pin (Zig: writing through `startPtr`).
+    pub fn set_start(&mut self, list: &mut PageList, pin: Pin) {
+        match &mut self.bounds {
+            Bounds::Untracked { start, .. } => *start = pin,
+            Bounds::Tracked { start, .. } => {
+                list.set_tracked_pin(*start, pin)
+                    .expect("selection pin must be valid");
+            }
+        }
+    }
+
+    /// Set the ending pin (Zig: writing through `endPtr`).
+    pub fn set_end(&mut self, list: &mut PageList, pin: Pin) {
+        match &mut self.bounds {
+            Bounds::Untracked { end, .. } => *end = pin,
+            Bounds::Tracked { end, .. } => {
+                list.set_tracked_pin(*end, pin)
+                    .expect("selection pin must be valid");
+            }
+        }
+    }
+
+    /// Returns true if this is a tracked selection.
+    pub fn tracked(&self) -> bool {
+        matches!(self.bounds, Bounds::Tracked { .. })
+    }
+
+    /// Convert this selection a tracked selection. It is asserted this is
+    /// an untracked selection. The tracked selection is returned.
+    pub fn track(&self, list: &mut PageList) -> Result<Selection, Error> {
+        let Bounds::Untracked { start, end } = self.bounds else {
+            panic!("selection is already tracked");
+        };
+
+        // Track our pins
+        let tracked_start = list.track_pin(start)?;
+        let tracked_end = match list.track_pin(end) {
+            Ok(v) => v,
+            Err(e) => {
+                list.untrack_pin(tracked_start);
+                return Err(e);
+            }
+        };
+
+        Ok(Selection {
+            bounds: Bounds::Tracked {
+                start: tracked_start,
+                end: tracked_end,
+            },
+            rectangle: self.rectangle,
+        })
+    }
+
+    /// Returns the top left point of the selection.
+    pub fn top_left(&self, list: &PageList) -> Pin {
+        match self.order(list) {
+            Order::Forward => self.start(list),
+            Order::Reverse => self.end(list),
+            Order::MirroredForward => {
+                let mut p = self.start(list);
+                p.x = self.end(list).x;
+                p
+            }
+            Order::MirroredReverse => {
+                let mut p = self.end(list);
+                p.x = self.start(list).x;
+                p
+            }
+        }
+    }
+
+    /// Returns the bottom right point of the selection.
+    pub fn bottom_right(&self, list: &PageList) -> Pin {
+        match self.order(list) {
+            Order::Forward => self.end(list),
+            Order::Reverse => self.start(list),
+            Order::MirroredForward => {
+                let mut p = self.end(list);
+                p.x = self.start(list).x;
+                p
+            }
+            Order::MirroredReverse => {
+                let mut p = self.start(list);
+                p.x = self.end(list).x;
+                p
+            }
+        }
+    }
+
+    pub fn order(&self, list: &PageList) -> Order {
+        let start_pt = screen_coord(list, self.start(list));
+        let end_pt = screen_coord(list, self.end(list));
+
+        if self.rectangle {
+            // Reverse (also handles single-column)
+            if start_pt.y > end_pt.y && start_pt.x >= end_pt.x {
+                return Order::Reverse;
+            }
+            if start_pt.y >= end_pt.y && start_pt.x > end_pt.x {
+                return Order::Reverse;
+            }
+
+            // Mirror, bottom-left to top-right
+            if start_pt.y > end_pt.y && start_pt.x < end_pt.x {
+                return Order::MirroredReverse;
+            }
+
+            // Mirror, top-right to bottom-left
+            if start_pt.y < end_pt.y && start_pt.x > end_pt.x {
+                return Order::MirroredForward;
+            }
+
+            // Forward
+            return Order::Forward;
+        }
+
+        if start_pt.y < end_pt.y {
+            return Order::Forward;
+        }
+        if start_pt.y > end_pt.y {
+            return Order::Reverse;
+        }
+        if start_pt.x <= end_pt.x {
+            return Order::Forward;
+        }
+        Order::Reverse
+    }
+
+    /// Returns the selection in the given order.
+    ///
+    /// The returned selection is always a new untracked selection.
+    ///
+    /// Note that only forward and reverse are useful desired orders for this
+    /// function. All other orders act as if forward order was desired.
+    pub fn ordered(&self, list: &PageList, desired: Order) -> Selection {
+        if self.order(list) == desired {
+            return Selection::new(self.start(list), self.end(list), self.rectangle);
+        }
+
+        let tl = self.top_left(list);
+        let br = self.bottom_right(list);
+        match desired {
+            Order::Reverse => Selection::new(br, tl, self.rectangle),
+            _ => Selection::new(tl, br, self.rectangle),
+        }
+    }
+
+    /// Returns true if the selection contains the given point.
+    ///
+    /// This recalculates top left and bottom right each call. If you have
+    /// many points to check, it is cheaper to do the containment logic
+    /// yourself and cache the topleft/bottomright.
+    pub fn contains(&self, list: &PageList, pin: Pin) -> bool {
+        let tl_pin = self.top_left(list);
+        let br_pin = self.bottom_right(list);
+
+        // This is definitely not very efficient. Low-hanging fruit to
+        // improve this.
+        let tl = screen_coord(list, tl_pin);
+        let br = screen_coord(list, br_pin);
+        let p = screen_coord(list, pin);
+
+        // If we're in rectangle select, we can short-circuit with an easy check
+        // here
+        if self.rectangle {
+            return p.y >= tl.y && p.y <= br.y && p.x >= tl.x && p.x <= br.x;
+        }
+
+        // If tl/br are same line
+        if tl.y == br.y {
+            return p.y == tl.y && p.x >= tl.x && p.x <= br.x;
+        }
+
+        // If on top line, just has to be left of X
+        if p.y == tl.y {
+            return p.x >= tl.x;
+        }
+
+        // If on bottom line, just has to be right of X
+        if p.y == br.y {
+            return p.x <= br.x;
+        }
+
+        // If between the top/bottom, always good.
+        p.y > tl.y && p.y < br.y
+    }
+
+    /// Get a selection for a single row in the screen. This will return None
+    /// if the row is not included in the selection.
+    ///
+    /// This is a very expensive operation. It has to traverse the linked list
+    /// of pages for the top-left, bottom-right, and the given pin to find
+    /// the coordinates. If you are calling this repeatedly, prefer
+    /// `contained_row_cached`.
+    pub fn contained_row(&self, list: &PageList, pin: Pin) -> Option<Selection> {
+        let tl_pin = self.top_left(list);
+        let br_pin = self.bottom_right(list);
+
+        // This is definitely not very efficient. Low-hanging fruit to
+        // improve this. Callers should prefer contained_row_cached if they
+        // can swing it.
+        let tl = screen_coord(list, tl_pin);
+        let br = screen_coord(list, br_pin);
+        let p = screen_coord(list, pin);
+
+        self.contained_row_cached(list, tl_pin, br_pin, pin, tl, br, p)
+    }
+
+    /// Same as `contained_row` but useful if you're calling it repeatedly
+    /// so that the pins can be cached across calls. Advanced.
+    #[allow(clippy::too_many_arguments)]
+    pub fn contained_row_cached(
+        &self,
+        list: &PageList,
+        tl_pin: Pin,
+        br_pin: Pin,
+        pin: Pin,
+        tl: Coordinate,
+        br: Coordinate,
+        p: Coordinate,
+    ) -> Option<Selection> {
+        if p.y < tl.y || p.y > br.y {
+            return None;
+        }
+
+        // Rectangle case: we can return early as the x range will always be the
+        // same. We've already validated that the row is in the selection.
+        if self.rectangle {
+            return Some(Selection::new(
+                Pin { x: tl.x, ..pin },
+                Pin { x: br.x, ..pin },
+                true,
+            ));
+        }
+
+        if p.y == tl.y {
+            // If the selection is JUST this line, return it as-is.
+            if p.y == br.y {
+                return Some(Selection::new(tl_pin, br_pin, false));
+            }
+
+            // Selection top-left line matches only.
+            return Some(Selection::new(
+                tl_pin,
+                Pin {
+                    x: list.cols - 1,
+                    ..pin
+                },
+                false,
+            ));
+        }
+
+        // Row is our bottom selection, so we return the selection from the
+        // beginning of the line to the br. We know our selection is more than
+        // one line (due to conditionals above)
+        if p.y == br.y {
+            assert!(p.y != tl.y);
+            return Some(Selection::new(Pin { x: 0, ..pin }, br_pin, false));
+        }
+
+        // Row is somewhere between our selection lines so we return the full line.
+        Some(Selection::new(
+            Pin { x: 0, ..pin },
+            Pin {
+                x: list.cols - 1,
+                ..pin
+            },
+            false,
+        ))
+    }
+
+    /// Adjust the selection by some given adjustment. An adjustment allows
+    /// a selection to be expanded slightly left, right, up, down, etc.
+    pub fn adjust(&mut self, list: &mut PageList, adjustment: Adjustment) {
+        // Note that we always adjust "end" because end always represents
+        // the last point of the selection by mouse, not necessarily the
+        // top/bottom visually. So this results in the correct behavior
+        // whether the user drags up or down.
+        let end_pin = self.end(list);
+        match adjustment {
+            Adjustment::Up => {
+                if let Some(new_end) = end_pin.up(list, 1) {
+                    self.set_end(list, new_end);
+                } else {
+                    self.adjust(list, Adjustment::BeginningOfLine);
+                }
+            }
+
+            Adjustment::Down => {
+                // Find the next non-blank row
+                let mut current = end_pin;
+                loop {
+                    let Some(next) = current.down(list, 1) else {
+                        // If we're at the bottom, just go to the end of the line
+                        self.adjust(list, Adjustment::EndOfLine);
+                        break;
+                    };
+                    let has_text = list
+                        .node(next.node)
+                        .and_then(|n| n.data.get_cells(usize::from(next.y)))
+                        .is_some_and(Cell::has_text_any);
+                    if has_text {
+                        self.set_end(list, next);
+                        break;
+                    }
+                    current = next;
+                }
+            }
+
+            Adjustment::Left => {
+                let found = pin_iter::cell_iterator(list, end_pin, Direction::LeftUp, None)
+                    .skip(1)
+                    .find(|p| cell_has_text(list, *p));
+                if let Some(next) = found {
+                    self.set_end(list, next);
+                }
+            }
+
+            Adjustment::Right => {
+                // Step right, wrapping to the next row down at the start of each new line,
+                // until we find a non-empty cell.
+                let found = pin_iter::cell_iterator(list, end_pin, Direction::RightDown, None)
+                    .skip(1)
+                    .find(|p| cell_has_text(list, *p));
+                if let Some(next) = found {
+                    self.set_end(list, next);
+                }
+            }
+
+            Adjustment::PageUp => {
+                if let Some(new_end) = end_pin.up(list, usize::from(list.rows)) {
+                    self.set_end(list, new_end);
+                } else {
+                    self.adjust(list, Adjustment::Home);
+                }
+            }
+
+            Adjustment::PageDown => {
+                if let Some(new_end) = end_pin.down(list, usize::from(list.rows)) {
+                    self.set_end(list, new_end);
+                } else {
+                    self.adjust(list, Adjustment::End);
+                }
+            }
+
+            Adjustment::Home => {
+                let p = list
+                    .pin(Point::Screen(Coordinate { x: 0, y: 0 }))
+                    .expect("screen has a top-left");
+                self.set_end(list, p);
+            }
+
+            Adjustment::End => {
+                let found = list
+                    .row_iterator(
+                        Direction::LeftUp,
+                        Point::Screen(Coordinate::default()),
+                        None,
+                    )
+                    .find_map(|next| {
+                        let cells = list.node(next.node)?.data.get_cells(usize::from(next.y))?;
+                        if Cell::has_text_any(cells) {
+                            Some(Pin {
+                                x: (cells.len() - 1) as u16,
+                                ..next
+                            })
+                        } else {
+                            None
+                        }
+                    });
+                if let Some(p) = found {
+                    self.set_end(list, p);
+                }
+            }
+
+            Adjustment::BeginningOfLine => {
+                self.set_end(list, Pin { x: 0, ..end_pin });
+            }
+
+            Adjustment::EndOfLine => {
+                let cols = list
+                    .node(end_pin.node)
+                    .map_or(list.cols, |n| n.data.size.cols);
+                self.set_end(
+                    list,
+                    Pin {
+                        x: cols - 1,
+                        ..end_pin
+                    },
+                );
+            }
+        }
+    }
+}
+
+fn cell_has_text(list: &PageList, p: Pin) -> bool {
+    p.row_and_cell(list).is_some_and(|(_, c)| c.has_text())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::screen::{Options, Screen};
+
+    fn init(cols: u16, rows: u16, max_scrollback: usize) -> Screen {
+        Screen::new(Options::new(cols, rows, max_scrollback)).unwrap()
+    }
+
+    /// `s.pages.pin(.{ .screen = .{ .x, .y } }).?`
+    fn sp(s: &Screen, x: u16, y: u32) -> Pin {
+        s.pages.pin(Point::Screen(Coordinate { x, y })).unwrap()
+    }
+
+    /// `s.pages.pointFromPin(.screen, pin).?`
+    fn spt(s: &Screen, p: Pin) -> Point {
+        s.pages.point_from_pin(Tag::Screen, p).unwrap()
+    }
+
+    fn pt(x: u16, y: u32) -> Point {
+        Point::Screen(Coordinate { x, y })
+    }
+
+    fn sel_of(s: &Screen, a: (u16, u32), b: (u16, u32), rect: bool) -> Selection {
+        Selection::new(sp(s, a.0, a.1), sp(s, b.0, b.1), rect)
+    }
+
+    /// Adjust a fresh selection and check the resulting start/end points.
+    fn check_adjust(
+        s: &mut Screen,
+        start: (u16, u32),
+        end: (u16, u32),
+        adj: Adjustment,
+        want_start: (u16, u32),
+        want_end: (u16, u32),
+    ) {
+        let mut sel = sel_of(s, start, end, false);
+        sel.adjust(&mut s.pages, adj);
+        assert_eq!(pt(want_start.0, want_start.1), spt(s, sel.start(&s.pages)));
+        assert_eq!(pt(want_end.0, want_end.1), spt(s, sel.end(&s.pages)));
+        sel.deinit(&mut s.pages);
+    }
+
+    #[test]
+    fn selection_adjust_right() {
+        let mut s = init(10, 10, 0);
+        s.test_write_string("A1234\nB5678\nC1234\nD5678").unwrap();
+
+        // Simple movement right
+        check_adjust(&mut s, (5, 1), (3, 3), Adjustment::Right, (5, 1), (4, 3));
+
+        // Already at end of the line.
+        check_adjust(&mut s, (4, 1), (4, 2), Adjustment::Right, (4, 1), (0, 3));
+
+        // Already at end of the screen
+        check_adjust(&mut s, (5, 1), (4, 3), Adjustment::Right, (5, 1), (4, 3));
+    }
+
+    #[test]
+    fn selection_adjust_left() {
+        let mut s = init(10, 10, 0);
+        s.test_write_string("A1234\nB5678\nC1234\nD5678").unwrap();
+
+        // Simple movement left
+        check_adjust(&mut s, (5, 1), (3, 3), Adjustment::Left, (5, 1), (2, 3));
+
+        // Already at beginning of the line.
+        check_adjust(&mut s, (5, 1), (0, 3), Adjustment::Left, (5, 1), (4, 2));
+    }
+
+    #[test]
+    fn selection_adjust_left_skips_blanks() {
+        let mut s = init(10, 10, 0);
+        s.test_write_string("A1234\nB5678\nC12\nD56").unwrap();
+
+        // Same line
+        check_adjust(&mut s, (5, 1), (4, 3), Adjustment::Left, (5, 1), (2, 3));
+
+        // Edge
+        check_adjust(&mut s, (5, 1), (0, 3), Adjustment::Left, (5, 1), (2, 2));
+    }
+
+    #[test]
+    fn selection_adjust_up() {
+        let mut s = init(10, 10, 0);
+        s.test_write_string("A\nB\nC\nD\nE").unwrap();
+
+        // Not on the first line
+        check_adjust(&mut s, (5, 1), (3, 3), Adjustment::Up, (5, 1), (3, 2));
+
+        // On the first line
+        check_adjust(&mut s, (5, 1), (3, 0), Adjustment::Up, (5, 1), (0, 0));
+    }
+
+    #[test]
+    fn selection_adjust_down() {
+        let mut s = init(10, 10, 0);
+        s.test_write_string("A\nB\nC\nD\nE").unwrap();
+
+        // Not on the first line
+        check_adjust(&mut s, (5, 1), (3, 3), Adjustment::Down, (5, 1), (3, 4));
+
+        // On the last line
+        check_adjust(&mut s, (4, 1), (3, 4), Adjustment::Down, (4, 1), (9, 4));
+    }
+
+    #[test]
+    fn selection_adjust_down_with_not_full_screen() {
+        let mut s = init(10, 10, 0);
+        s.test_write_string("A\nB\nC").unwrap();
+
+        // On the last line
+        check_adjust(&mut s, (4, 1), (3, 2), Adjustment::Down, (4, 1), (9, 2));
+    }
+
+    #[test]
+    fn selection_adjust_home() {
+        let mut s = init(10, 10, 0);
+        s.test_write_string("A\nB\nC").unwrap();
+
+        // On the last line
+        check_adjust(&mut s, (4, 1), (1, 2), Adjustment::Home, (4, 1), (0, 0));
+    }
+
+    #[test]
+    fn selection_adjust_end_with_not_full_screen() {
+        let mut s = init(10, 10, 0);
+        s.test_write_string("A\nB\nC").unwrap();
+
+        // On the last line
+        check_adjust(&mut s, (4, 0), (1, 1), Adjustment::End, (4, 0), (9, 2));
+    }
+
+    #[test]
+    fn selection_adjust_beginning_of_line() {
+        let mut s = init(8, 10, 0);
+        s.test_write_string("A12 B34\nC12 D34").unwrap();
+
+        // Not at beginning of the line
+        check_adjust(
+            &mut s,
+            (5, 1),
+            (5, 1),
+            Adjustment::BeginningOfLine,
+            (5, 1),
+            (0, 1),
+        );
+
+        // Already at beginning of the line
+        check_adjust(
+            &mut s,
+            (5, 1),
+            (0, 1),
+            Adjustment::BeginningOfLine,
+            (5, 1),
+            (0, 1),
+        );
+
+        // End pin moves to start pin
+        check_adjust(
+            &mut s,
+            (0, 1),
+            (5, 1),
+            Adjustment::BeginningOfLine,
+            (0, 1),
+            (0, 1),
+        );
+    }
+
+    #[test]
+    fn selection_adjust_end_of_line() {
+        let mut s = init(8, 10, 0);
+        s.test_write_string("A12 B34\nC12 D34").unwrap();
+
+        // Not at end of the line
+        check_adjust(
+            &mut s,
+            (1, 0),
+            (1, 0),
+            Adjustment::EndOfLine,
+            (1, 0),
+            (7, 0),
+        );
+
+        // Already at end of the line
+        check_adjust(
+            &mut s,
+            (1, 0),
+            (7, 0),
+            Adjustment::EndOfLine,
+            (1, 0),
+            (7, 0),
+        );
+
+        // End pin moves to start pin
+        check_adjust(
+            &mut s,
+            (7, 0),
+            (1, 0),
+            Adjustment::EndOfLine,
+            (7, 0),
+            (7, 0),
+        );
+    }
+
+    #[test]
+    fn selection_order_standard() {
+        let s = init(100, 100, 1);
+
+        // forward, multi-line
+        assert_eq!(
+            Order::Forward,
+            sel_of(&s, (2, 1), (2, 2), false).order(&s.pages)
+        );
+        // reverse, multi-line
+        assert_eq!(
+            Order::Reverse,
+            sel_of(&s, (2, 2), (2, 1), false).order(&s.pages)
+        );
+        // forward, same-line
+        assert_eq!(
+            Order::Forward,
+            sel_of(&s, (2, 1), (3, 1), false).order(&s.pages)
+        );
+        // forward, single char
+        assert_eq!(
+            Order::Forward,
+            sel_of(&s, (2, 1), (2, 1), false).order(&s.pages)
+        );
+        // reverse, single line
+        assert_eq!(
+            Order::Reverse,
+            sel_of(&s, (2, 1), (1, 1), false).order(&s.pages)
+        );
+    }
+
+    #[test]
+    fn selection_order_rectangle() {
+        let s = init(100, 100, 1);
+
+        // Conventions:
+        // TL - top left
+        // BL - bottom left
+        // TR - top right
+        // BR - bottom right
+
+        // forward (TL -> BR)
+        assert_eq!(
+            Order::Forward,
+            sel_of(&s, (1, 1), (2, 2), true).order(&s.pages)
+        );
+        // reverse (BR -> TL)
+        assert_eq!(
+            Order::Reverse,
+            sel_of(&s, (2, 2), (1, 1), true).order(&s.pages)
+        );
+        // mirrored_forward (TR -> BL)
+        assert_eq!(
+            Order::MirroredForward,
+            sel_of(&s, (3, 1), (1, 3), true).order(&s.pages)
+        );
+        // mirrored_reverse (BL -> TR)
+        assert_eq!(
+            Order::MirroredReverse,
+            sel_of(&s, (1, 3), (3, 1), true).order(&s.pages)
+        );
+        // forward, single line (left -> right )
+        assert_eq!(
+            Order::Forward,
+            sel_of(&s, (1, 1), (3, 1), true).order(&s.pages)
+        );
+        // reverse, single line (right -> left)
+        assert_eq!(
+            Order::Reverse,
+            sel_of(&s, (3, 1), (1, 1), true).order(&s.pages)
+        );
+        // forward, single column (top -> bottom)
+        assert_eq!(
+            Order::Forward,
+            sel_of(&s, (2, 1), (2, 3), true).order(&s.pages)
+        );
+        // reverse, single column (bottom -> top)
+        assert_eq!(
+            Order::Reverse,
+            sel_of(&s, (2, 3), (2, 1), true).order(&s.pages)
+        );
+        // forward, single cell
+        assert_eq!(
+            Order::Forward,
+            sel_of(&s, (1, 1), (1, 1), true).order(&s.pages)
+        );
+    }
+
+    #[test]
+    fn top_left() {
+        let s = init(10, 10, 0);
+        // forward
+        let sel = sel_of(&s, (1, 1), (3, 1), true);
+        assert_eq!(pt(1, 1), spt(&s, sel.top_left(&s.pages)));
+        // reverse
+        let sel = sel_of(&s, (3, 1), (1, 1), true);
+        assert_eq!(pt(1, 1), spt(&s, sel.top_left(&s.pages)));
+        // mirrored_forward
+        let sel = sel_of(&s, (3, 1), (1, 3), true);
+        assert_eq!(pt(1, 1), spt(&s, sel.top_left(&s.pages)));
+        // mirrored_reverse
+        let sel = sel_of(&s, (1, 3), (3, 1), true);
+        assert_eq!(pt(1, 1), spt(&s, sel.top_left(&s.pages)));
+    }
+
+    #[test]
+    fn bottom_right() {
+        let s = init(10, 10, 0);
+        // forward
+        let sel = sel_of(&s, (1, 1), (3, 1), false);
+        assert_eq!(pt(3, 1), spt(&s, sel.bottom_right(&s.pages)));
+        // reverse
+        let sel = sel_of(&s, (3, 1), (1, 1), false);
+        assert_eq!(pt(3, 1), spt(&s, sel.bottom_right(&s.pages)));
+        // mirrored_forward
+        let sel = sel_of(&s, (3, 1), (1, 3), true);
+        assert_eq!(pt(3, 3), spt(&s, sel.bottom_right(&s.pages)));
+        // mirrored_reverse
+        let sel = sel_of(&s, (1, 3), (3, 1), true);
+        assert_eq!(pt(3, 3), spt(&s, sel.bottom_right(&s.pages)));
+    }
+
+    #[test]
+    fn ordered() {
+        let s = init(10, 10, 0);
+        let l = &s.pages;
+        {
+            // forward
+            let sel = sel_of(&s, (1, 1), (3, 1), false);
+            let sel_reverse = sel_of(&s, (3, 1), (1, 1), false);
+            assert!(sel.ordered(l, Order::Forward).eql(l, &sel));
+            assert!(sel.ordered(l, Order::Reverse).eql(l, &sel_reverse));
+            assert!(sel.ordered(l, Order::MirroredForward).eql(l, &sel));
+        }
+        {
+            // reverse
+            let sel = sel_of(&s, (3, 1), (1, 1), false);
+            let sel_forward = sel_of(&s, (1, 1), (3, 1), false);
+            assert!(sel.ordered(l, Order::Forward).eql(l, &sel_forward));
+            assert!(sel.ordered(l, Order::Reverse).eql(l, &sel));
+            assert!(sel.ordered(l, Order::MirroredForward).eql(l, &sel_forward));
+        }
+        {
+            // mirrored_forward
+            let sel = sel_of(&s, (3, 1), (1, 3), true);
+            let sel_forward = sel_of(&s, (1, 1), (3, 3), true);
+            let sel_reverse = sel_of(&s, (3, 3), (1, 1), true);
+            assert!(sel.ordered(l, Order::Forward).eql(l, &sel_forward));
+            assert!(sel.ordered(l, Order::Reverse).eql(l, &sel_reverse));
+            assert!(sel.ordered(l, Order::MirroredReverse).eql(l, &sel_forward));
+        }
+        {
+            // mirrored_reverse
+            let sel = sel_of(&s, (1, 3), (3, 1), true);
+            let sel_forward = sel_of(&s, (1, 1), (3, 3), true);
+            let sel_reverse = sel_of(&s, (3, 3), (1, 1), true);
+            assert!(sel.ordered(l, Order::Forward).eql(l, &sel_forward));
+            assert!(sel.ordered(l, Order::Reverse).eql(l, &sel_reverse));
+            assert!(sel.ordered(l, Order::MirroredForward).eql(l, &sel_forward));
+        }
+    }
+
+    #[test]
+    fn selection_contains() {
+        let s = init(10, 10, 0);
+        let l = &s.pages;
+        {
+            let sel = sel_of(&s, (5, 1), (3, 2), false);
+
+            assert!(sel.contains(l, sp(&s, 6, 1)));
+            assert!(sel.contains(l, sp(&s, 1, 2)));
+            assert!(!sel.contains(l, sp(&s, 1, 1)));
+            assert!(!sel.contains(l, sp(&s, 5, 2)));
+        }
+
+        // Reverse
+        {
+            let sel = sel_of(&s, (3, 2), (5, 1), false);
+
+            assert!(sel.contains(l, sp(&s, 6, 1)));
+            assert!(sel.contains(l, sp(&s, 1, 2)));
+            assert!(!sel.contains(l, sp(&s, 1, 1)));
+            assert!(!sel.contains(l, sp(&s, 5, 2)));
+        }
+
+        // Single line
+        {
+            let sel = sel_of(&s, (5, 1), (8, 1), false);
+
+            assert!(sel.contains(l, sp(&s, 6, 1)));
+            assert!(!sel.contains(l, sp(&s, 2, 1)));
+            assert!(!sel.contains(l, sp(&s, 9, 1)));
+        }
+    }
+
+    #[test]
+    fn selection_contains_rectangle() {
+        let s = init(15, 15, 0);
+        let l = &s.pages;
+        for (a, b) in [((3, 3), (7, 9)), ((7, 9), (3, 3))] {
+            // The second iteration is the "Reverse" case.
+            let sel = sel_of(&s, a, b, true);
+
+            assert!(sel.contains(l, sp(&s, 5, 6))); // Center
+            assert!(sel.contains(l, sp(&s, 3, 6))); // Left border
+            assert!(sel.contains(l, sp(&s, 7, 6))); // Right border
+            assert!(sel.contains(l, sp(&s, 5, 3))); // Top border
+            assert!(sel.contains(l, sp(&s, 5, 9))); // Bottom border
+
+            assert!(!sel.contains(l, sp(&s, 5, 2))); // Above center
+            assert!(!sel.contains(l, sp(&s, 5, 10))); // Below center
+            assert!(!sel.contains(l, sp(&s, 2, 6))); // Left center
+            assert!(!sel.contains(l, sp(&s, 8, 6))); // Right center
+            assert!(!sel.contains(l, sp(&s, 8, 3))); // Just right of top right
+            assert!(!sel.contains(l, sp(&s, 2, 9))); // Just left of bottom left
+        }
+
+        // Single line
+        // NOTE: This is the same as normal selection but we just do it for brevity
+        {
+            let sel = sel_of(&s, (5, 1), (10, 1), true);
+
+            assert!(sel.contains(l, sp(&s, 6, 1)));
+            assert!(!sel.contains(l, sp(&s, 2, 1)));
+            assert!(!sel.contains(l, sp(&s, 12, 1)));
+        }
+    }
+
+    #[test]
+    fn selection_contained_row() {
+        let s = init(10, 5, 0);
+        let l = &s.pages;
+        let last = s.pages.cols - 1;
+
+        {
+            let sel = sel_of(&s, (5, 1), (3, 3), false);
+
+            // Not contained
+            assert!(sel.contained_row(l, sp(&s, 1, 4)).is_none());
+
+            // Start line
+            assert_eq!(
+                Selection::new(sel.start(l), sp(&s, last, 1), false),
+                sel.contained_row(l, sp(&s, 1, 1)).unwrap()
+            );
+
+            // End line
+            assert_eq!(
+                Selection::new(sp(&s, 0, 3), sel.end(l), false),
+                sel.contained_row(l, sp(&s, 2, 3)).unwrap()
+            );
+
+            // Middle line
+            assert_eq!(
+                Selection::new(sp(&s, 0, 2), sp(&s, last, 2), false),
+                sel.contained_row(l, sp(&s, 2, 2)).unwrap()
+            );
+        }
+
+        // Rectangle
+        {
+            let sel = sel_of(&s, (3, 1), (6, 3), true);
+
+            // Not contained
+            assert!(sel.contained_row(l, sp(&s, 1, 4)).is_none());
+
+            // Start line
+            assert_eq!(
+                Selection::new(sp(&s, 3, 1), sp(&s, 6, 1), true),
+                sel.contained_row(l, sp(&s, 1, 1)).unwrap()
+            );
+
+            // End line
+            assert_eq!(
+                Selection::new(sp(&s, 3, 3), sp(&s, 6, 3), true),
+                sel.contained_row(l, sp(&s, 2, 3)).unwrap()
+            );
+
+            // Middle line
+            assert_eq!(
+                Selection::new(sp(&s, 3, 2), sp(&s, 6, 2), true),
+                sel.contained_row(l, sp(&s, 2, 2)).unwrap()
+            );
+        }
+
+        // Single-line selection
+        {
+            let sel = sel_of(&s, (2, 1), (6, 1), false);
+
+            // Not contained
+            assert!(sel.contained_row(l, sp(&s, 1, 0)).is_none());
+            assert!(sel.contained_row(l, sp(&s, 1, 2)).is_none());
+
+            // Contained
+            assert_eq!(sel, sel.contained_row(l, sp(&s, 1, 1)).unwrap());
+        }
+    }
+}

crates/ghostty-terminal/src/tabstops.rs

@@ -0,0 +1,244 @@
+//! Keep track of the location of tabstops.
+//!
+//! This is implemented as a bit set. There is a preallocation segment that
+//! is used for almost all screen sizes. Then there is a dynamically allocated
+//! segment if the screen is larger than the preallocation amount.
+//!
+//! In reality, tabstops don't need to be the most performant in any metric.
+//! This implementation tries to balance denser memory usage (by using a bitset)
+//! and minimizing unnecessary allocations.
+use std::collections::TryReserveError;
+
+/// Unit is the type we use per tabstop unit (see file docs).
+type Unit = u8;
+const UNIT_BITS: usize = Unit::BITS as usize;
+
+/// The number of columns we preallocate for. This is kind of high which
+/// costs us some memory, but this is more columns than my 6k monitor at
+/// 12-point font size, so this should prevent allocation in almost all
+/// real world scenarios for the price of wasting at most
+/// (columns / sizeOf(Unit)) bytes.
+const PREALLOC_COLUMNS: usize = 512;
+
+/// The number of entries we need for our preallocation.
+const PREALLOC_COUNT: usize = PREALLOC_COLUMNS / UNIT_BITS;
+
+/// We precompute all the possible masks since we never use a huge bit size.
+const MASKS: [Unit; UNIT_BITS] = {
+    let mut res = [0; UNIT_BITS];
+    let mut i = 0;
+    while i < UNIT_BITS {
+        res[i] = 1 << i;
+        i += 1;
+    }
+    res
+};
+
+/// Returns the entry in the stops array that would contain this column.
+#[inline]
+const fn entry(col: usize) -> usize {
+    col / UNIT_BITS
+}
+
+#[inline]
+const fn index(col: usize) -> usize {
+    col % UNIT_BITS
+}
+
+/// Tabstop bit set.
+#[derive(Debug, Clone)]
+pub struct Tabstops {
+    /// The number of columns this tabstop is set to manage. Use `resize`
+    /// to change this number.
+    pub cols: usize,
+
+    /// Preallocated tab stops.
+    prealloc_stops: [Unit; PREALLOC_COUNT],
+
+    /// Dynamically expanded stops above prealloc stops.
+    dynamic_stops: Vec<Unit>,
+}
+
+impl Default for Tabstops {
+    fn default() -> Self {
+        Self {
+            cols: 0,
+            prealloc_stops: [0; PREALLOC_COUNT],
+            dynamic_stops: Vec::new(),
+        }
+    }
+}
+
+impl Tabstops {
+    pub fn new(cols: usize, interval: usize) -> Result<Self, TryReserveError> {
+        let mut res = Self::default();
+        res.resize(cols)?;
+        res.reset(interval);
+        Ok(res)
+    }
+
+    /// Set the tabstop at a certain column. The columns are 0-indexed.
+    pub fn set(&mut self, col: usize) {
+        let i = entry(col);
+        let idx = index(col);
+        if i < PREALLOC_COUNT {
+            self.prealloc_stops[i] |= MASKS[idx];
+            return;
+        }
+
+        let dynamic_i = i - PREALLOC_COUNT;
+        assert!(dynamic_i < self.dynamic_stops.len());
+        self.dynamic_stops[dynamic_i] |= MASKS[idx];
+    }
+
+    /// Unset the tabstop at a certain column. The columns are 0-indexed.
+    ///
+    /// Note: like the Zig implementation this XORs the bit, so unsetting a
+    /// tabstop that is not set will set it.
+    pub fn unset(&mut self, col: usize) {
+        let i = entry(col);
+        let idx = index(col);
+        if i < PREALLOC_COUNT {
+            self.prealloc_stops[i] ^= MASKS[idx];
+            return;
+        }
+
+        let dynamic_i = i - PREALLOC_COUNT;
+        assert!(dynamic_i < self.dynamic_stops.len());
+        self.dynamic_stops[dynamic_i] ^= MASKS[idx];
+    }
+
+    /// Get the value of a tabstop at a specific column. The columns are 0-indexed.
+    pub fn get(&self, col: usize) -> bool {
+        let i = entry(col);
+        let idx = index(col);
+        let mask = MASKS[idx];
+        let unit = if i < PREALLOC_COUNT {
+            self.prealloc_stops[i]
+        } else {
+            let dynamic_i = i - PREALLOC_COUNT;
+            assert!(dynamic_i < self.dynamic_stops.len());
+            self.dynamic_stops[dynamic_i]
+        };
+
+        unit & mask == mask
+    }
+
+    /// Resize this to support up to cols columns.
+    // TODO: needs interval to set new tabstops
+    pub fn resize(&mut self, cols: usize) -> Result<(), TryReserveError> {
+        // Do nothing if it fits.
+        if cols <= PREALLOC_COLUMNS {
+            self.cols = cols;
+            return Ok(());
+        }
+
+        // What we need in the dynamic size
+        let size = cols - PREALLOC_COLUMNS;
+        if size < self.dynamic_stops.len() {
+            self.cols = cols;
+            return Ok(());
+        }
+
+        // Allocate first so that failure leaves our state untouched.
+        let mut new: Vec<Unit> = Vec::new();
+        new.try_reserve_exact(size)?;
+        new.resize(size, 0);
+        new[..self.dynamic_stops.len()].copy_from_slice(&self.dynamic_stops);
+
+        self.dynamic_stops = new;
+        self.cols = cols;
+        Ok(())
+    }
+
+    /// Return the maximum number of columns this can support currently.
+    pub fn capacity(&self) -> usize {
+        (PREALLOC_COUNT + self.dynamic_stops.len()) * UNIT_BITS
+    }
+
+    /// Unset all tabstops and then reset the initial tabstops to the given
+    /// interval. An interval of 0 sets no tabstops.
+    pub fn reset(&mut self, interval: usize) {
+        self.prealloc_stops.fill(0);
+        self.dynamic_stops.fill(0);
+
+        if interval > 0 {
+            let mut i = interval;
+            while i + 1 < self.cols {
+                self.set(i);
+                i += interval;
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn tabstops_basic() {
+        let mut t = Tabstops::default();
+        assert_eq!(0, entry(4));
+        assert_eq!(1, entry(8));
+        assert_eq!(0, index(0));
+        assert_eq!(1, index(1));
+        assert_eq!(1, index(9));
+
+        assert_eq!(0b00001000, MASKS[3]);
+        assert_eq!(0b00010000, MASKS[4]);
+
+        assert!(!t.get(4));
+        t.set(4);
+        assert!(t.get(4));
+        assert!(!t.get(3));
+
+        t.reset(0);
+        assert!(!t.get(4));
+
+        t.set(4);
+        assert!(t.get(4));
+        t.unset(4);
+        assert!(!t.get(4));
+    }
+
+    #[test]
+    fn tabstops_dynamic_allocations() {
+        let mut t = Tabstops::default();
+
+        // Grow the capacity by 2.
+        let cap = t.capacity();
+        t.resize(cap * 2).unwrap();
+
+        // Set something that was out of range of the first
+        t.set(cap + 5);
+        assert!(t.get(cap + 5));
+        assert!(!t.get(cap + 4));
+
+        // Prealloc still works
+        assert!(!t.get(5));
+    }
+
+    #[test]
+    fn tabstops_interval() {
+        let t = Tabstops::new(80, 4).unwrap();
+        assert!(!t.get(0));
+        assert!(t.get(4));
+        assert!(!t.get(5));
+        assert!(t.get(8));
+    }
+
+    #[test]
+    fn tabstops_count_on_80() {
+        // https://superuser.com/questions/710019/why-there-are-11-tabstops-on-a-80-column-console
+        let t = Tabstops::new(80, 8).unwrap();
+
+        // Count the tabstops
+        let count = (0..80).filter(|&i| t.get(i)).count();
+        assert_eq!(9, count);
+    }
+
+    // "Tabstops: resize alloc failure preserves state" is skipped: it uses
+    // Zig tripwire allocation failure injection. The Rust resize allocates
+    // before mutating, so a failure leaves `cols` unchanged by construction.
+}