Struct Engine 

pub struct Engine<P = ShellProcessManager>
where
    P: ProcessManager,
{ /* private fields */ }

Host-extension engine: the single front door for registering Rust functions and types and running scripts against them.

The type parameter selects the process manager: the default DefaultProcessManager runs real subprocesses, while test harnesses pass their mock (Engine::<MockProcessManager>::new_custom() in crates/oxdock-core/tests/integration/custom_types.rs shows the shape). Staged IO applies to every run; the process manager and the filesystem are chosen per run, so one engine serves many roots.

Implementations

impl<P> Engine<P>

where P: ProcessManager,

pub fn new_custom() -> Engine<P>

Empty engine for a custom process manager, with default IO and no host surface. Prefer Engine::new for the default manager: a bare Engine::new() pins the manager type for inference, while this constructor needs the turbofish (Engine::<Mock>::new_custom()). Engine::<P>::default() works the same way.

pub fn with_io(self, io: ExecIo) -> Engine<P>

Stage custom IO (for example inherited environment overrides) for every run. Chainable.

pub fn register_module(&mut self, module: HostModule<P>) -> &mut Engine<P>

Register a host library module: its functions become callable as MODULE::NAME, its types join the run’s name directory. Chainable. Group #[oxdock_func] markers (for example MakeTag for make_tag) with their #[oxdock_type] payloads here. Panics on a duplicate qualified name, including collisions with STD builtins; the registry re-checks at run time for direct state users.

pub fn register_type<T>(&mut self) -> &mut Engine<P>

where T: OxDockType,

Register a #[oxdock_type] payload struct. Chainable. Staged for the run: values mint straight from the payload type’s own descriptor, which needs no registration to exist.

pub fn module_table(&self) -> ModuleTable

Parse-time module table for this engine: stock STD builtins plus every staged host module (function names and RPN eligibility). Unknown modules stay unknown: the oxdock! macro declares its own opaque modules via the modules: prefix instead.

pub fn run_script_on( &self, fs: Box<dyn WorkspaceFs>, script: &str, process: P, ) -> Result<EngineOutput, Error>

Parse and run script on a caller-built filesystem with process as the manager and the registered host surface available.

pub fn run_steps_on( &self, fs: Box<dyn WorkspaceFs>, steps: &[Step], process: P, ) -> Result<EngineOutput, Error>

Run already parsed steps (for example from the oxdock! macro, which builds the same DSL at compile time) on a caller-built filesystem with process as the manager and the registered host surface available.

impl Engine

pub fn new() -> Engine

Empty engine with default IO and no host surface. Concrete by construction, so let mut engine = Engine::new() needs no annotation; custom managers use Engine::<P>::new_custom().

pub fn run_script( &self, root: &GuardedPath, script: &str, ) -> Result<EngineOutput, Error>

Parse and run script with root as the workspace, with the registered host surface available. Uses the default process manager and a resolver built from root.

pub fn run_steps( &self, root: &GuardedPath, steps: &[Step], ) -> Result<EngineOutput, Error>

Run already parsed steps (for example from the oxdock! macro, which builds the same DSL at compile time) with root as the workspace and the registered host surface available. Uses the default process manager and a resolver built from root.

Trait Implementations

impl<P> Default for Engine<P>

where P: ProcessManager,

fn default() -> Engine<P>

Returns the “default value” for a type.