Struct Session 

pub struct Session {

    pub version: u32,
    pub working_dir: PathBuf,
    pub split_layout: SerializedSplitNode,
    pub active_split_id: usize,
    pub split_states: HashMap<usize, SerializedSplitViewState>,
    pub config_overrides: SessionConfigOverrides,
    pub file_explorer: FileExplorerState,
    pub histories: SessionHistories,
    pub search_options: SearchOptions,
    pub bookmarks: HashMap<char, SerializedBookmark>,
    pub terminals: Vec<SerializedTerminalSession>,
    pub external_files: Vec<PathBuf>,
    pub saved_at: u64,
}

Persisted session state for a working directory

Fields

version: u32

Schema version for future migrations

working_dir: PathBuf

Working directory this session belongs to (for validation)

split_layout: SerializedSplitNode

Split layout tree

active_split_id: usize

Active split ID

split_states: HashMap<usize, SerializedSplitViewState>

Per-split view states (keyed by split_id)

config_overrides: SessionConfigOverrides

Editor config overrides (toggles that differ from defaults)

file_explorer: FileExplorerState

File explorer state

histories: SessionHistories

Input histories (search, replace, command palette, etc.)

search_options: SearchOptions

Search options (persist across searches within session)

bookmarks: HashMap<char, SerializedBookmark>

Bookmarks (character key -> file position)

terminals: Vec<SerializedTerminalSession>

Open terminal sessions (for restoration)

external_files: Vec<PathBuf>

External files open in the session (files outside working_dir) These are stored as absolute paths since they can’t be made relative

saved_at: u64

Timestamp when session was saved (Unix epoch seconds)

Implementations

impl Session

pub fn load(working_dir: &Path) -> Result<Option<Session>, SessionError>

Load session for a working directory (if exists)

pub fn save(&self) -> Result<(), SessionError>

Save session to file using atomic write (temp file + rename)

This ensures the session file is never left in a corrupted state:

1. Write to a temporary file in the same directory
2. Sync to disk (fsync)
3. Atomically rename to the final path

pub fn delete(working_dir: &Path) -> Result<(), SessionError>

Delete session for a working directory

pub fn new(working_dir: PathBuf) -> Self

Create a new session with current timestamp

pub fn touch(&mut self)

Update the saved_at timestamp to now

Trait Implementations

impl Clone for Session

fn clone(&self) -> Session

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Session

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Session

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Session

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

where __S: Serializer,

Serialize this value into the given Serde serializer.