Struct EditingState 

pub struct EditingState {

    pub mode_stack: ModeStack,
    pub pending_keys: KeySequence,
    pub windows: WindowLayout,
    pub viewport: Viewport,
    pub selection: Option<ClientSelection>,
    pub extensions: ExtensionMap,
    pub compositor: Option<Box<dyn RootCompositor>>,
    pub tabs: TabPageSet,
    pub registers: RegisterBank,
    pub clipboard_history: HistoryRing,
    pub local_marks: MarkBank,
    pub jumplist: Jumplist,
    pub active_buffer: Option<BufferId>,
    pub terminal_size: (u16, u16),
}

Editing state for a client.

Contains all per-client state needed for editing operations. All clients have this state - it’s not just for “owners” anymore.

Multi-Client Isolation (#471)

Each client owns their own WindowLayout with independent cursors. This ensures Client A’s cursor/mode doesn’t affect Client B. Buffers are still shared (all clients see same text content).

Client Model Mapping (#480)

This struct maps to ClientViewState in the common client model. Only a subset is transmitted:

EditingState field	ClientViewState field	Transform
mode_stack	mode	.current().name()
windows	cursor: Position	.focused().cursor
windows	buffer_id	.focused().buffer_id
selection	selection	.to_driver_selection()

Per-client editing state (#471, #477).

Contains all client-specific state including mode, windows, viewport, selection, and module extensions. Each client has independent state to prevent cross-client interference (e.g., Client A’s pending count affecting Client B’s motions).

Fields

mode_stack: ModeStack

Mode stack (current mode on top).

pending_keys: KeySequence

Keys accumulated but not yet processed.

windows: WindowLayout

Per-client window layout with independent cursors (#471).

Each window contains its own cursor position. This replaces the old shared session.windows that caused multi-client bugs.

viewport: Viewport

Viewport (visible area).

selection: Option<ClientSelection>

Active selection (for visual mode).

extensions: ExtensionMap

Per-client module extensions (#477).

Type-erased storage for module state like VimSessionState, SearchState, CmdlineState. Each client has independent extensions to prevent state leakage between clients.

Why Per-Client

Without isolation, Client A pressing 5 (pending_count=5) would cause Client B’s j to move 5 lines instead of 1. This field ensures complete module state isolation.

compositor: Option<Box<dyn RootCompositor>>

Per-client compositor for window layout (#474).

Each client owns their own compositor, cloned from the shared template at join time. This ensures window IDs are consistent between the compositor (geometry) and per-client windows (cursor/viewport).

Before this field, the shared compositor and per-client windows used independent ID namespaces, causing cross-namespace mismatches in notifications and state queries.

tabs: TabPageSet

Per-client tab pages (#401).

Manages tab page lifecycle. Each tab can have its own window layout and compositor. Currently starts with a single default tab. Future work will integrate with windows and compositor fields so that active_tab().windows() becomes the source of truth.

registers: RegisterBank

Per-client register storage (#515).

Each client owns their own registers (unnamed "", named a-z/A-Z). System clipboard (+, *) remains shared via ClipboardProvider. This prevents Client A’s "ayy from overwriting Client B’s register ‘a’.

clipboard_history: HistoryRing

Per-client clipboard history ring (#515).

Tracks yank/delete history for numbered registers 0-9. Each client has independent history so Client A’s deletes don’t shift Client B’s numbered registers.

local_marks: MarkBank

Per-client local marks (a-z, per-client special marks) (#515).

Each client owns their own local marks. Global marks (A-Z) remain shared in KernelContext.global_marks.

jumplist: Jumplist

Per-client jump list for Ctrl-O / Ctrl-I navigation (#654).

Each client owns their own jump list. Jump positions are recorded on cursor movements across buffer boundaries or large jumps.

active_buffer: Option<BufferId>

Per-client active buffer (#471).

Each client tracks which buffer they are viewing independently. New clients are initialized with the first kernel buffer (scratch).

terminal_size: (u16, u16)

Per-client terminal dimensions (width, height) (#471).

Each client has independent terminal size. Initialized to VT100 default (80, 24); updated when the client sends a resize RPC.

Implementations

impl EditingState

pub fn with_mode_stack(mode_stack: ModeStack) -> Self

Create editing state with a specific mode stack.

pub fn with_mode_stack_and_window(mode_stack: ModeStack, window: Window) -> Self

Create editing state with mode stack and initial window.

Used when a client joins a session that already has buffers.

pub fn current_mode(&self) -> &ModeId

Get the current mode ID.

pub fn clear_pending_keys(&mut self)

Clear pending keys.

pub fn client_context(&mut self) -> ClientContext<'_>

Borrow the 7 per-client mutable fields as a [ClientContext].

This bundles the fields that SessionRuntime needs, avoiding 7-argument parameter lists throughout the session execution chain.

Trait Implementations

impl Clone for EditingState

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EditingState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for EditingState

fn default() -> Self

Returns the “default value” for a type.