Struct ProcessExecutor 

pub struct ProcessExecutor { /* private fields */ }

Process-based executor that runs cells in isolated worker processes.

Unlike LinearExecutor, this executor can truly interrupt cell execution by killing the worker process. This provides:

• Immediate interruption (no need for cooperative checks)
• Crash isolation (panics don’t affect the server)
• Memory isolation (runaway cells can’t OOM the server)

Implementations

impl ProcessExecutor

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

Create a new process executor.

pub fn with_state(state: StateManager) -> Self

Create with an existing state manager.

pub fn with_warm_pool( state_dir: impl AsRef<Path>, pool_size: usize, ) -> Result<Self>

Create with a pre-warmed worker pool.

pub fn set_callback(&mut self, callback: impl ExecutionCallback + 'static)

Set the execution callback for progress reporting.

pub fn set_abort_handle(&mut self, handle: AbortHandle)

Set the abort handle for interruption.

pub fn abort_handle(&self) -> Option<&AbortHandle>

Get the current abort handle.

pub fn register_cell(&mut self, compiled: CompiledCell, dep_count: usize)

Register a compiled cell for execution.

Unlike LinearExecutor::load_cell, this doesn’t actually load the dylib. The worker process will load it when executing.

pub fn unregister_cell(&mut self, cell_id: CellId) -> Option<CompiledCell>

Unregister a cell.

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

Check if a cell is registered.

pub fn execute_cell( &mut self, cell_id: CellId, inputs: &[Arc<BoxedOutput>], ) -> Result<BoxedOutput>

Execute a single cell with the given inputs.

This runs the cell in a worker process that can be killed for interruption.

pub fn execute_cell_with_widgets( &mut self, cell_id: CellId, inputs: &[Arc<BoxedOutput>], widget_values_json: Vec<u8>, ) -> Result<(BoxedOutput, Vec<u8>)>

Execute a single cell with the given inputs and widget values.

This runs the cell in a worker process that can be killed for interruption. Returns the cell output and any registered widget definitions as JSON.

pub fn execute_and_store( &mut self, cell_id: CellId, inputs: &[Arc<BoxedOutput>], ) -> Result<()>

Execute a cell and store the output in the state manager.

pub fn execute_in_order( &mut self, order: &[CellId], deps: &HashMap<CellId, Vec<CellId>>, ) -> Result<()>

Execute cells in the given order, resolving dependencies from state.

pub fn kill_current(&self)

Kill the currently executing cell immediately.

This is the key feature - we can terminate the worker process mid-computation without any cooperation from the cell. This method is thread-safe and can be called from any thread.

pub fn get_kill_handle(&self) -> Option<ExecutorKillHandle>

Get a handle that can be used to kill the current execution from another thread.

Returns None if no execution is in progress. The returned handle is safe to clone and use from any thread.

pub fn abort(&mut self)

Abort execution and kill any running cell.

Sets the abort flag and kills the current worker.

pub fn state(&self) -> &StateManager

Get a reference to the state manager.

pub fn state_mut(&mut self) -> &mut StateManager

Get a mutable reference to the state manager.

pub fn shutdown(&mut self)

Shutdown the executor and all workers.

Trait Implementations

impl Drop for ProcessExecutor

fn drop(&mut self)

Executes the destructor for this type.