Wasmtime

https://docs.rs/wasmtime/latest/
Admin
Wasmtime is a WebAssembly engine that provides an embedding API for JIT-compiled or ahead-of-time...
Tokens:2,165,995
Snippets:16,803
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Concurrent execution setup example

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/component/concurrent.rs.html?search=u32+-%3E+bool

Example setup for using concurrent features within a Wasmtime store.

```rust
# use {
#   wasmtime::{
#     error::{Result},
#     component::{ Component, Linker, Resource, ResourceTable},
#     Config, Engine, Store
#   },
# };
#
# struct MyResource(u32);
# struct Ctx { table: ResourceTable }
#
# async fn foo() -> Result<()> {
# let mut config = Config::new();
# let engine = Engine::new(&config)?;
```

--------------------------------

### Example setup for concurrent execution

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/component/concurrent.rs.html?search=

Initializes a Wasmtime store and engine configuration for concurrent component operations.

```rust
    /// # Example
    ///
    /// ```
    /// # use {
    /// #   wasmtime::{
    /// #     error::{Result},
    /// #     component::{ Component, Linker, Resource, ResourceTable},
    /// #     Config, Engine, Store
    /// #   },
    /// # };
    /// #
    /// # struct MyResource(u32);
    /// # struct Ctx { table: ResourceTable }
    /// #
    /// # async fn foo() -> Result<()> {
    /// # let mut config = Config::new();
    /// # let engine = Engine::new(&config)?;
```

--------------------------------

### Concurrent Function Call Setup

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/component/concurrent/func.rs.html

Demonstrates the initial setup for using concurrent function calls, including the necessary imports and store configuration.

```rust
# use {
#   wasmtime::{
#     error::{Result},
#     component::{Component, Linker, ResourceTable},
#     Config, Engine, Store
#   },
# };
#
# struct Ctx { table: ResourceTable }
#
# async fn foo() -> Result<()> {
# let mut config = Config::new();
# let engine = Engine::new(&config)?;
```

--------------------------------

### Starting a Concurrent Call

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/component/concurrent/func.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates the setup required to initiate a concurrent function call using an Accessor obtained from StoreContextMut::run_concurrent.

```rust
# use {
#   wasmtime::{
#     error::{Result},
#     component::{Component, Linker, ResourceTable},
#     Config, Engine, Store
#   },
# };
#
# struct Ctx { table: ResourceTable }
#
# async fn foo() -> Result<()> {
# let mut config = Config::new();
# let engine = Engine::new(&config)?;
# let mut store = Store::new(&engine, Ctx { table: ResourceTable::new() });
```

--------------------------------

### InstancePre::instantiate_async

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/instance.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new instance, running the start function asynchronously.

```APIDOC
## pub async fn instantiate_async(&self, mut store: impl AsContextMut<Data = T>) -> Result<Instance>

### Description
Creates a new instance, running the start function asynchronously instead of inline. This requires the `async` feature to be enabled.

### Parameters
- **store** (impl AsContextMut<Data = T>) - The store in which to instantiate the module.

### Errors
- Returns an `OutOfMemory` error if memory allocation fails.

### Panics
- Panics if any import isn't owned by the store or if the store does not have async support enabled.
```

--------------------------------

### Example Usage of RootScope and ExternRef

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/gc/enabled/rooting.rs.html

Demonstrates creating a root scope and rooting an ExternRef.

```rust
    let mut scope = RootScope::new(&mut store);
    let x = ExternRef::new(&mut scope, 1234)?;
    x.to_owned_rooted(&mut scope)?
};

// Place `x` into our store.
*store.data_mut() = Some(x);

// Do a bunch stuff that may or may not access, replace, or take `x`...
# Ok(())
# }
```

--------------------------------

### Define a WIT package

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/component/mod.rs.html

Example WIT package definition for a component world.

```text
package component:my-package;

world my-world {
    import name: func() -> string;
    export greet: func() -> string;
}
```

--------------------------------

### Extracting Ok value with into_ok

Source: https://docs.rs/wasmtime/latest/wasmtime/type.Result.html?search=

Returns the contained Ok value. This example assumes a function returning a Result that can be converted.

```rust
let s: String = only_good_news().into_ok();
println!("{s}");
```

--------------------------------

### Async Start and Sync Start

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/vm/component/libcalls.rs.html

Functions to initiate synchronous or asynchronous component execution.

```rust
#[cfg(feature = "component-model-async")]
unsafe fn sync_start(
    store: &mut dyn VMStore,
    instance: Instance,
    callback: *mut u8,
    storage: *mut u8,
    storage_len: usize,
    callee: *mut u8,
    param_count: u32,
) -> Result<()> {
    unsafe {
        store.component_async_store().sync_start(
            instance,
            callback.cast::<crate::vm::VMFuncRef>(),
            NonNull::new(callee).unwrap().cast::<crate::vm::VMFuncRef>(),
            param_count,
            storage.cast::<core::mem::MaybeUninit<crate::ValRaw>>(),
            storage_len,
        )
    }
}
```

```rust
#[cfg(feature = "component-model-async")]
unsafe fn async_start(
    store: &mut dyn VMStore,
    instance: Instance,
    callback: *mut u8,
    post_return: *mut u8,
    callee: *mut u8,
    param_count: u32,
    result_count: u32,
    flags: u32,
) -> Result<u32> {
    unsafe {
        store.component_async_store().async_start(
            instance,
            callback.cast::<crate::vm::VMFuncRef>(),
            post_return.cast::<crate::vm::VMFuncRef>(),
            NonNull::new(callee).unwrap().cast::<crate::vm::VMFuncRef>(),
            param_count,
            result_count,
            flags,
        )
    }
}
```

--------------------------------

### Instantiating a Hello World Component

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/component/bindgen_examples/mod.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to link and instantiate a simple component using Wasmtime's generated bindings.

```rust
    let mut linker = Linker::new(&engine);
    HelloWorld::add_to_linker::<_, HasSelf<_>>(&mut linker, |state| state)?;

    // As with the core wasm API of Wasmtime instantiation occurs within a
    // `Store`. The bindings structure contains an `instantiate` method which
    // takes the store, component, and linker. This returns the `bindings`
    // structure which is an instance of `HelloWorld` and supports typed access
    // to the exports of the component.
    let mut store = Store::new(
        &engine,
        MyState {
            name: "me".to_string(),
        },
    );
    let bindings = HelloWorld::instantiate(&mut store, &component, &linker)?;

    // Here our `greet` function doesn't take any parameters for the component,
    // but in the Wasmtime embedding API the first argument is always a `Store`.
    bindings.call_greet(&mut store)?;
    Ok(())
}
```

--------------------------------

### HelloWorldPre::instantiate_async

Source: https://docs.rs/wasmtime/latest/src/wasmtime/opt/rustwide/target/debug/build/wasmtime-internal-component-macro-2be6d4360b51bee3/out/hello-world0.rs.html?search=

Asynchronously instantiates a new instance of HelloWorld within the provided store.

```APIDOC
## pub async fn instantiate_async(&self, mut store: impl crate::AsContextMut<Data = _T>) -> crate::Result<HelloWorld>

### Description
An asynchronous version of the `instantiate` method for creating a `HelloWorld` instance.
```

--------------------------------

### Typed Function Invocation Examples

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/component/func.rs.html?search=

Examples demonstrating how to cast a Func to a TypedFunc for type-safe execution.

```rust
# use wasmtime::component::Func;
# use wasmtime::Store;
# fn foo(func: &Func, store: &mut Store<()>) -> wasmtime::Result<()> {
let typed = func.typed::<(), ()>(&store)?;
typed.call(store, ())?;
# Ok(())
# }
```

```rust
# use wasmtime::component::Func;
# use wasmtime::Store;
# fn foo(func: &Func, store: &mut Store<()>) -> wasmtime::Result<()> {
# let typed = func.typed::<(), ()>(&store)?;
# typed.call(store, ())?;
# Ok(())
# }
```

--------------------------------

### HelloWorldPre::instantiate

Source: https://docs.rs/wasmtime/latest/src/wasmtime/opt/rustwide/target/debug/build/wasmtime-internal-component-macro-2be6d4360b51bee3/out/hello-world0.rs.html?search=

Instantiates a new instance of HelloWorld within the provided store.

```APIDOC
## pub fn instantiate(&self, mut store: impl crate::AsContextMut<Data = _T>) -> crate::Result<HelloWorld>

### Description
Instantiates a new instance of `HelloWorld` within the `store` provided. This function uses the pre-instantiated instance to perform instantiation and loads the necessary indices for exports.
```

--------------------------------

### Example of optimized address map entries

Source: https://docs.rs/wasmtime/latest/wasmtime/struct.Module.html

This example shows the optimized version of the address map where redundant entries are removed.

```rust
[
    // ...
    (10, Some(42)),
    (13, Some(43)),
    // ...
]
```

--------------------------------

### HelloWorld::new

Source: https://docs.rs/wasmtime/latest/wasmtime/component/bindgen_examples/_2_world_exports/struct.HelloWorld.html

Creates a new HelloWorld instance from an existing instance.

```APIDOC
## pub fn new(store: impl AsContextMut, instance: &Instance) -> Result<HelloWorld>

### Description
Convenience wrapper around `HelloWorldIndices::new` and `HelloWorldIndices::load` for an already instantiated instance.

### Parameters
- **store** (impl AsContextMut) - Required - The store context.
- **instance** (&Instance) - Required - The already instantiated component instance.
```

--------------------------------

### Create and start a Wasmtime instance

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/instance.rs.html?search=

Internal helper to instantiate a module and execute its start function, handling both synchronous and asynchronous contexts.

```rust
pub(crate) async unsafe fn new_started<T>(
        store: &mut StoreContextMut<'_, T>,
        module: &Module,
        imports: Imports<'_>,
        asyncness: Asyncness,
    ) -> Result<Instance> {
        let instance = {
            let (mut limiter, store) = store.0.resource_limiter_and_store_opaque();
            // SAFETY: the safety contract of `new_raw` is the same as this
            // function.
            unsafe { Instance::new_raw(store, limiter.as_mut(), module, imports).await? }
        };

        // If this instance requires startup, which is a dynamic decision made
        // at this point in conjunction with analysis at compile time, the
        // instance gets started. Note that this isn't just the wasm start
        // function itself, but it's finalization of initialization of this
        // instance, for example for complicated global initialization
        // expressions.
        if instance.id.get_mut(store.0).needs_startup() {
            if asyncness == Asyncness::No {
                instance.start_raw(store)?;
            } else {
                #[cfg(feature = "async")]
                {
                    store.on_fiber(|store| instance.start_raw(store)).await??;
                }
                #[cfg(not(feature = "async"))]
                unreachable!();
            }
        }
        Ok(instance)
    }
```

--------------------------------

### HelloWorldPre::new

Source: https://docs.rs/wasmtime/latest/src/wasmtime/opt/rustwide/target/debug/build/wasmtime-internal-component-macro-2be6d4360b51bee3/out/hello-world0.rs.html?search=

Creates a new copy of HelloWorldPre bindings which can be used to instantiate a component into a store.

```APIDOC
## pub fn new(instance_pre: crate::component::InstancePre<_T>) -> crate::Result<Self>

### Description
Creates a new copy of `HelloWorldPre` bindings which can then be used to instantiate into a particular store. This method may fail if the component behind `instance_pre` does not have the required exports.
```

--------------------------------

### Example of redundant address map entries

Source: https://docs.rs/wasmtime/latest/wasmtime/struct.Module.html

This example illustrates a sequence of address map entries that would be dropped because they map to the same Wasm binary offset.

```rust
[
    // ...
    (10, Some(42)),
    (11, Some(42)),
    (12, Some(42)),
    (13, Some(43)),
    // ...
]
```

--------------------------------

### HelloWorld::instantiate_async

Source: https://docs.rs/wasmtime/latest/wasmtime/component/bindgen_examples/_2_world_exports/struct.HelloWorld.html?search=std%3A%3Avec

Asynchronously instantiates a component that implements the hello-world world.

```APIDOC
## pub async fn instantiate_async<_T>(store: impl AsContextMut<Data = _T>, component: &Component, linker: &Linker<_T>) -> Result<HelloWorld>

### Description
Asynchronous convenience wrapper around HelloWorldPre::new and HelloWorldPre::instantiate_async.

### Parameters
- **store** (impl AsContextMut<Data = _T>) - Required - The store to use for the component instance.
- **component** (&Component) - Required - The compiled component to instantiate.
- **linker** (&Linker<_T>) - Required - The linker used to resolve imports.
```

--------------------------------

### Configure and Access VMStore

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/component/concurrent/tls.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The set function configures the store for a closure, while get retrieves it. Note that get will panic if the store is not set or is already taken.

```rust
pub fn set<R>(store: &mut dyn VMStore, f: impl FnOnce() -> R) -> R {
    let mut storage = SetStorage::Present(NonNull::from(store));
    let _reset = ResetTls(component_async_tls_get());
    tls_set(Some(NonNull::from(&mut storage)));
    return f();

    struct ResetTls(*mut u8);

    impl Drop for ResetTls {
        fn drop(&mut self) {
            component_async_tls_set(self.0);
        }
    }
}
```

```rust
pub fn get<R>(f: impl FnOnce(&mut dyn VMStore) -> R) -> R {
    try_get(|val| match val {
        TryGet::Some(store) => f(store),
        TryGet::None => get_failed(false),
        TryGet::Taken => get_failed(true),
    })
}
```

--------------------------------

### HelloWorldPre::new

Source: https://docs.rs/wasmtime/latest/wasmtime/component/bindgen_examples/_0_hello_world/struct.HelloWorldPre.html

Creates a new instance of HelloWorldPre bindings from a pre-instantiated component.

```APIDOC
## pub fn new(instance_pre: InstancePre<_T>) -> Result<Self>

### Description
Creates a new copy of HelloWorldPre bindings which can then be used to instantiate into a particular store. This method may fail if the component behind instance_pre does not have the required exports.
```

--------------------------------

### Guest Function Wrappers for Get and Set

Source: https://docs.rs/wasmtime/latest/src/wasmtime/opt/rustwide/target/debug/build/wasmtime-internal-component-macro-2be6d4360b51bee3/out/with-exports5.rs.html?search=u32+-%3E+bool

These methods provide safe wrappers for calling the 'get' and 'set' functions on a guest instance using TypedFunc.

```rust
impl Guest {
    pub fn func_get(
        &self,
    ) -> crate::component::TypedFunc<(&str,), (crate::component::__internal::String,)>
    {
        unsafe {
            crate::component::TypedFunc::<(&str, ), (crate::component::__internal::String, )>::new_unchecked(self.get)
        }
    }
    pub fn call_get<S: crate::AsContextMut>(
        &self,
        mut store: S,
        arg0: &str,
    ) -> crate::Result<crate::component::__internal::String> {
        let callee = self.func_get();
        let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?;
        Ok(ret0)
    }
    pub fn func_set(&self) -> crate::component::TypedFunc<(&str, &str), ()> {
        unsafe { crate::component::TypedFunc::<(&str, &str), ()>::new_unchecked(self.set) }
    }
    pub fn call_set<S: crate::AsContextMut>(
        &self,
        mut store: S,
        arg0: &str,
        arg1: &str,
    ) -> crate::Result<()> {
        let callee = self.func_set();
        let () = callee.call(store.as_context_mut(), (arg0, arg1))?;
        Ok(())
    }
}
```

--------------------------------

### HelloWorldPre::new

Source: https://docs.rs/wasmtime/latest/wasmtime/component/bindgen_examples/_0_hello_world/struct.HelloWorldPre.html?search=

Creates a new instance of HelloWorldPre from a pre-instantiated component instance.

```APIDOC
## pub fn new(instance_pre: InstancePre<_T>) -> Result<Self>

### Description
Creates a new copy of `HelloWorldPre` bindings which can then be used to instantiate into a particular store. This method may fail if the component behind `instance_pre` does not have the required exports.
```

--------------------------------

### Configure and Access VMStore Context

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/component/concurrent/tls.rs.html

The set function configures the store for the duration of a closure, while get retrieves it. Recursive calls to get are prevented by the Taken state in SetStorage.

```rust
pub fn set<R>(store: &mut dyn VMStore, f: impl FnOnce() -> R) -> R {
    let mut storage = SetStorage::Present(NonNull::from(store));
    let _reset = ResetTls(component_async_tls_get());
    tls_set(Some(NonNull::from(&mut storage)));
    return f();

    struct ResetTls(*mut u8);

    impl Drop for ResetTls {
        fn drop(&mut self) {
            component_async_tls_set(self.0);
        }
    }
}

pub fn get<R>(f: impl FnOnce(&mut dyn VMStore) -> R) -> R {
    try_get(|val| match val {
        TryGet::Some(store) => f(store),
        TryGet::None => get_failed(false),
        TryGet::Taken => get_failed(true),
    })
}
```

--------------------------------

### HelloWorld::instantiate_async

Source: https://docs.rs/wasmtime/latest/wasmtime/component/bindgen_examples/_2_world_exports/struct.HelloWorld.html?search=

Asynchronously instantiates the component world.

```APIDOC
## pub async fn instantiate_async<_T>(store: impl AsContextMut<Data = _T>, component: &Component, linker: &Linker<_T>) -> Result<HelloWorld>

### Description
Asynchronous convenience wrapper around `HelloWorldPre::new` and `HelloWorldPre::instantiate_async`.

### Parameters
- **store** (impl AsContextMut<Data = _T>) - Required - The store to use for the component instance.
- **component** (&Component) - Required - The compiled component to instantiate.
- **linker** (&Linker<_T>) - Required - The linker used to resolve imports.
```

--------------------------------

### ty

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/gc/enabled/exnref.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Get the type of this exception reference.

```APIDOC
## pub fn ty(&self, store: impl AsContext) -> Result<ExnType>

### Description
Retrieves the `ExnType` associated with this exception reference. Panics if the reference is associated with a different store.

### Parameters
- **store** (impl AsContext) - Required - The store context.

### Returns
- **Result<ExnType>** - The type of the exception.
```

--------------------------------

### ExnRef::ty

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/gc/enabled/exnref.rs.html?search=

Get the type of this reference.

```APIDOC
## pub fn ty(&self, store: impl AsContext) -> Result<ExnType>

### Description
Returns the `ExnType` of this reference. Returns an error if this reference has been unrooted, and panics if this reference is associated with a different store.

### Parameters
- **store** (impl AsContext) - Required - The store context to use for retrieving the type.
```

--------------------------------

### Command Module Instantiation

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/linker.rs.html?search=

Shows the setup for a Command module where a new instance is created for each execution.

```rust
let mut linker = Linker::new(&engine);

// Create a Command that attempts to count the number of times it is run, but is
// foiled by each call getting a new instance.
let wat = r#"
    (module
        (global $counter (mut i32) (i32.const 0))
        (func (export "_start")
```

--------------------------------

### get

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/component/resource_table.rs.html?search=std%3A%3Avec

Retrieves an immutable reference to a resource.

```APIDOC
## get<T>

### Description
Gets an immutable reference to a resource of a given type at the index specified by the resource key.

### Parameters
- **key** (&Resource<T>) - The resource handle.

### Returns
- **Result<&T, ResourceTableError>** - Returns a reference to the resource if the type matches, otherwise returns WrongType error.
```

--------------------------------

### instantiate()

Source: https://docs.rs/wasmtime/latest/wasmtime/component/struct.InstancePre.html

Performs the instantiation process into the provided store.

```APIDOC
### pub fn instantiate(&self, store: impl AsContextMut<Data = T>) -> Result<Instance>

Performs the instantiation process into the store specified. Returns an `OutOfMemory` error if memory allocation fails.
```

--------------------------------

### edit_breakpoints

Source: https://docs.rs/wasmtime/latest/wasmtime/struct.Caller.html?search=u32+-%3E+bool

Starts an edit session to update breakpoints.

```APIDOC
## pub fn edit_breakpoints<'b>(&'b mut self) -> Option<BreakpointEdit<'b>>

### Description
Initiates an edit session to modify breakpoints. This method is only available when the 'debug' crate feature is enabled.

### Returns
- **Option<BreakpointEdit<'b>>** - An optional breakpoint edit session.
```

--------------------------------

### get

Source: https://docs.rs/wasmtime/latest/wasmtime/struct.ArrayRef.html

Retrieves a specific element from the array by index.

```APIDOC
## pub fn get(&self, store: impl AsContextMut, index: u32) -> Result<Val>

### Description
Gets the value at the specified index. i8 and i16 values are zero-extended into Val::I32.

### Parameters
- **store** (impl AsContextMut) - The mutable store context.
- **index** (u32) - The index of the element to retrieve.

### Returns
- **Result<Val>** - The value at the index, or an error if the index is out of bounds.
```

--------------------------------

### HelloWorld::instantiate_async

Source: https://docs.rs/wasmtime/latest/wasmtime/component/bindgen_examples/_2_world_exports/struct.HelloWorld.html

Asynchronous convenience wrapper to instantiate a component within a store using a linker.

```APIDOC
## pub async fn instantiate_async<_T>(store: impl AsContextMut<Data = _T>, component: &Component, linker: &Linker<_T>) -> Result<HelloWorld>

### Description
Asynchronous convenience wrapper around `HelloWorldPre::new` and `HelloWorldPre::instantiate_async` to create a `HelloWorld` instance.

### Parameters
- **store** (impl AsContextMut<Data = _T>) - Required - The store to instantiate the component into.
- **component** (&Component) - Required - The component to instantiate.
- **linker** (&Linker<_T>) - Required - The linker used to resolve imports.
```

--------------------------------

### get

Source: https://docs.rs/wasmtime/latest/wasmtime/struct.ArrayRef.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves a specific element from the array by index.

```APIDOC
## pub fn get(&self, store: impl AsContextMut, index: u32) -> Result<Val>

Gets the element at the specified index. Returns an error if the index is out of bounds.
```

--------------------------------

### HelloWorldPre Methods

Source: https://docs.rs/wasmtime/latest/wasmtime/component/bindgen_examples/_0_hello_world/struct.HelloWorldPre.html

Methods for creating and using pre-instantiated component bindings.

```rust
pub fn new(instance_pre: InstancePre<_T>) -> Result<Self>
```

```rust
pub fn engine(&self) -> &Engine
```

```rust
pub fn instance_pre(&self) -> &InstancePre<_T>
```

```rust
pub fn instantiate( &self, store: impl AsContextMut<Data = _T>, ) -> Result<HelloWorld>
```

```rust
pub async fn instantiate_async( &self, store: impl AsContextMut<Data = _T>, ) -> Result<HelloWorld>
```

--------------------------------

### ref_

Source: https://docs.rs/wasmtime/latest/wasmtime/enum.Val.html

Get this value’s underlying reference, if any.

```APIDOC
### pub fn ref_(self) -> Option<Ref>

Get this value’s underlying reference, if any.
```

--------------------------------

### instantiate

Source: https://docs.rs/wasmtime/latest/wasmtime/component/bindgen_examples/_4_imported_resources/struct.ImportSomeResources.html?search=std%3A%3Avec

Creates a new instance of the component using the provided store, component, and linker.

```APIDOC
## fn instantiate<_T>(store: impl AsContextMut<Data = _T>, component: &Component, linker: &Linker<_T>) -> Result<ImportSomeResources>

### Description
Convenience wrapper around `ImportSomeResourcesPre::new` and `ImportSomeResourcesPre::instantiate` to create a new instance of the component.

### Parameters
- **store** (impl AsContextMut<Data = _T>) - Required - The store to use for the instantiation.
- **component** (&Component) - Required - The compiled component to instantiate.
- **linker** (&Linker<_T>) - Required - The linker used to satisfy imports.
```

--------------------------------

### call_get

Source: https://docs.rs/wasmtime/latest/wasmtime/component/bindgen_examples/_5_all_world_export_kinds/exports/environment/struct.Guest.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Calls the exported 'get' function from the component.

```APIDOC
## pub fn call_get<S: AsContextMut>(&self, store: S, arg0: &str) -> Result<String>

### Description
Invokes the 'get' function exported by the component. It takes a mutable store context and a string argument, returning a Result containing the resulting String.

### Parameters
- **store** (S: AsContextMut) - Required - The mutable context for the Wasmtime store.
- **arg0** (&str) - Required - The input string argument for the function.

### Returns
- **Result<String>** - The result of the function call, containing the returned string on success.
```

--------------------------------

### Initialize Instance Tags

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/vm/instance.rs.html?search=

Sets up tag definitions using signature indices from the module.

```rust
unsafe {
            let offsets = instance.runtime_info.offsets();
            let mut ptr = instance.vmctx_plus_offset_raw(offsets.vmctx_tags_begin());
            for i in 0..module.num_defined_tags() {
                let defined_index = DefinedTagIndex::new(i);
                let tag_index = module.tag_index(defined_index);
                let tag = module.tags[tag_index];
                ptr.write(VMTagDefinition::new(
                    tag.signature.unwrap_engine_type_index(),
                ));
                ptr = ptr.add(1);
            }
        }
```

--------------------------------

### HelloWorld Implementation Methods

Source: https://docs.rs/wasmtime/latest/wasmtime/component/bindgen_examples/_2_world_exports/struct.HelloWorld.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for instantiating and managing the HelloWorld component instance.

```rust
pub fn instantiate<_T>( store: impl AsContextMut<Data = _T>, component: &Component, linker: &Linker<_T>, ) -> Result<HelloWorld>
```

```rust
pub fn new(store: impl AsContextMut, instance: &Instance) -> Result<HelloWorld>
```

```rust
pub async fn instantiate_async<_T>( store: impl AsContextMut<Data = _T>, component: &Component, linker: &Linker<_T>, ) -> Result<HelloWorld>
where _T: Send,
```

```rust
pub fn add_to_linker<T, D>( linker: &mut Linker<T>, host_getter: fn(&mut T) -> D::Data<'_>, ) -> Result<()>
where D: HostWithStore<T>, for<'a> D::Data<'a>: Host, T: 'static,
```

```rust
pub fn demo(&self) -> &Guest
```

--------------------------------

### call_get

Source: https://docs.rs/wasmtime/latest/wasmtime/component/bindgen_examples/_5_all_world_export_kinds/exports/environment/struct.Guest.html

Invokes the 'get' function on the guest component.

```APIDOC
## fn call_get<S: AsContextMut>(&self, store: S, arg0: &str) -> Result<String>

### Description
Calls the 'get' function exported by the guest component.

### Parameters
- **store** (S) - The mutable context for the store.
- **arg0** (&str) - The input string argument.

### Returns
- **Result<String>** - The string result returned by the guest function.
```

--------------------------------

### HelloWorld Convenience Wrappers

Source: https://docs.rs/wasmtime/latest/src/wasmtime/opt/rustwide/target/debug/build/wasmtime-internal-component-macro-2be6d4360b51bee3/out/hello-world2.rs.html?search=u32+-%3E+bool

Provides methods for synchronous and asynchronous instantiation of components and linking host functionality.

```rust
pub fn instantiate<_T>(
            store: impl crate::AsContextMut<Data = _T>,
            component: &crate::component::Component,
            linker: &crate::component::Linker<_T>,
        ) -> crate::Result<HelloWorld> {
            let pre = linker.instantiate_pre(component)?;
            HelloWorldPre::new(pre)?.instantiate(store)
        }

        pub fn new(
            mut store: impl crate::AsContextMut,
            instance: &crate::component::Instance,
        ) -> crate::Result<HelloWorld> {
            let indices = HelloWorldIndices::new(&instance.instance_pre(&store))?;
            indices.load(&mut store, instance)
        }

        pub async fn instantiate_async<_T>(
            store: impl crate::AsContextMut<Data = _T>,
            component: &crate::component::Component,
            linker: &crate::component::Linker<_T>,
        ) -> crate::Result<HelloWorld>
        where
            _T: Send,
        {
            let pre = linker.instantiate_pre(component)?;
            HelloWorldPre::new(pre)?.instantiate_async(store).await
        }

        pub fn add_to_linker<T, D>(
            linker: &mut crate::component::Linker<T>,

            host_getter: fn(&mut T) -> D::Data<'_>,
        ) -> crate::Result<()>
        where
            D: my::project::host::HostWithStore<T>,
            for<'a> D::Data<'a>: my::project::host::Host,
            T: 'static,
        {
            my::project::host::add_to_linker::<T, D>(linker, host_getter)?;
            Ok(())
        }
```

--------------------------------

### get

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/externals/table.rs.html

Retrieves an element from the table at a specific index.

```APIDOC
## pub fn get(&self, mut store: impl AsContextMut, index: u64) -> Option<Ref>

### Description
Returns the table element value at the specified index. Returns None if the index is out of bounds. Panics if the store does not own the table.

### Parameters
- **store** (impl AsContextMut) - Required - The store context.
- **index** (u64) - Required - The index of the element to retrieve.
```

--------------------------------

### get

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/externals/table.rs.html?search=

Retrieves an element from the table at a specific index.

```APIDOC
## pub fn get(&self, mut store: impl AsContextMut, index: u64) -> Option<Ref>

### Description
Returns the table element value at the specified index. Returns None if the index is out of bounds.

### Parameters
- **store** (impl AsContextMut) - Required - The store that owns the table.
- **index** (u64) - Required - The index of the element to retrieve.

### Panics
Panics if the provided store does not own this table.
```

--------------------------------

### Initialize VMContext

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/vm/instance.rs.html?search=

Sets up the VMContext memory, including writing the magic constant and associating the store.

```rust
unsafe fn initialize_vmctx(self: Pin<&mut Self>, store: &StoreOpaque, imports: Imports) {
        let (module, mut instance) = self.module_and_self();

        // SAFETY: the type of the magic field is indeed `u32` and this function
        // is initializing its value.
        unsafe {
            let offsets = instance.runtime_info.offsets();
            instance
                .vmctx_plus_offset_raw::<u32>(offsets.ptr.vmctx_magic())
                .write(VMCONTEXT_MAGIC);
        }

        // SAFETY: it's up to the caller to provide a valid store pointer here.
        unsafe {
            instance.as_mut().set_store(store);
        }
    }
```

--------------------------------

### get

Source: https://docs.rs/wasmtime/latest/wasmtime/trait.CacheStore.html

Retrieves a cached entry associated with the provided key.

```APIDOC
### fn get(&self, key: &[u8]) -> Option<Cow<'_, [u8]>>

#### Description
Try to retrieve an arbitrary cache key entry, and returns a reference to bytes that were inserted via `Self::insert` before.

#### Parameters
- **key** (&[u8]) - The key to look up in the cache.

#### Returns
- **Option<Cow<'_, [u8]>>** - Returns the cached data if found, otherwise None.
```

--------------------------------

### Instantiate and call a component

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/component/mod.rs.html

Demonstrates loading a component, configuring a linker with host functions, and invoking an exported function.

```rust
fn main() -> wasmtime::Result<()> {
    #   if true { return Ok(()) }
    // Instantiate the engine and store
    let engine = wasmtime::Engine::default();
    let mut store = wasmtime::Store::new(&engine, ());

    // Load the component from disk
    let bytes = std::fs::read("my_component.wasm")?;
    let component = wasmtime::component::Component::new(&engine, bytes)?;

    // Configure the linker
    let mut linker = wasmtime::component::Linker::new(&engine);
    // The component expects one import `name` that
    // takes no params and returns a string
    linker
        .root()
        .func_wrap("name", |_store, _params: ()| {
            Ok((String::from("Alice"),))
        })?;

    // Instantiate the component
    let instance = linker.instantiate(&mut store, &component)?;

    // Call the `greet` function
    let func = instance.get_func(&mut store, "greet").expect("greet export not found");
    let mut result = [wasmtime::component::Val::String("".into())];
    func.call(&mut store, &[], &mut result)?;

    // This should print out `Greeting: [String("Hello, Alice!")]`
    println!("Greeting: {:?}", result);

    Ok(())
}
```

--------------------------------

### Initialize and Configure Linker

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/component/linker.rs.html?search=u32+-%3E+bool

Create a new Linker instance and toggle name shadowing behavior.

```rust
pub fn new(engine: &Engine) -> Linker<T> {
    Linker {
        engine: engine.clone(),
        strings: StringPool::default(),
        map: NameMap::default(),
        allow_shadowing: false,
        path: Vec::new(),
        _marker: marker::PhantomData,
    }
}

/// Returns the [`Engine`] this is connected to.
pub fn engine(&self) -> &Engine {
    &self.engine
}

/// Configures whether or not name-shadowing is allowed.
///
/// By default name shadowing is not allowed and it's an error to redefine
/// the same name within a linker.
pub fn allow_shadowing(&mut self, allow: bool) -> &mut Self {
    self.allow_shadowing = allow;
    self
}
```

--------------------------------

### StructRef::field

Source: https://docs.rs/wasmtime/latest/wasmtime/struct.StructRef.html?search=u32+-%3E+bool

Get a specific field value by index.

```APIDOC
## pub fn field(&self, store: impl AsContextMut, index: usize) -> Result<Val>

### Description
Retrieves the value of the field at the specified index.

### Parameters
- **index** (usize) - The index of the field to retrieve.
```

--------------------------------

### Instantiate a Module with Linker

Source: https://docs.rs/wasmtime/latest/src/wasmtime/runtime/linker.rs.html?search=

Demonstrates how to define host functions and instantiate a WebAssembly module using a Linker.

```rust
let mut linker = Linker::new(&engine);
linker.func_wrap("host", "double", |x: i32| x * 2)?;

let wat = r#"
    (module
        (import "host" "double" (func (param i32) (result i32)))
    )
"#;
let module = Module::new(&engine, wat)?;
linker.instantiate(&mut store, &module)?;
```

--------------------------------

### text

Source: https://docs.rs/wasmtime/latest/wasmtime/struct.Module.html

Get the module's compiled executable code.

```APIDOC
## pub fn text(&self) -> &[u8]

### Description
Returns the byte slice representing the module's .text section, which contains the compiled executable code.
```

--------------------------------

### get<T>(key: &Resource<T>)

Source: https://docs.rs/wasmtime/latest/wasmtime/component/struct.ResourceTable.html?search=u32+-%3E+bool

Retrieves an immutable reference to a resource.

```APIDOC
## pub fn get<T: Any + Sized>(&self, key: &Resource<T>) -> Result<&T, ResourceTableError>

### Description
Get an immutable reference to a resource of a given type at a given index.

### Parameters
- **key** (&Resource<T>) - The resource handle to retrieve.

### Returns
- **Result<&T, ResourceTableError>** - An immutable reference to the resource or an error if not found.
```

--------------------------------

### fn greet(&mut self) -> String

Source: https://docs.rs/wasmtime/latest/wasmtime/component/bindgen_examples/_1_world_imports/trait.MyWorldImports.html

Fetches a greeting string from the host implementation.

```APIDOC
### fn greet(&mut self) -> String

#### Description
Fetch a greeting to present.

#### Returns
- **String** - The greeting message provided by the host.
```

--------------------------------

### Compiling and Instantiating a Component

Source: https://docs.rs/wasmtime/latest/wasmtime/struct.CodeBuilder.html?search=u32+-%3E+bool

Example demonstrating the compilation of a component using CodeBuilder and its subsequent instantiation into a store.

```rust
;; Lift the implementation's `main` from a core function to a component function
            ;; and export it!
            (func (export "main")
                (canon lift (core func $instance "main"))
            )
        )
    "#.as_bytes(),
    None,
)?;

// Finish the builder and compile the component.
let component = builder.compile_component()?;

// Create a new `Store<StoreData>`, wrapping a buffer of the given elements.
let mut store = Store::new(&engine, StoreData::new([0, 10, 20, 30, 40, 50]));

// Instantiate our component into the store.
let instance = linker.instantiate(&mut store, &component)?;

// Get the instance's exported `main` function and call it.
instance
    .get_typed_func::<(), ()>(&mut store, "main")?
    .call(&mut store, ())?;

// Our `StoreData`'s buffer had each element incremented directly from Wasm!
assert_eq!(store.data().buf(), &[1, 11, 21, 31, 41, 51]);
```

--------------------------------

### call_get

Source: https://docs.rs/wasmtime/latest/wasmtime/component/bindgen_examples/_5_all_world_export_kinds/exports/environment/struct.Guest.html?search=u32+-%3E+bool

Calls the 'get' function exported by the WebAssembly component.

```APIDOC
## pub fn call_get<S: AsContextMut>(&self, store: S, arg0: &str) -> Result<String>

### Description
Invokes the 'get' function exported by the component, passing a string argument and returning a result containing a String.

### Parameters
- **store** (S: AsContextMut) - Required - The mutable context for the store.
- **arg0** (&str) - Required - The string argument to pass to the component function.

### Response
- **Result<String>** - Returns the string result from the component or an error if the call fails.
```
Tokens:
Raw