wasmcomponentlayer

wasm_component_layer is a runtime agnostic implementation of the WebAssembly component model. It supports loading and linking WASM components, inspecting and generating component interface types at runtime, and more atop any WebAssembly backend. The implementation is based upon the wasmtime, js-component-bindgen, and wit-parser crates.

Usage

To use wasm_component_layer, a runtime is required. The wasm_runtime_layer crate provides the common interface used for WebAssembly runtimes, so when using this crate it must also be added to the Cargo.toml file with the appropriate runtime selected. For instance, the examples in this repository use the wasmi runtime:

toml wasm_component_layer = "0.1.0" wasm_runtime_layer = { version = "0.1.1", features = [ "backend_wasmi" ] }

The following is a small overview of wasm_component_layer's API. The complete example may be found in the examples folder. Consider a WASM component with the following WIT:

```wit package test:guest

interface foo { // Selects the item in position n within list x select-nth: func(x: list, n: u32) -> string }

world guest { export foo } ```

The component can be loaded into wasm_component_layer and invoked as follows:

```rust use wasmcomponentlayer::*;

// The bytes of the component. const WASM: &[u8] = includebytes!("singlecomponent/component.wasm");

pub fn main() { // Create a new engine for instantiating a component. let engine = Engine::new(wasmi::Engine::default());

// Create a store for managing WASM data and any custom user-defined state.
let mut store = Store::new(&engine, ());

// Parse the component bytes and load its imports and exports.
let component = Component::new(&engine, WASM).unwrap();
// Create a linker that will be used to resolve the component's imports, if any.
let linker = Linker::default();
// Create an instance of the component using the linker.
let instance = linker.instantiate(&mut store, &component).unwrap();

// Get the interface that the interface exports.
let interface = instance.exports().instance(&"test:guest/foo".try_into().unwrap()).unwrap();
// Get the function for selecting a list element.
let select_nth = interface.func("select-nth").unwrap().typed::<(Vec<String>, u32), String>().unwrap();

// Create an example list to test upon.
let example = ["a", "b", "c"].iter().map(ToString::to_string).collect::<Vec<_>>();

println!("Calling select-nth({example:?}, 1) == {}", select_nth.call(&mut store, (example.clone(), 1)).unwrap());
// Prints 'Calling select-nth(["a", "b", "c"], 1) == b'

} ```

Features

wasm_component_layer supports the following major features:

• Parsing and instantiating WASM component binaries
• Runtime generation of component interface types
• Specialized list types for faster
• Structural equality of component interface types, as mandated by the spec
• Support for guest resources
• Support for strongly-typed host resources with destructors

The following features have yet to be implemented:

• String transcoders
• A macro for generating host bindings
• More comprehensive tests
• Subtyping