Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust
170 KB
Raw Blame
//! The textarea owns editable composer text, placeholder elements, cursor/wrap state, and a
//! single-entry kill buffer. Single-line inputs ignore line breaks and scroll horizontally.
//!
//! Whole-buffer replacement APIs intentionally rebuild only the visible draft state. They clear
//! element ranges and derived cursor/wrapping caches, but they keep the kill buffer intact so a
//! caller can clear or rewrite the draft and still allow `Ctrl+Y` to restore the user's most
//! recent `Ctrl+K`. This is the contract higher-level composer flows rely on after submit,
//! slash-command dispatch, and other synthetic clears.
//!
//! This module does not implement an Emacs-style multi-entry kill ring. It keeps only the most
//! recent killed span.
//!
//! Wrapping also reserves a visible insertion point: full logical lines get continuation rows,
//! and trailing spaces wrap instead of moving the cursor outside the textarea. At soft word
//! breaks, interior separators hang off the preceding row without changing the editable text.
//! Visible web URLs carry their complete terminal hyperlink destination across wrapped rows;
//! masked rendering never exposes hyperlink destinations.
//! Mouse selection and wheel browsing use those same visual rows and keep graphemes and elements
//! atomic. Wheel browsing leaves the caret in place; moving or editing returns to caret following.
//! The editing module resolves replacement targets shared by insertion and paste-context inspection.

use crate::key_hint::KeyBindingListExt;
use crate::key_hint::is_altgr;
use crate::keymap::EditorKeymap;
use crate::keymap::KeymapContext;
use crate::keymap::RuntimeKeymap;
use crate::keymap::VimNormalKeymap;
use crate::keymap::VimOperatorKeymap;
use crate::keymap::VimSearchKeymap;
use crate::keymap::VimTextObjectKeymap;
use crate::width::display_width;
use codex_protocol::user_input::ByteRange;
use codex_protocol::user_input::TextElement as UserTextElement;
use crossterm::event::KeyCode;
use crossterm::event::KeyEvent;
use crossterm::event::KeyEventKind;
use crossterm::event::KeyModifiers;
use ratatui::buffer::Buffer;
use ratatui::layout::Rect;
use ratatui::style::Color;
use ratatui::style::Style;
use ratatui::style::Stylize;
use ratatui::text::Span;
use ratatui::widgets::StatefulWidgetRef;
use ratatui::widgets::WidgetRef;
use std::borrow::Cow;
use std::cell::Cell;
use std::cell::OnceCell;
use std::cell::Ref;
use std::cell::RefCell;
use std::ops::Range;
use std::sync::Arc;
use unicode_segmentation::UnicodeSegmentation;

mod editing;
mod hyperlinks;
mod mouse;
mod single_line;
mod vim;
mod vim_commands;
mod vim_search;
mod wrapping;

use self::vim::VimMode;
use self::vim::VimMotion;
use self::vim::VimOperator;
use self::vim::VimPending;
use self::vim::VimTextObject;
use self::vim::VimTextObjectScope;
use self::vim_commands::VimAction;
use self::vim_commands::VimCommandState;
use self::vim_commands::VimEditTarget;
use self::vim_commands::VimInsertPosition;
pub(crate) use self::vim_commands::VimPersistentState;
pub(crate) use editing::EditTarget;

const WORD_SEPARATORS: &str = "`~!@#$%^&*()-=+[{]}\\|;:'\",.<>/?";

fn is_word_separator(ch: char) -> bool {
    WORD_SEPARATORS.contains(ch)
}

fn split_word_pieces(run: &str) -> Vec<(usize, &str)> {
    let mut pieces = Vec::new();
    for (segment_start, segment) in run.split_word_bound_indices() {
        let mut piece_start = 0;
        let mut chars = segment.char_indices();
        let Some((_, first_char)) = chars.next() else {
            continue;
        };
        let mut in_separator = is_word_separator(first_char);

        for (idx, ch) in chars {
            let is_separator = is_word_separator(ch);
            if is_separator == in_separator {
                continue;
            }
            pieces.push((segment_start + piece_start, &segment[piece_start..idx]));
            piece_start = idx;
            in_separator = is_separator;
        }

        pieces.push((segment_start + piece_start, &segment[piece_start..]));
    }

    pieces
}

/// Replace tabs with the one-column representation used for rendering and wrapping.
///
/// A tab and a space are both one byte, so ranges computed from this text still index the original
/// editable text.
fn text_for_display(text: &str) -> Cow<'_, str> {
    if text.contains('\t') {
        Cow::Owned(text.replace('\t', " "))
    } else {
        Cow::Borrowed(text)
    }
}

#[derive(Debug, Clone)]
struct TextElement {
    id: u64,
    range: Range<usize>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct TextElementSnapshot {
    pub(crate) id: u64,
    pub(crate) range: Range<usize>,
    pub(crate) text: String,
}

/// `TextArea` is the editable buffer behind the TUI composer.
///
/// It owns the raw UTF-8 text, placeholder-like text elements that must move atomically with
/// edits, cursor/wrapping state for rendering, and a single-entry kill buffer for `Ctrl+K` /
/// `Ctrl+Y` style editing. Callers may replace the entire visible buffer through
/// [`Self::set_text_clearing_elements`] or [`Self::set_text_with_elements`] without disturbing the
/// kill buffer; if they incorrectly assume those methods fully reset editing state, a later yank
/// will appear to restore stale text from the user's perspective.
#[derive(Debug)]
pub(crate) struct TextArea {
    text: String,
    single_line: bool,
    cursor_pos: usize,
    mouse_selection: Option<mouse::MouseSelection>,
    last_click: Option<(std::time::Instant, u16, u16, u8)>,
    rendered_area: Cell<Rect>,
    wrap_cache: RefCell<Option<WrapCache>>,
    preferred_col: Option<usize>,
    elements: Vec<TextElement>,
    next_element_id: u64,
    kill_buffer: String,
    kill_buffer_kind: KillBufferKind,
    vim_enabled: bool,
    vim_mode: VimMode,
    vim_pending: VimPending,
    vim_commands: VimCommandState,
    vim_search: vim_search::VimSearch,
    vim_search_enabled: bool,
    editor_keymap: Arc<EditorKeymap>,
    vim_normal_keymap: VimNormalKeymap,
    vim_operator_keymap: VimOperatorKeymap,
    vim_search_keymap: VimSearchKeymap,
    vim_text_object_keymap: VimTextObjectKeymap,
}

#[derive(Debug, Clone)]
struct WrapCache {
    width: u16,
    lines: Vec<Range<usize>>,
    hyperlinks: OnceCell<hyperlinks::HyperlinkCache>,
}

#[derive(Debug, Default, Clone, Copy)]
pub(crate) struct TextAreaState {
    /// Index into wrapped lines of the first visible line.
    pub(in crate::bottom_pane) scroll: u16,
    /// Caret at the time of manual scrolling. A changed caret resumes following automatically.
    manual_cursor: Option<usize>,
}

impl TextAreaState {
    pub(crate) fn follow_cursor(&mut self) {
        self.manual_cursor = None;
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum KillBufferKind {
    /// Characterwise kills and yanks paste at the cursor.
    Characterwise,
    /// Linewise kills and yanks paste as whole lines below the cursor line.
    Linewise,
}

/// The last editor kill or Vim yank, carried between chat composers in the same TUI session.
pub(crate) struct KillBufferSnapshot {
    text: String,
    kind: KillBufferKind,
}

impl Default for TextArea {
    fn default() -> Self {
        Self::new()
    }
}

impl TextArea {
    pub fn new() -> Self {
        let defaults = RuntimeKeymap::defaults();
        Self {
            text: String::new(),
            single_line: false,
            cursor_pos: 0,
            mouse_selection: None,
            last_click: None,
            rendered_area: Cell::new(Rect::default()),
            wrap_cache: RefCell::new(None),
            preferred_col: None,
            elements: Vec::new(),
            next_element_id: 1,
            kill_buffer: String::new(),
            kill_buffer_kind: KillBufferKind::Characterwise,
            vim_enabled: false,
            vim_mode: VimMode::Insert,
            vim_pending: VimPending::None,
            vim_commands: VimCommandState::default(),
            vim_search: vim_search::VimSearch::default(),
            vim_search_enabled: false,
            editor_keymap: defaults.editor,
            vim_normal_keymap: defaults.vim_normal,
            vim_operator_keymap: defaults.vim_operator,
            vim_search_keymap: defaults.vim_search,
            vim_text_object_keymap: defaults.vim_text_object,
        }
    }

    /// Replace the editor and Vim keymaps used by subsequent text-editing input.
    ///
    /// This method intentionally swaps only the keymap caches. It does not
    /// reinterpret pending input, change Vim mode, move the cursor, or mutate
    /// the kill buffer, so callers can safely apply a live config update while
    /// preserving the current draft exactly as typed.
    pub fn set_keymap_bindings(&mut self, keymap: &RuntimeKeymap) {
        self.editor_keymap = Arc::clone(&keymap.editor);
        self.vim_normal_keymap = keymap.vim_normal.clone();
        self.vim_operator_keymap = keymap.vim_operator.clone();
        self.vim_search_keymap = keymap.vim_search.clone();
        self.vim_text_object_keymap = keymap.vim_text_object.clone();
    }

    /// Replace the visible textarea text and clear any existing text elements.
    ///
    /// This is the "fresh buffer" path for callers that want plain text with no placeholder
    /// ranges. It intentionally preserves the current kill buffer, because higher-level flows such
    /// as submit or slash-command dispatch clear the draft through this method and still want
    /// `Ctrl+Y` to recover the user's most recent kill.
    pub fn set_text_clearing_elements(&mut self, text: &str) {
        self.set_text_inner(text, /*elements*/ None);
    }

    /// Replace the visible textarea text and rebuild the provided text elements.
    ///
    /// As with [`Self::set_text_clearing_elements`], this resets only state derived from the
    /// visible buffer. The kill buffer survives so callers restoring drafts or external edits do
    /// not silently discard a pending yank target.
    pub fn set_text_with_elements(&mut self, text: &str, elements: &[UserTextElement]) {
        self.set_text_inner(text, Some(elements));
    }

    fn set_text_inner(&mut self, text: &str, elements: Option<&[UserTextElement]>) {
        let filtered = self.filter_line_breaks(text);
        let text = filtered.as_ref();
        self.mouse_selection = None;
        // Stage 1: replace the raw text and keep the cursor in a safe byte range.
        self.text = text.to_string();
        self.cursor_pos = self.cursor_pos.clamp(0, self.text.len());
        // Stage 2: rebuild element ranges from scratch against the new text.
        self.elements.clear();
        if let Some(elements) = elements {
            for elem in elements {
                let mut start = elem.byte_range.start.min(self.text.len());
                let mut end = elem.byte_range.end.min(self.text.len());
                start = self.clamp_pos_to_char_boundary(start);
                end = self.clamp_pos_to_char_boundary(end);
                if start >= end {
                    continue;
                }
                let id = self.next_element_id();
                self.elements.push(TextElement {
                    id,
                    range: start..end,
                });
            }
            self.elements.sort_by_key(|e| e.range.start);
        }
        // Stage 3: clamp the cursor and reset derived state tied to the prior content.
        // The kill buffer is editing history rather than visible-buffer state, so full-buffer
        // replacements intentionally leave it alone.
        self.cursor_pos = self.clamp_pos_to_nearest_boundary(self.cursor_pos);
        self.wrap_cache.replace(None);
        self.preferred_col = None;
        self.vim_pending = VimPending::None;
        self.vim_search = vim_search::VimSearch::default();
        self.vim_commands = VimCommandState::default();
    }

    /// Enable or disable modal Vim editing for the textarea.
    ///
    /// Enabling always enters normal mode and disabling always returns to
    /// insert semantics. Pending operators are cleared in both directions so a
    /// toggle cannot leave the next keypress interpreted as the second half of
    /// an old `d` or `y` command.
    pub(crate) fn set_vim_enabled(&mut self, enabled: bool) {
        self.vim_enabled = enabled;
        self.vim_pending = VimPending::None;
        self.vim_search = vim_search::VimSearch::default();
        self.vim_commands = VimCommandState::default();
        self.vim_mode = if enabled {
            VimMode::Normal
        } else {
            VimMode::Insert
        };
    }

    /// Return whether modal Vim editing is currently enabled.
    pub(crate) fn is_vim_enabled(&self) -> bool {
        self.vim_enabled
    }

    /// Return whether Vim mode is enabled and currently waiting in normal mode.
    ///
    /// Composer-level handlers use this to decide whether Up/Down should be
    /// offered to history navigation only after normal-mode movement reaches a
    /// text boundary.
    pub(crate) fn is_vim_normal_mode(&self) -> bool {
        self.vim_enabled && self.vim_mode == VimMode::Normal
    }

    /// Return the cursor position that represents the last editable item in Vim normal mode.
    pub(crate) fn vim_normal_end_cursor(&self) -> usize {
        if self.text.is_empty() {
            0
        } else {
            self.prev_atomic_boundary(self.text.len())
        }
    }

    /// Return whether a Vim operator is waiting for a motion.
    ///
    /// This is observable so the composer can avoid stealing the second key of
    /// `d{motion}` or `y{motion}` for higher-level shortcuts.
    pub(crate) fn is_vim_operator_pending(&self) -> bool {
        self.vim_query().is_some() || !matches!(self.vim_pending, VimPending::None)
    }

    /// Return the keymap context that owns the next editing key.
    pub(crate) fn keymap_context(&self) -> KeymapContext {
        if !self.vim_enabled
            || matches!(self.vim_mode, VimMode::Insert | VimMode::Replace)
            || self.vim_query().is_some()
        {
            return KeymapContext::Editor;
        }
        match self.vim_pending {
            VimPending::None => KeymapContext::VimNormal,
            VimPending::Replace | VimPending::Find { .. } => KeymapContext::Editor,
            VimPending::Operator(_) => KeymapContext::VimOperator,
            VimPending::TextObject { .. } => KeymapContext::VimTextObject,
        }
    }

    /// Enter Vim insert mode if modal editing is enabled.
    ///
    /// Calling this while Vim is disabled is a no-op, which lets parent
    /// workflows reset mode after submissions without first branching on the
    /// current keymap state.
    pub(crate) fn enter_vim_insert_mode(&mut self) {
        if self.vim_enabled {
            self.vim_mode = VimMode::Insert;
            self.vim_pending = VimPending::None;
            self.clear_vim_replace_recovery();
            self.cancel_vim_search();
            if self.vim_commands.pending_change.is_empty() && !self.vim_commands.replaying {
                self.start_vim_edit(VimAction::Insert(VimInsertPosition::Cursor));
            }
        }
    }

    /// Enter Vim normal mode if modal editing is enabled.
    ///
    /// This clears any pending operator and preferred vertical column. The
    /// latter matches normal Vim navigation expectations after leaving insert
    /// mode; preserving the old column would make the next `j` or `k` jump to a
    /// stale visual target.
    pub(crate) fn enter_vim_normal_mode(&mut self) {
        if self.vim_enabled {
            self.vim_mode = VimMode::Normal;
            self.vim_pending = VimPending::None;
            self.cancel_vim_search();
            self.preferred_col = None;
            self.clear_vim_replace_recovery();
        }
    }

    /// Return whether rapid plain-key bursts should be treated as paste input.
    ///
    /// Paste burst detection is disabled in Vim normal mode so a fast sequence
    /// like `dd` or `yw` remains command input instead of being converted into
    /// literal text.
    pub(crate) fn allows_paste_burst(&self) -> bool {
        !self.vim_enabled || matches!(self.vim_mode, VimMode::Insert | VimMode::Replace)
    }

    /// Return whether rendering should use the insert-mode cursor style.
    pub(crate) fn uses_vim_insert_cursor(&self) -> bool {
        self.vim_enabled && self.vim_mode == VimMode::Insert
    }

    /// Return whether Escape should be intercepted before composer-level routing.
    ///
    /// In Vim insert mode or while a command is pending, Escape is an editing
    /// transition rather than a popup cancel/backtrack or turn-interrupt shortcut.
    pub(crate) fn should_handle_vim_insert_escape(&self, event: KeyEvent) -> bool {
        self.vim_enabled
            && (matches!(self.vim_mode, VimMode::Insert | VimMode::Replace)
                || self.is_vim_operator_pending())
            && event.code == KeyCode::Esc
            && event.modifiers == KeyModifiers::NONE
            && matches!(event.kind, KeyEventKind::Press | KeyEventKind::Repeat)
    }

    /// Return the footer label for the active Vim mode.
    ///
    /// `None` means Vim editing is disabled, so callers should omit the mode
    /// indicator rather than rendering an insert-mode label for normal
    /// non-modal editing.
    #[cfg(test)]
    pub(crate) fn vim_mode_label(&self) -> Option<&'static str> {
        if !self.vim_enabled {
            return None;
        }
        Some(match self.vim_mode {
            VimMode::Normal => "Normal",
            VimMode::Insert => "Insert",
            VimMode::Replace => "Replace",
        })
    }

    /// Return the styled footer indicator for the active Vim editing mode.
    pub(crate) fn vim_mode_indicator_span(&self) -> Option<Span<'static>> {
        if !self.vim_enabled {
            return None;
        }
        Some(match self.vim_mode {
            VimMode::Normal => "Vim: Normal".magenta(),
            VimMode::Insert => "Vim: Insert".green(),
            VimMode::Replace => "Vim: Replace".cyan(),
        })
    }

    pub fn text(&self) -> &str {
        &self.text
    }

    pub fn insert_str_at(&mut self, pos: usize, text: &str) {
        let filtered = self.filter_line_breaks(text);
        let text = filtered.as_ref();
        self.mouse_selection = None;
        self.clear_vim_replace_recovery();
        let pos = self.clamp_pos_for_insertion(pos);
        self.text.insert_str(pos, text);
        self.wrap_cache.replace(None);
        if pos <= self.cursor_pos {
            self.cursor_pos += text.len();
        }
        self.shift_elements(pos, /*removed*/ 0, text.len());
        self.preferred_col = None;
    }

    pub fn replace_range(&mut self, range: std::ops::Range<usize>, text: &str) {
        self.clear_vim_replace_recovery();
        self.replace_range_preserving_recovery(range, text);
    }

    // Replace typing and Backspace keep contiguous recovery, but still respect atomic elements.
    fn replace_range_preserving_recovery(&mut self, range: Range<usize>, text: &str) {
        let range = self.expand_range_to_element_boundaries(range);
        self.replace_range_raw(range, text);
    }

    fn replace_range_raw(&mut self, range: std::ops::Range<usize>, text: &str) {
        let filtered = self.filter_line_breaks(text);
        let text = filtered.as_ref();
        self.mouse_selection = None;
        assert!(range.start <= range.end);
        let start = range.start.clamp(0, self.text.len());
        let end = range.end.clamp(0, self.text.len());
        let removed_len = end - start;
        let inserted_len = text.len();
        if removed_len == 0 && inserted_len == 0 {
            return;
        }
        let diff = inserted_len as isize - removed_len as isize;

        self.text.replace_range(range, text);
        self.wrap_cache.replace(None);
        self.preferred_col = None;
        self.update_elements_after_replace(start, end, inserted_len);

        // Update the cursor position to account for the edit.
        self.cursor_pos = if self.cursor_pos < start {
            // Cursor was before the edited range – no shift.
            self.cursor_pos
        } else if self.cursor_pos <= end {
            // Cursor was inside the replaced range – move to end of the new text.
            start + inserted_len
        } else {
            // Cursor was after the replaced range – shift by the length diff.
            ((self.cursor_pos as isize) + diff) as usize
        }
        .min(self.text.len());

        // Ensure cursor is not inside an element
        self.cursor_pos = self.clamp_pos_to_nearest_boundary(self.cursor_pos);
    }

    pub fn cursor(&self) -> usize {
        self.cursor_pos
    }

    pub fn set_cursor(&mut self, pos: usize) {
        self.mouse_selection = None;
        self.cursor_pos = pos.clamp(0, self.text.len());
        self.cursor_pos = self.clamp_pos_to_nearest_boundary(self.cursor_pos);
        self.preferred_col = None;
    }

    pub fn desired_height(&self, width: u16) -> u16 {
        if self.single_line {
            return 1;
        }
        self.wrapped_lines(width).len() as u16
    }

    #[cfg_attr(not(test), allow(dead_code))]
    pub fn cursor_pos(&self, area: Rect) -> Option<(u16, u16)> {
        self.cursor_pos_with_state(area, TextAreaState::default())
    }

    /// Returns an on-screen cursor position within `area`, accounting for wrapping and scrolling.
    ///
    /// Returns `None` when the viewport or caret is not visible.
    pub fn cursor_pos_with_state(&self, area: Rect, state: TextAreaState) -> Option<(u16, u16)> {
        if area.is_empty() {
            return None;
        }

        if self.single_line {
            let (_, col) = self.single_line_viewport(area.width);
            return Some((area.x + col, area.y));
        }
        let lines = self.wrapped_lines(area.width);
        let effective_scroll = self.effective_scroll(area, &lines, state);
        let (i, col) = wrapping::cursor_position(&self.text, &lines, area.width, self.cursor_pos)?;
        let screen_row = i.checked_sub(usize::from(effective_scroll))?;
        (screen_row < usize::from(area.height))
            .then(|| (area.x + col as u16, area.y + screen_row as u16))
    }

    pub fn is_empty(&self) -> bool {
        self.text.is_empty()
    }

    fn current_display_col(&self) -> usize {
        let bol = self.beginning_of_current_line();
        display_width(&self.text[bol..self.cursor_pos])
    }

    fn move_to_display_col_on_line(
        &mut self,
        line_start: usize,
        line_end: usize,
        target_col: usize,
    ) {
        let pos = self.position_at_display_col_on_line(line_start, line_end, target_col);
        self.cursor_pos = self.clamp_pos_to_nearest_boundary(pos);
    }

    fn position_at_display_col_on_line(
        &self,
        line_start: usize,
        line_end: usize,
        target_col: usize,
    ) -> usize {
        let mut width_so_far = 0usize;
        for (i, g) in self.text[line_start..line_end].grapheme_indices(true) {
            width_so_far += display_width(g);
            if width_so_far > target_col {
                return line_start + i;
            }
        }
        line_end
    }

    fn beginning_of_line(&self, pos: usize) -> usize {
        self.text[..pos].rfind('\n').map(|i| i + 1).unwrap_or(0)
    }
    fn beginning_of_current_line(&self) -> usize {
        self.beginning_of_line(self.cursor_pos)
    }

    fn first_non_blank_of_current_line(&self) -> usize {
        let bol = self.beginning_of_current_line();
        let eol = self.end_of_current_line();
        self.text[bol..eol]
            .char_indices()
            .find_map(|(offset, ch)| (!ch.is_whitespace()).then_some(bol + offset))
            .unwrap_or(eol)
    }

    fn end_of_line(&self, pos: usize) -> usize {
        self.text[pos..]
            .find('\n')
            .map(|i| i + pos)
            .unwrap_or(self.text.len())
    }
    fn end_of_current_line(&self) -> usize {
        self.end_of_line(self.cursor_pos)
    }

    pub fn input(&mut self, event: KeyEvent) {
        // Only process key presses or repeats; ignore releases to avoid inserting
        // characters on key-up events when modifiers are no longer reported.
        if !matches!(event.kind, KeyEventKind::Press | KeyEventKind::Repeat) {
            return;
        }
        self.last_click = None;
        if self.vim_enabled {
            if self.is_vim_normal_mode() {
                self.mouse_selection = None;
            }
            self.handle_vim_input(event);
        } else {
            let keymap = self.editor_keymap.clone();
            self.input_with_keymap(event, &keymap);
        }
    }

    pub fn input_with_keymap(&mut self, event: KeyEvent, keymap: &EditorKeymap) {
        self.last_click = None;
        self.end_mouse_drag();
        if keymap.insert_newline.is_pressed(event) {
            self.insert_str("\n");
            return;
        }

        if keymap.delete_backward_word.is_pressed(event) {
            self.apply_vim_insert_action(VimAction::DeleteBackwardWord);
            return;
        }

        // Windows AltGr generates ALT|CONTROL. Preserve typed characters for AltGr users
        // unless a specific shortcut already matched above.
        if let KeyEvent {
            code: KeyCode::Char(c),
            modifiers,
            ..
        } = event
            && is_altgr(modifiers)
        {
            self.insert_str(&c.to_string());
            return;
        }

        if keymap.delete_backward.is_pressed(event) {
            self.apply_vim_insert_action(VimAction::DeleteBackward);
            return;
        }
        if keymap.delete_forward_word.is_pressed(event) {
            self.apply_vim_insert_action(VimAction::DeleteForwardWord);
            return;
        }
        if keymap.delete_forward.is_pressed(event) {
            self.apply_vim_insert_action(VimAction::DeleteForward);
            return;
        }
        if keymap.kill_line_start.is_pressed(event) {
            self.apply_vim_insert_action(VimAction::KillLineStart);
            return;
        }
        if keymap.kill_whole_line.is_pressed(event) {
            self.apply_vim_insert_action(VimAction::KillLine);
            return;
        }
        if keymap.kill_line_end.is_pressed(event) {
            self.apply_vim_insert_action(VimAction::KillLineEnd);
            return;
        }
        if keymap.yank.is_pressed(event) {
            self.yank();
            return;
        }
        if keymap.move_word_left.is_pressed(event) {
            self.apply_vim_insert_action(VimAction::MoveWordLeft);
            return;
        }
        if keymap.move_word_right.is_pressed(event) {
            self.apply_vim_insert_action(VimAction::MoveWordRight);
            return;
        }
        if keymap.move_left.is_pressed(event) {
            self.apply_vim_insert_action(VimAction::MoveLeft);
            return;
        }
        if keymap.move_right.is_pressed(event) {
            self.apply_vim_insert_action(VimAction::MoveRight);
            return;
        }
        if keymap.move_up.is_pressed(event) {
            self.apply_vim_insert_action(VimAction::MoveUp);
            return;
        }
        if keymap.move_down.is_pressed(event) {
            self.apply_vim_insert_action(VimAction::MoveDown);
            return;
        }
        if keymap.move_line_start.is_pressed(event) {
            let move_up_at_bol = matches!(
                event,
                KeyEvent {
                    code: KeyCode::Char('a'),
                    modifiers: KeyModifiers::CONTROL,
                    ..
                }
            );
            self.apply_vim_insert_action(VimAction::MoveLineStart { move_up_at_bol });
            return;
        }
        if keymap.move_line_end.is_pressed(event) {
            let move_down_at_eol = matches!(
                event,
                KeyEvent {
                    code: KeyCode::Char('e'),
                    modifiers: KeyModifiers::CONTROL,
                    ..
                }
            );
            self.apply_vim_insert_action(VimAction::MoveLineEnd { move_down_at_eol });
            return;
        }

        if let KeyEvent {
            code: KeyCode::Char(c),
            modifiers: KeyModifiers::NONE | KeyModifiers::SHIFT,
            ..
        } = event
        {
            // Insert plain characters (and Shift-modified). Do not insert when ALT is held,
            // because many terminals map Option/Meta combos to ALT+<char>.
            if c.is_ascii_control() {
                return;
            }
            self.insert_str(&c.to_string());
        }

        tracing::debug!("Unhandled key event in TextArea: {:?}", event);
        self.mouse_selection = None;
    }

    fn handle_vim_input(&mut self, event: KeyEvent) {
        if self.handle_vim_search_key(event) {
            return;
        }
        let prior_mode = self.vim_mode;
        match self.vim_mode {
            VimMode::Insert | VimMode::Replace => self.handle_vim_insert(event),
            VimMode::Normal => self.handle_vim_normal(event),
        }
        if matches!(prior_mode, VimMode::Insert | VimMode::Replace)
            && self.vim_mode == VimMode::Normal
        {
            self.finish_pending_vim_change();
        }
    }

    fn handle_vim_insert(&mut self, event: KeyEvent) {
        if matches!(event.code, KeyCode::Esc) {
            self.leave_vim_insert_mode();
            return;
        }
        if self.is_vim_replace_mode()
            && self.mouse_selection_range().is_none()
            && self.is_delete_backward_key(event)
            && self.apply_vim_insert_action(VimAction::RestoreReplacedCharacter)
        {
            return;
        }
        let keymap = self.editor_keymap.clone();
        self.input_with_keymap(event, &keymap);
    }

    pub(in crate::bottom_pane) fn is_delete_backward_key(&self, event: KeyEvent) -> bool {
        self.editor_keymap.delete_backward.is_pressed(event)
    }

    fn leave_vim_insert_mode(&mut self) {
        self.mouse_selection = None;
        let bol = self.beginning_of_current_line();
        if self.cursor_pos > bol {
            self.cursor_pos = self.prev_atomic_boundary(self.cursor_pos).max(bol);
        }
        self.enter_vim_normal_mode();
    }

    fn handle_vim_normal(&mut self, event: KeyEvent) {
        let pending = std::mem::replace(&mut self.vim_pending, VimPending::None);
        match pending {
            VimPending::None => {}
            VimPending::Operator(op) => {
                self.handle_vim_operator(op, event);
                return;
            }
            VimPending::TextObject { operator, scope } => {
                self.handle_vim_text_object(operator, scope, event);
                return;
            }
            VimPending::Replace | VimPending::Find { .. } => {
                self.handle_vim_pending_command(pending, event);
                return;
            }
        }

        if self.vim_normal_keymap.enter_insert.is_pressed(event) {
            self.start_vim_edit(VimAction::Insert(VimInsertPosition::Cursor));
            return;
        }
        if self.vim_normal_keymap.append_after_cursor.is_pressed(event) {
            self.start_vim_edit(VimAction::Insert(VimInsertPosition::AfterCursor));
            return;
        }
        if self.vim_normal_keymap.append_line_end.is_pressed(event) {
            self.start_vim_edit(VimAction::Insert(VimInsertPosition::LineEnd));
            return;
        }
        if self.vim_normal_keymap.insert_line_start.is_pressed(event) {
            self.start_vim_edit(VimAction::Insert(VimInsertPosition::LineStart));
            return;
        }
        if self.vim_normal_keymap.open_line_below.is_pressed(event) {
            if !self.single_line {
                self.start_vim_edit(VimAction::Insert(VimInsertPosition::OpenBelow));
            }
            return;
        }
        if self.vim_normal_keymap.open_line_above.is_pressed(event) {
            if !self.single_line {
                self.start_vim_edit(VimAction::Insert(VimInsertPosition::OpenAbove));
            }
            return;
        }
        if self.vim_normal_keymap.move_left.is_pressed(event) {
            self.move_cursor_left();
            return;
        }
        if self.vim_normal_keymap.move_right.is_pressed(event) {
            self.move_cursor_right();
            return;
        }
        if self.vim_normal_keymap.move_down.is_pressed(event) {
            self.move_cursor_down();
            return;
        }
        if self.vim_normal_keymap.move_up.is_pressed(event) {
            self.move_cursor_up();
            return;
        }
        if self.vim_normal_keymap.move_word_forward.is_pressed(event) {
            self.set_cursor(self.beginning_of_next_word());
            return;
        }
        if self.vim_normal_keymap.move_word_backward.is_pressed(event) {
            self.set_cursor(self.beginning_of_previous_word());
            return;
        }
        if self.vim_normal_keymap.move_word_end.is_pressed(event) {
            self.set_cursor(self.vim_word_end_cursor());
            return;
        }
        if self.vim_normal_keymap.move_line_start.is_pressed(event) {
            self.set_cursor(self.beginning_of_current_line());
            return;
        }
        if self.vim_normal_keymap.move_line_end.is_pressed(event) {
            self.set_cursor(self.vim_line_end_cursor());
            return;
        }
        if self.vim_normal_keymap.delete_char.is_pressed(event) {
            self.start_vim_edit(VimAction::Delete(VimEditTarget::Character));
            return;
        }
        if self.vim_normal_keymap.substitute_char.is_pressed(event) {
            self.start_vim_edit(VimAction::Change(VimEditTarget::Character));
            return;
        }
        if self.vim_normal_keymap.delete_to_line_end.is_pressed(event) {
            self.start_vim_edit(VimAction::Delete(VimEditTarget::LineEnd));
            return;
        }
        if self.vim_normal_keymap.change_to_line_end.is_pressed(event) {
            self.start_vim_edit(VimAction::Change(VimEditTarget::LineEnd));
            return;
        }
        if self.vim_normal_keymap.yank_line.is_pressed(event) {
            self.yank_current_line();
            return;
        }
        if self.vim_normal_keymap.paste_after.is_pressed(event) {
            self.start_vim_edit(VimAction::PasteAfter);
            return;
        }
        if self
            .vim_normal_keymap
            .start_delete_operator
            .is_pressed(event)
        {
            self.vim_pending = VimPending::Operator(VimOperator::Delete);
            return;
        }
        if self.vim_normal_keymap.start_yank_operator.is_pressed(event) {
            self.vim_pending = VimPending::Operator(VimOperator::Yank);
            return;
        }
        if self
            .vim_normal_keymap
            .start_change_operator
            .is_pressed(event)
        {
            self.vim_pending = VimPending::Operator(VimOperator::Change);
            return;
        }
        if self.vim_normal_keymap.cancel_operator.is_pressed(event) {
            self.vim_pending = VimPending::None;
            self.cancel_vim_search();
            return;
        }
        self.handle_vim_extra_command(event);
    }

    fn handle_vim_operator(&mut self, op: VimOperator, event: KeyEvent) -> bool {
        if op == VimOperator::Delete && self.vim_operator_keymap.delete_line.is_pressed(event) {
            self.start_vim_edit(VimAction::Delete(VimEditTarget::Line));
            return true;
        }
        if op == VimOperator::Yank && self.vim_operator_keymap.yank_line.is_pressed(event) {
            self.yank_current_line();
            return true;
        }
        if self.vim_operator_keymap.cancel.is_pressed(event) {
            return true;
        }
        if let Some(scope) = self.vim_text_object_scope_for_event(event) {
            self.vim_pending = VimPending::TextObject {
                operator: op,
                scope,
            };
            return true;
        }

        if let Some(motion) = self.vim_motion_for_event(event) {
            match op {
                VimOperator::Delete => {
                    self.start_vim_edit(VimAction::Delete(VimEditTarget::Motion(motion)));
                }
                VimOperator::Change => {
                    self.start_vim_edit(VimAction::Change(VimEditTarget::Motion(motion)));
                }
                VimOperator::Yank => self.apply_vim_operator(op, motion),
            }
            return true;
        }
        if op == VimOperator::Change
            && self
                .vim_normal_keymap
                .start_change_operator
                .is_pressed(event)
        {
            self.start_vim_edit(VimAction::Change(VimEditTarget::Line));
            return true;
        }
        self.handle_vim_operator_command(op, event)
    }

    fn handle_vim_text_object(
        &mut self,
        op: VimOperator,
        scope: VimTextObjectScope,
        event: KeyEvent,
    ) -> bool {
        if self.vim_text_object_keymap.cancel.is_pressed(event) {
            return true;
        }
        let Some(object) = self.vim_text_object_for_event(event) else {
            return false;
        };
        match op {
            VimOperator::Delete => {
                self.start_vim_edit(VimAction::Delete(VimEditTarget::TextObject {
                    scope,
                    object,
                }));
            }
            VimOperator::Change => {
                self.start_vim_edit(VimAction::Change(VimEditTarget::TextObject {
                    scope,
                    object,
                }));
            }
            VimOperator::Yank => {
                if let Some(range) = self.text_object_range(object, scope) {
                    self.apply_vim_operator_to_range(op, range);
                }
            }
        }
        true
    }

    fn vim_motion_for_event(&self, event: KeyEvent) -> Option<VimMotion> {
        if self.vim_operator_keymap.motion_left.is_pressed(event) {
            return Some(VimMotion::Left);
        }
        if self.vim_operator_keymap.motion_right.is_pressed(event) {
            return Some(VimMotion::Right);
        }
        if self.vim_operator_keymap.motion_down.is_pressed(event) {
            return Some(VimMotion::Down);
        }
        if self.vim_operator_keymap.motion_up.is_pressed(event) {
            return Some(VimMotion::Up);
        }
        if self
            .vim_operator_keymap
            .motion_word_forward
            .is_pressed(event)
        {
            return Some(VimMotion::WordForward);
        }
        if self
            .vim_operator_keymap
            .motion_word_backward
            .is_pressed(event)
        {
            return Some(VimMotion::WordBackward);
        }
        if self.vim_operator_keymap.motion_word_end.is_pressed(event) {
            return Some(VimMotion::WordEnd);
        }
        if self.vim_operator_keymap.motion_line_start.is_pressed(event) {
            return Some(VimMotion::LineStart);
        }
        if self.vim_operator_keymap.motion_line_end.is_pressed(event) {
            return Some(VimMotion::LineEnd);
        }
        None
    }

    fn apply_vim_operator(&mut self, op: VimOperator, motion: VimMotion) {
        if op == VimOperator::Change && motion == VimMotion::WordForward {
            let target = if self.text[self.cursor_pos..]
                .chars()
                .next()
                .is_some_and(|ch| !ch.is_whitespace())
            {
                self.end_of_next_word()
            } else {
                self.beginning_of_next_word()
                    .min(self.end_of_current_line())
            };
            if target > self.cursor_pos {
                self.apply_vim_operator_to_range(op, self.cursor_pos..target);
            } else {
                self.vim_mode = VimMode::Insert;
            }
            return;
        }
        let Some(range) = self.range_for_motion(motion) else {
            if op == VimOperator::Change && motion == VimMotion::LineEnd {
                self.vim_mode = VimMode::Insert;
            }
            return;
        };
        if op == VimOperator::Change && matches!(motion, VimMotion::Up | VimMotion::Down) {
            if motion == VimMotion::Up && self.beginning_of_current_line() == 0
                || motion == VimMotion::Down && self.end_of_current_line() == self.text.len()
            {
                return;
            }
            let retain_newline =
                range.end < self.text.len() && self.text[range.clone()].ends_with('\n');
            let start = range.start;
            self.kill_line_range(range);
            if retain_newline {
                self.insert_str_at(start, "\n");
                self.set_cursor(start);
            }
            self.vim_mode = VimMode::Insert;
            return;
        }
        self.apply_vim_operator_to_range(op, range);
    }

    fn apply_vim_operator_to_range(&mut self, op: VimOperator, range: Range<usize>) {
        match op {
            VimOperator::Delete => self.kill_range(range),
            VimOperator::Yank => self.yank_range(range),
            VimOperator::Change => {
                self.kill_range(range);
                self.vim_mode = VimMode::Insert;
            }
        }
    }

    fn range_for_motion(&mut self, motion: VimMotion) -> Option<Range<usize>> {
        if matches!(motion, VimMotion::Up | VimMotion::Down) {
            return self.linewise_range_for_vertical_motion(motion);
        }
        let start = self.cursor_pos;
        let target = self.target_for_motion(motion);
        if start == target {
            return None;
        }
        let (range_start, range_end) = if target < start {
            (target, start)
        } else {
            (start, target)
        };
        Some(range_start..range_end)
    }

    fn linewise_range_for_vertical_motion(&self, motion: VimMotion) -> Option<Range<usize>> {
        let current = self.current_line_range_with_newline();
        let range = match motion {
            VimMotion::Up => {
                let start = if current.start == 0 {
                    current.start
                } else {
                    self.beginning_of_line(current.start.saturating_sub(1))
                };
                start..current.end
            }
            VimMotion::Down => {
                let end = if current.end >= self.text.len() {
                    current.end
                } else {
                    let next_eol = self.end_of_line(current.end);
                    if next_eol < self.text.len() {
                        next_eol + 1
                    } else {
                        next_eol
                    }
                };
                current.start..end
            }
            VimMotion::Left
            | VimMotion::Right
            | VimMotion::WordForward
            | VimMotion::WordBackward
            | VimMotion::WordEnd
            | VimMotion::LineStart
            | VimMotion::LineEnd => return None,
        };
        (range.start < range.end).then_some(range)
    }

    fn target_for_motion(&mut self, motion: VimMotion) -> usize {
        let original_cursor = self.cursor_pos;
        let original_preferred = self.preferred_col;
        match motion {
            VimMotion::Left => self.move_cursor_left(),
            VimMotion::Right => self.move_cursor_right(),
            VimMotion::Up => self.move_cursor_up(),
            VimMotion::Down => self.move_cursor_down(),
            VimMotion::WordForward => self.set_cursor(self.beginning_of_next_word()),
            VimMotion::WordBackward => self.set_cursor(self.beginning_of_previous_word()),
            VimMotion::WordEnd => self.set_cursor(self.vim_word_end_exclusive()),
            VimMotion::LineStart => self.set_cursor(self.beginning_of_current_line()),
            VimMotion::LineEnd => self.set_cursor(self.end_of_current_line()),
        }
        let target = self.cursor_pos;
        self.cursor_pos = original_cursor;
        self.preferred_col = original_preferred;
        target
    }

    // ####### Input Functions #######
    pub fn delete_backward(&mut self, n: usize) {
        if n == 0 || self.cursor_pos == 0 {
            return;
        }
        let mut target = self.cursor_pos;
        for _ in 0..n {
            if let Some((boundary, ch)) = self.text[..target].char_indices().next_back()
                && matches!(
                    ch,
                    // Thai-only special casing is not ideal; refactor if it becomes more complex.
                    // All Thai nonspacing marks: vowel signs, tone marks, and other diacritics.
                    '\u{0e31}' | '\u{0e34}'..='\u{0e3a}' | '\u{0e47}'..='\u{0e4e}'
                )
                && !self
                    .elements
                    .iter()
                    .any(|element| target > element.range.start && target <= element.range.end)
            {
                target = boundary;
            } else {
                target = self.prev_atomic_boundary(target);
            }
            if target == 0 {
                break;
            }
        }
        self.replace_range(target..self.cursor_pos, "");
    }

    pub fn delete_forward(&mut self, n: usize) {
        if n == 0 || self.cursor_pos >= self.text.len() {
            return;
        }
        let mut target = self.cursor_pos;
        for _ in 0..n {
            target = self.next_atomic_boundary(target);
            if target >= self.text.len() {
                break;
            }
        }
        self.replace_range(self.cursor_pos..target, "");
    }

    pub fn delete_forward_kill(&mut self, n: usize) {
        if n == 0 || self.cursor_pos >= self.text.len() {
            return;
        }
        let mut target = self.cursor_pos;
        for _ in 0..n {
            target = self.next_atomic_boundary(target);
            if target >= self.text.len() {
                break;
            }
        }
        self.kill_range(self.cursor_pos..target);
    }

    pub fn delete_backward_word(&mut self) {
        let start = self.beginning_of_previous_word();
        self.kill_range(start..self.cursor_pos);
    }

    /// Delete text to the right of the cursor using "word" semantics.
    ///
    /// Deletes from the current cursor position through the end of the next word as determined
    /// by `end_of_next_word()`. Any whitespace (including newlines) between the cursor and that
    /// word is included in the deletion.
    pub fn delete_forward_word(&mut self) {
        let end = self.end_of_next_word();
        if end > self.cursor_pos {
            self.kill_range(self.cursor_pos..end);
        }
    }

    /// Kill from the cursor to the end of the current logical line.
    ///
    /// If the cursor is already at end-of-line and a trailing newline exists, this kills that
    /// newline so repeated invocations continue making progress. The removed text becomes the next
    /// yank target and remains available even if a caller later clears or rewrites the visible
    /// buffer via `set_text_*`.
    pub fn kill_to_end_of_line(&mut self) {
        let eol = self.end_of_current_line();
        let range = if self.cursor_pos == eol {
            if eol < self.text.len() {
                Some(self.cursor_pos..eol + 1)
            } else {
                None
            }
        } else {
            Some(self.cursor_pos..eol)
        };

        if let Some(range) = range {
            self.kill_range(range);
        }
    }

    fn vim_kill_to_end_of_line(&mut self) {
        let eol = self.end_of_current_line();
        if self.cursor_pos < eol {
            self.kill_range(self.cursor_pos..eol);
        }
    }

    pub fn kill_to_beginning_of_line(&mut self) {
        let bol = self.beginning_of_current_line();
        let range = if self.cursor_pos == bol {
            if bol > 0 { Some(bol - 1..bol) } else { None }
        } else {
            Some(bol..self.cursor_pos)
        };

        if let Some(range) = range {
            self.kill_range(range);
        }
    }

    /// Insert the most recently killed text at the cursor.
    ///
    /// This uses the textarea's single-entry kill buffer. Because whole-buffer replacement APIs do
    /// not clear that buffer, `yank` can restore text after composer-level clears such as submit
    /// and slash-command dispatch.
    pub fn yank(&mut self) {
        if self.kill_buffer.is_empty() {
            return;
        }
        let text = self.kill_buffer.clone();
        self.insert_str(&text);
    }

    pub(crate) fn take_kill_buffer_snapshot(&mut self) -> KillBufferSnapshot {
        KillBufferSnapshot {
            text: std::mem::take(&mut self.kill_buffer),
            kind: self.kill_buffer_kind,
        }
    }

    pub(crate) fn restore_kill_buffer_snapshot(&mut self, snapshot: KillBufferSnapshot) {
        self.kill_buffer = snapshot.text;
        self.kill_buffer_kind = snapshot.kind;
    }

    fn kill_range(&mut self, range: Range<usize>) {
        self.kill_range_with_kind(range, KillBufferKind::Characterwise);
    }

    fn kill_line_range(&mut self, range: Range<usize>) {
        self.kill_range_with_kind(range, KillBufferKind::Linewise);
    }

    fn kill_range_with_kind(&mut self, range: Range<usize>, kind: KillBufferKind) {
        let range = self.expand_range_to_element_boundaries(range);
        if range.start >= range.end {
            return;
        }

        let removed = self.text[range.clone()].to_string();
        if removed.is_empty() {
            return;
        }

        self.store_kill_buffer(removed, kind);
        self.replace_range_raw(range, "");
    }

    fn yank_range(&mut self, range: Range<usize>) {
        self.yank_range_with_kind(range, KillBufferKind::Characterwise);
    }

    fn yank_line_range(&mut self, range: Range<usize>) {
        self.yank_range_with_kind(range, KillBufferKind::Linewise);
    }

    fn yank_range_with_kind(&mut self, range: Range<usize>, kind: KillBufferKind) {
        let range = self.expand_range_to_element_boundaries(range);
        if range.start >= range.end {
            return;
        }
        let removed = self.text[range].to_string();
        if removed.is_empty() {
            return;
        }
        self.store_kill_buffer(removed, kind);
    }

    fn store_kill_buffer(&mut self, text: String, kind: KillBufferKind) {
        self.kill_buffer = text;
        self.kill_buffer_kind = kind;
    }

    fn paste_after_cursor(&mut self) {
        if self.kill_buffer.is_empty() {
            return;
        }
        if self.kill_buffer_kind == KillBufferKind::Linewise && !self.single_line {
            self.paste_line_after_current_line();
            return;
        }
        let insert_at = self.next_atomic_boundary(self.cursor_pos);
        self.set_cursor(insert_at);
        let text = self.kill_buffer.clone();
        self.insert_str(&text);
    }

    fn paste_line_after_current_line(&mut self) {
        let eol = self.end_of_current_line();
        let insert_at = if eol < self.text.len() { eol + 1 } else { eol };
        let cursor = if eol < self.text.len() {
            insert_at
        } else {
            insert_at + 1
        };
        let text = if eol < self.text.len() {
            if self.kill_buffer.ends_with('\n') {
                self.kill_buffer.clone()
            } else {
                format!("{}\n", self.kill_buffer)
            }
        } else {
            format!("\n{}", self.kill_buffer.trim_end_matches('\n'))
        };
        self.insert_str_at(insert_at, &text);
        self.set_cursor(cursor.min(self.text.len()));
    }

    fn yank_current_line(&mut self) {
        let range = self.current_line_range_with_newline();
        self.yank_line_range(range);
    }

    fn kill_current_line(&mut self) {
        let range = self.current_line_range_with_newline();
        self.kill_line_range(range);
    }

    fn current_line_range_with_newline(&self) -> Range<usize> {
        let bol = self.beginning_of_current_line();
        let eol = self.end_of_current_line();
        let end = if eol < self.text.len() { eol + 1 } else { eol };
        bol..end
    }

    /// Move the cursor left by a single grapheme cluster.
    pub fn move_cursor_left(&mut self) {
        self.cursor_pos = self.prev_atomic_boundary(self.cursor_pos);
        self.preferred_col = None;
    }

    /// Move the cursor right by a single grapheme cluster.
    pub fn move_cursor_right(&mut self) {
        self.cursor_pos = self.next_atomic_boundary(self.cursor_pos);
        self.preferred_col = None;
    }

    pub fn move_cursor_up(&mut self) {
        // If we have a wrapping cache, prefer navigating across wrapped (visual) lines.
        if let Some((target_col, maybe_line)) = {
            let cache_ref = self.wrap_cache.borrow();
            if let Some(cache) = cache_ref.as_ref() {
                let lines = &cache.lines;
                if let Some((idx, col)) =
                    wrapping::cursor_position(&self.text, lines, cache.width, self.cursor_pos)
                {
                    let cur_range = &lines[idx];
                    // A saved column can outlive a resize. Do not land in hanging whitespace
                    // that is displayed on the following row.
                    let target_col = self
                        .preferred_col
                        .unwrap_or(col)
                        .min(usize::from(cache.width.saturating_sub(1)));
                    if idx > 0 {
                        let prev = &lines[idx - 1];
                        let line_start = prev.start;
                        let mut line_end = prev.end.saturating_sub(1);
                        if line_end == cur_range.start {
                            line_end = self.prev_atomic_boundary(line_end).max(line_start);
                        }
                        Some((target_col, Some((line_start, line_end))))
                    } else {
                        Some((target_col, None))
                    }
                } else {
                    None
                }
            } else {
                None
            }
        } {
            // We had wrapping info. Apply movement accordingly.
            match maybe_line {
                Some((line_start, line_end)) => {
                    if self.preferred_col.is_none() {
                        self.preferred_col = Some(target_col);
                    }
                    self.move_to_display_col_on_line(line_start, line_end, target_col);
                    return;
                }
                None => {
                    // Already at first visual line -> move to start
                    self.cursor_pos = 0;
                    self.preferred_col = None;
                    return;
                }
            }
        }

        // Fallback to logical line navigation if we don't have wrapping info yet.
        if let Some(prev_nl) = self.text[..self.cursor_pos].rfind('\n') {
            let target_col = match self.preferred_col {
                Some(c) => c,
                None => {
                    let c = self.current_display_col();
                    self.preferred_col = Some(c);
                    c
                }
            };
            let prev_line_start = self.text[..prev_nl].rfind('\n').map(|i| i + 1).unwrap_or(0);
            let prev_line_end = prev_nl;
            self.move_to_display_col_on_line(prev_line_start, prev_line_end, target_col);
        } else {
            self.cursor_pos = 0;
            self.preferred_col = None;
        }
    }

    pub fn move_cursor_down(&mut self) {
        // If we have a wrapping cache, prefer navigating across wrapped (visual) lines.
        if let Some((target_col, move_to_last)) = {
            let cache_ref = self.wrap_cache.borrow();
            if let Some(cache) = cache_ref.as_ref() {
                let lines = &cache.lines;
                if let Some((idx, col)) =
                    wrapping::cursor_position(&self.text, lines, cache.width, self.cursor_pos)
                {
                    let target_col = self
                        .preferred_col
                        .unwrap_or(col)
                        .min(usize::from(cache.width.saturating_sub(1)));
                    if idx + 1 < lines.len() {
                        let next = &lines[idx + 1];
                        let line_start = next.start;
                        let mut line_end = next.end.saturating_sub(1);
                        if lines
                            .get(idx + 2)
                            .is_some_and(|following| following.start == line_end)
                        {
                            line_end = self.prev_atomic_boundary(line_end).max(line_start);
                        }
                        Some((target_col, Some((line_start, line_end))))
                    } else {
                        Some((target_col, None))
                    }
                } else {
                    None
                }
            } else {
                None
            }
        } {
            match move_to_last {
                Some((line_start, line_end)) => {
                    if self.preferred_col.is_none() {
                        self.preferred_col = Some(target_col);
                    }
                    self.move_to_display_col_on_line(line_start, line_end, target_col);
                    return;
                }
                None => {
                    // Already on last visual line -> move to end
                    self.cursor_pos = self.text.len();
                    self.preferred_col = None;
                    return;
                }
            }
        }

        // Fallback to logical line navigation if we don't have wrapping info yet.
        let target_col = match self.preferred_col {
            Some(c) => c,
            None => {
                let c = self.current_display_col();
                self.preferred_col = Some(c);
                c
            }
        };
        if let Some(next_nl) = self.text[self.cursor_pos..]
            .find('\n')
            .map(|i| i + self.cursor_pos)
        {
            let next_line_start = next_nl + 1;
            let next_line_end = self.text[next_line_start..]
                .find('\n')
                .map(|i| i + next_line_start)
                .unwrap_or(self.text.len());
            self.move_to_display_col_on_line(next_line_start, next_line_end, target_col);
        } else {
            self.cursor_pos = self.text.len();
            self.preferred_col = None;
        }
    }

    pub fn move_cursor_to_beginning_of_line(&mut self, move_up_at_bol: bool) {
        let bol = self.beginning_of_current_line();
        if move_up_at_bol && self.cursor_pos == bol {
            self.set_cursor(self.beginning_of_line(self.cursor_pos.saturating_sub(1)));
        } else {
            self.set_cursor(bol);
        }
        self.preferred_col = None;
    }

    pub fn move_cursor_to_end_of_line(&mut self, move_down_at_eol: bool) {
        let eol = self.end_of_current_line();
        if move_down_at_eol && self.cursor_pos == eol {
            let next_pos = (self.cursor_pos.saturating_add(1)).min(self.text.len());
            self.set_cursor(self.end_of_line(next_pos));
        } else {
            self.set_cursor(eol);
        }
    }

    // ===== Text elements support =====

    pub fn element_payloads(&self) -> Vec<String> {
        self.elements
            .iter()
            .filter_map(|e| self.text.get(e.range.clone()).map(str::to_string))
            .collect()
    }

    pub fn text_elements(&self) -> Vec<UserTextElement> {
        self.elements
            .iter()
            .map(|e| {
                let placeholder = self.text.get(e.range.clone()).map(str::to_string);
                UserTextElement::new(
                    ByteRange {
                        start: e.range.start,
                        end: e.range.end,
                    },
                    placeholder,
                )
            })
            .collect()
    }

    pub(crate) fn text_element_snapshots(&self) -> Vec<TextElementSnapshot> {
        self.elements
            .iter()
            .filter_map(|element| {
                self.text
                    .get(element.range.clone())
                    .map(|text| TextElementSnapshot {
                        id: element.id,
                        range: element.range.clone(),
                        text: text.to_string(),
                    })
            })
            .collect()
    }

    /// Iterates borrowed atomic element ranges in ascending start order.
    pub(crate) fn text_element_ranges(&self) -> impl Iterator<Item = &Range<usize>> {
        self.elements.iter().map(|element| &element.range)
    }

    /// Iterates ordered atomic element ranges that overlap `range`.
    ///
    /// Elements ending exactly at the range start or starting exactly at its end are excluded.
    pub(crate) fn text_element_ranges_overlapping(
        &self,
        range: Range<usize>,
    ) -> impl Iterator<Item = &Range<usize>> {
        let first = self
            .elements
            .partition_point(|element| element.range.end <= range.start);
        self.elements[first..]
            .iter()
            .take_while(move |element| element.range.start < range.end)
            .map(|element| &element.range)
    }

    pub(crate) fn element_id_for_exact_range(&self, range: Range<usize>) -> Option<u64> {
        self.elements
            .iter()
            .find(|element| element.range == range)
            .map(|element| element.id)
    }

    /// Renames a single text element in-place, keeping it atomic.
    ///
    /// Use this when the element payload is an identifier (e.g. a placeholder) that must be
    /// updated without converting the element back into normal text.
    pub fn replace_element_payload(&mut self, old: &str, new: &str) -> bool {
        let filtered = self.filter_line_breaks(new);
        let new = filtered.as_ref();
        let Some(idx) = self
            .elements
            .iter()
            .position(|e| self.text.get(e.range.clone()) == Some(old))
        else {
            return false;
        };

        let range = self.elements[idx].range.clone();
        let start = range.start;
        let end = range.end;
        if start > end || end > self.text.len() {
            return false;
        }

        let removed_len = end - start;
        let inserted_len = new.len();
        let diff = inserted_len as isize - removed_len as isize;

        self.mouse_selection = None;
        self.text.replace_range(range, new);
        self.wrap_cache.replace(None);
        self.preferred_col = None;

        // Update the modified element's range.
        self.elements[idx].range = start..(start + inserted_len);

        // Shift element ranges that occur after the replaced element.
        if diff != 0 {
            for (j, e) in self.elements.iter_mut().enumerate() {
                if j == idx {
                    continue;
                }
                if e.range.end <= start {
                    continue;
                }
                if e.range.start >= end {
                    e.range.start = ((e.range.start as isize) + diff) as usize;
                    e.range.end = ((e.range.end as isize) + diff) as usize;
                    continue;
                }

                // Elements should not partially overlap each other; degrade gracefully by
                // snapping anything intersecting the replaced range to the new bounds.
                e.range.start = start.min(e.range.start);
                e.range.end = (start + inserted_len).max(e.range.end.saturating_add_signed(diff));
            }
        }

        // Update the cursor position to account for the edit.
        self.cursor_pos = if self.cursor_pos < start {
            self.cursor_pos
        } else if self.cursor_pos <= end {
            start + inserted_len
        } else {
            ((self.cursor_pos as isize) + diff) as usize
        };
        self.cursor_pos = self.clamp_pos_to_nearest_boundary(self.cursor_pos);

        // Keep element ordering deterministic.
        self.elements.sort_by_key(|e| e.range.start);

        true
    }

    fn add_element(&mut self, range: Range<usize>) -> u64 {
        let id = self.next_element_id();
        self.elements.push(TextElement { id, range });
        self.elements.sort_by_key(|e| e.range.start);
        id
    }

    /// Mark an existing text range as an atomic element without changing the text.
    ///
    /// This is used to convert already-typed tokens (like `/plan`) into elements
    /// so they render and edit atomically. Overlapping or duplicate ranges are ignored.
    pub fn add_element_range(&mut self, range: Range<usize>) -> Option<u64> {
        let start = self.clamp_pos_to_char_boundary(range.start.min(self.text.len()));
        let end = self.clamp_pos_to_char_boundary(range.end.min(self.text.len()));
        if start >= end {
            return None;
        }
        if self
            .elements
            .iter()
            .any(|e| e.range.start == start && e.range.end == end)
        {
            return None;
        }
        if self
            .elements
            .iter()
            .any(|e| start < e.range.end && end > e.range.start)
        {
            return None;
        }
        let id = self.add_element(start..end);
        Some(id)
    }

    pub fn remove_element_range(&mut self, range: Range<usize>) -> bool {
        let start = self.clamp_pos_to_char_boundary(range.start.min(self.text.len()));
        let end = self.clamp_pos_to_char_boundary(range.end.min(self.text.len()));
        if start >= end {
            return false;
        }
        let len_before = self.elements.len();
        self.elements
            .retain(|elem| elem.range.start != start || elem.range.end != end);
        len_before != self.elements.len()
    }

    fn next_element_id(&mut self) -> u64 {
        let id = self.next_element_id;
        self.next_element_id = self.next_element_id.saturating_add(1);
        id
    }
    fn find_element_containing(&self, pos: usize) -> Option<usize> {
        self.elements
            .iter()
            .position(|e| pos > e.range.start && pos < e.range.end)
    }

    fn clamp_pos_to_char_boundary(&self, pos: usize) -> usize {
        let pos = pos.min(self.text.len());
        if self.text.is_char_boundary(pos) {
            return pos;
        }
        let mut prev = pos;
        while prev > 0 && !self.text.is_char_boundary(prev) {
            prev -= 1;
        }
        let mut next = pos;
        while next < self.text.len() && !self.text.is_char_boundary(next) {
            next += 1;
        }
        if pos.saturating_sub(prev) <= next.saturating_sub(pos) {
            prev
        } else {
            next
        }
    }

    fn clamp_pos_to_nearest_boundary(&self, pos: usize) -> usize {
        let pos = self.clamp_pos_to_char_boundary(pos);
        if let Some(idx) = self.find_element_containing(pos) {
            let e = &self.elements[idx];
            let dist_start = pos.saturating_sub(e.range.start);
            let dist_end = e.range.end.saturating_sub(pos);
            if dist_start <= dist_end {
                self.clamp_pos_to_char_boundary(e.range.start)
            } else {
                self.clamp_pos_to_char_boundary(e.range.end)
            }
        } else {
            pos
        }
    }

    fn clamp_pos_for_insertion(&self, pos: usize) -> usize {
        let pos = self.clamp_pos_to_char_boundary(pos);
        // Do not allow inserting into the middle of an element
        if let Some(idx) = self.find_element_containing(pos) {
            let e = &self.elements[idx];
            // Choose closest edge for insertion
            let dist_start = pos.saturating_sub(e.range.start);
            let dist_end = e.range.end.saturating_sub(pos);
            if dist_start <= dist_end {
                self.clamp_pos_to_char_boundary(e.range.start)
            } else {
                self.clamp_pos_to_char_boundary(e.range.end)
            }
        } else {
            pos
        }
    }

    fn expand_range_to_element_boundaries(&self, mut range: Range<usize>) -> Range<usize> {
        // Expand to include any intersecting elements fully
        loop {
            let mut changed = false;
            for e in &self.elements {
                if e.range.start < range.end && e.range.end > range.start {
                    let new_start = range.start.min(e.range.start);
                    let new_end = range.end.max(e.range.end);
                    if new_start != range.start || new_end != range.end {
                        range.start = new_start;
                        range.end = new_end;
                        changed = true;
                    }
                }
            }
            if !changed {
                break;
            }
        }
        range
    }

    fn shift_elements(&mut self, at: usize, removed: usize, inserted: usize) {
        // Generic shift: for pure insert, removed = 0; for delete, inserted = 0.
        let end = at + removed;
        let diff = inserted as isize - removed as isize;
        // Remove elements fully deleted by the operation and shift the rest
        self.elements
            .retain(|e| !(e.range.start >= at && e.range.end <= end));
        for e in &mut self.elements {
            if e.range.end <= at {
                // before edit
            } else if e.range.start >= end {
                // after edit
                e.range.start = ((e.range.start as isize) + diff) as usize;
                e.range.end = ((e.range.end as isize) + diff) as usize;
            } else {
                // Overlap with element but not fully contained (shouldn't happen when using
                // element-aware replace, but degrade gracefully by snapping element to new bounds)
                let new_start = at.min(e.range.start);
                let new_end = at + inserted.max(e.range.end.saturating_sub(end));
                e.range.start = new_start;
                e.range.end = new_end;
            }
        }
    }

    fn update_elements_after_replace(&mut self, start: usize, end: usize, inserted_len: usize) {
        self.shift_elements(start, end.saturating_sub(start), inserted_len);
    }

    fn prev_atomic_boundary(&self, pos: usize) -> usize {
        if pos == 0 {
            return 0;
        }
        // If currently at an element end or inside, jump to start of that element.
        if let Some(idx) = self
            .elements
            .iter()
            .position(|e| pos > e.range.start && pos <= e.range.end)
        {
            return self.elements[idx].range.start;
        }
        let mut gc = unicode_segmentation::GraphemeCursor::new(pos, self.text.len(), false);
        match gc.prev_boundary(&self.text, 0) {
            Ok(Some(b)) => {
                if let Some(idx) = self.find_element_containing(b) {
                    self.elements[idx].range.start
                } else {
                    b
                }
            }
            Ok(None) => 0,
            Err(_) => pos.saturating_sub(1),
        }
    }

    fn next_atomic_boundary(&self, pos: usize) -> usize {
        if pos >= self.text.len() {
            return self.text.len();
        }
        // If currently at an element start or inside, jump to end of that element.
        if let Some(idx) = self
            .elements
            .iter()
            .position(|e| pos >= e.range.start && pos < e.range.end)
        {
            return self.elements[idx].range.end;
        }
        let mut gc = unicode_segmentation::GraphemeCursor::new(pos, self.text.len(), false);
        match gc.next_boundary(&self.text, 0) {
            Ok(Some(b)) => {
                if let Some(idx) = self.find_element_containing(b) {
                    self.elements[idx].range.end
                } else {
                    b
                }
            }
            Ok(None) => self.text.len(),
            Err(_) => pos.saturating_add(1),
        }
    }

    pub(crate) fn beginning_of_previous_word(&self) -> usize {
        let prefix = &self.text[..self.cursor_pos];
        let Some((first_non_ws_idx, ch)) = prefix
            .char_indices()
            .rev()
            .find(|&(_, ch)| !ch.is_whitespace())
        else {
            return 0;
        };
        let run_start = prefix[..first_non_ws_idx]
            .char_indices()
            .rev()
            .find(|&(_, ch)| ch.is_whitespace())
            .map_or(0, |(idx, ch)| idx + ch.len_utf8());
        let run_end = first_non_ws_idx + ch.len_utf8();
        let pieces = split_word_pieces(&prefix[run_start..run_end]);
        let mut pieces = pieces.into_iter().rev().peekable();
        let Some((piece_start, piece)) = pieces.next() else {
            return run_start;
        };
        let mut start = run_start + piece_start;

        if piece.chars().all(is_word_separator) {
            while let Some((idx, piece)) = pieces.peek() {
                if !piece.chars().all(is_word_separator) {
                    break;
                }
                start = run_start + *idx;
                pieces.next();
            }
        }

        self.adjust_pos_out_of_elements(start, /*prefer_start*/ true)
    }

    pub(crate) fn end_of_next_word(&self) -> usize {
        self.end_of_next_word_from(self.cursor_pos)
    }

    fn end_of_next_word_from(&self, cursor_pos: usize) -> usize {
        let suffix = &self.text[cursor_pos..];
        let Some(first_non_ws) = suffix.find(|ch: char| !ch.is_whitespace()) else {
            return self.text.len();
        };
        let run = &suffix[first_non_ws..];
        let run = &run[..run.find(char::is_whitespace).unwrap_or(run.len())];
        let mut pieces = split_word_pieces(run).into_iter().peekable();
        let Some((start, piece)) = pieces.next() else {
            return cursor_pos + first_non_ws;
        };
        let word_start = cursor_pos + first_non_ws + start;
        let mut end = word_start + piece.len();
        if piece.chars().all(is_word_separator) {
            while let Some((idx, piece)) = pieces.peek() {
                if !piece.chars().all(is_word_separator) {
                    break;
                }
                end = cursor_pos + first_non_ws + *idx + piece.len();
                pieces.next();
            }
        }

        self.adjust_pos_out_of_elements(end, /*prefer_start*/ false)
    }

    fn vim_word_end_exclusive(&self) -> usize {
        let end = self.end_of_next_word();
        let target = if end > self.cursor_pos {
            self.prev_atomic_boundary(end)
        } else {
            end
        };
        if target == self.cursor_pos && end < self.text.len() {
            self.end_of_next_word_from(end)
        } else {
            end
        }
    }

    fn vim_word_end_cursor(&self) -> usize {
        let end = self.vim_word_end_exclusive();
        if end > self.cursor_pos {
            self.prev_atomic_boundary(end)
        } else {
            end
        }
    }

    fn vim_line_end_cursor(&self) -> usize {
        let bol = self.beginning_of_current_line();
        let eol = self.end_of_current_line();
        if eol > bol {
            self.prev_atomic_boundary(eol).max(bol)
        } else {
            eol
        }
    }

    pub(crate) fn beginning_of_next_word(&self) -> usize {
        let Some(first_non_ws) = self.text[self.cursor_pos..].find(|c: char| !c.is_whitespace())
        else {
            return self.text.len();
        };
        let word_start = self.cursor_pos + first_non_ws;
        if word_start != self.cursor_pos {
            return self.adjust_pos_out_of_elements(word_start, /*prefer_start*/ true);
        }
        let end = self.end_of_next_word();
        if end >= self.text.len() {
            return self.text.len();
        }
        let Some(next_non_ws) = self.text[end..].find(|c: char| !c.is_whitespace()) else {
            return self.text.len();
        };
        self.adjust_pos_out_of_elements(end + next_non_ws, /*prefer_start*/ true)
    }

    fn adjust_pos_out_of_elements(&self, pos: usize, prefer_start: bool) -> usize {
        if let Some(idx) = self.find_element_containing(pos) {
            let e = &self.elements[idx];
            if prefer_start {
                e.range.start
            } else {
                e.range.end
            }
        } else {
            pos
        }
    }

    /// Returns cached grapheme-safe visual ranges, including cursor-position sentinel bytes.
    ///
    /// Overflowing spaces wrap without separating a partial whitespace continuation from the next
    /// word, existing word breakpoints stay intact, and full logical lines receive a continuation
    /// row so their insertion point stays visible.
    #[expect(clippy::unwrap_used)]
    fn wrapped_lines(&self, width: u16) -> Ref<'_, Vec<Range<usize>>> {
        // Ensure cache is ready (potentially mutably borrow, then drop)
        {
            let mut cache = self.wrap_cache.borrow_mut();
            let needs_recalc = match cache.as_ref() {
                Some(c) => c.width != width,
                None => true,
            };
            if needs_recalc {
                let display_text = text_for_display(&self.text);
                let lines = wrapping::wrapped_lines(display_text.as_ref(), width);
                *cache = Some(WrapCache {
                    width,
                    lines,
                    hyperlinks: OnceCell::new(),
                });
            }
        }

        let cache = self.wrap_cache.borrow();
        Ref::map(cache, |c| &c.as_ref().unwrap().lines)
    }

    /// Calculate the scroll offset that should be used to satisfy the
    /// invariants given the current area size and wrapped lines.
    ///
    /// - Cursor is on screen unless the user scrolled away without moving it.
    /// - No scrolling if content fits in the area.
    fn effective_scroll(&self, area: Rect, lines: &[Range<usize>], state: TextAreaState) -> u16 {
        let total_lines = u16::try_from(lines.len()).unwrap_or(u16::MAX);
        if area.height >= total_lines {
            return 0;
        }

        let cursor_line_idx =
            wrapping::cursor_position(&self.text, lines, area.width, self.cursor_pos)
                .map_or(0, |(row, _)| row) as u16;

        let max_scroll = total_lines.saturating_sub(area.height);
        let mut scroll = state.scroll.min(max_scroll);
        if state.manual_cursor == Some(self.cursor_pos) {
            return scroll;
        }

        // Ensure cursor is visible within [scroll, scroll + area_height)
        if cursor_line_idx < scroll {
            scroll = cursor_line_idx;
        } else if cursor_line_idx >= scroll + area.height {
            scroll = cursor_line_idx + 1 - area.height;
        }
        scroll
    }
}

impl WidgetRef for &TextArea {
    fn render_ref(&self, area: Rect, buf: &mut Buffer) {
        if self.single_line {
            StatefulWidgetRef::render_ref(self, area, buf, &mut TextAreaState::default());
            return;
        }
        let lines = self.wrapped_lines(area.width);
        self.render_lines(
            area,
            buf,
            &lines,
            0..lines.len().min(usize::from(area.height)),
            Style::default(),
            &[],
        );
    }
}

impl StatefulWidgetRef for &TextArea {
    type State = TextAreaState;

    fn render_ref(&self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
        self.rendered_area.set(area);
        if self.single_line {
            if !area.is_empty() {
                let (start, _) = self.single_line_viewport(area.width);
                self.render_lines(
                    area,
                    buf,
                    std::slice::from_ref(&(start..self.text.len() + 1)),
                    0..1,
                    Style::default(),
                    &[],
                );
            }
            return;
        }
        let lines = self.wrapped_lines(area.width);
        let scroll = self.effective_scroll(area, &lines, *state);
        state.scroll = scroll;

        let start = scroll as usize;
        let end = (scroll + area.height).min(lines.len() as u16) as usize;
        self.render_lines(area, buf, &lines, start..end, Style::default(), &[]);
    }
}

impl TextArea {
    pub(crate) fn render_ref_masked(
        &self,
        area: Rect,
        buf: &mut Buffer,
        state: &mut TextAreaState,
        mask_char: char,
    ) {
        self.rendered_area.set(area);
        let lines = self.wrapped_lines(area.width);
        let scroll = self.effective_scroll(area, &lines, *state);
        state.scroll = scroll;

        let start = scroll as usize;
        let end = (scroll + area.height).min(lines.len() as u16) as usize;
        self.render_lines_masked(area, buf, &lines, start..end, mask_char);
    }

    /// Render the textarea with `base_style` plus additional render-only highlight ranges.
    ///
    /// Highlight ranges are byte ranges in `self.text`. They affect only the buffer rendering and
    /// do not mutate the editable text, cursor, element metadata, or wrapping cache.
    pub(crate) fn render_ref_styled_with_highlights(
        &self,
        area: Rect,
        buf: &mut Buffer,
        state: &mut TextAreaState,
        base_style: Style,
        highlights: &[(Range<usize>, Style)],
    ) {
        self.rendered_area.set(area);
        let lines = self.wrapped_lines(area.width);
        let scroll = self.effective_scroll(area, &lines, *state);
        state.scroll = scroll;

        let start = scroll as usize;
        let end = (scroll + area.height).min(lines.len() as u16) as usize;
        self.render_lines(area, buf, &lines, start..end, base_style, highlights);
    }

    /// Renders visible text and styled overlays without writing outside the textarea viewport.
    fn render_lines(
        &self,
        area: Rect,
        buf: &mut Buffer,
        lines: &[Range<usize>],
        range: std::ops::Range<usize>,
        base_style: Style,
        highlights: &[(Range<usize>, Style)],
    ) {
        let element_style = base_style.fg(Color::Cyan);
        for (row, idx) in range.clone().enumerate() {
            let r = &lines[idx];
            let y = area.y + row as u16;
            let visible = wrapping::visible_prefix(&self.text[r.start..r.end - 1], area.width);
            let line_range = r.start..r.start + visible.len();
            buf.set_style(Rect::new(area.x, y, area.width, 1), base_style);
            // Draw base line with the provided style.
            buf.set_stringn(
                area.x,
                y,
                text_for_display(visible),
                usize::from(area.width),
                base_style,
            );

            // Selection takes precedence over elements and search highlights.
            let selection = self.mouse_selection_range();
            let overlays = self
                .elements
                .iter()
                .map(|element| (&element.range, element_style))
                .chain(highlights.iter().map(|(range, style)| (range, *style)))
                .chain(
                    selection
                        .as_ref()
                        .map(|range| (range, base_style.reversed())),
                );
            for (overlay_range, style) in overlays {
                let overlap_start = overlay_range.start.max(line_range.start);
                let overlap_end = overlay_range.end.min(line_range.end);
                if overlap_start >= overlap_end {
                    continue;
                }
                let styled = &self.text[overlap_start..overlap_end];
                let x_off = display_width(&self.text[line_range.start..overlap_start]);
                if x_off >= usize::from(area.width) {
                    continue;
                }
                let x_off = x_off as u16;
                buf.set_stringn(
                    area.x + x_off,
                    y,
                    text_for_display(styled),
                    usize::from(area.width.saturating_sub(x_off)),
                    style,
                );
            }
        }
        if let Some(wrap_cache) = self.wrap_cache.borrow().as_ref() {
            wrap_cache
                .hyperlinks
                .get_or_init(|| hyperlinks::HyperlinkCache::new(&self.text, lines))
                .mark(buf, area, &self.text, lines, range);
        }
    }

    /// Renders width-preserving mask glyphs without writing outside the textarea viewport.
    fn render_lines_masked(
        &self,
        area: Rect,
        buf: &mut Buffer,
        lines: &[Range<usize>],
        range: std::ops::Range<usize>,
        mask_char: char,
    ) {
        for (row, idx) in range.enumerate() {
            let r = &lines[idx];
            let y = area.y + row as u16;
            let visible = wrapping::visible_prefix(&self.text[r.start..r.end - 1], area.width);
            let masked = visible
                .graphemes(/*is_extended*/ true)
                .flat_map(|grapheme| std::iter::repeat_n(mask_char, display_width(grapheme)))
                .collect::<String>();
            buf.set_stringn(
                area.x,
                y,
                &masked,
                usize::from(area.width),
                Style::default(),
            );
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::key_hint;
    // crossterm types are intentionally not imported here to avoid unused warnings
    use pretty_assertions::assert_eq;
    use rand::prelude::*;
    use ratatui::Terminal;
    use ratatui::backend::TestBackend;

    fn rand_grapheme(rng: &mut rand::rngs::StdRng) -> String {
        let r: u8 = rng.random_range(0..100);
        match r {
            0..=4 => "\n".to_string(),
            5..=12 => " ".to_string(),
            13..=35 => (rng.random_range(b'a'..=b'z') as char).to_string(),
            36..=45 => (rng.random_range(b'A'..=b'Z') as char).to_string(),
            46..=52 => (rng.random_range(b'0'..=b'9') as char).to_string(),
            53..=65 => {
                // Some emoji (wide graphemes)
                let choices = ["👍", "😊", "🐍", "🚀", "🧪", "🌟"];
                choices[rng.random_range(0..choices.len())].to_string()
            }
            66..=75 => {
                // CJK wide characters
                let choices = ["漢", "字", "測", "試", "你", "好", "界", "编", "码"];
                choices[rng.random_range(0..choices.len())].to_string()
            }
            76..=85 => {
                // Combining mark sequences
                let base = ["e", "a", "o", "n", "u"][rng.random_range(0..5)];
                let marks = ["\u{0301}", "\u{0308}", "\u{0302}", "\u{0303}"];
                format!("{base}{}", marks[rng.random_range(0..marks.len())])
            }
            86..=92 => {
                // Some non-latin single codepoints (Greek, Cyrillic, Hebrew)
                let choices = ["Ω", "β", "Ж", "ю", "ש", "م", "ह"];
                choices[rng.random_range(0..choices.len())].to_string()
            }
            _ => {
                // ZWJ sequences (single graphemes but multi-codepoint)
                let choices = [
                    "👩\u{200D}💻", // woman technologist
                    "👨\u{200D}💻", // man technologist
                    "🏳️\u{200D}🌈", // rainbow flag
                ];
                choices[rng.random_range(0..choices.len())].to_string()
            }
        }
    }

    fn ta_with(text: &str) -> TextArea {
        let mut t = TextArea::new();
        t.insert_str(text);
        t
    }

    #[test]
    fn insert_and_replace_update_cursor_and_text() {
        // insert helpers
        let mut t = ta_with("hello");
        t.set_cursor(/*pos*/ 5);
        t.insert_str("!");
        assert_eq!(t.text(), "hello!");
        assert_eq!(t.cursor(), 6);

        t.insert_str_at(/*pos*/ 0, "X");
        assert_eq!(t.text(), "Xhello!");
        assert_eq!(t.cursor(), 7);

        // Insert after the cursor should not move it
        t.set_cursor(/*pos*/ 1);
        let end = t.text().len();
        t.insert_str_at(end, "Y");
        assert_eq!(t.text(), "Xhello!Y");
        assert_eq!(t.cursor(), 1);

        // replace_range cases
        // 1) cursor before range
        let mut t = ta_with("abcd");
        t.set_cursor(/*pos*/ 1);
        t.replace_range(2..3, "Z");
        assert_eq!(t.text(), "abZd");
        assert_eq!(t.cursor(), 1);

        // 2) cursor inside range
        let mut t = ta_with("abcd");
        t.set_cursor(/*pos*/ 2);
        t.replace_range(1..3, "Q");
        assert_eq!(t.text(), "aQd");
        assert_eq!(t.cursor(), 2);

        // 3) cursor after range with shifted by diff
        let mut t = ta_with("abcd");
        t.set_cursor(/*pos*/ 4);
        t.replace_range(0..1, "AA");
        assert_eq!(t.text(), "AAbcd");
        assert_eq!(t.cursor(), 5);
    }

    #[test]
    fn insert_str_at_clamps_to_char_boundary() {
        let mut t = TextArea::new();
        t.insert_str("你");
        t.set_cursor(/*pos*/ 0);
        t.insert_str_at(/*pos*/ 1, "A");
        assert_eq!(t.text(), "A你");
        assert_eq!(t.cursor(), 1);
    }

    #[test]
    fn set_text_clamps_cursor_to_char_boundary() {
        let mut t = TextArea::new();
        t.insert_str("abcd");
        t.set_cursor(/*pos*/ 1);
        t.set_text_clearing_elements("你");
        assert_eq!(t.cursor(), 0);
        t.insert_str("a");
        assert_eq!(t.text(), "a你");
    }

    #[test]
    fn delete_backward_and_forward_edges() {
        let mut t = ta_with("abc");
        t.set_cursor(/*pos*/ 1);
        t.delete_backward(/*n*/ 1);
        assert_eq!(t.text(), "bc");
        assert_eq!(t.cursor(), 0);

        // deleting backward at start is a no-op
        t.set_cursor(/*pos*/ 0);
        t.delete_backward(/*n*/ 1);
        assert_eq!(t.text(), "bc");
        assert_eq!(t.cursor(), 0);

        // forward delete removes next grapheme
        t.set_cursor(/*pos*/ 1);
        t.delete_forward(/*n*/ 1);
        assert_eq!(t.text(), "b");
        assert_eq!(t.cursor(), 1);

        // forward delete at end is a no-op
        t.set_cursor(t.text().len());
        t.delete_forward(/*n*/ 1);
        assert_eq!(t.text(), "b");
    }

    #[test]
    fn delete_backward_removes_thai_marks_one_at_a_time() {
        let mut t = ta_with("ที่");

        t.input(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE));

        let area = Rect::new(0, 0, /*width*/ 8, /*height*/ 1);
        let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
        let mut state = TextAreaState::default();
        terminal
            .draw(|frame| {
                StatefulWidgetRef::render_ref(&(&t), frame.area(), frame.buffer_mut(), &mut state);
            })
            .unwrap();
        insta::assert_snapshot!(
            "textarea_thai_backspace_preserves_remaining_marks",
            format!("cursor: {:?}\n{}", t.cursor_pos(area), terminal.backend())
        );
        assert_eq!(t.text(), "ที");

        t.delete_backward(/*n*/ 1);
        assert_eq!(t.text(), "ท");

        t.delete_backward(/*n*/ 1);
        assert_eq!(t.text(), "");
    }

    #[test]
    fn delete_backward_preserves_other_grapheme_behavior() {
        let mut thai_spacing_vowel = ta_with("ซ้ำ");
        thai_spacing_vowel.delete_backward(/*n*/ 1);
        assert_eq!(thai_spacing_vowel.text(), "ซ้");

        let mut decomposed_latin = ta_with("e\u{301}");
        decomposed_latin.delete_backward(/*n*/ 1);
        assert_eq!(decomposed_latin.text(), "");

        let mut family_emoji = ta_with("👨\u{200d}👩\u{200d}👧\u{200d}👦");
        family_emoji.delete_backward(/*n*/ 1);
        assert_eq!(family_emoji.text(), "");
    }

    #[test]
    fn delete_backward_keeps_thai_elements_atomic() {
        let mut t = TextArea::new();
        t.insert_str("before ");
        t.insert_element("ที่");
        t.insert_str(" after");

        t.set_cursor(t.elements[0].range.end);
        t.delete_backward(/*n*/ 1);

        assert_eq!(t.text(), "before  after");
        assert_eq!(t.cursor(), "before ".len());
        assert!(t.elements.is_empty());
    }

    #[test]
    fn delete_forward_deletes_element_at_left_edge() {
        let mut t = TextArea::new();
        t.insert_str("a");
        t.insert_element("<element>");
        t.insert_str("b");

        let elem_start = t.elements[0].range.start;
        t.set_cursor(elem_start);
        t.delete_forward(/*n*/ 1);

        assert_eq!(t.text(), "ab");
        assert_eq!(t.cursor(), elem_start);
    }

    #[test]
    fn vim_insert_and_escape() {
        let mut t = TextArea::new();
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('h'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));

        assert_eq!(t.text(), "h");
        assert_eq!(t.vim_mode_label(), Some("Normal"));
        assert_eq!(t.cursor(), 0);
    }

    #[test]
    fn vim_insert_key_enters_insert_mode() {
        let mut t = TextArea::new();
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Insert, KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('h'), KeyModifiers::NONE));

        assert_eq!(t.text(), "h");
        assert_eq!(t.vim_mode_label(), Some("Insert"));
    }

    #[test]
    fn vim_normal_arrow_keys_move_cursor() {
        let mut t = ta_with("ab\ncd");
        t.set_cursor(/*pos*/ 1);
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Right, KeyModifiers::NONE));
        assert_eq!(t.cursor(), 2);

        t.input(KeyEvent::new(KeyCode::Down, KeyModifiers::NONE));
        assert_eq!(t.cursor(), 5);

        t.input(KeyEvent::new(KeyCode::Left, KeyModifiers::NONE));
        assert_eq!(t.cursor(), 4);

        t.input(KeyEvent::new(KeyCode::Up, KeyModifiers::NONE));
        assert_eq!(t.cursor(), 1);
    }

    #[test]
    fn vim_escape_from_insert_at_start_does_not_underflow() {
        let mut t = TextArea::new();
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('z'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));

        assert_eq!(t.vim_mode_label(), Some("Normal"));
        assert_eq!(t.cursor(), 0);
    }

    #[test]
    fn vim_escape_from_insert_at_line_start_stays_on_line() {
        let mut t = ta_with("one\ntwo");
        t.set_cursor(/*pos*/ "one\n".len());
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));

        assert_eq!(t.vim_mode_label(), Some("Normal"));
        assert_eq!(t.cursor(), "one\n".len());
    }

    #[test]
    fn vim_escape_moves_by_grapheme_boundary() {
        let mut t = ta_with("👍👍");
        t.set_cursor(t.text().len());
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));

        assert_eq!(t.vim_mode_label(), Some("Normal"));
        assert_eq!(t.cursor(), "👍".len());
    }

    #[test]
    fn vim_escape_respects_atomic_element_boundary() {
        let mut t = TextArea::new();
        t.insert_str("a");
        t.insert_element("<element>");
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));

        assert_eq!(t.vim_mode_label(), Some("Normal"));
        assert_eq!(t.cursor(), 1);
    }

    #[test]
    fn vim_shift_i_enters_insert_at_first_non_blank_with_shift_only_binding() {
        let mut t = ta_with("hello\n  world");
        t.vim_normal_keymap.insert_line_start = vec![key_hint::shift(KeyCode::Char('i'))];
        t.set_cursor(/*pos*/ "hello\n  wor".len());
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('I'), KeyModifiers::NONE));

        assert_eq!(t.vim_mode_label(), Some("Insert"));
        assert_eq!(t.cursor(), "hello\n  ".len());
    }

    #[test]
    fn vim_shift_a_enters_insert_at_line_end_with_shift_only_binding() {
        let mut t = ta_with("hello\nworld");
        t.vim_normal_keymap.append_line_end = vec![key_hint::shift(KeyCode::Char('a'))];
        t.set_cursor(/*pos*/ 8);
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('A'), KeyModifiers::NONE));

        assert_eq!(t.vim_mode_label(), Some("Insert"));
        assert_eq!(t.cursor(), 11);
    }

    #[test]
    fn vim_shift_c_changes_to_line_end_and_enters_insert_mode() {
        let mut t = ta_with("hello world\nnext line");
        t.set_cursor(/*pos*/ 6);
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::SHIFT));

        assert_eq!(t.text(), "hello \nnext line");
        assert_eq!(t.vim_mode_label(), Some("Insert"));
        assert_eq!(t.cursor(), 6);
        assert_eq!(t.kill_buffer, "world");
    }

    #[test]
    fn vim_uppercase_c_changes_to_line_end() {
        let mut t = ta_with("hello world\nnext line");
        t.set_cursor(/*pos*/ 6);
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('C'), KeyModifiers::NONE));

        assert_eq!(t.text(), "hello \nnext line");
        assert_eq!(t.vim_mode_label(), Some("Insert"));
        assert_eq!(t.cursor(), 6);
    }

    #[test]
    fn vim_s_substitutes_current_character_and_enters_insert_mode() {
        let mut t = ta_with("abc");
        t.set_cursor(/*pos*/ 1);
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE));

        assert_eq!(t.text(), "ac");
        assert_eq!(t.cursor(), 1);
        assert_eq!(t.vim_mode_label(), Some("Insert"));

        t.input(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::NONE));

        assert_eq!(t.text(), "aXc");
        assert_eq!(t.cursor(), 2);
        assert_eq!(t.vim_mode_label(), Some("Insert"));
    }

    #[test]
    fn vim_s_on_empty_line_enters_insert_without_deleting_newline() {
        let mut t = ta_with("before\n\nnext");
        t.set_cursor(/*pos*/ "before\n".len());
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE));

        assert_eq!(t.text(), "before\n\nnext");
        assert_eq!(t.cursor(), "before\n".len());
        assert_eq!(t.vim_mode_label(), Some("Insert"));
    }

    #[test]
    fn vim_d_at_line_end_does_not_remove_newline() {
        let mut t = ta_with("hello\nworld");
        t.set_cursor(/*pos*/ "hello".len());
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('D'), KeyModifiers::NONE));

        assert_eq!(t.text(), "hello\nworld");
        assert_eq!(t.vim_mode_label(), Some("Normal"));
        assert_eq!(t.kill_buffer, "");
    }

    #[test]
    fn vim_c_at_line_end_enters_insert_without_removing_newline() {
        let mut t = ta_with("hello\nworld");
        t.set_cursor(/*pos*/ "hello".len());
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('C'), KeyModifiers::NONE));

        assert_eq!(t.text(), "hello\nworld");
        assert_eq!(t.vim_mode_label(), Some("Insert"));
        assert_eq!(t.cursor(), "hello".len());
        assert_eq!(t.kill_buffer, "");
    }

    #[test]
    fn vim_shift_o_opens_line_above_with_shift_only_binding() {
        let mut t = ta_with("hello\nworld");
        t.vim_normal_keymap.open_line_above = vec![key_hint::shift(KeyCode::Char('o'))];
        t.set_cursor(/*pos*/ 8);
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('O'), KeyModifiers::NONE));

        assert_eq!(t.text(), "hello\n\nworld");
        assert_eq!(t.vim_mode_label(), Some("Insert"));
        assert_eq!(t.cursor(), 6);
    }

    #[test]
    fn vim_o_opens_line_below_on_inserted_line() {
        let mut t = ta_with("one\ntwo");
        t.set_cursor(/*pos*/ 1);
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('o'), KeyModifiers::NONE));

        assert_eq!(t.text(), "one\n\ntwo");
        assert_eq!(t.vim_mode_label(), Some("Insert"));
        assert_eq!(t.cursor(), "one\n".len());
    }

    #[test]
    fn vim_o_opens_line_below_final_line_and_moves_to_new_line() {
        let mut t = ta_with("one");
        t.set_cursor(/*pos*/ 1);
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('o'), KeyModifiers::NONE));

        assert_eq!(t.text(), "one\n");
        assert_eq!(t.vim_mode_label(), Some("Insert"));
        assert_eq!(t.cursor(), "one\n".len());
    }

    #[test]
    fn vim_delete_word() {
        let mut t = ta_with("hello world");
        t.set_cursor(/*pos*/ 0);
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('w'), KeyModifiers::NONE));

        assert_eq!(t.text(), "world");
        assert_eq!(t.kill_buffer, "hello ");
    }

    #[test]
    fn vim_change_inner_word_deletes_word_and_enters_insert() {
        let mut t = ta_with("hello world");
        t.set_cursor(/*pos*/ "hello ".len());
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('w'), KeyModifiers::NONE));

        assert_eq!(t.text(), "hello ");
        assert_eq!(t.kill_buffer, "world");
        assert_eq!(t.cursor(), "hello ".len());
        assert_eq!(t.vim_mode_label(), Some("Insert"));
    }

    #[test]
    fn vim_word_text_objects_cover_delete_yank_and_big_word() {
        let mut t = ta_with("hello world");
        t.set_cursor(/*pos*/ 1);
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('a'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('w'), KeyModifiers::NONE));

        assert_eq!(t.text(), "hello world");
        assert_eq!(t.kill_buffer, "hello ");
        assert_eq!(t.vim_mode_label(), Some("Normal"));

        let mut t = ta_with("foo.bar/baz qux");
        t.set_cursor(/*pos*/ "foo.".len());
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('W'), KeyModifiers::NONE));

        assert_eq!(t.text(), " qux");
        assert_eq!(t.kill_buffer, "foo.bar/baz");
    }

    #[test]
    fn vim_word_text_objects_accept_cursor_at_word_end() {
        let mut t = ta_with("hello world");
        t.set_cursor(/*pos*/ "hello".len());
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('a'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('w'), KeyModifiers::NONE));

        assert_eq!(t.text(), "world");
        assert_eq!(t.kill_buffer, "hello ");

        let mut t = ta_with("foo bar");
        t.set_cursor(t.text().len());
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('W'), KeyModifiers::NONE));

        assert_eq!(t.text(), "foo ");
        assert_eq!(t.kill_buffer, "bar");
        assert_eq!(t.cursor(), "foo ".len());
        assert_eq!(t.vim_mode_label(), Some("Insert"));
    }

    #[test]
    fn vim_delimiter_text_objects_select_innermost_pair_and_aliases() {
        let mut t = ta_with("a(b(c)d)e");
        t.set_cursor(/*pos*/ "a(b(".len());
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('b'), KeyModifiers::NONE));

        assert_eq!(t.text(), "a(b()d)e");
        assert_eq!(t.kill_buffer, "c");
        assert_eq!(t.vim_mode_label(), Some("Insert"));

        let mut t = ta_with("a [b] c");
        t.set_cursor(/*pos*/ "a [".len());
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('a'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char(']'), KeyModifiers::NONE));

        assert_eq!(t.text(), "a  c");
        assert_eq!(t.kill_buffer, "[b]");
    }

    #[test]
    fn vim_empty_inner_text_objects_are_valid_targets() {
        let mut t = ta_with("call()");
        t.set_cursor(/*pos*/ "call(".len());
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('('), KeyModifiers::NONE));

        assert_eq!(t.text(), "call()");
        assert_eq!(t.kill_buffer, "");
        assert_eq!(t.cursor(), "call(".len());
        assert_eq!(t.vim_mode_label(), Some("Insert"));

        let mut t = ta_with(r#"say "" now"#);
        t.set_cursor(/*pos*/ r#"say ""#.len());
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('"'), KeyModifiers::NONE));

        assert_eq!(t.text(), r#"say "" now"#);
        assert_eq!(t.kill_buffer, "");
        assert_eq!(t.cursor(), r#"say ""#.len());
        assert_eq!(t.vim_mode_label(), Some("Insert"));
    }

    #[test]
    fn vim_quote_text_objects_are_line_local_and_handle_escapes() {
        let mut t = ta_with(r#"say "a \"b\" c" now"#);
        t.set_cursor(/*pos*/ r#"say "a \"#.len());
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('"'), KeyModifiers::SHIFT));

        assert_eq!(t.text(), r#"say "" now"#);
        assert_eq!(t.kill_buffer, r#"a \"b\" c"#);
        assert_eq!(t.vim_mode_label(), Some("Insert"));

        let mut t = ta_with("one \"two\nthree\" four");
        t.set_cursor(/*pos*/ "one \"two\n".len());
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('"'), KeyModifiers::NONE));

        assert_eq!(t.text(), "one \"two\nthree\" four");
        assert_eq!(t.kill_buffer, "");
    }

    #[test]
    fn vim_text_object_cancellation_does_not_edit() {
        let mut t = ta_with("hello world");
        t.set_cursor(/*pos*/ 1);
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
        assert!(t.is_vim_operator_pending());
        t.input(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));

        assert_eq!(t.text(), "hello world");
        assert_eq!(t.kill_buffer, "");
        assert!(!t.is_vim_operator_pending());
    }

    #[test]
    fn vim_operator_invalid_motion_is_consumed() {
        let mut t = ta_with("hello");
        t.set_cursor(/*pos*/ 0);
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE));
        assert!(t.is_vim_operator_pending());

        t.input(KeyEvent::new(KeyCode::Char('z'), KeyModifiers::NONE));

        assert_eq!(t.text(), "hello");
        assert_eq!(t.vim_mode_label(), Some("Normal"));
        assert_eq!(t.cursor(), 0);
        assert!(!t.is_vim_operator_pending());
    }

    #[test]
    fn vim_e_lands_on_word_end_character() {
        let mut t = ta_with("abc");
        t.set_cursor(/*pos*/ 0);
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE));

        assert_eq!(t.cursor(), 2);

        t.input(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE));

        assert_eq!(t.text(), "ab");
        assert_eq!(t.kill_buffer, "c");
    }

    #[test]
    fn vim_e_advances_from_each_word_end() {
        let mut t = ta_with("alpha beta gamma");
        t.set_cursor("alph".len()); // codespell:ignore alph
        t.set_vim_enabled(/*enabled*/ true);
        let mut states = Vec::new();

        for _ in 0..3 {
            t.input(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE));
            states.push(format!("{}\n{}^", t.text(), " ".repeat(t.cursor())));
        }

        insta::assert_snapshot!("vim_e_advances_from_each_word_end", states.join("\n\n"));
    }

    #[test]
    fn vim_delete_to_word_end_advances_from_existing_word_end() {
        let mut t = ta_with("alpha beta gamma");
        t.set_cursor("alph".len()); // codespell:ignore alph
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE));

        assert_eq!(t.text(), "alph gamma"); // codespell:ignore alph
        assert_eq!(t.kill_buffer, "a beta");
    }

    #[test]
    fn vim_e_from_word_end_can_land_on_trailing_space() {
        let mut t = ta_with("alpha   ");
        t.set_cursor("alph".len()); // codespell:ignore alph
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE));

        assert_eq!(t.cursor(), "alpha  ".len());
    }

    #[test]
    fn vim_e_advances_across_atomic_element_word_ends() {
        let mut t = TextArea::new();
        t.insert_str("alpha ");
        t.insert_element("<element>");
        t.insert_str(" gamma");
        let element_start = t.elements[0].range.start;
        t.set_cursor("alph".len()); // codespell:ignore alph
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE));
        assert_eq!(t.cursor(), element_start);

        t.input(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE));
        assert_eq!(t.cursor(), "alpha <element> gamm".len());
    }

    #[test]
    fn vim_dollar_lands_on_line_end_character() {
        let mut t = ta_with("abc\n123");
        t.set_cursor(/*pos*/ 1);
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('$'), KeyModifiers::NONE));

        assert_eq!(t.cursor(), 2);

        t.input(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE));

        assert_eq!(t.text(), "ab\n123");
        assert_eq!(t.kill_buffer, "c");
    }

    #[test]
    fn vim_linewise_yank_pastes_below_current_line() {
        let mut t = ta_with("abc\n123\nxyz");
        t.set_cursor(/*pos*/ 1);
        t.set_vim_enabled(/*enabled*/ true);

        t.input(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
        t.input(KeyEvent::new(KeyCode::Char('p'), KeyModifiers::NONE));

        assert_eq!(t.text(), "abc\nabc\n123\nxyz");
        assert_eq!(t.cursor(), "abc\n".len());
        assert_eq!(t.kill_buffer, "abc\n");
        assert_eq!(t.kill_buffer_kind, KillBufferKind::Linewise);
    }

    #[test]
    fn delete_backward_word_and_kill_line_variants() {
        // delete backward word at end removes the whole previous word
        let mut t = ta_with("hello   world  ");
        t.set_cursor(t.text().len());
        t.delete_backward_word();
        assert_eq!(t.text(), "hello   ");
        assert_eq!(t.cursor(), 8);

        // From inside a word, delete from word start to cursor
        let mut t = ta_with("foo bar");
        t.set_cursor(/*pos*/ 6); // inside "bar" (after 'a')
        t.delete_backward_word();
        assert_eq!(t.text(), "foo r");
        assert_eq!(t.cursor(), 4);

        // From end, delete the last word only
        let mut t = ta_with("foo bar");
        t.set_cursor(t.text().len());
        t.delete_backward_word();
        assert_eq!(t.text(), "foo ");
        assert_eq!(t.cursor(), 4);

        // kill_to_end_of_line when not at EOL
        let mut t = ta_with("abc\ndef");
        t.set_cursor(/*pos*/ 1); // on first line, middle
        t.kill_to_end_of_line();
        assert_eq!(t.text(), "a\ndef");
        assert_eq!(t.cursor(), 1);

        // kill_to_end_of_line when at EOL deletes newline
        let mut t = ta_with("abc\ndef");
        t.set_cursor(/*pos*/ 3); // EOL of first line
        t.kill_to_end_of_line();
        assert_eq!(t.text(), "abcdef");
        assert_eq!(t.cursor(), 3);

        // kill_to_beginning_of_line from middle of line
        let mut t = ta_with("abc\ndef");
        t.set_cursor(/*pos*/ 5); // on second line, after 'e'
        t.kill_to_beginning_of_line();
        assert_eq!(t.text(), "abc\nef");

        // kill_to_beginning_of_line at beginning of non-first line removes the previous newline
        let mut t = ta_with("abc\ndef");
        t.set_cursor(/*pos*/ 4); // beginning of second line
        t.kill_to_beginning_of_line();
        assert_eq!(t.text(), "abcdef");
        assert_eq!(t.cursor(), 3);
    }

    #[test]
    fn super_line_editing_defaults_follow_macos_conventions() {
        let mut textarea = ta_with("first\nsecond third");
        textarea.set_cursor("first\nsecond".len());

        textarea.input(KeyEvent::new(KeyCode::Left, KeyModifiers::SUPER));
        assert_eq!(textarea.cursor(), "first\n".len());

        textarea.input(KeyEvent::new(KeyCode::Right, KeyModifiers::SUPER));
        assert_eq!(textarea.cursor(), textarea.text().len());

        textarea.input(KeyEvent::new(KeyCode::Backspace, KeyModifiers::SUPER));
        assert_eq!(textarea.text(), "first\n");
        assert_eq!(textarea.cursor(), "first\n".len());
    }

    #[test]
    fn kill_current_line_removes_current_line_linewise() {
        let mut t = ta_with("abc\ndef\nghi");
        t.set_cursor(/*pos*/ 5);

        t.kill_current_line();

        assert_eq!(t.text(), "abc\nghi");
        assert_eq!(t.cursor(), 4);
        assert_eq!(t.kill_buffer, "def\n");
        assert_eq!(t.kill_buffer_kind, KillBufferKind::Linewise);
    }

    #[test]
    fn kill_current_line_keeps_previous_newline_for_final_line() {
        let mut t = ta_with("abc\ndef");
        t.set_cursor(/*pos*/ 5);

        t.kill_current_line();

        assert_eq!(t.text(), "abc\n");
        assert_eq!(t.cursor(), 4);
        assert_eq!(t.kill_buffer, "def");
        assert_eq!(t.kill_buffer_kind, KillBufferKind::Linewise);
    }

    #[test]
    fn kill_whole_line_keymap_dispatch_uses_linewise_kill() {
        let mut t = ta_with("abc\ndef\nghi");
        t.set_cursor(/*pos*/ 5);
        let mut keymap = RuntimeKeymap::defaults().editor;
        Arc::make_mut(&mut keymap).kill_line_start.clear();
        Arc::make_mut(&mut keymap).kill_whole_line = vec![key_hint::ctrl(KeyCode::Char('u'))];

        t.input_with_keymap(
            KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL),
            &keymap,
        );

        assert_eq!(t.text(), "abc\nghi");
        assert_eq!(t.cursor(), 4);
        assert_eq!(t.kill_buffer, "def\n");
        assert_eq!(t.kill_buffer_kind, KillBufferKind::Linewise);
    }

    #[test]
    fn delete_forward_word_variants() {
        let mut t = ta_with("hello   world ");
        t.set_cursor(/*pos*/ 0);
        t.delete_forward_word();
        assert_eq!(t.text(), "   world ");
        assert_eq!(t.cursor(), 0);

        let mut t = ta_with("hello   world ");
        t.set_cursor(/*pos*/ 1);
        t.delete_forward_word();
        assert_eq!(t.text(), "h   world ");
        assert_eq!(t.cursor(), 1);

        let mut t = ta_with("hello   world");
        t.set_cursor(t.text().len());
        t.delete_forward_word();
        assert_eq!(t.text(), "hello   world");
        assert_eq!(t.cursor(), t.text().len());

        let mut t = ta_with("foo   \nbar");
        t.set_cursor(/*pos*/ 3);
        t.delete_forward_word();
        assert_eq!(t.text(), "foo");
        assert_eq!(t.cursor(), 3);

        let mut t = ta_with("foo\nbar");
        t.set_cursor(/*pos*/ 3);
        t.delete_forward_word();
        assert_eq!(t.text(), "foo");
        assert_eq!(t.cursor(), 3);

        let mut t = ta_with("hello   world ");
        t.set_cursor(t.text().len() + 10);
        t.delete_forward_word();
        assert_eq!(t.text(), "hello   world ");
        assert_eq!(t.cursor(), t.text().len());
    }

    #[test]
    fn delete_forward_word_handles_atomic_elements() {
        let mut t = TextArea::new();
        t.insert_element("<element>");
        t.insert_str(" tail");

        t.set_cursor(/*pos*/ 0);
        t.delete_forward_word();
        assert_eq!(t.text(), " tail");
        assert_eq!(t.cursor(), 0);

        let mut t = TextArea::new();
        t.insert_str("   ");
        t.insert_element("<element>");
        t.insert_str(" tail");

        t.set_cursor(/*pos*/ 0);
        t.delete_forward_word();
        assert_eq!(t.text(), " tail");
        assert_eq!(t.cursor(), 0);

        let mut t = TextArea::new();
        t.insert_str("prefix ");
        t.insert_element("<element>");
        t.insert_str(" tail");

        // cursor in the middle of the element, delete_forward_word deletes the element
        let elem_range = t.elements[0].range.clone();
        t.cursor_pos = elem_range.start + (elem_range.len() / 2);
        t.delete_forward_word();
        assert_eq!(t.text(), "prefix  tail");
        assert_eq!(t.cursor(), elem_range.start);
    }

    #[test]
    fn delete_backward_word_respects_word_separators() {
        let mut t = ta_with("path/to/file");
        t.set_cursor(t.text().len());
        t.delete_backward_word();
        assert_eq!(t.text(), "path/to/");
        assert_eq!(t.cursor(), t.text().len());

        t.delete_backward_word();
        assert_eq!(t.text(), "path/to");
        assert_eq!(t.cursor(), t.text().len());

        let mut t = ta_with("foo/ ");
        t.set_cursor(t.text().len());
        t.delete_backward_word();
        assert_eq!(t.text(), "foo");
        assert_eq!(t.cursor(), 3);

        let mut t = ta_with("foo /");
        t.set_cursor(t.text().len());
        t.delete_backward_word();
        assert_eq!(t.text(), "foo ");
        assert_eq!(t.cursor(), 4);
    }

    #[test]
    fn delete_forward_word_respects_word_separators() {
        let mut t = ta_with("path/to/file");
        t.set_cursor(/*pos*/ 0);
        t.delete_forward_word();
        assert_eq!(t.text(), "/to/file");
        assert_eq!(t.cursor(), 0);

        t.delete_forward_word();
        assert_eq!(t.text(), "to/file");
        assert_eq!(t.cursor(), 0);

        let mut t = ta_with("/ foo");
        t.set_cursor(/*pos*/ 0);
        t.delete_forward_word();
        assert_eq!(t.text(), " foo");
        assert_eq!(t.cursor(), 0);

        let mut t = ta_with(" /foo");
        t.set_cursor(/*pos*/ 0);
        t.delete_forward_word();
        assert_eq!(t.text(), "foo");
        assert_eq!(t.cursor(), 0);
    }

    #[test]
    fn yank_restores_last_kill() {
        let mut t = ta_with("hello");
        t.set_cursor(/*pos*/ 0);
        t.kill_to_end_of_line();
        assert_eq!(t.text(), "");
        assert_eq!(t.cursor(), 0);

        t.yank();
        assert_eq!(t.text(), "hello");
        assert_eq!(t.cursor(), 5);

        let mut t = ta_with("hello world");
        t.set_cursor(t.text().len());
        t.delete_backward_word();
        assert_eq!(t.text(), "hello ");
        assert_eq!(t.cursor(), 6);

        t.yank();
        assert_eq!(t.text(), "hello world");
        assert_eq!(t.cursor(), 11);

        let mut t = ta_with("hello");
        t.set_cursor(/*pos*/ 5);
        t.kill_to_beginning_of_line();
        assert_eq!(t.text(), "");
        assert_eq!(t.cursor(), 0);

        t.yank();
        assert_eq!(t.text(), "hello");
        assert_eq!(t.cursor(), 5);
    }

    #[test]
    fn kill_buffer_persists_across_set_text() {
        let mut t = ta_with("restore me");
        t.set_cursor(/*pos*/ 0);
        t.kill_to_end_of_line();
        assert!(t.text().is_empty());

        t.set_text_clearing_elements("/diff");
        t.set_text_clearing_elements("");
        t.yank();

        assert_eq!(t.text(), "restore me");
        assert_eq!(t.cursor(), "restore me".len());
    }

    #[test]
    fn cursor_left_and_right_handle_graphemes() {
        let mut t = ta_with("a👍b");
        t.set_cursor(t.text().len());

        t.move_cursor_left(); // before 'b'
        let after_first_left = t.cursor();
        t.move_cursor_left(); // before '👍'
        let after_second_left = t.cursor();
        t.move_cursor_left(); // before 'a'
        let after_third_left = t.cursor();

        assert!(after_first_left < t.text().len());
        assert!(after_second_left < after_first_left);
        assert!(after_third_left < after_second_left);

        // Move right back to end safely
        t.move_cursor_right();
        t.move_cursor_right();
        t.move_cursor_right();
        assert_eq!(t.cursor(), t.text().len());
    }

    #[test]
    fn control_b_and_f_move_cursor() {
        let mut t = ta_with("abcd");
        t.set_cursor(/*pos*/ 1);

        t.input(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::CONTROL));
        assert_eq!(t.cursor(), 2);

        t.input(KeyEvent::new(KeyCode::Char('b'), KeyModifiers::CONTROL));
        assert_eq!(t.cursor(), 1);
    }

    #[test]
    fn control_b_f_fallback_control_chars_move_cursor() {
        let mut t = ta_with("abcd");
        t.set_cursor(/*pos*/ 2);

        // Simulate terminals that send C0 control chars without CONTROL modifier.
        // ^B (U+0002) should move left
        t.input(KeyEvent::new(KeyCode::Char('\u{0002}'), KeyModifiers::NONE));
        assert_eq!(t.cursor(), 1);

        // ^F (U+0006) should move right
        t.input(KeyEvent::new(KeyCode::Char('\u{0006}'), KeyModifiers::NONE));
        assert_eq!(t.cursor(), 2);
    }

    #[test]
    fn c0_line_feed_inserts_newline_through_insert_newline_keymap() {
        let mut t = ta_with("ab");
        t.set_cursor(/*pos*/ 1);

        t.input(KeyEvent::new(KeyCode::Char('\u{000a}'), KeyModifiers::NONE));

        assert_eq!(t.text(), "a\nb");
        assert_eq!(t.cursor(), 2);
    }

    #[test]
    fn c0_control_chars_respect_unbound_editor_movement() {
        let mut t = ta_with("a\nb");
        t.set_cursor(/*pos*/ 2);
        let mut keymap = RuntimeKeymap::defaults().editor;
        Arc::make_mut(&mut keymap).move_up.clear();

        t.input_with_keymap(
            KeyEvent::new(KeyCode::Char('\u{0010}'), KeyModifiers::NONE),
            &keymap,
        );

        assert_eq!(t.cursor(), 2);
    }

    #[test]
    fn c0_control_chars_respect_remapped_editor_movement() {
        let mut t = ta_with("a\nb");
        t.set_cursor(/*pos*/ 0);
        let mut keymap = RuntimeKeymap::defaults().editor;
        Arc::make_mut(&mut keymap).move_up.clear();
        Arc::make_mut(&mut keymap).move_down = vec![crate::key_hint::ctrl(KeyCode::Char('p'))];

        t.input_with_keymap(
            KeyEvent::new(KeyCode::Char('\u{0010}'), KeyModifiers::NONE),
            &keymap,
        );

        assert_eq!(t.cursor(), 2);
    }

    #[test]
    fn delete_backward_word_alt_keys() {
        // Test the custom Alt+Ctrl+h binding
        let mut t = ta_with("hello world");
        t.set_cursor(t.text().len()); // cursor at the end
        t.input(KeyEvent::new(
            KeyCode::Char('h'),
            KeyModifiers::CONTROL | KeyModifiers::ALT,
        ));
        assert_eq!(t.text(), "hello ");
        assert_eq!(t.cursor(), 6);

        // Test the standard Alt+Backspace binding
        let mut t = ta_with("hello world");
        t.set_cursor(t.text().len()); // cursor at the end
        t.input(KeyEvent::new(KeyCode::Backspace, KeyModifiers::ALT));
        assert_eq!(t.text(), "hello ");
        assert_eq!(t.cursor(), 6);
    }

    #[test]
    fn shift_backspace_and_shift_delete_keep_grapheme_delete_behavior() {
        let mut t = ta_with("abc");
        t.set_cursor(/*pos*/ 2);

        t.input(KeyEvent::new(KeyCode::Backspace, KeyModifiers::SHIFT));
        assert_eq!(t.text(), "ac");
        assert_eq!(t.cursor(), 1);

        let mut t = ta_with("abc");
        t.set_cursor(/*pos*/ 1);

        t.input(KeyEvent::new(KeyCode::Delete, KeyModifiers::SHIFT));
        assert_eq!(t.text(), "ac");
        assert_eq!(t.cursor(), 1);
    }

    #[test]
    fn control_backspace_variants_delete_backward_word() {
        for modifiers in [
            KeyModifiers::CONTROL,
            KeyModifiers::CONTROL | KeyModifiers::SHIFT,
        ] {
            let mut t = ta_with("hello world");
            t.set_cursor(t.text().len());

            t.input(KeyEvent::new(KeyCode::Backspace, modifiers));
            assert_eq!(t.text(), "hello ");
            assert_eq!(t.cursor(), 6);
        }
    }

    #[test]
    fn control_delete_variants_delete_forward_word() {
        for modifiers in [
            KeyModifiers::CONTROL,
            KeyModifiers::CONTROL | KeyModifiers::SHIFT,
        ] {
            let mut t = ta_with("hello world");
            t.set_cursor(/*pos*/ 0);

            t.input(KeyEvent::new(KeyCode::Delete, modifiers));
            assert_eq!(t.text(), " world");
            assert_eq!(t.cursor(), 0);
        }
    }

    #[test]
    fn delete_backward_word_handles_narrow_no_break_space() {
        let mut t = ta_with("32\u{202F}AM");
        t.set_cursor(t.text().len());
        t.input(KeyEvent::new(KeyCode::Backspace, KeyModifiers::ALT));
        pretty_assertions::assert_eq!(t.text(), "32\u{202F}");
        pretty_assertions::assert_eq!(t.cursor(), t.text().len());
    }

    #[test]
    fn delete_forward_word_with_without_alt_modifier() {
        let mut t = ta_with("hello world");
        t.set_cursor(/*pos*/ 0);
        t.input(KeyEvent::new(KeyCode::Delete, KeyModifiers::ALT));
        assert_eq!(t.text(), " world");
        assert_eq!(t.cursor(), 0);

        let mut t = ta_with("hello");
        t.set_cursor(/*pos*/ 0);
        t.input(KeyEvent::new(KeyCode::Delete, KeyModifiers::NONE));
        assert_eq!(t.text(), "ello");
        assert_eq!(t.cursor(), 0);
    }

    #[test]
    fn delete_forward_word_alt_d() {
        let mut t = ta_with("hello world");
        t.set_cursor(/*pos*/ 6);
        t.input(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::ALT));
        pretty_assertions::assert_eq!(t.text(), "hello ");
        pretty_assertions::assert_eq!(t.cursor(), 6);
    }

    #[test]
    fn control_h_backspace() {
        // Test Ctrl+H as backspace
        let mut t = ta_with("12345");
        t.set_cursor(/*pos*/ 3); // cursor after '3'
        t.input(KeyEvent::new(KeyCode::Char('h'), KeyModifiers::CONTROL));
        assert_eq!(t.text(), "1245");
        assert_eq!(t.cursor(), 2);

        // Test Ctrl+H at beginning (should be no-op)
        t.set_cursor(/*pos*/ 0);
        t.input(KeyEvent::new(KeyCode::Char('h'), KeyModifiers::CONTROL));
        assert_eq!(t.text(), "1245");
        assert_eq!(t.cursor(), 0);

        // Test Ctrl+H at end
        t.set_cursor(t.text().len());
        t.input(KeyEvent::new(KeyCode::Char('h'), KeyModifiers::CONTROL));
        assert_eq!(t.text(), "124");
        assert_eq!(t.cursor(), 3);
    }

    #[cfg_attr(not(windows), ignore = "AltGr modifier only applies on Windows")]
    #[test]
    fn altgr_ctrl_alt_char_inserts_literal() {
        let mut t = ta_with("");
        t.input(KeyEvent::new(
            KeyCode::Char('c'),
            KeyModifiers::CONTROL | KeyModifiers::ALT,
        ));
        assert_eq!(t.text(), "c");
        assert_eq!(t.cursor(), 1);
    }

    #[test]
    fn cursor_vertical_movement_across_lines_and_bounds() {
        let mut t = ta_with("short\nloooooooooong\nmid");
        // Place cursor on second line, column 5
        let second_line_start = 6; // after first '\n'
        t.set_cursor(second_line_start + 5);

        // Move up: target column preserved, clamped by line length
        t.move_cursor_up();
        assert_eq!(t.cursor(), 5); // first line has len 5

        // Move up again goes to start of text
        t.move_cursor_up();
        assert_eq!(t.cursor(), 0);

        // Move down: from start to target col tracked
        t.move_cursor_down();
        // On first move down, we should land on second line, at col 0 (target col remembered as 0)
        let pos_after_down = t.cursor();
        assert!(pos_after_down >= second_line_start);

        // Move down again to third line; clamp to its length
        t.move_cursor_down();
        let third_line_start = t.text().find("mid").unwrap();
        let third_line_end = third_line_start + 3;
        assert!(t.cursor() >= third_line_start && t.cursor() <= third_line_end);

        // Moving down at last line jumps to end
        t.move_cursor_down();
        assert_eq!(t.cursor(), t.text().len());
    }

    #[test]
    fn home_end_and_emacs_style_home_end() {
        let mut t = ta_with("one\ntwo\nthree");
        // Position at middle of second line
        let second_line_start = t.text().find("two").unwrap();
        t.set_cursor(second_line_start + 1);

        t.move_cursor_to_beginning_of_line(/*move_up_at_bol*/ false);
        assert_eq!(t.cursor(), second_line_start);

        // Ctrl-A behavior: if at BOL, go to beginning of previous line
        t.move_cursor_to_beginning_of_line(/*move_up_at_bol*/ true);
        assert_eq!(t.cursor(), 0); // beginning of first line

        // Move to EOL of first line
        t.move_cursor_to_end_of_line(/*move_down_at_eol*/ false);
        assert_eq!(t.cursor(), 3);

        // Ctrl-E: if at EOL, go to end of next line
        t.move_cursor_to_end_of_line(/*move_down_at_eol*/ true);
        // end of second line ("two") is right before its '\n'
        let end_second_nl = t.text().find("\nthree").unwrap();
        assert_eq!(t.cursor(), end_second_nl);
    }

    #[test]
    fn end_of_line_or_down_at_end_of_text() {
        let mut t = ta_with("one\ntwo");
        // Place cursor at absolute end of the text
        t.set_cursor(t.text().len());
        // Should remain at end without panicking
        t.move_cursor_to_end_of_line(/*move_down_at_eol*/ true);
        assert_eq!(t.cursor(), t.text().len());

        // Also verify behavior when at EOL of a non-final line:
        let eol_first_line = 3; // index of '\n' in "one\ntwo"
        t.set_cursor(eol_first_line);
        t.move_cursor_to_end_of_line(/*move_down_at_eol*/ true);
        assert_eq!(t.cursor(), t.text().len()); // moves to end of next (last) line
    }

    #[test]
    fn word_navigation_helpers() {
        let t = ta_with("  alpha  beta   gamma");
        let mut t = t; // make mutable for set_cursor
        // Put cursor after "alpha"
        let after_alpha = t.text().find("alpha").unwrap() + "alpha".len();
        t.set_cursor(after_alpha);
        assert_eq!(t.beginning_of_previous_word(), 2); // skip initial spaces

        // Put cursor at start of beta
        let beta_start = t.text().find("beta").unwrap();
        t.set_cursor(beta_start);
        assert_eq!(t.end_of_next_word(), beta_start + "beta".len());

        // If at end, end_of_next_word returns len
        t.set_cursor(t.text().len());
        assert_eq!(t.end_of_next_word(), t.text().len());
    }

    #[test]
    fn word_navigation_cjk_each_char_is_boundary() {
        let text = "你好世界";
        let mut t = ta_with(text);

        t.set_cursor(/*pos*/ text.len());
        assert_eq!(t.beginning_of_previous_word(), 9);

        t.set_cursor(/*pos*/ 9);
        assert_eq!(t.beginning_of_previous_word(), 6);

        t.set_cursor(/*pos*/ 6);
        assert_eq!(t.beginning_of_previous_word(), 3);

        t.set_cursor(/*pos*/ 3);
        assert_eq!(t.beginning_of_previous_word(), 0);
    }

    #[test]
    fn word_navigation_cjk_forward() {
        let text = "你好世界";
        let mut t = ta_with(text);

        t.set_cursor(/*pos*/ 0);
        assert_eq!(t.end_of_next_word(), 3);

        t.set_cursor(/*pos*/ 3);
        assert_eq!(t.end_of_next_word(), 6);

        t.set_cursor(/*pos*/ 6);
        assert_eq!(t.end_of_next_word(), 9);

        t.set_cursor(/*pos*/ 9);
        assert_eq!(t.end_of_next_word(), 12);
    }

    #[test]
    fn word_navigation_mixed_ascii_cjk() {
        let text = "hello你好";
        let mut t = ta_with(text);

        t.set_cursor(/*pos*/ 0);
        assert_eq!(t.end_of_next_word(), 5);

        t.set_cursor(/*pos*/ 5);
        assert_eq!(t.end_of_next_word(), 8);

        t.set_cursor(/*pos*/ text.len());
        assert_eq!(t.beginning_of_previous_word(), 8);

        t.set_cursor(/*pos*/ 8);
        assert_eq!(t.beginning_of_previous_word(), 5);

        t.set_cursor(/*pos*/ 5);
        assert_eq!(t.beginning_of_previous_word(), 0);
    }

    #[test]
    fn word_navigation_preserves_separator_breaks_within_unicode_segments() {
        let mut t = ta_with("can't 32.3 foo.bar");

        t.set_cursor(/*pos*/ 5);
        assert_eq!(t.beginning_of_previous_word(), 4);

        t.set_cursor(/*pos*/ 4);
        assert_eq!(t.beginning_of_previous_word(), 3);

        t.set_cursor(/*pos*/ 10);
        assert_eq!(t.beginning_of_previous_word(), 9);

        t.set_cursor(/*pos*/ 18);
        assert_eq!(t.beginning_of_previous_word(), 15);
    }

    #[test]
    fn wrapping_and_cursor_positions() {
        let mut t = ta_with("hello world here");
        let area = Rect::new(0, 0, 6, 10); // width 6 -> wraps words
        // desired height counts wrapped lines
        assert!(t.desired_height(area.width) >= 3);

        // Place cursor in "world"
        let world_start = t.text().find("world").unwrap();
        t.set_cursor(world_start + 3);
        let (_x, y) = t.cursor_pos(area).unwrap();
        assert_eq!(y, 1); // world should be on second wrapped line

        // With state and small height, cursor is mapped onto visible row
        let mut state = TextAreaState::default();
        let small_area = Rect::new(0, 0, 6, 1);
        // First call: cursor not visible -> effective scroll ensures it is
        let (_x, y) = t.cursor_pos_with_state(small_area, state).unwrap();
        assert_eq!(y, 0);

        // Render with state to update actual scroll value
        let mut buf = Buffer::empty(small_area);
        ratatui::widgets::StatefulWidgetRef::render_ref(&(&t), small_area, &mut buf, &mut state);
        // After render, state.scroll should be adjusted so cursor row fits
        let effective_lines = t.desired_height(small_area.width);
        assert!(state.scroll < effective_lines);
    }

    #[test]
    fn cursor_wraps_after_filling_the_final_line() {
        for text in ["abad", "界界", "abガ"] {
            let mut t = ta_with(text);
            t.set_cursor(t.text().len());
            let area = Rect::new(2, 3, /*width*/ 4, /*height*/ 2);

            assert_eq!(t.desired_height(area.width), 2);
            assert_eq!(t.cursor_pos(area), Some((2, 4)));
        }
    }

    #[test]
    fn full_non_final_lines_reserve_visible_cursor_rows() {
        for text in ["abad\nef", "界界\nef", "abガ\nef"] {
            let mut t = ta_with(text);
            let area = Rect::new(0, 0, /*width*/ 4, /*height*/ 3);
            let newline = text.find('\n').unwrap();

            assert_eq!(t.desired_height(area.width), 3);

            t.set_cursor(newline);
            assert_eq!(t.cursor_pos(area), Some((0, 1)));

            t.set_cursor(newline + 1);
            assert_eq!(t.cursor_pos(area), Some((0, 2)));
        }
    }

    #[test]
    fn full_non_final_line_cursor_snapshot() {
        let mut t = ta_with("abad\nef");
        t.set_cursor(/*pos*/ 4);
        let area = Rect::new(0, 0, /*width*/ 4, /*height*/ 3);
        let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
        let mut state = TextAreaState::default();
        terminal
            .draw(|frame| {
                StatefulWidgetRef::render_ref(&(&t), frame.area(), frame.buffer_mut(), &mut state);
            })
            .unwrap();

        insta::assert_snapshot!(
            "textarea_full_non_final_line_has_a_visible_cursor_row",
            format!("cursor: {:?}\n{}", t.cursor_pos(area), terminal.backend())
        );
    }

    #[test]
    fn trailing_spaces_wrap_without_letting_the_cursor_escape() {
        let mut t = ta_with("abad        ");
        t.set_cursor(t.text().len());
        let area = Rect::new(0, 0, /*width*/ 5, /*height*/ 3);
        let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
        let mut state = TextAreaState::default();
        terminal
            .draw(|frame| {
                StatefulWidgetRef::render_ref(&(&t), frame.area(), frame.buffer_mut(), &mut state);
            })
            .unwrap();

        assert_eq!(t.desired_height(area.width), 3);
        insta::assert_snapshot!(
            "textarea_trailing_spaces_wrap_without_cursor_overflow",
            format!("cursor: {:?}\n{}", t.cursor_pos(area), terminal.backend())
        );
    }

    #[test]
    fn separator_after_full_line_hangs_before_following_text() {
        let mut t = ta_with("abad a");
        t.set_cursor(t.text().len());
        let area = Rect::new(0, 0, /*width*/ 4, /*height*/ 2);
        let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
        let mut state = TextAreaState::default();
        terminal
            .draw(|frame| {
                StatefulWidgetRef::render_ref(&(&t), frame.area(), frame.buffer_mut(), &mut state);
            })
            .unwrap();

        assert_eq!(t.desired_height(area.width), 2);
        assert_eq!(t.cursor_pos(area), Some((1, 1)));
        insta::assert_snapshot!(
            "textarea_separator_after_full_line_hangs_before_following_text",
            format!("cursor: {:?}\n{}", t.cursor_pos(area), terminal.backend())
        );

        for text in ["界界 a", "abガ a", "abad\ta"] {
            let mut t = ta_with(text);
            t.set_cursor(t.text().len());

            assert_eq!(t.desired_height(area.width), 2);
            assert_eq!(t.cursor_pos(area), Some((1, 1)));
        }
    }

    #[test]
    fn breakable_unicode_space_hangs_before_following_text() {
        let mut t = ta_with("abad\u{3000}abcde");
        t.set_cursor(t.text().len());
        let area = Rect::new(0, 0, /*width*/ 4, /*height*/ 3);
        let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
        let mut state = TextAreaState::default();
        terminal
            .draw(|frame| {
                StatefulWidgetRef::render_ref(&(&t), frame.area(), frame.buffer_mut(), &mut state);
            })
            .unwrap();

        assert_eq!(t.desired_height(area.width), 3);
        assert_eq!(t.cursor_pos(area), Some((1, 2)));
        insta::assert_snapshot!(
            "textarea_breakable_unicode_space_hangs_before_following_text",
            format!("cursor: {:?}\n{}", t.cursor_pos(area), terminal.backend())
        );
    }

    #[test]
    fn leading_space_reflows_across_following_wrapped_fragments() {
        let mut t = ta_with("abad abcde wxyz");
        let area = Rect::new(0, 0, /*width*/ 4, /*height*/ 5);
        assert_eq!(t.desired_height(area.width), 5);
        for (cursor, expected) in [(11, (0, 3)), (14, (3, 3)), (15, (0, 4))] {
            t.set_cursor(cursor);
            assert_eq!(t.cursor_pos(area), Some(expected));
        }

        let mut t = ta_with("abad abcde xy zz");
        let area = Rect::new(0, 0, /*width*/ 4, /*height*/ 4);
        assert_eq!(t.desired_height(area.width), 4);
        for (cursor, expected) in [
            (4, (0, 1)),
            (5, (0, 1)),
            (8, (3, 1)),
            (9, (0, 2)),
            (10, (1, 2)),
            (11, (2, 2)),
            (12, (3, 2)),
            (13, (0, 3)),
            (14, (0, 3)),
            (16, (2, 3)),
        ] {
            t.set_cursor(cursor);
            assert_eq!(t.cursor_pos(area), Some(expected));
        }

        let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
        let mut state = TextAreaState::default();
        terminal
            .draw(|frame| {
                StatefulWidgetRef::render_ref(&(&t), frame.area(), frame.buffer_mut(), &mut state);
            })
            .unwrap();

        insta::assert_snapshot!(
            "textarea_leading_space_reflows_across_following_wrapped_fragments",
            format!("cursor: {:?}\n{}", t.cursor_pos(area), terminal.backend())
        );
    }

    #[test]
    fn reflow_keeps_fitting_remainder_on_current_row() {
        for (text, width, expected_height, expected_cursor) in [
            ("  -", 1, 4, (0, 3)),
            ("p    a b", 3, 3, (0, 2)),
            ("p     a b", 5, 2, (3, 1)),
            (" aaaa a   ", 3, 4, (1, 3)),
        ] {
            let mut t = ta_with(text);
            t.set_cursor(t.text().len());
            let area = Rect::new(0, 0, width, expected_height);

            assert_eq!(t.desired_height(area.width), expected_height);
            assert_eq!(t.cursor_pos(area), Some(expected_cursor));
            for range in t.wrapped_lines(width).iter() {
                assert!(
                    display_width(text[range.start..range.end - 1].trim_end_matches(' '))
                        <= usize::from(width)
                );
            }
        }

        let mut t = ta_with("p     a b");
        t.set_cursor(t.text().len());
        let area = Rect::new(0, 0, /*width*/ 5, /*height*/ 2);
        let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
        let mut state = TextAreaState::default();
        terminal
            .draw(|frame| {
                StatefulWidgetRef::render_ref(&(&t), frame.area(), frame.buffer_mut(), &mut state);
            })
            .unwrap();

        insta::assert_snapshot!(
            "textarea_reflow_keeps_fitting_remainder_on_current_row",
            format!("cursor: {:?}\n{}", t.cursor_pos(area), terminal.backend())
        );
    }

    #[test]
    fn reflow_preserves_hyphenated_word_breakpoint_when_rendering() {
        let mut t = ta_with("a foo-barbaz");
        t.set_cursor(t.text().len());
        let area = Rect::new(0, 0, /*width*/ 10, /*height*/ 2);
        let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
        let mut state = TextAreaState::default();
        terminal
            .draw(|frame| {
                StatefulWidgetRef::render_ref(&(&t), frame.area(), frame.buffer_mut(), &mut state);
            })
            .unwrap();

        insta::assert_snapshot!(
            "textarea_reflow_preserves_hyphenated_word_breakpoint",
            format!("cursor: {:?}\n{}", t.cursor_pos(area), terminal.backend())
        );
    }

    #[test]
    fn space_runs_hang_before_later_text() {
        let mut t = ta_with("abad     next");
        let area = Rect::new(0, 0, /*width*/ 4, /*height*/ 3);

        assert_eq!(t.desired_height(area.width), 3);

        for cursor in 4..=9 {
            t.set_cursor(cursor);
            assert_eq!(t.cursor_pos(area), Some((0, 1)));
        }
    }

    #[test]
    fn full_final_line_scrolls_to_its_visible_cursor_row() {
        let mut t = ta_with("abcdefgh");
        t.set_cursor(t.text().len());
        let area = Rect::new(0, 0, /*width*/ 4, /*height*/ 2);
        let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
        let mut state = TextAreaState::default();
        terminal
            .draw(|frame| {
                StatefulWidgetRef::render_ref(&(&t), frame.area(), frame.buffer_mut(), &mut state);
            })
            .unwrap();

        assert_eq!(t.desired_height(area.width), 3);
        insta::assert_snapshot!(
            "textarea_full_final_line_scrolls_to_visible_cursor_row",
            format!(
                "scroll: {}\ncursor: {:?}\n{}",
                state.scroll,
                t.cursor_pos_with_state(area, state),
                terminal.backend()
            )
        );
    }

    #[test]
    fn text_rendering_does_not_overwrite_cells_outside_the_textarea() {
        let t = ta_with("abad     next");
        let area = Rect::new(0, 0, /*width*/ 4, /*height*/ 3);
        let mut state = TextAreaState::default();
        let mut buf = Buffer::empty(Rect::new(0, 0, /*width*/ 8, /*height*/ 3));
        let protected_style = Style::default().fg(Color::Red);
        buf.set_style(Rect::new(4, 0, /*width*/ 4, /*height*/ 3), protected_style);
        let protected_cell = buf[(4, 0)].clone();

        StatefulWidgetRef::render_ref(&(&t), area, &mut buf, &mut state);

        assert_eq!(buf[(4, 0)], protected_cell);
    }

    #[test]
    fn styled_text_rendering_does_not_overwrite_cells_outside_the_textarea() {
        let mut snapshots = Vec::new();
        for overlay in ["element", "highlight"] {
            let mut t = ta_with("abad     next");
            if overlay == "element" {
                t.add_element_range(0..9);
            }
            let highlights = if overlay == "highlight" {
                vec![(0..9, Style::default().fg(Color::Magenta))]
            } else {
                Vec::new()
            };
            let area = Rect::new(0, 0, /*width*/ 4, /*height*/ 3);
            let mut terminal = Terminal::new(TestBackend::new(/*width*/ 8, area.height)).unwrap();
            let mut state = TextAreaState::default();
            terminal
                .draw(|frame| {
                    frame.buffer_mut().set_string(
                        /*x*/ 4,
                        /*y*/ 0,
                        "KEEP",
                        Style::default().fg(Color::Red),
                    );
                    t.render_ref_styled_with_highlights(
                        area,
                        frame.buffer_mut(),
                        &mut state,
                        Style::default(),
                        &highlights,
                    );
                })
                .unwrap();

            assert_eq!(terminal.backend().buffer()[(4, 0)].symbol(), "K");
            snapshots.push(format!("{overlay}\n{}", terminal.backend()));
        }

        insta::assert_snapshot!(
            "textarea_styled_overlays_stay_inside_the_textarea",
            snapshots.join("\n\n")
        );
    }

    #[test]
    fn empty_textarea_areas_do_not_have_a_cursor() {
        let t = ta_with("abad");

        assert_eq!(
            t.cursor_pos(Rect::new(0, 0, /*width*/ 0, /*height*/ 1)),
            None
        );
        assert_eq!(
            t.cursor_pos(Rect::new(0, 0, /*width*/ 1, /*height*/ 0)),
            None
        );
    }

    #[test]
    fn render_highlights_apply_style_without_mutating_text() {
        let t = ta_with("hello world");
        let area = Rect::new(0, 0, 20, 1);
        let mut state = TextAreaState::default();
        let mut buf = Buffer::empty(area);
        let highlight_style = Style::default().add_modifier(ratatui::style::Modifier::REVERSED);

        t.render_ref_styled_with_highlights(
            area,
            &mut buf,
            &mut state,
            Style::default(),
            &[(6..11, highlight_style)],
        );

        assert_eq!(t.text(), "hello world");
        assert!(
            !buf[(0, 0)]
                .style()
                .add_modifier
                .contains(ratatui::style::Modifier::REVERSED)
        );
        assert!(
            buf[(6, 0)]
                .style()
                .add_modifier
                .contains(ratatui::style::Modifier::REVERSED)
        );
        assert!(
            buf[(10, 0)]
                .style()
                .add_modifier
                .contains(ratatui::style::Modifier::REVERSED)
        );
    }

    #[test]
    fn tabs_render_as_spaces_and_align_with_cursor_snapshot() {
        use ratatui::Terminal;
        use ratatui::backend::TestBackend;

        let text = "❌\tSimulation\tformatter[large/dataset.py]\t7.4 ms\t8.1 ms\t-8.29%";
        let mut t = ta_with(text);
        t.set_cursor(text.len());

        let mut terminal = Terminal::new(TestBackend::new(/*width*/ 100, /*height*/ 1)).unwrap();
        terminal
            .draw(|frame| {
                ratatui::widgets::WidgetRef::render_ref(&(&t), frame.area(), frame.buffer_mut());
            })
            .unwrap();

        let cursor = t.cursor_pos(terminal.backend().buffer().area).unwrap();
        assert_eq!(
            terminal.backend().buffer()[(cursor.0 - 1, cursor.1)].symbol(),
            "%"
        );
        insta::assert_snapshot!(
            "textarea_tabs_render_as_spaces_and_align_with_cursor",
            format!("cursor: {cursor:?}\n{}", terminal.backend())
        );
    }

    #[test]
    fn tabs_wrap_at_their_rendered_width() {
        let text = "1234\t5";
        let mut t = ta_with(text);
        t.set_cursor(text.len());
        let area = Rect::new(0, 0, /*width*/ 5, /*height*/ 2);
        let mut buf = Buffer::empty(area);

        ratatui::widgets::WidgetRef::render_ref(&(&t), area, &mut buf);

        assert_eq!(t.desired_height(area.width), 2);
        assert_eq!(t.cursor_pos(area), Some((1, 1)));
        assert_eq!(buf[(0, 1)].symbol(), "5");
    }

    #[test]
    fn halfwidth_sound_marks_wrap_and_align_with_the_cursor() {
        use ratatui::Terminal;
        use ratatui::backend::TestBackend;

        let mut snapshots = Vec::new();
        for (label, text, width, height, cursor, cells) in [
            ("dakuten", "12ガx", 4, 2, (1, 1), [(2, 0, "ガ"), (0, 1, "x")]),
            (
                "handakuten",
                "abパc",
                3,
                3,
                (0, 2),
                [(0, 1, "パ"), (2, 1, "c")],
            ),
            ("standalone", "a ゙b", 2, 3, (0, 2), [(0, 1, "゙"), (1, 1, "b")]),
        ] {
            let mut t = ta_with(text);
            t.set_cursor(text.len());
            let area = Rect::new(0, 0, width, height);
            let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
            terminal
                .draw(|frame| {
                    ratatui::widgets::WidgetRef::render_ref(
                        &(&t),
                        frame.area(),
                        frame.buffer_mut(),
                    );
                })
                .unwrap();

            assert_eq!(t.desired_height(area.width), height);
            assert_eq!(t.cursor_pos(area), Some(cursor));
            for (x, y, expected) in cells {
                assert_eq!(terminal.backend().buffer()[(x, y)].symbol(), expected);
            }
            snapshots.push(format!(
                "{label}\ncursor: {:?}\n{}",
                t.cursor_pos(area),
                terminal.backend()
            ));
        }

        insta::assert_snapshot!(
            "textarea_halfwidth_sound_marks_wrap_and_align_with_cursor",
            snapshots.join("\n\n")
        );
    }

    #[test]
    fn masked_graphemes_align_with_the_cursor() {
        use ratatui::Terminal;
        use ratatui::backend::TestBackend;

        let text = "界゙a";
        let mut t = ta_with(text);
        t.set_cursor(text.len());
        let area = Rect::new(0, 0, /*width*/ 4, /*height*/ 2);
        let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
        let mut state = TextAreaState::default();
        terminal
            .draw(|frame| {
                t.render_ref_masked(frame.area(), frame.buffer_mut(), &mut state, '*');
            })
            .unwrap();

        assert_eq!(t.cursor_pos(area), Some((0, 1)));
        insta::assert_snapshot!(
            "textarea_masked_graphemes_align_with_cursor",
            format!("cursor: {:?}\n{}", t.cursor_pos(area), terminal.backend())
        );
    }

    #[test]
    fn overwide_halfwidth_sound_marks_keep_the_final_cursor_visible() {
        let area = Rect::new(0, 0, /*width*/ 2, /*height*/ 3);

        for grapheme in ["ガ゙", "界゙"] {
            let text = format!("{grapheme}ab");
            let mut t = ta_with(&text);
            t.set_cursor(text.len());

            assert_eq!(t.desired_height(area.width), 3);
            assert_eq!(t.cursor_pos(area), Some((0, 2)));

            t.set_cursor(grapheme.len());
            assert_eq!(t.cursor_pos(area), Some((0, 1)));
        }
    }

    #[test]
    fn cursor_pos_with_state_basic_and_scroll_behaviors() {
        // Case 1: No wrapping needed, height fits — scroll ignored, y maps directly.
        let mut t = ta_with("hello world");
        t.set_cursor(/*pos*/ 3);
        let area = Rect::new(2, 5, 20, 3);
        // Even if an absurd scroll is provided, when content fits the area the
        // effective scroll is 0 and the cursor position matches cursor_pos.
        let bad_state = TextAreaState {
            scroll: 999,
            ..Default::default()
        };
        let (x1, y1) = t.cursor_pos(area).unwrap();
        let (x2, y2) = t.cursor_pos_with_state(area, bad_state).unwrap();
        assert_eq!((x2, y2), (x1, y1));

        // Case 2: Cursor below the current window — y should be clamped to the
        // bottom row (area.height - 1) after adjusting effective scroll.
        let mut t = ta_with("one two three four five six");
        // Force wrapping to many visual lines.
        let wrap_width = 4;
        let _ = t.desired_height(wrap_width);
        // Put cursor somewhere near the end so it's definitely below the first window.
        t.set_cursor(t.text().len().saturating_sub(2));
        let small_area = Rect::new(0, 0, wrap_width, 2);
        let state = TextAreaState {
            scroll: 0,
            ..Default::default()
        };
        let (_x, y) = t.cursor_pos_with_state(small_area, state).unwrap();
        assert_eq!(y, small_area.y + small_area.height - 1);

        // Case 3: Cursor above the current window — y should be top row (0)
        // when the provided scroll is too large.
        let mut t = ta_with("alpha beta gamma delta epsilon zeta");
        let wrap_width = 5;
        let lines = t.desired_height(wrap_width);
        // Place cursor near start so an excessive scroll moves it to top row.
        t.set_cursor(/*pos*/ 1);
        let area = Rect::new(0, 0, wrap_width, 3);
        let state = TextAreaState {
            scroll: lines.saturating_mul(2),
            ..Default::default()
        };
        let (_x, y) = t.cursor_pos_with_state(area, state).unwrap();
        assert_eq!(y, area.y);
    }

    #[test]
    fn wrapped_navigation_across_visual_lines() {
        let mut t = ta_with("abcdefghij");
        // Force wrapping at width 4: lines -> ["abcd", "efgh", "ij"]
        let _ = t.desired_height(/*width*/ 4);

        // From the very start, moving down should go to the start of the next wrapped line (index 4)
        t.set_cursor(/*pos*/ 0);
        t.move_cursor_down();
        assert_eq!(t.cursor(), 4);

        // Cursor at boundary index 4 should be displayed at start of second wrapped line
        t.set_cursor(/*pos*/ 4);
        let area = Rect::new(0, 0, 4, 10);
        let (x, y) = t.cursor_pos(area).unwrap();
        assert_eq!((x, y), (0, 1));

        // With state and small height, cursor should be visible at row 0, col 0
        let small_area = Rect::new(0, 0, 4, 1);
        let state = TextAreaState::default();
        let (x, y) = t.cursor_pos_with_state(small_area, state).unwrap();
        assert_eq!((x, y), (0, 0));

        // Place cursor in the middle of the second wrapped line ("efgh"), at 'g'
        t.set_cursor(/*pos*/ 6);
        // Move up should go to same column on previous wrapped line -> index 2 ('c')
        t.move_cursor_up();
        assert_eq!(t.cursor(), 2);

        // Move down should return to same position on the next wrapped line -> back to index 6 ('g')
        t.move_cursor_down();
        assert_eq!(t.cursor(), 6);

        // Move down again should go to third wrapped line. Target col is 2, but the line has len 2 -> clamp to end
        t.move_cursor_down();
        assert_eq!(t.cursor(), t.text().len());
    }

    #[test]
    fn cursor_pos_with_state_after_movements() {
        let mut t = ta_with("abcdefghij");
        // Wrap width 4 -> visual lines: abcd | efgh | ij
        let _ = t.desired_height(/*width*/ 4);
        let area = Rect::new(0, 0, 4, 2);
        let mut state = TextAreaState::default();
        let mut buf = Buffer::empty(area);

        // Start at beginning
        t.set_cursor(/*pos*/ 0);
        ratatui::widgets::StatefulWidgetRef::render_ref(&(&t), area, &mut buf, &mut state);
        let (x, y) = t.cursor_pos_with_state(area, state).unwrap();
        assert_eq!((x, y), (0, 0));

        // Move down to second visual line; should be at bottom row (row 1) within 2-line viewport
        t.move_cursor_down();
        ratatui::widgets::StatefulWidgetRef::render_ref(&(&t), area, &mut buf, &mut state);
        let (x, y) = t.cursor_pos_with_state(area, state).unwrap();
        assert_eq!((x, y), (0, 1));

        // Move down to third visual line; viewport scrolls and keeps cursor on bottom row
        t.move_cursor_down();
        ratatui::widgets::StatefulWidgetRef::render_ref(&(&t), area, &mut buf, &mut state);
        let (x, y) = t.cursor_pos_with_state(area, state).unwrap();
        assert_eq!((x, y), (0, 1));

        // Move up to second visual line; with current scroll, it appears on top row
        t.move_cursor_up();
        ratatui::widgets::StatefulWidgetRef::render_ref(&(&t), area, &mut buf, &mut state);
        let (x, y) = t.cursor_pos_with_state(area, state).unwrap();
        assert_eq!((x, y), (0, 0));

        // Column preservation across moves: set to col 2 on first line, move down
        t.set_cursor(/*pos*/ 2);
        ratatui::widgets::StatefulWidgetRef::render_ref(&(&t), area, &mut buf, &mut state);
        let (x0, y0) = t.cursor_pos_with_state(area, state).unwrap();
        assert_eq!((x0, y0), (2, 0));
        t.move_cursor_down();
        ratatui::widgets::StatefulWidgetRef::render_ref(&(&t), area, &mut buf, &mut state);
        let (x1, y1) = t.cursor_pos_with_state(area, state).unwrap();
        assert_eq!((x1, y1), (2, 1));
    }

    #[test]
    fn wrapped_navigation_with_newlines_and_spaces() {
        // Include spaces and an explicit newline to exercise boundaries
        let mut t = ta_with("word1  word2\nword3");
        // Width 6 leaves both separators on the first visual row.
        let _ = t.desired_height(/*width*/ 6);

        // Put the cursor at column 1 of "word2".
        let start_word2 = t.text().find("word2").unwrap();
        t.set_cursor(start_word2 + 1);

        // Up moves directly to the preceding visual line while preserving the visual column.
        t.move_cursor_up();
        assert_eq!(t.cursor(), 1);

        // Down returns to the same visual column of "word2".
        t.move_cursor_down();
        assert_eq!(t.cursor(), start_word2 + 1);

        // Down crosses the logical newline to the next visual line ("word3").
        t.move_cursor_down();
        let start_word3 = t.text().find("word3").unwrap();
        assert_eq!(t.cursor(), start_word3 + 1);
    }

    #[test]
    fn wrapped_navigation_with_wide_graphemes() {
        // Four thumbs up, each of display width 2, with width 3 to force wrapping inside grapheme boundaries
        let mut t = ta_with("👍👍👍👍");
        let _ = t.desired_height(/*width*/ 3);

        // Put cursor after the second emoji (which should be on first wrapped line)
        t.set_cursor("👍👍".len());

        // Move down should go to the start of the next wrapped line (same column preserved but clamped)
        t.move_cursor_down();
        // We expect to land somewhere within the third emoji or at the start of it
        let pos_after_down = t.cursor();
        assert!(pos_after_down >= "👍👍".len());

        // Moving up should take us back to the original position
        t.move_cursor_up();
        assert_eq!(t.cursor(), "👍👍".len());
    }

    #[test]
    fn fuzz_textarea_randomized() {
        // Deterministic seed for reproducibility
        // Seed the RNG based on the current day in Pacific Time (PST/PDT). This
        // keeps the fuzz test deterministic within a day while still varying
        // day-to-day to improve coverage.
        let pst_today_seed: u64 = (chrono::Utc::now() - chrono::Duration::hours(8))
            .date_naive()
            .and_hms_opt(0, 0, 0)
            .unwrap()
            .and_utc()
            .timestamp() as u64;
        let mut rng = rand::rngs::StdRng::seed_from_u64(pst_today_seed);

        for _case in 0..500 {
            let mut ta = TextArea::new();
            let mut state = TextAreaState::default();
            // Track element payloads we insert. Payloads use characters '[' and ']' which
            // are not produced by rand_grapheme(), avoiding accidental collisions.
            let mut elem_texts: Vec<String> = Vec::new();
            let mut next_elem_id: usize = 0;
            // Start with a random base string
            let base_len = rng.random_range(0..30);
            let mut base = String::new();
            for _ in 0..base_len {
                base.push_str(&rand_grapheme(&mut rng));
            }
            ta.set_text_clearing_elements(&base);
            // Choose a valid char boundary for initial cursor
            let mut boundaries: Vec<usize> = vec![0];
            boundaries.extend(ta.text().char_indices().map(|(i, _)| i).skip(1));
            boundaries.push(ta.text().len());
            let init = boundaries[rng.random_range(0..boundaries.len())];
            ta.set_cursor(init);

            let mut width: u16 = rng.random_range(1..=12);
            let mut height: u16 = rng.random_range(1..=4);

            for _step in 0..60 {
                // Mostly stable width/height, occasionally change
                if rng.random_bool(0.1) {
                    width = rng.random_range(1..=12);
                }
                if rng.random_bool(0.1) {
                    height = rng.random_range(1..=4);
                }

                // Pick an operation
                match rng.random_range(0..18) {
                    0 => {
                        // insert small random string at cursor
                        let len = rng.random_range(0..6);
                        let mut s = String::new();
                        for _ in 0..len {
                            s.push_str(&rand_grapheme(&mut rng));
                        }
                        ta.insert_str(&s);
                    }
                    1 => {
                        // replace_range with small random slice
                        let mut b: Vec<usize> = vec![0];
                        b.extend(ta.text().char_indices().map(|(i, _)| i).skip(1));
                        b.push(ta.text().len());
                        let i1 = rng.random_range(0..b.len());
                        let i2 = rng.random_range(0..b.len());
                        let (start, end) = if b[i1] <= b[i2] {
                            (b[i1], b[i2])
                        } else {
                            (b[i2], b[i1])
                        };
                        let insert_len = rng.random_range(0..=4);
                        let mut s = String::new();
                        for _ in 0..insert_len {
                            s.push_str(&rand_grapheme(&mut rng));
                        }
                        let before = ta.text().len();
                        // If the chosen range intersects an element, replace_range will expand to
                        // element boundaries, so the naive size delta assertion does not hold.
                        let intersects_element = elem_texts.iter().any(|payload| {
                            if let Some(pstart) = ta.text().find(payload) {
                                let pend = pstart + payload.len();
                                pstart < end && pend > start
                            } else {
                                false
                            }
                        });
                        ta.replace_range(start..end, &s);
                        if !intersects_element {
                            let after = ta.text().len();
                            assert_eq!(
                                after as isize,
                                before as isize + (s.len() as isize) - ((end - start) as isize)
                            );
                        }
                    }
                    2 => ta.delete_backward(rng.random_range(0..=3)),
                    3 => ta.delete_forward(rng.random_range(0..=3)),
                    4 => ta.delete_backward_word(),
                    5 => ta.kill_to_beginning_of_line(),
                    6 => ta.kill_to_end_of_line(),
                    7 => ta.move_cursor_left(),
                    8 => ta.move_cursor_right(),
                    9 => ta.move_cursor_up(),
                    10 => ta.move_cursor_down(),
                    11 => ta.move_cursor_to_beginning_of_line(/*move_up_at_bol*/ true),
                    12 => ta.move_cursor_to_end_of_line(/*move_down_at_eol*/ true),
                    13 => {
                        // Insert an element with a unique sentinel payload
                        let payload =
                            format!("[[EL#{}:{}]]", next_elem_id, rng.random_range(1000..9999));
                        next_elem_id += 1;
                        ta.insert_element(&payload);
                        elem_texts.push(payload);
                    }
                    14 => {
                        // Try inserting inside an existing element (should clamp to boundary)
                        if let Some(payload) = elem_texts.choose(&mut rng).cloned()
                            && let Some(start) = ta.text().find(&payload)
                        {
                            let end = start + payload.len();
                            if end - start > 2 {
                                let pos = rng.random_range(start + 1..end - 1);
                                let ins = rand_grapheme(&mut rng);
                                ta.insert_str_at(pos, &ins);
                            }
                        }
                    }
                    15 => {
                        // Replace a range that intersects an element -> whole element should be replaced
                        if let Some(payload) = elem_texts.choose(&mut rng).cloned()
                            && let Some(start) = ta.text().find(&payload)
                        {
                            let end = start + payload.len();
                            // Create an intersecting range [start-δ, end-δ2)
                            let mut s = start.saturating_sub(rng.random_range(0..=2));
                            let mut e = (end + rng.random_range(0..=2)).min(ta.text().len());
                            // Align to char boundaries to satisfy String::replace_range contract
                            let txt = ta.text();
                            while s > 0 && !txt.is_char_boundary(s) {
                                s -= 1;
                            }
                            while e < txt.len() && !txt.is_char_boundary(e) {
                                e += 1;
                            }
                            if s < e {
                                // Small replacement text
                                let mut srep = String::new();
                                for _ in 0..rng.random_range(0..=2) {
                                    srep.push_str(&rand_grapheme(&mut rng));
                                }
                                ta.replace_range(s..e, &srep);
                            }
                        }
                    }
                    16 => {
                        // Try setting the cursor to a position inside an element; it should clamp out
                        if let Some(payload) = elem_texts.choose(&mut rng).cloned()
                            && let Some(start) = ta.text().find(&payload)
                        {
                            let end = start + payload.len();
                            if end - start > 2 {
                                let pos = rng.random_range(start + 1..end - 1);
                                ta.set_cursor(pos);
                            }
                        }
                    }
                    _ => {
                        // Jump to word boundaries
                        if rng.random_bool(0.5) {
                            let p = ta.beginning_of_previous_word();
                            ta.set_cursor(p);
                        } else {
                            let p = ta.end_of_next_word();
                            ta.set_cursor(p);
                        }
                    }
                }

                // Sanity invariants
                assert!(ta.cursor() <= ta.text().len());

                // Element invariants
                for payload in &elem_texts {
                    if let Some(start) = ta.text().find(payload) {
                        let end = start + payload.len();
                        // 1) Text inside elements matches the initially set payload
                        assert_eq!(&ta.text()[start..end], payload);
                        // 2) Cursor is never strictly inside an element
                        let c = ta.cursor();
                        assert!(
                            c <= start || c >= end,
                            "cursor inside element: {start}..{end} at {c}"
                        );
                    }
                }

                // Render and compute cursor positions; ensure they are in-bounds and do not panic
                let area = Rect::new(0, 0, width, height);
                // Stateless render into an area tall enough for all wrapped lines
                let total_lines = ta.desired_height(width);
                let full_area = Rect::new(0, 0, width, total_lines.max(1));
                let mut buf = Buffer::empty(full_area);
                ratatui::widgets::WidgetRef::render_ref(&(&ta), full_area, &mut buf);

                // Both cursor helpers must keep the insertion point inside the viewport.
                for (x, y) in [ta.cursor_pos(area), ta.cursor_pos_with_state(area, state)]
                    .into_iter()
                    .flatten()
                {
                    assert!(
                        area.contains((x, y).into()),
                        "cursor escaped {area:?}: ({x}, {y})"
                    );
                }

                // Stateful render should not panic, and updates scroll
                let mut sbuf = Buffer::empty(area);
                ratatui::widgets::StatefulWidgetRef::render_ref(
                    &(&ta),
                    area,
                    &mut sbuf,
                    &mut state,
                );

                // After wrapping, desired height equals the number of lines we would render without scroll
                let total_lines = total_lines as usize;
                // state.scroll must not exceed total_lines when content fits within area height
                if (height as usize) >= total_lines {
                    assert_eq!(state.scroll, 0);
                }
            }
        }
    }
}