Struct EditorState 

pub struct EditorState {

    pub buffer: Buffer,
    pub highlighter: HighlightEngine,
    pub indent_calculator: RefCell<IndentCalculator>,
    pub overlays: OverlayManager,
    pub marker_list: MarkerList,
    pub virtual_texts: VirtualTextManager,
    pub conceals: ConcealManager,
    pub soft_breaks: SoftBreakManager,
    pub popups: PopupManager,
    pub margins: MarginManager,
    pub primary_cursor_line_number: LineNumber,
    pub mode: String,
    pub text_properties: TextPropertyManager,
    pub show_cursors: bool,
    pub cursor_visibility_locked: bool,
    pub editing_disabled: bool,
    pub scrollable: bool,
    pub buffer_settings: BufferSettings,
    pub reference_highlighter: ReferenceHighlighter,
    pub is_composite_buffer: bool,
    pub debug_highlight_mode: bool,
    pub reference_highlight_overlay: ReferenceHighlightOverlay,
    pub bracket_highlight_overlay: BracketHighlightOverlay,
    pub semantic_tokens: Option<SemanticTokenStore>,
    pub folding_ranges: LspFoldRanges,
    pub language: String,
    pub display_name: String,
    pub line_wrap_cache: LineWrapCache,
    pub visual_row_index: VisualRowIndex,
}

The complete editor state - everything needed to represent the current editing session

NOTE: Viewport is NOT stored here - it lives in SplitViewState. This is because viewport is view-specific (each split can view the same buffer at different scroll positions), while EditorState represents the buffer content.

Fields

buffer: Buffer

The text buffer

highlighter: HighlightEngine

Syntax highlighter (tree-sitter or TextMate based on language)

indent_calculator: RefCell<IndentCalculator>

Auto-indent calculator for smart indentation (RefCell for interior mutability)

overlays: OverlayManager

Overlays for visual decorations (underlines, highlights, etc.)

marker_list: MarkerList

Marker list for content-anchored overlay positions

virtual_texts: VirtualTextManager

Virtual text manager for inline hints (type hints, parameter hints, etc.)

conceals: ConcealManager

Conceal ranges for hiding/replacing byte ranges during rendering

soft_breaks: SoftBreakManager

Soft break points for marker-based line wrapping during rendering

popups: PopupManager

Popups for floating windows (completion, documentation, etc.)

margins: MarginManager

Margins for line numbers, annotations, gutter symbols, etc.)

primary_cursor_line_number: LineNumber

Cached line number for primary cursor (0-indexed) Maintained incrementally to avoid O(n) scanning on every render

mode: String

Current mode (for modal editing, if implemented)

text_properties: TextPropertyManager

Text properties for virtual buffers (embedded metadata in text ranges) Used by virtual buffers to store location info, severity, etc.

show_cursors: bool

Whether to show cursors in this buffer (default true) Can be set to false for virtual buffers like diagnostics panels

cursor_visibility_locked: bool

Set once a plugin explicitly controls this buffer’s cursor visibility via setBufferShowCursors. When true, the widget runtime stops overriding the cursor (apply_widget_focus_cursor becomes a no-op for this buffer) — letting a widget-panel plugin own its pane’s cursor, e.g. git log’s cursor-driven commit list.

editing_disabled: bool

Whether editing is disabled for this buffer (default false) When true, typing, deletion, cut/paste, undo/redo are blocked but navigation, selection, and copy are still allowed

scrollable: bool

Whether this buffer can be scrolled (default true). Fixed buffer-group panels (toolbars, headers, footers) set this to false so the mouse wheel is ignored and no scrollbar is drawn.

buffer_settings: BufferSettings

Per-buffer user settings (tab size, indentation style, etc.) These settings are preserved across file reloads (auto-revert)

reference_highlighter: ReferenceHighlighter

Semantic highlighter for word occurrence highlighting

is_composite_buffer: bool

Whether this buffer is a composite view (e.g., side-by-side diff)

debug_highlight_mode: bool

Debug mode: reveal highlight/overlay spans (WordPerfect-style)

reference_highlight_overlay: ReferenceHighlightOverlay

Debounced semantic highlight cache

bracket_highlight_overlay: BracketHighlightOverlay

Bracket matching highlight overlay

semantic_tokens: Option<SemanticTokenStore>

Cached LSP semantic tokens (converted to buffer byte ranges)

folding_ranges: LspFoldRanges

Last-known LSP folding ranges for this buffer, tracked by byte markers so they auto-adjust when content is inserted or deleted around them (issue #1571).

language: String

The detected language ID for this buffer (e.g., “rust”, “csharp”, “text”). Used for LSP config lookup and internal identification.

display_name: String

Human-readable language display name (e.g., “Rust”, “C#”, “Plain Text”). Shown in the status bar and Set Language prompt.

line_wrap_cache: LineWrapCache

Per-logical-line visual-row-count cache (pipeline-output). Populated by both the renderer (as a side effect of rendering a visible frame) and the scroll-math miss handler. Entries are keyed on every pipeline input; mutations to any input produce a different key so stale entries are never returned — see docs/internal/line-wrap-cache-plan.md.

visual_row_index: VisualRowIndex

Whole-buffer prefix-sum index over per-line visual row counts. Sits one tier above line_wrap_cache: answers “what visual row contains byte B?” / “what byte sits at row R?” in O(log N_lines) for scrollbar drag, scrollbar render, and ensure_visible wrapped scrolling. Built lazily from line_wrap_cache; same invalidation source (pipeline-input version + geometry). See crate::view::visual_row_index for invariants.

Implementations

impl EditorState

pub fn apply_language(&mut self, detected: DetectedLanguage)

Create a new editor state with an empty buffer

Note: width/height parameters are kept for backward compatibility but are no longer used - viewport is now owned by SplitViewState. Apply a detected language to this state. This is the single mutation point for changing the language of a buffer after creation.

pub fn new( _width: u16, _height: u16, large_file_threshold: usize, fs: Arc<dyn FileSystem + Send + Sync>, ) -> Self

pub fn new_with_path( large_file_threshold: usize, fs: Arc<dyn FileSystem + Send + Sync>, path: PathBuf, ) -> Self

Create a new editor state with an empty buffer associated with a file path. Used for files that don’t exist yet — the path is set so saving will create the file.

pub fn set_language_from_name(&mut self, name: &str, registry: &GrammarRegistry)

Set the syntax highlighting language based on a virtual buffer name. Handles names like *OLD:test.ts* or *OURS*.c by stripping markers and detecting language from the cleaned filename.

pub fn from_file( path: &Path, _width: u16, _height: u16, large_file_threshold: usize, registry: &GrammarRegistry, fs: Arc<dyn FileSystem + Send + Sync>, ) -> Result<Self>

Create an editor state from a file

Note: width/height parameters are kept for backward compatibility but are no longer used - viewport is now owned by SplitViewState.

pub fn from_file_with_languages( path: &Path, _width: u16, _height: u16, large_file_threshold: usize, registry: &GrammarRegistry, languages: &HashMap<String, LanguageConfig>, fs: Arc<dyn FileSystem + Send + Sync>, ) -> Result<Self>

Create an editor state from a file with language configuration.

This version uses the provided languages configuration for syntax detection, allowing user-configured filename patterns to be respected for highlighting.

Note: width/height parameters are kept for backward compatibility but are no longer used - viewport is now owned by SplitViewState.

pub fn from_file_with_languages_force_text( path: &Path, _width: u16, _height: u16, large_file_threshold: usize, registry: &GrammarRegistry, languages: &HashMap<String, LanguageConfig>, fs: Arc<dyn FileSystem + Send + Sync>, ) -> Result<Self>

Create an editor state from a file, always treating it as text.

Like from_file_with_languages but skips binary detection — the backing file is always loaded through the text path. Used for the terminal scrollback view so raw PTY output containing control bytes never flips the buffer into binary mode, which would otherwise suppress ANSI-color rendering in scrollback (#2449).

pub fn from_buffer_with_language( buffer: Buffer, detected: DetectedLanguage, ) -> Self

Create an editor state from a buffer and a pre-built DetectedLanguage.

This is useful when you have already loaded a buffer with a specific encoding and want to create an EditorState from it.

pub fn apply(&mut self, cursors: &mut Cursors, event: &Event)

Apply an event to the state - THE ONLY WAY TO MODIFY STATE This is the heart of the event-driven architecture

pub fn capture_displaced_markers( &self, range: &Range<usize>, ) -> Vec<(u64, usize)>

Capture positions of markers strictly inside a deleted range. Call this BEFORE applying the delete. Returns encoded displaced markers.

pub fn capture_displaced_markers_bulk( &self, edits: &[(usize, usize, String)], ) -> Vec<(u64, usize)>

Capture displaced markers for multiple delete ranges (BulkEdit).

pub fn restore_displaced_markers(&mut self, displaced: &[(u64, usize)])

Restore displaced markers to their exact original positions.

pub fn apply_many(&mut self, cursors: &mut Cursors, events: &[Event])

Apply multiple events in sequence

pub fn on_focus_lost(&mut self)

Called when this buffer loses focus (e.g., switching to another buffer, opening a prompt, focusing file explorer, etc.) Dismisses transient popups like Hover and Signature Help.

impl EditorState

pub fn prepare_for_render(&mut self, top_byte: usize, height: u16) -> Result<()>

Prepare viewport for rendering (called before frame render)

This pre-loads all data that will be needed for rendering the current viewport, ensuring that subsequent read-only access during rendering will succeed.

Takes viewport parameters since viewport is now owned by SplitViewState.

pub fn collect_virtual_line_positions(&self) -> Vec<usize>

Resolve all plugin-injected virtual-line anchor byte positions for this buffer. Sorted ascending.

Used by Viewport::scroll_down / scroll_up / find_max_visual_scroll_position so the scroll math counts the rows the renderer actually draws (e.g. markdown_compose’s ┌─┬─┐ table borders) when computing max_scroll_row. Without this, mouse wheel and PageDown clamp to a row count that ignores virtual lines and stop short of the buffer’s real tail.

Empty when no plugin has added virtual lines.

pub fn collect_soft_break_positions(&self) -> Vec<(usize, u16)>

Resolve all plugin-injected soft-break (byte_position, indent) pairs for this buffer.

Returns a sorted slice suitable for passing to Viewport::scroll_up / scroll_down, which use it to keep their visual-row counting in lock-step with the renderer (which applies these same breaks via apply_soft_breaks). The indent field is the column count of hanging-indent spaces the plugin asked the renderer to inject after the break — the wrap counter needs it to compute the continuation segment’s effective width correctly.

Empty when no plugin is wrapping the buffer.

pub fn get_text_range(&mut self, start: usize, end: usize) -> String

Get text in a range, driving lazy loading transparently

This is a convenience wrapper around DocumentModel::get_range that:

• Drives lazy loading automatically (never fails due to unloaded data)
• Uses byte offsets directly
• Returns String (not Result) - errors are logged internally
• Returns empty string for invalid ranges

This is the preferred API for getting text ranges. The caller never needs to worry about lazy loading or buffer preparation.

Example

let text = state.get_text_range(0, 100);

pub fn get_line_at_offset(&mut self, offset: usize) -> Option<(usize, String)>

Get the content of a line by its byte offset

Returns the line containing the given offset, along with its start position. This uses DocumentModel’s viewport functionality for consistent behavior.

Returns

Some((line_start_offset, line_content)) if successful, None if offset is invalid

pub fn get_text_to_end_of_line(&mut self, cursor_pos: usize) -> Result<String>

Get text from current cursor position to end of line

This is a common pattern in editing operations. Uses DocumentModel for consistent behavior across file sizes.

pub fn set_semantic_tokens(&mut self, store: SemanticTokenStore)

Replace cached semantic tokens with a new store.

pub fn clear_semantic_tokens(&mut self)

Clear cached semantic tokens (e.g., when tokens are invalidated).

pub fn semantic_tokens_result_id(&self) -> Option<&str>

Get the server-provided semantic token result_id if available.

Trait Implementations

impl DocumentModel for EditorState

Implement DocumentModel trait for EditorState

This provides a clean abstraction layer between rendering/editing operations and the underlying text buffer implementation.

fn capabilities(&self) -> DocumentCapabilities

Get document capabilities

fn get_viewport_content( &mut self, start_pos: DocumentPosition, max_lines: usize, ) -> Result<ViewportContent>

Get content at a viewport (the core rendering primitive)

fn position_to_offset(&self, pos: DocumentPosition) -> Result<usize>

Convert position to byte offset (always works)

fn offset_to_position(&self, offset: usize) -> DocumentPosition

Convert byte offset to a position

fn get_range( &mut self, start: DocumentPosition, end: DocumentPosition, ) -> Result<String>

Get a range of text by positions May trigger lazy loading for large files

fn get_line_content(&mut self, line_number: usize) -> Option<String>

Get a single line if line indexing is available

fn get_chunk_at_offset( &mut self, offset: usize, size: usize, ) -> Result<(usize, String)>

Get text around a byte offset (for operations that don’t need exact lines)

fn insert(&mut self, pos: DocumentPosition, text: &str) -> Result<usize>

Insert text at a position

fn delete( &mut self, start: DocumentPosition, end: DocumentPosition, ) -> Result<()>

Delete a range

fn replace( &mut self, start: DocumentPosition, end: DocumentPosition, text: &str, ) -> Result<()>

Replace a range

fn find_matches( &mut self, pattern: &str, search_range: Option<(DocumentPosition, DocumentPosition)>, ) -> Result<Vec<usize>>

Find all matches of a pattern in a range

fn has_line_index(&self) -> bool

Check if line indexing is available