A thread-safe reference-counting pointer. ‘Arc’ stands for ‘Atomically
Reference Counted’.
A boolean type which can be safely shared between threads.
An integer type which can be safely shared between threads.
An integer type which can be safely shared between threads.
A cheaply cloneable and sliceable chunk of contiguous memory.
A unique reference to a contiguous slice of memory.
A Condition Variable
The context of an asynchronous task.
A directory entry.
A pair of pipes that are connected together.
A Duration type to represent a span of time, typically used for system
timeouts.
An event that occurred.
The contents of an event for the eventtype::fd_read and
eventtype::fd_write variants
The state of the file descriptor subscribed to with
eventtype::fd_read or eventtype::fd_write.
File descriptor flags.
File descriptor attributes.
Which file time attributes to adjust.
TODO: wit appears to not have support for flags repr
(@witx repr u16)
A WebAssembly function instance.
An opaque reference to a function environment.
The function environment data is owned by the Store.
A WebAssembly global instance.
A
hash map implemented with quadratic probing and SIMD lookup.
A
hash set implemented as a
HashMap where the value is
().
A WebAssembly Instance is a stateful, executable
instance of a WebAssembly
Module.
An IPv4 address.
An IPv6 address.
A thread local storage key which owns its contents.
A WebAssembly memory instance.
Marker trait for 32-bit memories.
Marker trait for 64-bit memories.
A WebAssembly memory view.
A WebAssembly Module contains stateless WebAssembly
code that has already been compiled and can be instantiated
multiple times.
A mutual exclusion primitive useful for protecting shared data
Units of WebAssembly pages (as specified to be 65,536 bytes).
A slice of a path (akin to
str).
A pointer which pins its pointee in place.
A mutable memory location with dynamically checked borrow rules
File descriptor rights, determining which actions may be performed.
A struct representing an aborted instruction execution, with a message
indicating the cause.
The store represents all global state that can be manipulated by
WebAssembly programs. It consists of the runtime representation
of all instances of functions, tables, memories, and globals that
have been allocated during the lifetime of the abstract machine.
An event that occurred.
The contents of an event.
An event that occurred.
The contents of a subscription, snapshot0 version.
The contents of a subscription.
The contents of a subscription when the variant is
eventtype::fd_read or eventtype::fd_write.
A WebAssembly function that can be called natively
(using the Native ABI).
A zero-cost type that represents a pointer to something in Wasm linear
memory.
Reference to an array of values in Wasm memory.
File or memory access pattern advisory information.
Identifiers for clocks.
A clone-on-write smart pointer.
A view into a single entry in a map, which may either be vacant or occupied.
Error codes returned by functions.
Not all of these error codes are returned by the functions provided by this
API; some are used in higher-level library layers, and others are provided
merely for alignment with POSIX.
Type of a subscription to an event or its occurrence.
An Extern is the runtime representation of an entity that
can be imported or exported.
The type of a file descriptor or file.
Error type for external users
The error type for errors that can never happen.
An IP address, either IPv4 or IPv6.
Error for invalid
Memory access.
Error type describing things that can go wrong when operating on Wasm Memories.
After the stack is unwound via asyncify what
should the call loop do next
Atomic memory orderings
Indicates whether a value is available or if the current task has been
scheduled to receive a wakeup instead.
Identifiers for clocks, snapshot0 version.
An internet socket address, either IPv4 or IPv6.
WebAssembly computations manipulate values of basic value types:
Helper trait for a value that is convertible to a [StoreMut].
Helper trait for a value that is convertible to a [StoreRef].
An extension trait that adds utility methods to
AsyncSeek types.
Writes bytes to a sink.
A trait for borrowing data.
Used for immutable dereferencing operations, like *v.
Used for mutable dereferencing operations, like in *v = 1;.
Objects that can be converted into an
Waker. This trait is
automatically implemented for types that fulfill the waker interface.
Such types must be:
Trait for the Memory32 and Memory64 marker types.
The Read trait allows for reading bytes from a source.
The Seek trait provides a cursor which can be moved within a stream of
bytes.
An attempted conversion that consumes self, which may or may not be
expensive.
This trait relies on your file closing when it goes out of scope via Drop
A trait for objects which are byte-oriented sinks.
Asyncify takes the current thread and blocks on the async runtime associated with it
thus allowed for asynchronous operations to execute. It has built in functionality
to (optionally) timeout the IO, force exit the process, callback signals and pump
synchronous IO engine
Asyncify takes the current thread and blocks on the async runtime associated with it
thus allowed for asynchronous operations to execute. It has built in functionality
to (optionally) timeout the IO, force exit the process, callback signals and pump
synchronous IO engine
Asyncify takes the current thread and blocks on the async runtime associated with it
thus allowed for asynchronous operations to execute. It has built in functionality
to (optionally) timeout the IO, force exit the process, callback signals and pump
synchronous IO engine
Performs an immutable operation on the socket while running in an asynchronous runtime
This has built in signal support
Performs mutable work on a socket under an asynchronous runtime with
built in signal processing
Performs an immutable operation on the socket while running in an asynchronous runtime
This has built in signal support
Performs mutable work on a socket under an asynchronous runtime with
built in signal processing
Replaces a socket with another socket in under an asynchronous runtime.
This is used for opening sockets or connecting sockets which changes
the fundamental state of the socket to another state machine
Puts the process to deep sleep and wakes it again when
the supplied future completes
Exponentially increasing backoff of CPU usage
Writes data to the stderr
Reinterprets the bits of a value of one type as another type.