Milky2018/wasmoon_runtime/runtime does not have a README file
AsyncHostFunction
One asynchronous host function registered with a Store.
GcHeap
pub(open) trait GcHeap {
fn alloc_struct(Self, Int, Array[Value]) -> Int raise RuntimeError
fn alloc_array(Self, Int, Array[Value]) -> Int raise RuntimeError
fn struct_get(Self, Int, Int) -> Value raise RuntimeError
fn struct_set(Self, Int, Int, Value) -> Unit raise RuntimeError
fn array_len(Self, Int) -> Int raise RuntimeError
fn array_get(Self, Int, Int) -> Value raise RuntimeError
fn array_set(Self, Int, Int, Value) -> Unit raise RuntimeError
fn array_fill(Self, Int, Int, Value, Int) -> Unit raise RuntimeError
fn array_copy(Self, Int, Int, Int, Int, Int) -> Unit raise RuntimeError
fn get_type_idx(Self, Int) -> Int raise RuntimeError
fn is_valid(Self, Int) -> Bool
}Low-level GC heap interface for object storage
GcManager
pub(open) trait GcManager {
fn alloc_struct(Self, Int, Array[Value]) -> Int raise RuntimeError
fn alloc_array(Self, Int, Array[Value]) -> Int raise RuntimeError
fn struct_get(Self, Int, Int) -> Value raise RuntimeError
fn struct_set(Self, Int, Int, Value) -> Unit raise RuntimeError
fn array_len(Self, Int) -> Int raise RuntimeError
fn array_get(Self, Int, Int) -> Value raise RuntimeError
fn array_set(Self, Int, Int, Value) -> Unit raise RuntimeError
fn array_fill(Self, Int, Int, Value, Int) -> Unit raise RuntimeError
fn array_copy(Self, Int, Int, Int, Int, Int) -> Unit raise RuntimeError
fn get_type_idx(Self, Int) -> Int raise RuntimeError
fn is_valid(Self, Int) -> Bool
fn should_collect(Self) -> Bool
fn collect(Self, Array[Value]) -> Unit
fn stats(Self) -> GcStats
fn write_barrier(Self, Int, Value, Value) -> Unit
}Combined GC manager interface
GcRuntime
pub(open) trait GcRuntime {
fn should_collect(Self) -> Bool
fn collect(Self, Array[Value]) -> Unit
fn force_collect(Self, Array[Value]) -> Unit
fn write_barrier_pre(Self, Int, Value, Value) -> Unit
fn write_barrier_post(Self, Int, Value) -> Unit
fn read_barrier(Self, Int) -> Value
fn stats(Self) -> GcStats
fn collection_count(Self) -> Int
fn set_threshold(Self, Int) -> Unit
fn get_threshold(Self) -> Int
}Runtime GC coordination interface
SegmentDropBinding
pub(open) trait SegmentDropBinding {
fn bind_segment_drop_flags(Self, FixedArray[Bool], FixedArray[Bool]) -> Unit
}A call-scoped sink for the instance's authoritative segment drop flags.
GuestContinuationSignal
pub(all) suberror GuestContinuationSignal {
GuestContinuationYield(GuestContinuationEffect, GuestContinuationBody)
} derive(Debug)GuestContinuationSignal::to_repr
RuntimeError
pub(all) suberror RuntimeError {
UnsupportedHostCapability(String)
HostExit(Int)
StackUnderflow
StackOverflow
TypeMismatch
InvalidModule(String)
ForeignStore
InvalidHandle
StoreClosed
MemoryClosed
InvalidMemoryType(String)
InvalidTableType(String)
HeapRepresentationInUse
OutOfBoundsMemoryAccess
OutOfBoundsTableAccess
OutOfBoundsArrayAccess
UndefinedElement
UninitializedElement
IndirectCallTypeMismatch
DivisionByZero
IntegerOverflow
InvalidConversion
OutOfMemory
InvalidResourceLimit
InvalidExecutionLimit
ExecutionLimitsUnavailable
ExecutionCancelled
ExecutionTimedOut
ExecutionBudgetExceeded
ResourceLimitExceeded(ResourceKind)
TableAllocationOverflow
TableAllocationFailed
MemoryMinimumExceedsLimits(Int64)
AllocationTooLarge
AtomicWaitNonSharedMemory
Unreachable
UncaughtException
CallStackExhausted
UnknownImport(String, String)
LinkError
LinkErrorDetail(String)
CastFailure
NullReference
UnalignedAtomic
InvalidConstantExpression(String)
ContinuationAlreadyConsumed
UnhandledSuspension
UnsupportedGcContinuationStorage
AsyncHostRequiresAsyncCall
AsyncHostCallInProgress
AsyncHostCallCancelled
AsyncHostError(String)
} derive(Eq, Debug)impl Show for RuntimeErrorCustom Show implementation for WebAssembly-spec-compliant error messages
RuntimeError::from_error
Recover a structured runtime error from the language-wide Error type.
This is the single transport boundary used by executors and asynchronous
host-call adapters; unrelated errors return None instead of being
flattened to a string here.
ArrayInstance
Array instance - stores element values and length
impl Show for ArrayInstanceAsyncHostCallDriver
pub struct AsyncHostCallDriver {
// private fields
}Invocation-local owner of one pending asynchronous host operation.
The driver is intentionally opaque. Executors poll it only at an imported
hostcall and wait on it only after the Wasm continuation has been parked.
impl Debug for AsyncHostCallDriverAsyncHostCallDriver::cancel
Cancel the pending host operation, if any.
AsyncHostCallDriver::poll
fn AsyncHostCallDriver::poll(self : AsyncHostCallDriver, func_addr : Int, func : async (Caller, Array[Value]) -> Result[Array[Value], Error], caller : Caller, args : Array[Value]) -> AsyncHostPoll raise RuntimeErrorPoll the operation associated with the current imported call.
The first poll starts the host task. A later poll consumes its result after
wait_pending has returned.
AsyncHostCallDriver::to_repr
AsyncHostCallDriver::wait_pending
Wait without blocking the host thread until the parked host operation can
be consumed by a retry of the same Wasm call site.
AsyncHostPoll
Result of polling the host operation at the current Wasm call site.
CallStackEntry
pub(all) struct CallStackEntry {
func_idx : Int
func_name : String?
}A stack frame entry for error reporting
Caller
Caller context for host functions.
This mirrors Wasmtime's Caller concept at a simpler level:
- store gives access to runtime state (memories, tables, globals, etc.).
- instance is the wasm module instance that called into the host.
Caller::Caller
Caller::get_exported_func_addr
Look up an exported function address from the caller instance.
Caller::get_exported_memory
Look up an exported memory from the caller instance.
ExecutionScope
pub struct ExecutionScope {
// private fields
}A captured execution scope survives suspension. Nested scopes also charge
their parent, so a nested call cannot reset its caller's budget.
impl Debug for ExecutionScopeExecutionScope::check
ExnInstance
Exception instance - represents a caught exception
ExternVal
pub(all) enum ExternVal {
Func(Int)
Table(Int)
Memory(Int)
Global(Int)
Tag(Int)
}External value for imports
Frame
Call frame for function execution
Frame::Frame
Frame::locals_values
Snapshot local values (for GC root collection/debugging)
Frame::set_local
FuncInst
Function instance - either WASM code or host function
FuncOwner
FunctionIdentity
pub struct FunctionIdentity {
// private fields
}One allocation lifetime, independent of a reused function address or code.
GCObject
GC Object representation
Stores either a struct instance or an array instance
GCStats
pub struct GCStats {
total_objects : Int
live_objects : Int
free_slots : Int
collections : Int
bytes_allocated : Int64
bytes_collected : Int64
} derive(Debug)GcRootLease
pub struct GcRootLease {
// private fields
}One Store-owned lease that keeps a snapshot of GC references alive.
Executors use this while an invocation is parked outside an active Wasm
stack. Releasing a lease is idempotent.
GcRootLease::snapshot
Copy the explicit roots owned by this lease for continuation transfer.
GcStats
pub struct GcStats {
total_slots : Int
live_objects : Int
free_slots : Int
collections : Int
bytes_allocated : Int64
bytes_collected : Int64
} derive(Debug)GlobalInstance
Runtime representation of a global variable
GlobalInstance::GlobalInstance
fn GlobalInstance::GlobalInstance(type_ : GlobalType, value : Value) -> GlobalInstance raise RuntimeErrorGlobalInstance::bind_native
GlobalInstance::get_type
Get global type for type checking
GlobalInstance::native_binding
GlobalInstance::set
GuestContinuationBody
pub struct GuestContinuationBody {
run : (GuestContinuationInput) -> Array[Value] raise
cancel : () -> Unit
// private fields
}Engine-owned execution state. The Store owns its cancellation capability.
impl Debug for GuestContinuationBodyGuestContinuationBody::gc_root_leases
Transfer root leases together with engine state when rebinding a body.
GuestContinuationBody::gc_roots
Retained reference roots of an engine-owned continuation.
GuestContinuationBody::new
fn GuestContinuationBody::new(run : (GuestContinuationInput) -> Array[Value] raise, cancel : () -> Unit, roots? : Array[Value], leases? : Array[GcRootLease]) -> GuestContinuationBodyGuestContinuationBody::to_repr
GuestContinuationEffect
GuestContinuationEffect::to_repr
GuestContinuationInput
Delivery at a guest suspension point, including exception injection.
GuestContinuationInput::to_repr
Imports
type ImportsImport object: maps (module_name, name) to external values
Imports::add_func
Imports::add_global
Imports::add_memory
Imports::add_table
Imports::add_tag
Imports::check_store
InstanceAdmission
pub struct InstanceAdmission {
// private fields
}Admission before instance initialization. A token belongs to one Store and
can be consumed once. Cancel unused tokens explicitly; native also releases
them through its last-owner finalizer.
InstanceAdmission::cancel
Return an unused admission, including when the caller retains the token.
InstantiationTransaction
type InstantiationTransactionOne rollback stack shared by every layer of an instantiation.
Participants register inverse operations as they acquire state. Rollback
runs them in reverse order; commit discards them. Both terminal operations
are idempotent.
InstantiationTransaction::commit
InstantiationTransaction::registrar
InstantiationTransaction::rollback
InterpreterLimits
pub struct InterpreterLimits {
max_frames : Int
max_values : Int
max_controls : Int
max_reentry_depth : Int
} derive(Debug)Interpreter budgets per invocation. Values count operand and local slots,
not bytes; control frames include function and structured-control entries.
Host calls and guest-continuation callbacks share a native nesting budget
across interpreter contexts in the same Store.
These limits do not configure JIT stacks or guest linear-memory stacks.
InterpreterLimits::new
fn InterpreterLimits::new(max_frames? : Int, max_values? : Int, max_controls? : Int, max_reentry_depth? : Int) -> InterpreterLimits raise RuntimeErrorLinker
type LinkerLinker for managing multiple module instances and their dependencies
Linker::Linker
Create a new linker with a fresh store
Linker::add_async_host_func
Add an asynchronous host function to the linker.
The function can only be invoked through an asynchronous Wasm call. Its
future is polled while the Wasm continuation is parked.
Linker::add_async_host_func_with_caller
Add an asynchronous host function that receives the caller context.
Linker::add_global
fn Linker::add_global(self : Linker, mod_name : String, name : String, global : GlobalInstance) -> Unit raise RuntimeErrorAdd a global to the linker
Linker::add_host_func
fn Linker::add_host_func(self : Linker, mod_name : String, name : String, func : (Array[Value]) -> Array[Value] raise RuntimeError, func_type? : FuncType) -> Unit raise RuntimeErrorAdd a host function to the linker
This function will be available as an import for all subsequently instantiated modules
Linker::add_host_func_with_caller
fn Linker::add_host_func_with_caller(self : Linker, mod_name : String, name : String, func : (Caller, Array[Value]) -> Array[Value] raise RuntimeError, func_type? : FuncType) -> Unit raise RuntimeErrorAdd a host function that receives the caller context.
Linker::add_memory
fn Linker::add_memory(self : Linker, mod_name : String, name : String, mem : Memory) -> Unit raise RuntimeErrorAdd a memory to the linker
Linker::add_table
fn Linker::add_table(self : Linker, mod_name : String, name : String, table : Table) -> Unit raise RuntimeErrorAdd a table to the linker
Linker::build_imports
Build Imports from all registered modules
This allows a new module to import from any previously registered module
Linker::close
Release this linker's store after all module execution has ended.
This operation is idempotent and terminal.
Linker::get_module
Get a registered module instance by name
Linker::register
fn Linker::register(self : Linker, name : String, instance : ModuleInstance) -> Unit raise RuntimeErrorRegister a module instance with a name
The module's exports will be available as imports for subsequent modules
Linker::register_rollback
Register rollback for core allocations and names added by an instantiation.
MarkSweepHeap
GC Heap - manages all GC objects with mark-sweep garbage collection
impl GcHeap for MarkSweepHeapfn alloc_array(self : MarkSweepHeap, type_idx : Int, elements : Array[Value]) -> Int raise RuntimeErrorfn alloc_struct(self : MarkSweepHeap, type_idx : Int, fields : Array[Value]) -> Int raise RuntimeErrorfn array_copy(self : MarkSweepHeap, dst_idx : Int, dst_offset : Int, src_idx : Int, src_offset : Int, count : Int) -> Unit raise RuntimeErrorfn array_fill(self : MarkSweepHeap, array_idx : Int, offset : Int, value : Value, count : Int) -> Unit raise RuntimeErrorfn array_set(self : MarkSweepHeap, array_idx : Int, elem_idx : Int, value : Value) -> Unit raise RuntimeErrorfn struct_set(self : MarkSweepHeap, struct_idx : Int, field_idx : Int, value : Value) -> Unit raise RuntimeErrorimpl GcManager for MarkSweepHeapfn alloc_array(self : MarkSweepHeap, type_idx : Int, elements : Array[Value]) -> Int raise RuntimeErrorfn alloc_struct(self : MarkSweepHeap, type_idx : Int, fields : Array[Value]) -> Int raise RuntimeErrorfn array_copy(self : MarkSweepHeap, dst_idx : Int, dst_offset : Int, src_idx : Int, src_offset : Int, count : Int) -> Unit raise RuntimeErrorfn array_fill(self : MarkSweepHeap, array_idx : Int, offset : Int, value : Value, count : Int) -> Unit raise RuntimeErrorfn array_set(self : MarkSweepHeap, array_idx : Int, elem_idx : Int, value : Value) -> Unit raise RuntimeErrorfn struct_set(self : MarkSweepHeap, struct_idx : Int, field_idx : Int, value : Value) -> Unit raise RuntimeErrorfn write_barrier(_self : MarkSweepHeap, _obj_idx : Int, _old_value : Value, _new_value : Value) -> Unitimpl GcRuntime for MarkSweepHeapfn write_barrier_pre(_self : MarkSweepHeap, _obj_idx : Int, _old_value : Value, _new_value : Value) -> UnitMarkSweepHeap::MarkSweepHeap
Create a new empty GC heap
MarkSweepHeap::alloc_array
fn MarkSweepHeap::alloc_array(self : MarkSweepHeap, type_idx : Int, elements : Array[Value]) -> Int raise RuntimeErrorAllocate an array instance and return its reference index
MarkSweepHeap::alloc_struct
fn MarkSweepHeap::alloc_struct(self : MarkSweepHeap, type_idx : Int, fields : Array[Value]) -> Int raise RuntimeErrorAllocate a struct instance and return its reference index
MarkSweepHeap::array_copy
fn MarkSweepHeap::array_copy(self : MarkSweepHeap, dst_idx : Int, dst_offset : Int, src_idx : Int, src_offset : Int, count : Int) -> Unit raise RuntimeErrorCopy elements between arrays
MarkSweepHeap::array_fill
fn MarkSweepHeap::array_fill(self : MarkSweepHeap, array_idx : Int, offset : Int, value : Value, count : Int) -> Unit raise RuntimeErrorFill array elements with a value
MarkSweepHeap::array_get
fn MarkSweepHeap::array_get(self : MarkSweepHeap, array_idx : Int, elem_idx : Int) -> Value raise RuntimeErrorGet an array element value
MarkSweepHeap::array_len
Get array length
MarkSweepHeap::array_set
fn MarkSweepHeap::array_set(self : MarkSweepHeap, array_idx : Int, elem_idx : Int, value : Value) -> Unit raise RuntimeErrorSet an array element value
MarkSweepHeap::close
Release all objects and quota capacity. Closing is terminal and idempotent.
MarkSweepHeap::collect
Perform a full garbage collection cycle
Returns the number of objects collected
MarkSweepHeap::collection_count
MarkSweepHeap::force_collect
MarkSweepHeap::get
Get an object by reference index
MarkSweepHeap::get_array
Get an array instance by reference index
MarkSweepHeap::get_struct
Get a struct instance by reference index
MarkSweepHeap::get_threshold
Get the current GC threshold
MarkSweepHeap::get_type_idx
Get the type index of an object
MarkSweepHeap::is_alive
Check if an object index is valid and alive
MarkSweepHeap::is_valid
Check if an object reference is valid and alive
MarkSweepHeap::length
Get total number of allocated objects (including free slots)
MarkSweepHeap::mark
Mark an object as reachable (and recursively mark referenced objects)
MarkSweepHeap::mark_roots
Mark all objects reachable from the given roots
MarkSweepHeap::read_barrier
MarkSweepHeap::set_threshold
Set the GC threshold
MarkSweepHeap::should_collect
Check if GC should be triggered based on allocation count
MarkSweepHeap::struct_get
fn MarkSweepHeap::struct_get(self : MarkSweepHeap, struct_idx : Int, field_idx : Int) -> Value raise RuntimeErrorGet a struct field value
MarkSweepHeap::struct_set
fn MarkSweepHeap::struct_set(self : MarkSweepHeap, struct_idx : Int, field_idx : Int, value : Value) -> Unit raise RuntimeErrorSet a struct field value
MarkSweepHeap::sweep
Sweep phase: collect all unmarked objects
MarkSweepHeap::with_threshold
fn MarkSweepHeap::with_threshold(threshold : Int, resource_budget? : ResourceBudget?) -> MarkSweepHeapCreate a new GC heap with custom threshold
MarkSweepHeap::write_barrier
fn MarkSweepHeap::write_barrier(_self : MarkSweepHeap, _obj_idx : Int, _old_value : Value, _new_value : Value) -> UnitMarkSweepHeap::write_barrier_post
fn MarkSweepHeap::write_barrier_post(_self : MarkSweepHeap, _obj_idx : Int, _new_value : Value) -> UnitMarkSweepHeap::write_barrier_pre
fn MarkSweepHeap::write_barrier_pre(_self : MarkSweepHeap, _obj_idx : Int, _old_value : Value, _new_value : Value) -> UnitMemory
Memory::Memory
fn Memory::Memory(min : Int, max : Int?, is_memory64? : Bool, is_shared? : Bool, page_size_log2? : Int, resource_budget? : ResourceBudget?) -> Memory raise RuntimeErrorMemory::atomic_compare_exchange
fn Memory::atomic_compare_exchange(self : Memory, offset : Int64, width : Int, expected : Int64, replacement : Int64) -> Int64 raise RuntimeErrorMemory::atomic_load
Memory::atomic_notify
Memory::atomic_rmw
fn Memory::atomic_rmw(self : Memory, operation : AtomicRmwOp, offset : Int64, width : Int, value : Int64) -> Int64 raise RuntimeErrorMemory::atomic_store
fn Memory::atomic_store(self : Memory, offset : Int64, width : Int, value : Int64) -> Unit raise RuntimeErrorMemory::atomic_wait_begin
fn Memory::atomic_wait_begin(self : Memory, offset : Int64, width : Int, expected : Int64, timeout : Int64) -> NativeAtomicWait raise RuntimeErrorRegister a wait without blocking the embedding thread. The returned owner
keeps the native shared memory live until cancellation or finalization.
Memory::copy
Copy memory within the same memory instance
Handles overlapping regions correctly
Memory::copy_at
fn Memory::copy_at(self : Memory, destination : Int64, source : Int64, length : Int64) -> Unit raise RuntimeErrorMemory::copy_from
fn Memory::copy_from(self : Memory, destination : Int64, source : Memory, source_offset : Int64, length : Int64) -> Unit raise RuntimeErrorCopy bytes after checking both ranges, including zero-length copies.
Native memmove also handles aliases imported under different memory indices.
Memory::desc_ptr
Retain the native memory descriptor.
Existing handles stay live across Store close; closed Memory aliases return
an empty handle and reject further access through the Memory API.
Memory::fill
Fill memory region with a byte value
Memory::fill_at
fn Memory::fill_at(self : Memory, destination : Int64, value : Byte, length : Int64) -> Unit raise RuntimeErrorMemory::from_type
fn Memory::from_type(ty : MemoryType, resource_budget? : ResourceBudget?) -> Memory raise RuntimeErrorAllocate a validated module memory without narrowing its page limits.
Memory::get_limits
Legacy 32-bit page counts. Maxima wider than 32 bits are omitted.
Use get_limits64 for module type compatibility.
Memory::get_limits64
Return the full logical page limits for module import compatibility.
Memory::grow64
Grow by an unsigned memory64 page count; negative bit patterns cannot fit.
Memory::init_data
Initialize memory with data segment
Memory::init_data_at
fn Memory::init_data_at(self : Memory, destination : Int64, data : Bytes) -> Unit raise RuntimeErrorMemory::load_byte_at
Memory::load_f32_at
Memory::load_f64_at
Memory::load_i32_16s
Memory::load_i32_16s_at
Load 16-bit signed integer, sign-extend to i32
Memory::load_i32_16u
Memory::load_i32_16u_at
Load 16-bit unsigned integer, zero-extend to i32
Memory::load_i32_8s
Memory::load_i32_8s_at
Load 8-bit signed integer, sign-extend to i32
Memory::load_i32_8u
Memory::load_i32_8u_at
Load 8-bit unsigned integer, zero-extend to i32
Memory::load_i32_at
Memory::load_i64_16s
Memory::load_i64_16s_at
Load 16-bit signed integer, sign-extend to i64
Memory::load_i64_16u
Memory::load_i64_16u_at
Load 16-bit unsigned integer, zero-extend to i64
Memory::load_i64_32s
Memory::load_i64_32s_at
Load 32-bit signed integer, sign-extend to i64
Memory::load_i64_32u
Memory::load_i64_32u_at
Load 32-bit unsigned integer, zero-extend to i64
Memory::load_i64_8s
Memory::load_i64_8s_at
Load 8-bit signed integer, sign-extend to i64
Memory::load_i64_8u
Memory::load_i64_8u_at
Load 8-bit unsigned integer, zero-extend to i64
Memory::load_i64_at
Memory::new_guarded_memory0
fn Memory::new_guarded_memory0(min : Int, max : Int?, is_shared? : Bool) -> Memory raise RuntimeErrorMemory::read_byte
Read a byte from memory (non-raising version for WASI)
Memory::read_bytes
Read bytes from memory (non-raising version for WASI)
Memory::read_i32
Read i32 from memory (non-raising version for WASI)
Memory::read_i64
Read i64 from memory (non-raising version for WASI)
Memory::store_byte
Memory::store_byte_at
Memory::store_f32
Memory::store_f32_at
Memory::store_f64
Memory::store_f64_at
Memory::store_i32
Memory::store_i32_16
Memory::store_i32_16_at
Store low 16 bits of i32
Memory::store_i32_8
Memory::store_i32_8_at
Store low 8 bits of i32
Memory::store_i32_at
Memory::store_i64
Memory::store_i64_16
Memory::store_i64_16_at
Store low 16 bits of i64
Memory::store_i64_32
Memory::store_i64_32_at
Store low 32 bits of i64
Memory::store_i64_8
Memory::store_i64_8_at
Store low 8 bits of i64
Memory::store_i64_at
Memory::write_byte
Write a byte to memory (non-raising version for WASI)
Memory::write_i32
Write i32 to memory (non-raising version for WASI)
ModuleInstance
pub struct ModuleInstance {
types : ReadOnlyArray[SubType]
type_rec_groups : ReadOnlyArray[Int]
canonical_type_indices : ReadOnlyArray[Int]
func_addrs : ReadOnlyArray[Int]
func_type_indices : ReadOnlyArray[Int]
table_addrs : ReadOnlyArray[Int]
mem_addrs : ReadOnlyArray[Int]
global_addrs : ReadOnlyArray[Int]
tag_addrs : ReadOnlyArray[Int]
exports : ReadOnlyArray[Export]
elem_segments : ReadOnlyArray[Element]
data_segments : ReadOnlyArray[Data]
// private fields
} derive(Debug)Runtime instance of a WebAssembly module
impl Show for ModuleInstanceKeep Show behavior while migrating from deprecated derive(Show) to
derive(Debug).
ModuleInstance::bind_native_segments
fn[T : SegmentDropBinding] ModuleInstance::bind_native_segments(self : ModuleInstance, context : T) -> UnitNative integration: bind the instance's drop state without exposing mutable arrays.
ModuleInstance::data_dropped
ModuleInstance::drop_data
ModuleInstance::drop_element
Retire evaluated element values as well as their guest-visible availability.
ModuleInstance::element_dropped
ModuleInstance::element_value
fn ModuleInstance::element_value(self : ModuleInstance, segment : Int, index : Int) -> Value raise RuntimeErrorRead one evaluated element without copying a segment during bulk initialization.
ModuleInstance::element_values
fn ModuleInstance::element_values(self : ModuleInstance, index : Int) -> ReadOnlyArray[Value] raise RuntimeErrorModuleInstance::output
ModuleInstance::validated_array_type_at
The array type at idx, in an instance whose module passed validation.
ModuleInstance::validated_func_type_at
The function type at idx, in an instance whose module passed validation.
ModuleInstance::validated_struct_type_at
The struct type at idx, in an instance whose module passed validation.
NativeGlobalBinding
pub(all) struct NativeGlobalBinding {
address : Int64
root : () -> Value
read : () -> Value raise RuntimeError
write : (Value) -> Unit raise RuntimeError
release : () -> Unit
}Shared native storage for one store global, independent of module indices.
impl Debug for NativeGlobalBindingNativeGlobalBinding::to_repr
ResourceBudget
Aggregate quotas shared by explicitly related Stores. Units are logical
resource sizes, not process RSS. A reservation survives its Store when an
independently retained native allocation still owns it.
ResourceBudget::native_quota
A low-level native allocator capability. Callers must retain reservations
for the complete allocation lifetime; ordinary embedders use Store APIs.
ResourceBudget::new
fn ResourceBudget::new(compilation_depth? : Int, memory_bytes? : Int64, table_elements? : Int64, gc_bytes? : Int64, gc_objects? : Int64, instances? : Int64, code_bytes? : Int64, pending_work? : Int64, input_bytes? : Int64, compilation_units? : Int64) -> ResourceBudget raise RuntimeErrorResourceBudget::reserve
fn ResourceBudget::reserve(self : ResourceBudget, kind : ResourceKind, amount : Int64) -> ResourceLease raise RuntimeErrorReserve before side effects. Copies share one reservation and release once.
ResourceBudget::used
ResourceKind
Units admitted by one explicitly shared embedding budget.
ResourceLease
ResourceLease::resize
Resize an explicitly owned work reservation before the next unit of work.
Failure preserves the previous charge. Closed reservations cannot be reused.
RollbackRegistrar
type RollbackRegistrarRollbackRegistrar::on_finish
RollbackRegistrar::on_rollback
RootedValue
pub struct RootedValue {
// private fields
}An embedding value with Store provenance and an explicit GC root lifetime.
On native, MoonBit RC retires the root when this value is dropped. On wasm,
explicitly close it (normally with defer). Close invalidates all aliases;
Store.close also retires outstanding roots.
Primitive values can be passed between Stores.
RootedValue::scalar
Read a scalar without exposing Store-local reference indices.
RuntimeCapabilities
pub struct RuntimeCapabilities {
version : String
interpreter : Bool
jit : Bool
simd : Bool
relaxed_simd : Bool
reference_types : Bool
function_references : Bool
tail_call : Bool
exception_handling : Bool
gc : Bool
memory64 : Bool
multi_memory : Bool
component_model : Bool
wasi_preview1 : Bool
threads : Bool
}Structured capability snapshot.
RuntimeErrorContext
pub struct RuntimeErrorContext {
error : RuntimeError
call_stack : Array[CallStackEntry]
instruction : String?
func_idx : Int?
}Runtime error with additional context for debugging
impl Show for RuntimeErrorContextRuntimeErrorContext::RuntimeErrorContext
RuntimeErrorContext::format
Format the runtime error with full context for display
RuntimeErrorContext::output
RuntimeErrorContext::to_string
RuntimeErrorContext::with_call_stack
fn RuntimeErrorContext::with_call_stack(self : RuntimeErrorContext, stack : Array[CallStackEntry]) -> RuntimeErrorContextRuntimeErrorContext::with_func_idx
RuntimeErrorContext::with_instruction
fn RuntimeErrorContext::with_instruction(self : RuntimeErrorContext, instr : String) -> RuntimeErrorContextRuntimeFeature
pub(all) enum RuntimeFeature {
Interpreter
JIT
SIMD
RelaxedSIMD
ReferenceTypes
FunctionReferences
TailCall
ExceptionHandling
GC
Memory64
MultiMemory
ComponentModel
WasiPreview1
Threads
}Capability key for generic feature checks.
Stack
@types.Value stack for operands
Stack::active_values
Snapshot currently live stack values [0, sp)
Stack::pop_n
Pop n values from the stack, returning them in order (first popped is last in array)
Stack::reserve
Count frame locals against the same budget as live operand slots.
Store
pub struct Store {
nan_canonicalization : Bool
interpreter_limits : InterpreterLimits
resource_budget : ResourceBudget?
native_execution : NativeExecutionState
// private fields
} derive(Debug)The store contains all global runtime state
Store::Store
fn Store::Store(nan_canonicalization? : Bool, interpreter_limits? : InterpreterLimits, resource_budget? : ResourceBudget?) -> Store raise RuntimeErrorStore::admit_module_work
Temporarily admit validation or compilation of a caller-owned AST.
Store::alloc_array
fn Store::alloc_array(self : Store, type_idx : Int, elements : Array[Value], instance? : ModuleInstance) -> Int raise RuntimeErrorAllocate an array instance and return its reference index
Store::alloc_array_repeated
fn Store::alloc_array_repeated(self : Store, type_idx : Int, length : Int, value : Value, instance? : ModuleInstance) -> Int raise RuntimeErrorAllocate a repeated array without constructing an unadmitted temporary array.
Store::alloc_async_host_func
Allocate an asynchronous host function with its type.
Store::alloc_async_host_func_with_caller
Allocate an asynchronous host function that receives the caller context.
Store::alloc_exn
Allocate an exception instance and return its index
Store::alloc_func
fn Store::alloc_func(self : Store, module_ : ValidatedModule, index : Int) -> Int raise RuntimeErrorAllocate a WASM function with its type
Store::alloc_global
Store::alloc_host_func
fn Store::alloc_host_func(self : Store, func : (Array[Value]) -> Array[Value] raise RuntimeError, func_type? : FuncType, type_idx? : Int) -> Int raise RuntimeErrorAllocate a host function with its type
Store::alloc_host_func_with_caller
fn Store::alloc_host_func_with_caller(self : Store, func : (Caller, Array[Value]) -> Array[Value] raise RuntimeError, func_type? : FuncType, type_idx? : Int) -> Int raise RuntimeErrorAllocate a host function that receives the caller context.
Import shared memory with ownership independent of the source Store.
Closing either Store invalidates only its own Memory handle.
Store::alloc_struct
fn Store::alloc_struct(self : Store, type_idx : Int, fields : Array[Value], instance? : ModuleInstance) -> Int raise RuntimeErrorAllocate a struct instance and return its reference index
Store::alloc_table
Allocate a table in the store
Always creates a corresponding JIT table for cross-module sharing
Store::alloc_tag
Allocate a tag with its type (params from FuncType, results ignored)
Store::array_copy
fn Store::array_copy(self : Store, dst_idx : Int, dst_offset : Int, src_idx : Int, src_offset : Int, count : Int) -> Unit raise RuntimeErrorCopy elements between arrays
Store::array_fill
fn Store::array_fill(self : Store, array_idx : Int, offset : Int, value : Value, count : Int) -> Unit raise RuntimeErrorFill array elements with a value
Store::array_get
Get an array element value
Store::array_len
Get array length
Store::array_set
fn Store::array_set(self : Store, array_idx : Int, elem_idx : Int, value : Value) -> Unit raise RuntimeErrorSet an array element value
Store::begin_gc_tracing
Install the Store visitor only while native execution or a collection needs
it. A permanent native closure would create a Store/heap reference cycle.
Store::bind_native_callable_view
Publish the complete Store type universe to all installed callable contexts.
Store::borrow_rooted_value
Low-level execution bridge. Checks provenance and lease before revealing an index.
Store::borrow_typed_rooted_value
fn Store::borrow_typed_rooted_value(self : Store, value : RootedValue, instance : ModuleInstance, expected : ValueType) -> Value raise RuntimeErrorValidate typed continuation transfer as well as Store/root identity.
Store::check_instance
Store::check_instance_admission
fn Store::check_instance_admission(self : Store, admission : InstanceAdmission, validated? : ValidatedModule) -> Unit raise RuntimeErrorStore::close
Release resources owned by this store and break host-function reference
cycles.
This operation is idempotent and terminal. Every native invocation must
have returned or been cancelled before the store is closed.
Store::collect_garbage
Reclaim unreachable objects and temporary reference handles.
Host Values held outside guest execution must be pinned or supplied here.
Store::collect_roots
Collect the transitive object roots of this Store and explicit host roots.
Store::decode_module
Bound binary decoding before expanded locals/type vectors are allocated.
The returned AST belongs to the caller; its lifetime is not charged to the
Store. Instantiation separately admits and retains its compilation units.
Store::decode_native_exception
Store::enable_c_heap
Enable C heap for this store
Store::encode_native_exception
Store::end_gc_tracing
Balance begin_gc_tracing even when native execution traps or suspends.
Store::enter_interpreter_boundary
Reserve a native callback boundary before entering host or continuation code.
Store::func_type_is_subtype
fn Store::func_type_is_subtype(self : Store, address : Int, instance : ModuleInstance, expected : Int) -> BoolStore::function_identity
Low-level handle support: retain an allocation's identity without its closure.
Store::gc_type_is_subtype
fn Store::gc_type_is_subtype(self : Store, reference : Int, instance : ModuleInstance, expected : Int) -> BoolStore::get_c_heap_ptr
Get the C heap pointer (for JIT)
Store::get_exn
Get an exception instance by index
Store::get_func
Get function code for a store address that is known to refer to a Wasm function.
Store::get_func_canonical_type_idx
Get canonical type index for a function by store address
Returns the canonical type index from the function's owning module
Returns -1 if the function or owner is not found
Store::get_func_inst
Store::get_func_inst_opt
Get function instance by store address (returns None if out of range).
This is useful for embedding/JIT callbacks that must not raise.
Store::get_func_owner
Get the owning module instance for a function address
Store::get_func_owner_idx
Get the owning module instance index for a function address
Returns -1 if no owner (host function or unowned)
Store::get_func_type
Get function type by store address
Store::get_func_type_idx
Get function type index by store address (for structural comparison)
Store::get_func_type_opt
Get function type by store address (returns None if out of range).
This is useful for embedding/JIT callbacks that must not raise.
Store::get_gc_stats
Get GC statistics for the C heap
Returns (size, capacity, object_count, total_allocations, total_collections)
or (0, 0, 0, 0, 0) if no C heap is enabled
Store::get_gc_type_idx
Get the type index of a GC object
Store::get_global
Store::get_instance
Store::get_jit_table
Get the JIT table corresponding to a runtime table (if exists)
Store::get_memory
Get memory by index, rejecting missing memories without fabricating a handle.
Store::get_tag_owner
Get the owner module for a tag
Store::get_tag_type
Store::get_tag_type_idx
Get the original type index for a tag
Store::get_wasi_ctx_handle
Get the WASI context handle (for WAST runner to retrieve WASI context)
Store::get_wasi_memory
Get WASI module's memory
Uses the stored wasi_mem_addr if set, otherwise falls back to index 0
Store::has_guest_continuation
Store::host_call_instance
Construct a Store-owned call context for an existing host function.
Store::host_exports
fn Store::host_exports(self : Store, exports : ArrayView[(String, ExternVal)]) -> ModuleInstance raise RuntimeErrorPublish a checked namespace of host exports in this Store.
Store::in_execution_scope
fn[T, E : Error] Store::in_execution_scope(self : Store, captured : ExecutionScope?, run : () -> T raise E) -> T raise EDrive captured work without resetting its limits. Any currently active
parent policy is also applied, with each shared controller charged once.
Store::is_gc_valid
Check if a GC object reference is valid
Store::jit_funcref_entries
Store::lookup_jit_funcref_ptr
Store::lookup_jit_funcref_store_addr
Store::maybe_collect
Perform garbage collection if heap usage exceeds the threshold
Returns the number of objects collected, or 0 if GC was not triggered
Store::native_callable_registry
Share Store-wide callable identities while each context owns its local maps.
Returns None after the Store is closed.
Store::native_execution_state
Return the Store-owned native invocation registry.
Store::native_heap
Native integration capability; not part of the portable embedding interface.
Store::native_type_indices
Store::new_instance
fn Store::new_instance(self : Store, validated : ValidatedModule, func_addrs~ : ArrayView[Int], table_addrs~ : ArrayView[Int], mem_addrs~ : ArrayView[Int], global_addrs~ : ArrayView[Int], tag_addrs~ : ArrayView[Int], elem_values~ : Array[Array[Value]], admission? : InstanceAdmission) -> ModuleInstance raise RuntimeErrorPublish a validated module's address maps into this Store.
Addresses are Store-local low-level integration indices, checked before publication.
Store::pin_gc_roots
Store::publish_core_instance
Core segment/start traps preserve prior writes to imported resources. Once
an instance can escape through those writes, keep its addresses and budget
alive. An enclosing Component transaction keeps its own commit boundary.
Store::put_guest_continuation
fn Store::put_guest_continuation(self : Store, body : GuestContinuationBody) -> Int64 raise RuntimeErrorStore::register_instance
fn Store::register_instance(self : Store, instance : ModuleInstance, admission? : InstanceAdmission) -> Int raise RuntimeErrorRegister a module instance and set ownership for its functions
Only sets ownership for functions that don't already have an owner
(imported functions already belong to their original module)
Store::register_jit_funcrefs
fn Store::register_jit_funcrefs(self : Store, entries : Array[StoreFuncrefEntry], release_owner? : () -> Unit) -> StoreFuncrefRegistrationStore::register_suspended_execution
fn Store::register_suspended_execution(self : Store, cancel : () -> Unit) -> Int64 raise RuntimeErrorRegister parked execution for cancellation on terminal Store close.
The executor removes this registration before resuming or cancelling it.
Store::release_suspended_execution
Detach parked execution before running any of its cleanup callbacks.
Store::reserve_gc_array_work
fn Store::reserve_gc_array_work(self : Store, length : Int) -> (ResourceLease, ResourceLease)? raise RuntimeErrorAdmit the temporary representation before decoding/copying an array payload.
Release immediately before handing that payload to the heap allocator, which
performs the final admission. This bounds staging work, not process RSS.
Store::reserve_instance
Store::reserve_retained_resource
fn Store::reserve_retained_resource(self : Store, kind : ResourceKind, amount : Int64) -> Unit raise RuntimeErrorAdmit Store-owned metadata. A failed instantiation returns its reservations
through the current transaction; committed metadata stays charged until close.
Store::root_raw_value
Low-level bridge from Store-local raw values. Raw reference indices must
originate in this Store; portable clients should use executor.Function results.
Store::root_result_value
fn Store::root_result_value(self : Store, instance : ModuleInstance, value : Value, type_ : ValueType) -> RootedValue raise RuntimeErrorLow-level result bridge: the caller guarantees the declared result contract.
Store::set_module_types
Set module types and rec groups (needed for CHeap type lookups and canonical indices)
Store::set_wasi_ctx_handle
Set the WASI context handle (for WAST runner to store WASI context)
Store::set_wasi_mem_addr
Set the current WASI module's memory address
Should be called after instantiating a module that uses WASI
Store::should_collect
Check if GC should be triggered based on heap usage
Returns true if heap usage exceeds the threshold (default 75%)
Store::struct_get
Get a struct field value
Store::struct_set
fn Store::struct_set(self : Store, struct_idx : Int, field_idx : Int, value : Value) -> Unit raise RuntimeErrorSet a struct field value
Store::take_guest_continuation
fn Store::take_guest_continuation(self : Store, handle : Int64) -> GuestContinuationBody raise RuntimeErrorConsume before executing or rebinding. Handles are never reused in a Store.
The returned body owns its roots until run or cancel; the caller must finish
one of those operations, or transfer its leases to a rebound body.
Store::unwrap_extern
Unwrap an externref back to its internal value
For host externrefs (positive index), returns the ExternRef unchanged
For wrapped internals (negative index), returns the original value
Store::with_async_instantiation
Store::with_c_heap
fn Store::with_c_heap(nan_canonicalization? : Bool, interpreter_limits? : InterpreterLimits, resource_budget? : ResourceBudget?) -> Store raise RuntimeErrorCreate a store with C heap enabled (for JIT mode)
Store::with_execution_limits
Bound a group of calls and any continuations they publish. Safepoint units
count cooperative polls, not Wasm instructions or equivalent engine fuel.
Blocking synchronous host callbacks are checked after returning, not interrupted.
Store::with_instantiation
Join an enclosing component transaction, or own rollback for a Core entry.
StoreCounts
pub struct StoreCounts {
funcs : Int
func_types : Int
func_type_indices : Int
tables : Int
mems : Int
globals : Int
tags : Int
tag_type_indices : Int
tag_owners : Int
exns : Int
wrapped_externs : Int
func_owners : Int
instances : Int
jit_tables : Int
heap_slots : Int
heap_live : Int
wrapped_extern_capacity : Int
} derive(Debug)Read-only diagnostic counts; no mutable backing storage is exposed.
StoreFuncrefEntry
One Store-local function address and its native executable pointer.
StoreFuncrefEntry::StoreFuncrefEntry
StoreFuncrefEntry::equal
StoreFuncrefEntry::not_equal
StoreFuncrefRegistration
type StoreFuncrefRegistrationStoreFuncrefRegistration::release
StoreIdentity
pub struct StoreIdentity {
// private fields
}Opaque Store identity. Holding this token does not keep the Store alive.
StructInstance
Struct instance - stores field values
impl Show for StructInstanceKeep Show behavior while migrating from deprecated derive(Show) to
derive(Debug).
StructInstance::output
Table
WebAssembly table with target-specific backing storage
Table::Table
fn Table::Table(elem_type : ValueType, min : Int, max : Int?, init_value? : Value, is_table64? : Bool, resource_budget? : ResourceBudget?) -> Table raise RuntimeErrorTable::copy_from
fn Table::copy_from(self : Table, dest : Int, src_table : Table, src : Int, n : Int) -> Unit raise RuntimeErrorTable::copy_from_at
fn Table::copy_from_at(self : Table, dest : Int64, src_table : Table, src : Int64, n : Int64) -> Unit raise RuntimeErrorTable::fill
Fill a range of table elements with a value
table.fill: fill table[d..d+n] with value
Table::fill_at
Table::from_type
fn Table::from_type(ty : TableType, init_value? : Value, resource_budget? : ResourceBudget?) -> Table raise RuntimeErrorAllocate a module table without narrowing its declared limits.
Table::get_elem_type
Get element type for type checking
Table::get_limits
Get table limits (min, max) for type checking
Table::get_limits64
Full declared limits for import compatibility and native growth checks.
Table::grow64
Grow using an unsigned table64 count, preserving allocation failures.
Table::is_table64
Check if this is a table64 (i64-indexed table)
Table::set_at
format_runtime_error
Format a basic RuntimeError without context
runtime_capabilities
Structured capability query.
supports_feature
Generic capability query.
with_async_host_call_driver
Run one asynchronous Wasm invocation with structured ownership of every
host task it starts.
Source Files
- async_host.mbt
- caller.mbt
- capability.mbt
- error.mbt
- execution_limits.mbt
- frame.mbt
- funcref_registry.mbt
- function_identity.mbt
- gc_tracing.mbt
- gc_tracing_native.mbt
- gc_traits.mbt
- global.mbt
- guest_continuation.mbt
- heap.mbt
- imports.mbt
- instance.mbt
- instantiation_transaction.mbt
- interpreter_limits.mbt
- linker.mbt
- memory.mbt
- memory_access.mbt
- memory_atomic.mbt
- memory_native.mbt
- module_budget.mbt
- native_exception.mbt
- resource_binding.mbt
- resource_budget.mbt
- rooted_value.mbt
- stack.mbt
- store.mbt
- store_inspection.mbt
- store_references.mbt
- store_references_native.mbt
- suspended_execution.mbt
- table.mbt
- table_native.mbt
- trait_extensions.mbt
- type_registry.mbt
Install
Download zipShared Wasmoon interpreter state and target-specific storage primitives
Apache-2.0
Updated yesterday
10 downloadsDependencies
- moonbitlang/x0.5.5
- Milky2018/wasm_core0.17.1
- Milky2018/wasm_milkir0.17.1
- moonbitlang/async0.22.4