Wasmtime Wasi

https://docs.rs/wasmtime-wasi/latest
Admin
This crate provides Wasmtime host implementations for different versions of WASI, using Rust crates...
Tokens:487,736
Snippets:4,306
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Execute WASI Command Example

Source: https://docs.rs/wasmtime-wasi/latest/src/wasmtime_wasi/p2/bindings.rs.html?search=

Example setup for executing a WASI command using the asynchronous bindings.

```rust
use wasmtime::{Engine, Result, Store, Config};
use wasmtime::component::{ResourceTable, Linker, Component};
use wasmtime_wasi::{WasiCtx, WasiCtxView, WasiView};
use wasmtime_wasi::p2::bindings::Command;
```

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

### Symlink Operation Setup

Source: https://docs.rs/wasmtime-wasi/latest/src/wasmtime_wasi/filesystem.rs.html

Initial setup for symlink operations, including platform-specific imports.

```rust
pub(crate) async fn symlink_at(
        &self,
        src_path: String,
        dest_path: String,
    ) -> Result<(), ErrorCode> {
        // On windows, Dir.symlink is provided by DirExt
        #[cfg(windows)]
        use cap_fs_ext::DirExt;
```

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

### Test Module Setup

Source: https://docs.rs/wasmtime-wasi/latest/src/wasmtime_wasi/cli.rs.html

Initial setup for the test module used to verify stream functionality.

```rust
#[cfg(test)]
mod test {
    use crate::cli::{AsyncStdoutStream, StdinStream, StdoutStream};
    use crate::p2::{self, OutputStream};
    use bytes::Bytes;
    use tokio::io::AsyncReadExt;
    use wasmtime::Result;

    #[test]
    fn memory_stdin_stream() {
        // A StdinStream has the property that there are multiple
        // InputStreams created, using the stream() method which are each
```

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

### start_listen

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/sockets/tcp/trait.HostTcpSocket.html?search=std%3A%3Avec

Starts listening for incoming connections on a bound socket.

```APIDOC
## start_listen

### Description
Transitions the socket into the listening state. The socket must be explicitly bound before calling this method.

### Parameters
- **self_** (Resource<TcpSocket>) - The socket resource to set to listening mode.

### Returns
- **Result<(), SocketError>** - Returns an empty result on success or a SocketError on failure.
```

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

### Start Listening

Source: https://docs.rs/wasmtime-wasi/latest/src/wasmtime_wasi/sockets/tcp.rs.html?search=u32+-%3E+bool

Transitions a bound socket into the listening state using p2 semantics.

```rust
pub(crate) fn start_listen(&mut self) -> Result<(), ErrorCode> {
        match mem::replace(&mut self.tcp_state, TcpState::Closed) {
            TcpState::Bound(tokio_socket) => {
                self.tcp_state = TcpState::ListenStarted(tokio_socket);
                Ok(())
            }
            previous_state => {
                self.tcp_state = previous_state;
                Err(ErrorCode::InvalidState)
            }
        }
    }
```

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

### Consume Box with Allocator

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/io/streams/type.InputStream.html

Examples demonstrating how to consume a Box into a raw pointer and allocator, with both automatic and manual cleanup strategies.

```rust
#![feature(allocator_api)]

use std::alloc::System;

let x = Box::new_in(String::from("Hello"), System);
let (ptr, alloc) = Box::into_raw_with_allocator(x);
let x = unsafe { Box::from_raw_in(ptr, alloc) };
```

```rust
#![feature(allocator_api)]

use std::alloc::{Allocator, Layout, System};
use std::ptr::{self, NonNull};

let x = Box::new_in(String::from("Hello"), System);
let (ptr, alloc) = Box::into_raw_with_allocator(x);
unsafe {
    ptr::drop_in_place(ptr);
    let non_null = NonNull::new_unchecked(ptr);
    alloc.deallocate(non_null.cast(), Layout::new::<String>());
}
```

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

### Constructing Box from Raw Pointer

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/io/streams/type.InputStream.html

Examples demonstrating how to reconstruct a Box from a raw pointer or manually allocate memory for a Box.

```rust
let x = Box::new(5);
let ptr = Box::into_raw(x);
let x = unsafe { Box::from_raw(ptr) };
```

```rust
use std::alloc::{alloc, Layout};

unsafe {
    let ptr = alloc(Layout::new::<i32>()) as *mut i32;
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `ptr`, though for this
    // simple example `*ptr = 5` would have worked as well.
    ptr.write(5);
    let x = Box::from_raw(ptr);
}
```

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

### instantiate

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/sync/struct.Command.html?search=std%3A%3Avec

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

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

### Description
Convenience wrapper around `CommandPre::new` and `CommandPre::instantiate` to create a new Command instance.

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

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

### instantiate

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/struct.Command.html

Convenience wrapper around CommandPre::new and CommandPre::instantiate to create a new Command instance.

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

### Description
Creates a new Command instance by wrapping CommandPre::new and CommandPre::instantiate.

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

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

### Stream Testing Examples

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

Examples of testing AsyncReadStream behavior with empty and infinite inputs.

```rust
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn empty_read_stream() {
    let mut reader = AsyncReadStream::new(tokio::io::empty());

    match reader.read(10) {
        Err(StreamError::Closed) => {}

        Ok(bs) => {
            assert!(bs.is_empty());
            resolves_immediately(reader.ready()).await;
            assert!(matches!(reader.read(0), Err(StreamError::Closed)));

            resolves_immediately(reader.ready()).await;
            assert!(matches!(reader.read(0), Err(StreamError::Closed)));
            assert!(matches!(reader.read(0), Err(StreamError::Closed)));
        }
        res => panic!("unexpected: {res:?}"),
    }
}

#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn infinite_read_stream() {
    let mut reader = AsyncReadStream::new(tokio::io::repeat(0));

    let bs = reader.read(10).unwrap();
    if bs.is_empty() {
        resolves_immediately(reader.ready()).await;
        let bs = reader.read(10).unwrap();
        assert_eq!(bs.len(), 10);
    } else {
        assert_eq!(bs.len(), 10);
    }

    let bs = reader.read(10).unwrap();
```

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

### Start and Finish TCP Listening

Source: https://docs.rs/wasmtime-wasi/latest/src/wasmtime_wasi/sockets/tcp.rs.html

Transitions the socket state to start listening and finalizes the process by binding to the runtime.

```rust
    pub(crate) fn start_listen(&mut self) -> Result<(), ErrorCode> {
        match mem::replace(&mut self.tcp_state, TcpState::Closed) {
            TcpState::Bound(tokio_socket) => {
                self.tcp_state = TcpState::ListenStarted(tokio_socket);
                Ok(())
            }
            previous_state => {
                self.tcp_state = previous_state;
                Err(ErrorCode::InvalidState)
            }
        }
    }

    pub(crate) fn finish_listen(&mut self) -> Result<(), ErrorCode> {
        let tokio_socket = match mem::replace(&mut self.tcp_state, TcpState::Closed) {
            TcpState::ListenStarted(tokio_socket) => tokio_socket,
            previous_state => {
                self.tcp_state = previous_state;
                return Err(ErrorCode::NotInProgress);
            }
        };

        self.listen_common(tokio_socket)
    }
```

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

### Create a WasiCtx with arguments and environment variables

Source: https://docs.rs/wasmtime-wasi/latest/src/wasmtime_wasi/ctx.rs.html

Initialize a builder, add command-line arguments and environment variables, and finalize the context.

```rust
use wasmtime_wasi::WasiCtx;

let mut wasi = WasiCtx::builder();
wasi.arg("./foo.wasm");
wasi.arg("--help");
wasi.env("FOO", "bar");

let wasi: WasiCtx = wasi.build();
```

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

### Add WASI P1 to Linker with Custom State (Full Example)

Source: https://docs.rs/wasmtime-wasi/latest/src/wasmtime_wasi/p1.rs.html?search=u32+-%3E+bool

A complete example of registering WASI P1 functions when the Linker state is a custom struct containing WasiP1Ctx.

```rust
use wasmtime::{Result, Linker, Engine};
use wasmtime_wasi::p1::{self, WasiP1Ctx};

struct MyState {
    // .. other custom state here ..

    wasi: WasiP1Ctx,
}

fn main() -> Result<()> {
    let engine = Engine::default();

    let mut linker: Linker<MyState> = Linker::new(&engine);
    p1::add_to_linker_async(&mut linker, |cx| &mut cx.wasi)?;

    // ... continue to add more to `linker` as necessary and use it ...

    Ok(())
}
```

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

### get_remote_address

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

Get the remote address of the socket.

```APIDOC
### fn get_remote_address(&mut self, socket: Resource<TcpSocket>) -> SocketResult<IpSocketAddress>

Get the remote address.
```

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

### start_connect

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/sockets/tcp/trait.HostTcpSocket.html?search=std%3A%3Avec

Initiates a connection to a remote endpoint. Transitions the socket to the connected state upon success.

```APIDOC
## start_connect

### Description
Connect to a remote endpoint. On success, the socket is transitioned into the connected state and a pair of streams is returned for communication.

### Parameters
- **self_** (Resource<TcpSocket>) - The socket resource to connect.
- **network** (Resource<Network>) - The network resource to use for the connection.
- **remote_address** (IpSocketAddress) - The destination address.

### Returns
- **Result<(), SocketError>** - Returns an empty result on success or a SocketError on failure.
```

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

### get_type

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

Get the dynamic type of a descriptor.

```APIDOC
## fn get_type(&mut self, fd: Resource<Descriptor>) -> FsResult<DescriptorType> 

### Description
Get the dynamic type of a descriptor.
```

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

### new

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/struct.Command.html?search=

Creates a new Command instance from an existing Instance.

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

### Description
Convenience wrapper around `CommandIndices::new` and `CommandIndices::load`.
```

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

### get_flags

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

Get flags associated with a descriptor.

```APIDOC
## fn get_flags(&mut self, fd: Resource<Descriptor>) -> FsResult<DescriptorFlags> 

### Description
Get flags associated with a descriptor.
```

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

### get_local_address

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

Get the bound local address of the socket.

```APIDOC
### fn get_local_address(&mut self, socket: Resource<TcpSocket>) -> SocketResult<IpSocketAddress>

Get the bound local address.
```

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

### instantiate_async

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/struct.Command.html

Asynchronous convenience wrapper around CommandPre::new and CommandPre::instantiate_async.

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

### Description
Asynchronously creates a new Command instance.

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

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

### send_buffer_size

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/sockets/udp/trait.HostUdpSocket.html

Gets or sets the send buffer size.

```APIDOC
## fn send_buffer_size(self_: Resource<UdpSocket>) -> Result<u64, SocketError>
## fn set_send_buffer_size(self_: Resource<UdpSocket>, value: u64) -> Result<(), SocketError>

### Description
Manages the kernel buffer space reserved for sends.
```

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

### Directory Initialization

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

Creates a new Dir instance with specified permissions and blocking configuration.

```rust
pub fn new(
    dir: cap_std::fs::Dir,
    perms: DirPerms,
    file_perms: FilePerms,
    open_mode: OpenMode,
    allow_blocking_current_thread: bool,
) -> Self {
    Dir {
        dir: Arc::new(dir),
        perms,
        file_perms,
        open_mode,
        allow_blocking_current_thread,
    }
}
```

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

### receive_buffer_size

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/sockets/udp/trait.HostUdpSocket.html

Gets or sets the receive buffer size.

```APIDOC
## fn receive_buffer_size(self_: Resource<UdpSocket>) -> Result<u64, SocketError>
## fn set_receive_buffer_size(self_: Resource<UdpSocket>, value: u64) -> Result<(), SocketError>

### Description
Manages the kernel buffer space reserved for receives. Setting a value of 0 results in an `invalid-argument` error.
```

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

### Executing Components with CommandPre

Source: https://docs.rs/wasmtime-wasi/latest/src/wasmtime_wasi/p2/bindings.rs.html?search=

Demonstrates front-loading component instantiation using CommandPre for improved performance.

```rust
use wasmtime::{Engine, Result, Store, Config};
use wasmtime::component::{ResourceTable, Linker, Component};
use wasmtime_wasi::{WasiCtx, WasiCtxView, WasiView};
use wasmtime_wasi::p2::bindings::sync::CommandPre;

// This example is an example shim of executing a component based on the
// command line arguments provided to this program.
fn main() -> Result<()> {
    let args = std::env::args().skip(1).collect::<Vec<_>>();

    // Configure and create `Engine`
    let engine = Engine::default();

    // Configure a `Linker` with WASI, compile a component based on
    // command line arguments, and then pre-instantiate it.
    let mut linker = Linker::<MyState>::new(&engine);
    wasmtime_wasi::p2::add_to_linker_sync(&mut linker)?;
    let component = Component::from_file(&engine, &args[0])?;
    let pre = CommandPre::new(linker.instantiate_pre(&component)?)?;


    // Configure a `WasiCtx` based on this program's environment. Then
    // build a `Store` to instantiate into.
    let mut builder = WasiCtx::builder();
    builder.inherit_stdio().inherit_env().args(&args);
    let mut store = Store::new(
        &engine,
        MyState {
            ctx: builder.build(),
            table: ResourceTable::new(),
        },
    );

    // Instantiate the component and we're off to the races.
    let command = pre.instantiate(&mut store)?;
    let program_result = command.wasi_cli_run().call_run(&mut store)?;
    match program_result {
        Ok(()) => Ok(()),
        Err(()) => std::process::exit(1),
    }
}

struct MyState {
    ctx: WasiCtx,
    table: ResourceTable,
}

impl WasiView for MyState {
    fn ctx(&mut self) -> WasiCtxView<'_> {
        WasiCtxView { ctx: &mut self.ctx, table: &mut self.table }
    }
}
```

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

### CommandPre::instantiate

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/sync/struct.CommandPre.html?search=std%3A%3Avec

Instantiates the pre-compiled component within the provided store.

```APIDOC
## CommandPre::instantiate

### Description
Instantiates the component into the provided store, returning a handle to the command interface.

### Signature
`pub fn instantiate(&self, store: &mut Store<T>) -> Result<Command>`

### Parameters
- **store** (&mut Store<T>) - The store to instantiate the component into.
```

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

### arg

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

Appends a single argument to get passed to wasm.

```APIDOC
### pub fn arg(&mut self, arg: impl AsRef<str>) -> &mut Self

Appends a single argument to get passed to wasm.
```

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

### CommandPre::instantiate

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/sync/struct.CommandPre.html?search=u32+-%3E+bool

Instantiates the pre-compiled component within the provided store.

```APIDOC
## CommandPre::instantiate

### Description
Instantiates the component using the provided store. This returns the `Command` interface which can then be used to invoke exported functions.

### Signature
`pub fn instantiate(&self, store: &mut Store<T>) -> Result<Command>`
```

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

### unicast_hop_limit

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/sockets/udp/trait.HostUdpSocket.html?search=std%3A%3Avec

Gets or sets the unicast hop limit (TTL).

```APIDOC
## unicast_hop_limit(self: Resource<UdpSocket>) -> Result<u8, SocketError>
## set_unicast_hop_limit(self: Resource<UdpSocket>, value: u8) -> Result<(), SocketError>

### Description
Gets or sets the unicast hop limit (TTL). Setting a value of 0 results in an `invalid-argument` error.
```

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

### Apply File Advice

Source: https://docs.rs/wasmtime-wasi/latest/src/wasmtime_wasi/filesystem/unix.rs.html

Provides platform-specific file advice hints to the kernel.

```rust
pub(crate) fn advise(file: impl AsFd, offset: u64, len: u64, advice: Advice) -> io::Result<()> {
    cfg_if::cfg_if! {
        if #[cfg(target_vendor = "apple")] {
            match advice {
                Advice::WillNeed => {
                    rustix::fs::fcntl_rdadvise(file, offset, len)?;
                }
                Advice::Normal |
                Advice::Sequential |
                Advice::Random |
                Advice::DontNeed |
                Advice::NoReuse => {}
            }
        } else if #[cfg(any(target_os = "linux", target_os = "android"))] {
            use std::num::NonZeroU64;
            let advice = match advice {
                Advice::Normal => rustix::fs::Advice::Normal,
                Advice::Sequential => rustix::fs::Advice::Sequential,
                Advice::Random => rustix::fs::Advice::Random,
                Advice::WillNeed => rustix::fs::Advice::WillNeed,
                Advice::DontNeed => rustix::fs::Advice::DontNeed,
                Advice::NoReuse => rustix::fs::Advice::NoReuse,
            };
            rustix::fs::fadvise(file, offset, NonZeroU64::new(len), advice)?;
        } else {
            // noop on other platforms
            let _ = (file, offset, len, advice);
        }
    }
    Ok(())
}
```

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

### send_buffer_size

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/sockets/udp/trait.HostUdpSocket.html?search=std%3A%3Avec

Gets or sets the kernel send buffer size.

```APIDOC
## fn send_buffer_size(&mut self, self_: Resource<UdpSocket>) -> Result<u64, SocketError>
## fn set_send_buffer_size(&mut self, self_: Resource<UdpSocket>, value: u64) -> Result<(), SocketError>

### Description
Gets or sets the kernel buffer space reserved for sends on this socket. Equivalent to the SO_SNDBUF socket option.
```

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

### unicast_hop_limit

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/sockets/udp/trait.HostUdpSocket.html?search=u32+-%3E+bool

Gets the current unicast hop limit (TTL).

```APIDOC
## unicast_hop_limit

### Description
Returns the current TTL or hop limit value for the socket.

### Parameters
- **self_** (Resource<UdpSocket>) - The socket resource.

### Returns
- **Result<u8, SocketError>** - The hop limit value.
```

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

### File::new

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/filesystem/struct.File.html?search=

Creates a new File instance with specified permissions and open mode.

```APIDOC
## pub fn new(file: File, perms: FilePerms, open_mode: OpenMode, allow_blocking_current_thread: bool) -> Self

### Description
Constructs a new File wrapper for the provided operating system file, applying the specified permissions and open mode.

### Parameters
- **file** (File) - The underlying operating system file.
- **perms** (FilePerms) - Permissions to enforce on access to the file.
- **open_mode** (OpenMode) - The mode the file was opened under.
- **allow_blocking_current_thread** (bool) - Flag indicating if blocking operations are allowed on the current thread.
```

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

### unicast_hop_limit

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/sockets/udp/trait.HostUdpSocket.html?search=

Gets or sets the unicast hop limit for the socket.

```APIDOC
## fn unicast_hop_limit(&mut self, self_: Resource<UdpSocket>) -> Result<u8, SocketError>
## fn set_unicast_hop_limit(&mut self, self_: Resource<UdpSocket>, value: u8) -> Result<(), SocketError>

### Description
Gets or sets the unicast hop limit. Equivalent to the IP_TTL and IPV6_UNICAST_HOPS socket options.

### Typical Errors
- **invalid-argument**: (set) The TTL value must be 1 or higher.
```

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

### Executing a component with Command

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/struct.Command.html

Demonstrates instantiating and running a component using the Command binding in an asynchronous context.

```rust
use wasmtime::{Engine, Result, Store, Config};
use wasmtime::component::{ResourceTable, Linker, Component};
use wasmtime_wasi::{WasiCtx, WasiCtxView, WasiView};
use wasmtime_wasi::p2::bindings::Command;

// This example is an example shim of executing a component based on the
// command line arguments provided to this program.
#[tokio::main]
async fn main() -> Result<()> {
    let args = std::env::args().skip(1).collect::<Vec<_>>();

    // Configure and create `Engine`
    let engine = Engine::default();

    // Configure a `Linker` with WASI, compile a component based on
    // command line arguments, and then pre-instantiate it.
    let mut linker = Linker::<MyState>::new(&engine);
    wasmtime_wasi::p2::add_to_linker_async(&mut linker)?;
    let component = Component::from_file(&engine, &args[0])?;


    // Configure a `WasiCtx` based on this program's environment. Then
    // build a `Store` to instantiate into.
    let mut builder = WasiCtx::builder();
    builder.inherit_stdio().inherit_env().args(&args);
    let mut store = Store::new(
        &engine,
        MyState {
            ctx: builder.build(),
            table: ResourceTable::new(),
        },
    );

    // Instantiate the component and we're off to the races.
    let command = Command::instantiate_async(&mut store, &component, &linker).await?;
    let program_result = command.wasi_cli_run().call_run(&mut store).await?;
    match program_result {
        Ok(()) => Ok(()),
        Err(()) => std::process::exit(1),
    }
}

struct MyState {
    ctx: WasiCtx,
    table: ResourceTable,
}

impl WasiView for MyState {
    fn ctx(&mut self) -> WasiCtxView<'_> {
        WasiCtxView { ctx: &mut self.ctx, table: &mut self.table }
    }
}
```

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

### Result::is_err Implementation

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/type.SocketResult.html

Example of checking if a Result is the Err variant.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_err(), false);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_err(), true);
```

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

### Execute a WASI component with CommandPre

Source: https://docs.rs/wasmtime-wasi/latest/src/wasmtime_wasi/p2/bindings.rs.html?search=

Shows how to use CommandPre to front-load instantiation work, which is useful for performance optimization.

```rust
use wasmtime::{Engine, Result, Store};
use wasmtime::component::{ResourceTable, Linker, Component};
use wasmtime_wasi::{WasiCtx, WasiCtxView, WasiView};
use wasmtime_wasi::p2::bindings::CommandPre;

// This example is an example shim of executing a component based on the
// command line arguments provided to this program.
#[tokio::main]
async fn main() -> Result<()> {
    let args = std::env::args().skip(1).collect::<Vec<_>>();

    // Configure and create `Engine`
    let engine = Engine::default();

    // Configure a `Linker` with WASI, compile a component based on
    // command line arguments, and then pre-instantiate it.
    let mut linker = Linker::<MyState>::new(&engine);
    wasmtime_wasi::p2::add_to_linker_async(&mut linker)?;
    let component = Component::from_file(&engine, &args[0])?;
    let pre = CommandPre::new(linker.instantiate_pre(&component)?)?;


    // Configure a `WasiCtx` based on this program's environment. Then
    // build a `Store` to instantiate into.
    let mut builder = WasiCtx::builder();
    builder.inherit_stdio().inherit_env().args(&args);
    let mut store = Store::new(
        &engine,
        MyState {
            ctx: builder.build(),
            table: ResourceTable::new(),
        },
    );

    // Instantiate the component and we're off to the races.
    let command = pre.instantiate_async(&mut store).await?;
    let program_result = command.wasi_cli_run().call_run(&mut store).await?;
    match program_result {
        Ok(()) => Ok(()),
        Err(()) => std::process::exit(1),
    }
}

struct MyState {
    ctx: WasiCtx,
    table: ResourceTable,
}

impl WasiView for MyState {
    fn ctx(&mut self) -> WasiCtxView<'_> {
        WasiCtxView { ctx: &mut self.ctx, table: &mut self.table }
    }
}
```

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

### Using WasiFilesystem with Linker

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

Demonstrates how to use the WasiFilesystem helper struct when adding WASI filesystem bindings to a Wasmtime Linker.

```rust
use wasmtime::component::{Linker, ResourceTable};
use wasmtime::{Engine, Result};
use wasmtime_wasi::filesystem::*;

struct MyStoreState {
    table: ResourceTable,
    filesystem: WasiFilesystemCtx,
}

fn main() -> Result<()> {
    let engine = Engine::default();
    let mut linker = Linker::new(&engine);

    wasmtime_wasi::p2::bindings::filesystem::types::add_to_linker::<MyStoreState, WasiFilesystem>(
        &mut linker,
        |state| WasiFilesystemCtxView {
            table: &mut state.table,
            ctx: &mut state.filesystem,
        },
    )?;
    Ok(())
}
```

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

### Result::is_ok Implementation

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/type.SocketResult.html

Example of checking if a Result is the Ok variant.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);
```

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

### Result::is_ok and is_err Implementation

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/type.FsResult.html?search=

Examples of checking the variant of a Result.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);
```

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_err(), false);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_err(), true);
```

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

### Command::instantiate_async

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/struct.Command.html

Instantiates a component as a Command asynchronously using a store, component, and linker.

```APIDOC
## Command::instantiate_async

### Description
Instantiates a component as a Command asynchronously. This is the most convenient way to create a Command instance.

### Signature
`pub async fn instantiate_async<T>(store: &mut Store<T>, component: &Component, linker: &Linker<T>) -> Result<Command>`

### Parameters
- **store** (&mut Store<T>) - The Wasmtime store to instantiate into.
- **component** (&Component) - The compiled component to instantiate.
- **linker** (&Linker<T>) - The linker configured with WASI bindings.
```

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

### Result::flatten Implementation

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/type.FsResult.html?search=

Examples of flattening nested Result types.

```rust
let x: Result<Result<&'static str, u32>, u32> = Ok(Ok("hello"));
assert_eq!(Ok("hello"), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));
assert_eq!(Err(6), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Err(6);
assert_eq!(Err(6), x.flatten());
```

```rust
let x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok("hello")));
assert_eq!(Ok(Ok("hello")), x.flatten());
assert_eq!(Ok("hello"), x.flatten().flatten());
```

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

### instantiate

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/struct.Command.html?search=

Synchronously instantiates a Command from a component and linker.

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

### Description
Convenience wrapper around `CommandPre::new` and `CommandPre::instantiate` to create a new Command instance.
```

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

### as_mut

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/type.DynFuture.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets a mutable reference to the pinned value this Pin points to.

```APIDOC
## pub fn as_mut(&mut self) -> Pin<&mut <Ptr as Deref>::Target>

### Description
Gets a mutable reference to the pinned value this `Pin<Ptr>` points to. This is useful when doing multiple calls to functions that consume the pinning pointer.
```

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

### InputFile::new

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/cli/struct.InputFile.html

Creates a new InputFile instance from a standard file.

```APIDOC
## pub fn new(file: File) -> Self

### Description
Creates a new `InputFile` instance that reads directly from the provided `File`.

### Parameters
- **file** (File) - Required - The file object to read from.
```

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

### as_ref

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/type.DynFuture.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets a shared reference to the pinned value this Pin points to.

```APIDOC
## pub fn as_ref(&self) -> Pin<&<Ptr as Deref>::Target>

### Description
Gets a shared reference to the pinned value this `Pin` points to. This is a safe method to go from `&Pin<Pointer<T>>` to `Pin<&T>`.
```

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

### Command::instantiate

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/sync/struct.Command.html?search=

Instantiates a component as a Command using a store, component, and linker.

```APIDOC
## Command::instantiate

### Description
Creates a new `Command` instance from a `Component` and a `Linker` within the provided `Store`.

### Signature
`pub fn instantiate(store: &mut Store<T>, component: &Component, linker: &Linker<T>) -> Result<Command>`
```

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

### create_directory_at

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

Create a directory.

```APIDOC
## fn create_directory_at(&mut self, fd: Resource<Descriptor>, path: String) -> FsResult<()> 

### Description
Create a directory.
```

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

### send_buffer_size

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/sync/sockets/udp/trait.HostUdpSocket.html?search=std%3A%3Avec

Gets the kernel buffer size reserved for sending on this socket.

```APIDOC
## send_buffer_size

### Description
Returns the kernel buffer space reserved for sends. Equivalent to SO_SNDBUF.

### Parameters
- **self_** (Resource<UdpSocket>) - Required - The socket resource.

### Returns
- **Result<u64, SocketError>** - The buffer size.
```

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

### instantiate_async

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/sync/struct.Command.html

Asynchronously creates a new Command instance.

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

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

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

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

### receive_buffer_size

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/sync/sockets/udp/trait.HostUdpSocket.html?search=std%3A%3Avec

Gets the kernel buffer size reserved for receiving on this socket.

```APIDOC
## receive_buffer_size

### Description
Returns the kernel buffer space reserved for receives. Equivalent to SO_RCVBUF.

### Parameters
- **self_** (Resource<UdpSocket>) - Required - The socket resource.

### Returns
- **Result<u64, SocketError>** - The buffer size.
```

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

### CommandPre::new

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/struct.CommandPre.html?search=std%3A%3Avec

Creates a new copy of CommandPre bindings from an InstancePre, which can then be used to instantiate into a particular store.

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

### Description
Creates a new copy of `CommandPre` 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.
```

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

### unicast_hop_limit

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/sync/sockets/udp/trait.HostUdpSocket.html?search=std%3A%3Avec

Gets the current unicast hop limit (TTL) for the socket.

```APIDOC
## unicast_hop_limit

### Description
Returns the current unicast hop limit (TTL). Equivalent to IP_TTL and IPV6_UNICAST_HOPS.

### Parameters
- **self_** (Resource<UdpSocket>) - Required - The socket resource.

### Returns
- **Result<u8, SocketError>** - The hop limit value.
```

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

### CommandPre::instantiate_async

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/struct.CommandPre.html

Asynchronously instantiates a new Command within the provided store.

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

An asynchronous version of the `instantiate` method for creating a `Command` instance.
```

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

### receive_buffer_size

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/sockets/udp/trait.HostUdpSocket.html

Gets or sets the kernel receive buffer size for the socket.

```APIDOC
## fn receive_buffer_size(&mut self, self_: Resource<UdpSocket>) -> Result<u64, SocketError>
## fn set_receive_buffer_size(&mut self, self_: Resource<UdpSocket>, value: u64) -> Result<(), SocketError>

### Description
Manages the kernel buffer space reserved for receives. Setting a value of 0 returns an `invalid-argument` error; other values may be clamped or rounded by the system.
```

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

### Command::instantiate

Source: https://docs.rs/wasmtime-wasi/latest/src/wasmtime_wasi/p2/bindings.rs.html

Instantiates a WASI component using a provided store, component, and linker. This is the primary entry point for running a WASI command synchronously.

```APIDOC
## Command::instantiate

### Description
Instantiates a WASI component into the provided store using the specified linker. This method prepares the component for execution within the WASI environment.

### Signature
`pub fn instantiate(store: &mut Store<T>, component: &Component, linker: &Linker<T>) -> Result<Command>`

### Parameters
- **store** (&mut Store<T>) - The Wasmtime store to instantiate the component into.
- **component** (&Component) - The compiled WASI component to instantiate.
- **linker** (&Linker<T>) - The linker configured with WASI host functions.

### Returns
- **Result<Command>** - Returns the instantiated Command object or an error if instantiation fails.
```

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

### unicast_hop_limit

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/sockets/udp/trait.HostUdpSocket.html

Gets or sets the unicast hop limit (TTL) for the socket.

```APIDOC
## fn unicast_hop_limit(&mut self, self_: Resource<UdpSocket>) -> Result<u8, SocketError>
## fn set_unicast_hop_limit(&mut self, self_: Resource<UdpSocket>, value: u8) -> Result<(), SocketError>

### Description
Gets or sets the unicast hop limit, equivalent to IP_TTL or IPV6_UNICAST_HOPS. Setting a value of 0 will return an `invalid-argument` error.
```

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

### Result::is_ok_and Implementation

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/type.FsResult.html?search=

Example of checking if a Result is Ok and matches a predicate.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.is_ok_and(|x| x > 1), true);

let x: Result<u32, &str> = Ok(0);
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<u32, &str> = Err("hey");
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<String, &str> = Ok("ownership".to_string());
assert_eq!(x.as_ref().is_ok_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

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

### Command::instantiate_async

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

Asynchronously instantiates a component that implements the command world.

```APIDOC
## Command::instantiate_async

### Description
Instantiates a component that implements the `wasi:cli/command` world. This is the primary method for setting up the command execution environment.

### Signature
`async fn instantiate_async<T>(store: &mut Store<T>, component: &Component, linker: &Linker<T>) -> Result<Command>`

### Parameters
- **store** (&mut Store<T>) - The store to instantiate the component into.
- **component** (&Component) - The compiled component to instantiate.
- **linker** (&Linker<T>) - The linker used to satisfy imports.
```

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

### Result::transpose Implementation

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/type.FsResult.html?search=

Example of transposing a Result of an Option into an Option of a Result.

```rust
#[derive(Debug, Eq, PartialEq)]
struct SomeErr;

let x: Result<Option<i32>, SomeErr> = Ok(Some(5));
let y: Option<Result<i32, SomeErr>> = Some(Ok(5));
assert_eq!(x.transpose(), y);
```

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

### CommandPre::new

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/struct.CommandPre.html?search=

Creates a new CommandPre instance from a pre-instantiated component instance.

```APIDOC
### CommandPre::new

#### Signature
`pub fn new(pre: InstancePre<T>) -> Result<CommandPre<T>>`

#### Description
Creates a new `CommandPre` structure from an `InstancePre` that has been created through a `Linker`.
```

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

### TrappableError::downcast_ref

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/struct.TrappableError.html

Attempts to get a reference to the contained error as a specific type.

```APIDOC
### pub fn downcast_ref(&self) -> Option<&T>

Returns an `Option<&T>` containing a reference to the internal error if it can be downcasted to type `T`.
```

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

### CommandPre::new

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

Creates a new CommandPre instance from a pre-instantiated component instance.

```APIDOC
## CommandPre::new

### Description
Creates a new `CommandPre` instance using a pre-instantiated component instance created through a `Linker`.

### Signature
`pub fn new(instance: InstancePre<T>) -> Result<CommandPre<T>>`
```

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

### as_deref_mut

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/type.DynFuture.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets Pin<&mut T> to the underlying pinned value from this nested Pin-pointer.

```APIDOC
## pub fn as_deref_mut(self: Pin<&mut Pin<Ptr>>) -> Pin<&mut <Ptr as Deref>::Target>

### Description
Gets `Pin<&mut T>` to the underlying pinned value from this nested `Pin`-pointer. This is a generic method to go from `Pin<&mut Pin<Pointer<T>>>` to `Pin<&mut T>`.
```

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

### CommandPre::instantiate_async

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/struct.CommandPre.html?search=

Instantiates the pre-compiled component asynchronously.

```APIDOC
### CommandPre::instantiate_async

#### Signature
`pub async fn instantiate_async<T>(&self, store: &mut Store<T>) -> Result<Command>`

#### Description
Instantiates the component using the provided store, returning a `Command` instance that can be used to execute the component's functions.
```

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

### try_get_u64

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/sync/io/streams/type.InputStream.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets an unsigned 64-bit integer from the stream in big-endian byte order.

```APIDOC
## fn try_get_u64(&mut self) -> Result<u64, TryGetError>

### Description
Gets an unsigned 64 bit integer from `self` in big-endian byte order.
```

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

### CommandPre::instantiate

Source: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/p2/bindings/struct.CommandPre.html?search=u32+-%3E+bool

Instantiates a new instance of Command within the provided store.

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

Instantiates a new instance of `Command` within the `store` provided. This function uses `self` as the pre-instantiated instance to perform instantiation and looks up exports on the resulting instance.
```
Tokens:
Raw