Struct Bootloader 

pub struct Bootloader { /* private fields */ }

A thin bootloader over LoadSession for a single-library product binary.

// `my-server ARGS...` boots exactly like `sim serve ARGS...`, dispatching the
// library's `cli/main/serve` entrypoint. No Cx::new in the binary.
let code = Bootloader::standard()
    .host_verb("serve", "lib/my-server", || Box::new(MyServeLib::new()))
    .run(std::iter::once("serve".into()).chain(std::env::args_os().skip(1)))?;
std::process::exit(code);

Implementations

impl Bootloader

pub fn standard() -> Self

The standard boot session: the in-process host loader only, matching the default sim binary. Add libraries with Bootloader::host_verb.

pub fn configure_session( self, configure: impl FnOnce(LoadSession) -> LoadSession, ) -> Self

Applies a reusable host composition to the underlying load session.

Product libraries use this when a standalone product binary and the standard sim distribution must install exactly the same host factories, capabilities, context support, and runtime configuration.

pub fn host_verb<F>(self, verb: &str, name: &str, factory: F) -> Self

where F: Fn() -> Box<dyn Lib> + Send + Sync + 'static,

Registers a statically-linked library under name and makes it the default source for verb, so a bare <verb> ARGS... dispatches to the library’s cli/main/<verb> entrypoint with no explicit --load.

The library must be a LibTarget::HostRegistered lib that exports a cli/main/<verb> function (see crate::cli_main_entrypoint_symbol).

pub fn host_verb_with_config<F>( self, verb: &str, name: &str, config_libs: Vec<Symbol>, factory: F, ) -> Self

where F: Fn(&RuntimeConfigState) -> Box<dyn Lib> + Send + Sync + 'static,

Registers a statically-linked library under name, makes it the default source for verb, and reads the supplied config library ids before the host library is instantiated.

pub fn host_lib<F>(self, name: &str, factory: F) -> Self

where F: Fn() -> Box<dyn Lib> + Send + Sync + 'static,

Registers a statically-linked library under name WITHOUT binding it to a verb – for a supporting library the served verb needs, most commonly the boot codec (register it under codec/<name> and pass --codec <name> so the boot resolves the host codec instead of the default).

pub fn with_capability(self, capability: CapabilityName) -> Self

Grants a capability the served library requires (for example a transport or tool-call capability).

pub fn with_context<F>(self, configure: F) -> Self

where F: FnOnce(&mut Cx),

Installs context-level runtime support into the boot Cx before dispatch (e.g. a codec, an eval policy, a supporting lib). Concrete serve behavior stays in the loaded library.

pub fn run<I, S>(self, args: I) -> Result<i32, CliError>

where I: IntoIterator<Item = S>, S: Into<OsString>,

Boots the runtime, applies the registered libraries, and dispatches args (typically the process arguments). A blocking serve verb runs to completion here; its returned value becomes the process exit code.