Struct EditorStateSnapshot 

pub struct EditorStateSnapshot {

    pub active_buffer_id: BufferId,
    pub active_split_id: usize,
    pub buffers: HashMap<BufferId, BufferInfo>,
    pub buffer_saved_diffs: HashMap<BufferId, BufferSavedDiff>,
    pub primary_cursor: Option<CursorInfo>,
    pub primary_cursor_line: Option<u32>,
    pub all_cursors: Vec<CursorInfo>,
    pub viewport: Option<ViewportInfo>,
    pub splits: Vec<SplitSnapshot>,
    pub buffer_cursor_positions: HashMap<BufferId, usize>,
    pub buffer_text_properties: HashMap<BufferId, Vec<TextProperty>>,
    pub selected_text: Option<String>,
    pub clipboard: String,
    pub working_dir: PathBuf,
    pub windows: Vec<WindowInfo>,
    pub active_window_id: WindowId,
    pub authority_label: String,
    pub workspace_trust_level: String,
    pub env_active: bool,
    pub detected_env: String,
    pub diagnostics: Arc<HashMap<String, Vec<Diagnostic>>>,
    pub folding_ranges: Arc<HashMap<String, Vec<FoldingRange>>>,
    pub config: Arc<Value>,
    pub user_config: Arc<Value>,
    pub available_grammars: Vec<GrammarInfoSnapshot>,
    pub last_grammar_gen: u64,
    pub editor_mode: Option<String>,
    pub plugin_view_states: HashMap<BufferId, HashMap<String, Value>>,
    pub plugin_view_states_split: usize,
    pub keybinding_labels: HashMap<String, String>,
    pub plugin_global_states: HashMap<String, HashMap<String, Value>>,
    pub active_session_plugin_states: HashMap<String, HashMap<String, Value>>,
    pub terminal_width: u16,
    pub terminal_height: u16,
    pub has_active_search: bool,
    pub macros: Vec<MacroSnapshot>,
}

Snapshot of editor state for plugin queries This is updated by the editor on each loop iteration

Fields

active_buffer_id: BufferId

Currently active buffer ID

active_split_id: usize

Currently active split ID

buffers: HashMap<BufferId, BufferInfo>

Information about all open buffers

buffer_saved_diffs: HashMap<BufferId, BufferSavedDiff>

Diff vs last saved snapshot for each buffer (line counts may be unknown)

primary_cursor: Option<CursorInfo>

Primary cursor position for the active buffer

primary_cursor_line: Option<u32>

Primary cursor’s line number (0-indexed) for the active buffer. Mirrors the editor’s primary_cursor_line_number cache so plugins can read “what line is the cursor on” without scanning the buffer. None when there is no active view state (e.g. before the first buffer is loaded).

all_cursors: Vec<CursorInfo>

All cursor positions for the active buffer

viewport: Option<ViewportInfo>

Viewport information for the active buffer

splits: Vec<SplitSnapshot>

Per-split snapshots: split id, buffer shown, viewport. Includes the active split. Order is unspecified.

buffer_cursor_positions: HashMap<BufferId, usize>

Cursor positions per buffer (for buffers other than active)

buffer_text_properties: HashMap<BufferId, Vec<TextProperty>>

Text properties per buffer (for virtual buffers with properties)

selected_text: Option<String>

Selected text from the primary cursor (if any selection exists) This is populated on each update to avoid needing full buffer access

clipboard: String

Internal clipboard content (for plugins that need clipboard access)

working_dir: PathBuf

Editor’s working directory (for file operations and spawning processes).

Equal to sessions[i].root where sessions[i].id == active_window_id. Plugins that just need “where am I” can read this directly; plugins orchestrating multiple sessions (Orchestrator) iterate sessions.

windows: Vec<WindowInfo>

All editor sessions, in id order. Always non-empty (the base session is id == 1). Updated when sessions are created/closed or relabelled.

active_window_id: WindowId

Id of the currently active session. Always present in sessions. Read by plugins via editor.activeWindow().

authority_label: String

Status-bar / explorer label for the active authority.

Empty = the local (default) authority with nothing to render. Non-empty means a non-local authority is installed (e.g. "Container:abc123def456" for a devcontainer). Plugins can read this via editor.getAuthorityLabel() to detect “already attached” without having to track state across editor restarts.

workspace_trust_level: String

Current Workspace Trust level for the active project: "restricted", "trusted", or "blocked". Empty when trust state is unavailable (e.g. the default local authority before a guarded one is installed). Plugins that run repo-controlled work read this via editor.workspaceTrustLevel() and should treat anything other than "trusted" as “do not execute”.

env_active: bool

Whether an environment is currently active (the env-manager has set a recipe via editor.setEnv). Plugins read this via editor.envActive() to reflect activation in the status bar and re-establish file watches after the restart that activation triggers.

detected_env: String

The environment core detected in the workspace, as a JSON string ({"name","kind","snippet"}) or empty when none is detected. The env-manager plugin reads this via editor.detectedEnv() instead of probing the filesystem itself — detection lives only in core (see workspace_trust::detect_env).

diagnostics: Arc<HashMap<String, Vec<Diagnostic>>>

LSP diagnostics per file URI. Maps file URI string to Vec of diagnostics for that file.

Wrapped in Arc so snapshot refresh is a refcount bump rather than a deep clone. The editor only mutates its own map through Arc::make_mut, which CoW-clones while this snapshot still holds a reference — a reader can never observe an in-place mutation.

#[serde(skip)]: serde out-of-the-box can’t serialize Arc<T> (behind the rc cargo feature we don’t enable). We never serialize the snapshot as a whole — plugin readers pull out these Arcs and serialize the inner value directly (e.g. get_all_diagnostics).

folding_ranges: Arc<HashMap<String, Vec<FoldingRange>>>

LSP folding ranges per file URI. Maps file URI string to Vec of folding ranges for that file. Arc-wrapped for the same CoW invariant as diagnostics; see that field for why this is #[serde(skip)].

config: Arc<Value>

Runtime config as serde_json::Value (merged user config + defaults). This is the runtime config, not just the user’s config file.

Wrapped in Arc so the snapshot update is a refcount bump. The editor reserializes its source Config only when the underlying Arc<Config> pointer has moved (i.e., after a real mutation), and swaps the whole Arc<Value> atomically — callers never see a partially-updated blob. #[serde(skip)] for the same reason as diagnostics.

user_config: Arc<Value>

User config as serde_json::Value (only what’s in the user’s config file). Fields not present here are using default values. Arc-wrapped; swapped as a whole when the user’s file is reloaded. #[serde(skip)] for the same reason as diagnostics.

available_grammars: Vec<GrammarInfoSnapshot>

Available grammars with provenance info, updated when grammar registry changes

last_grammar_gen: u64

Last-seen grammar registry generation. The state-snapshot updater rebuilds available_grammars only when this disagrees with the registry’s current catalog_gen(). #[serde(skip)] because the counter is a host-side detail not exposed to plugins.

editor_mode: Option<String>

Global editor mode for modal editing (e.g., “vi-normal”, “vi-insert”) When set, this mode’s keybindings take precedence over normal key handling

plugin_view_states: HashMap<BufferId, HashMap<String, Value>>

Plugin-managed per-buffer view state for the active split. Updated from BufferViewState.plugin_state during snapshot updates. Also written directly by JS plugins via setViewState for immediate read-back.

plugin_view_states_split: usize

Tracks which split was active when plugin_view_states was last populated. When the active split changes, plugin_view_states is fully repopulated.

keybinding_labels: HashMap<String, String>

Keybinding labels for plugin modes, keyed by “action\0mode” for fast lookup. Updated when modes are registered via defineMode().

plugin_global_states: HashMap<String, HashMap<String, Value>>

Plugin-managed global state, isolated per plugin. Outer key is plugin name, inner key is the state key set by the plugin. TODO: Need to think about plugin isolation / namespacing strategy for these APIs. Currently we isolate by plugin name, but we may want a more robust approach (e.g. preventing plugins from reading each other’s state, or providing explicit cross-plugin state sharing APIs).

active_session_plugin_states: HashMap<String, HashMap<String, Value>>

Plugin-managed per-session state, snapshotted as the active session’s plugin_state map. Updated wholesale on setActiveWindow (alongside the rest of the per-session state) — plugins that read this via editor.getWindowState(key) see the active session’s values without crossing the IPC boundary on every read. Outer key is plugin name, inner is the plugin-defined key.

terminal_width: u16

Total terminal dimensions in cells. Refreshed on every resize event. Plugins read this via editor.getScreenSize() when they need to size floating overlays against the whole terminal — getViewport() only reports the active split, which is smaller than the screen whenever splits exist.

terminal_height: u16

has_active_search: bool

Whether search highlights are currently active in the active buffer. True when a search has been confirmed and its match overlays are visible. Cleared when the search is cancelled or a new search is started.

macros: Vec<MacroSnapshot>

Recorded macros for the active session, in register order. Each entry’s steps is the macro rendered as ActionSpec[] — the same shape editor.executeActions consumes — so a plugin can read a macro and replay or serialise it without crossing the IPC boundary. Refreshed on every snapshot tick; read by editor.listMacros() / editor.getMacro().

Implementations

impl EditorStateSnapshot

pub fn new() -> EditorStateSnapshot

Trait Implementations

impl Clone for EditorStateSnapshot

fn clone(&self) -> EditorStateSnapshot

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EditorStateSnapshot

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

Formats the value using the given formatter.

impl Default for EditorStateSnapshot

fn default() -> EditorStateSnapshot

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for EditorStateSnapshot

fn deserialize<__D>( __deserializer: __D, ) -> Result<EditorStateSnapshot, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for EditorStateSnapshot

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TS for EditorStateSnapshot

type WithoutGenerics = EditorStateSnapshot

If this type does not have generic parameters, then WithoutGenerics should just be Self. If the type does have generic parameters, then all generic parameters must be replaced with a dummy type, e.g ts_rs::Dummy or ().
The only requirement for these dummy types is that EXPORT_TO must be None.

type OptionInnerType = EditorStateSnapshot

If the implementing type is std::option::Option<T>, then this associated type is set to T. All other implementations of TS should set this type to Self instead.

fn ident(cfg: &Config) -> String

Identifier of this type, excluding generic parameters.

fn docs() -> Option<String>

JSDoc comment to describe this type in TypeScript - when TS is derived, docs are automatically read from your doc comments or #[doc = ".."] attributes

fn name(cfg: &Config) -> String

Name of this type in TypeScript, including generic parameters

fn decl_concrete(cfg: &Config) -> String

Declaration of this type using the supplied generic arguments. The resulting TypeScript definition will not be generic. For that, see TS::decl(). If this type is not generic, then this function is equivalent to TS::decl().

fn decl(cfg: &Config) -> String

Declaration of this type, e.g. type User = { user_id: number, ... }. This function will panic if the type has no declaration.

fn inline(cfg: &Config) -> String

Formats this types definition in TypeScript, e.g { user_id: number }. This function will panic if the type cannot be inlined.

fn inline_flattened(cfg: &Config) -> String

Flatten a type declaration. This function will panic if the type cannot be flattened.

fn visit_generics(v: &mut impl TypeVisitor)

where EditorStateSnapshot: 'static,

Iterates over all type parameters of this type.

fn output_path() -> Option<PathBuf>

Returns the output path to where T should be exported, relative to the output directory. The returned path does not include any base directory.

fn visit_dependencies(v: &mut impl TypeVisitor)

where EditorStateSnapshot: 'static,

Iterates over all dependency of this type.

fn dependencies(cfg: &Config) -> Vec<Dependency>

where Self: 'static,

Resolves all dependencies of this type recursively.

fn export(cfg: &Config) -> Result<(), ExportError>

where Self: 'static,

Manually export this type to the filesystem. To export this type together with all of its dependencies, use TS::export_all.

fn export_all(cfg: &Config) -> Result<(), ExportError>

where Self: 'static,

Manually export this type to the filesystem, together with all of its dependencies. To export only this type, without its dependencies, use TS::export.

fn export_to_string(cfg: &Config) -> Result<String, ExportError>

where Self: 'static,

Manually generate bindings for this type, returning a String. This function does not format the output, even if the format feature is enabled.