Struct ExtismLoader 

pub struct ExtismLoader { /* private fields */ }

Top-level Extism plugin loader.

Construct one per uni-db instance; the loader owns the HostFnRegistry (capability metadata) and a parallel map of the runtime-callable extism::Functions keyed by host-fn name. The metadata map exists unconditionally so embedders without extism-runtime can still introspect the host-fn surface; the runtime functions only materialize when the SDK feature is on.

Implementations

impl ExtismLoader

pub fn new() -> Self

Construct a fresh loader with an empty host-fn registry.

pub fn host_fns_mut(&mut self) -> &mut HostFnRegistry

Mutable access to the host-fn registry (metadata).

pub fn host_fns(&self) -> &HostFnRegistry

Shared access to the host-fn registry (metadata).

pub fn register_host_function(&mut self, spec: HostFnSpec, function: Function)

Register a host function with both its metadata and its concrete extism::Function implementation.

The function is invocable from any plugin whose effective capability set contains spec.required_capability (or any plugin, if required_capability is None). The capability filter runs at Self::build_plugin time — plugins that don’t pass the filter never see this function in their import table.

pub fn runtime_fn_count(&self) -> usize

Number of registered runtime functions. Diagnostic / test helper.

pub fn with_kms(self, kms: Arc<dyn KmsProvider>) -> Self

Attach a KMS provider backing uni_kms_* (builder style).

Pair with crate::host_svc::register_default_host_svc to register the metadata specs; the concrete functions are built per load with the effective grant set so call-time attenuation is enforced.

pub fn with_secret_store(self, store: Arc<SecretStore>) -> Self

Attach a secret store backing uni_secret_acquire (builder style).

pub fn with_http(self, http: Arc<dyn HttpEgress>) -> Self

Attach an HTTP egress backing uni_http_* (builder style).

pub fn prepare( &self, manifest_json: &[u8], grants: &CapabilitySet, ) -> Result<PreparedExtismPlugin, ExtismError>

Parse a manifest JSON blob (as the plugin’s manifest export returns) and filter the host-fn registry through the granted capability set.

This is the deterministic, sandbox-free portion of the M6a loader path: it doesn’t instantiate any wasm. The host can use the returned PreparedExtismPlugin to decide whether to proceed with full SDK instantiation, prompt the user for additional capability grants, or reject the load outright.

Errors

• ExtismError::ManifestInvalid if the JSON doesn’t parse or doesn’t match ExtismPluginManifest.

pub fn prepare_parsed( &self, manifest: ExtismPluginManifest, grants: &CapabilitySet, ) -> PreparedExtismPlugin

Intersect declared/granted capabilities for an already-parsed manifest, skipping the JSON round-trip.

Self::load reads the manifest export off a bootstrap plugin (parsed ExtismPluginManifest), then needs the combined cap-intersection and host-fn-allow-list result. The previous implementation re-serialized the parsed struct to JSON and called Self::prepare which deserialized it straight back — a wasteful round-trip whose only purpose was reusing the cap-intersection loop. This entry point preserves the loop and skips the (de)serialization.

pub fn build_plugin( &self, bytes: &[u8], prepared: &PreparedExtismPlugin, ) -> Result<Plugin, ExtismError>

Build an extism::Plugin from raw wasm bytes against a prepared capability set.

Capability-gated host functions are filtered through prepared.allowed_host_fns — fns whose required_capability is not in the plugin’s effective set are omitted from the plugin’s import table. This is the Extism analogue of Component Model’s linker absence: the plugin literally cannot resolve an unauthorized host fn at link time. Per proposal §5.6.2 this is the structural half of capability enforcement; the call-time pattern attenuation in each host_svc body (kms_allows / secret_allows / network_allows) is the defense-in-depth half.

Resource limits declared in the parsed manifest are applied to the underlying wasmtime config: memory_max_pages (linear memory cap), timeout_ms (per-call wall-clock), fuel_per_call (instruction budget). If a field is None, the host’s default (no cap) applies.

Errors

• ExtismError::Instantiate if the wasm bytes fail to compile, link, or instantiate (invalid wasm, missing required imports, wasmtime errors).
• ExtismError::Internal if a runtime function recorded in the registry’s allow-list is somehow absent from runtime_fns (should be unreachable; indicates a registry-state bug).

pub fn load( &self, bytes: &[u8], host_grants: &CapabilitySet, registrar: &mut PluginRegistrar<'_>, ) -> Result<LoadOutcome, ExtismError>

End-to-end load: read manifest, intersect with host grants, re-instantiate with effective caps, read register export, push adapters into the supplied uni_plugin::PluginRegistrar.

The two-pass dance is the proposal’s §5.6 contract: the host cannot know what capabilities the plugin needs until it reads the manifest export, and reading that export requires a built plugin. The first pass uses an empty grant set — the manifest export must be implementable without any capability-gated host fn, which is trivially true (it just returns JSON). The second pass rebuilds with the intersected grants and the register export is read against that.

The currently-supported registration kinds are crate::exports::RegistrationEntry::Scalar; aggregate and procedure adapters land in M6a.2. Entries of unsupported kinds cause ExtismError::OutputDecode — better to fail loudly than silently ignore part of a plugin’s surface.

Errors

• ExtismError::Instantiate for wasmtime / extism build failures.
• ExtismError::ManifestInvalid for malformed manifests or unsupported argument types.
• ExtismError::InvalidPlugin if required exports (manifest, register) are missing.
• ExtismError::OutputDecode for malformed register payloads or unsupported entry kinds.
• ExtismError::Internal for PluginRegistrar registration failures (capability / qname conflicts).

Trait Implementations

impl Debug for ExtismLoader

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

Formats the value using the given formatter.

impl Default for ExtismLoader

fn default() -> ExtismLoader

Returns the “default value” for a type.