Struct StateManager 

pub struct StateManager { /* private fields */ }

Manages cell state persistence and invalidation.

Implementations

impl StateManager

pub fn new(state_dir: impl AsRef<Path>) -> Result<Self>

Create a new state manager with the given state directory.

pub fn save<T: CellOutput>(&mut self, cell_id: CellId, value: &T) -> Result<()>

Save a cell output.

pub fn load<T>(&self, cell_id: CellId) -> Result<T>

where T: CellOutput + Archive, T::Archived: Deserialize<T, Strategy<Pool, Error>>,

Load a cell output.

pub fn get_output(&self, cell_id: CellId) -> Option<Arc<BoxedOutput>>

Get a reference to a cached output without deserializing.

pub fn store_output(&mut self, cell_id: CellId, output: BoxedOutput)

Store a pre-serialized output directly.

Used by the execution engine to store outputs from FFI calls.

pub fn has_output(&self, cell_id: CellId) -> bool

Check if a cell has a cached output.

pub fn invalidate(&mut self, cell_id: CellId)

Invalidate a cell’s output (e.g., when its source changes).

pub fn invalidate_many(&mut self, cell_ids: &[CellId])

Invalidate multiple cells.

pub fn on_cell_modified( &mut self, cell_id: CellId, dependents: &[CellId], ) -> Vec<CellId>

Called when a cell is modified - invalidates it and all dependents.

Returns the list of invalidated cell IDs.

pub fn update_fingerprint( &mut self, cell_id: CellId, new_fingerprint: TypeFingerprint, ) -> SchemaChange

Update the type fingerprint for a cell and check for schema changes.

pub fn flush(&mut self) -> Result<()>

Persist all dirty outputs to disk.

Uses atomic write pattern to prevent partial state corruption. If any write fails, failed cells remain marked as dirty.

pub fn restore(&mut self) -> Result<usize>

Load all cached outputs from disk.

pub fn sync_output_to_salsa( &self, cell_id: CellId, inputs_hash: u64, execution_time_ms: u64, ) -> Option<CellOutputData>

Convert a single cell output to Salsa-compatible format.

Returns None if the cell has no cached output.

Arguments

• cell_id - The cell to export
• inputs_hash - Hash of the cell’s input values (for staleness detection)
• execution_time_ms - How long the cell took to execute

pub fn sync_all_to_salsa<F, G>( &self, cell_count: usize, get_inputs_hash: F, get_execution_time: G, ) -> Vec<ExecutionStatus>

where F: Fn(CellId) -> u64, G: Fn(CellId) -> u64,

Export all outputs to a vector of execution statuses for Salsa.

Creates a vector sized to cell_count where each index corresponds to a cell ID. Cells without outputs are marked as Pending.

Arguments

• cell_count - Total number of cells in the notebook
• get_inputs_hash - Closure to get the inputs hash for each cell
• get_execution_time - Closure to get execution time for each cell (0 if unknown)

pub fn load_from_salsa(&mut self, output_data: &CellOutputData)

Import an output from Salsa’s cached data.

Converts a CellOutputData back to a BoxedOutput and stores it.

pub fn load_all_from_salsa(&mut self, statuses: &[ExecutionStatus]) -> usize

Import all successful outputs from Salsa’s execution statuses.

Returns the number of outputs imported.

pub fn is_salsa_output_valid( &self, cell_id: CellId, _current_inputs_hash: u64, ) -> bool

Check if a Salsa output is still valid for the current inputs.

Note: The StateManager doesn’t store input hashes, so this method only checks if an output exists. For actual validation, use the is_valid_for() method on CellOutputData with the Salsa-cached output.

The _current_inputs_hash parameter is reserved for future use when input hash tracking is added to the StateManager.

pub fn clear(&mut self) -> Result<()>

Clear all state (for testing or reset).

pub fn stats(&self) -> StateStats

Get statistics about the state manager.