Call invokes this function with the provided `args`. This variadic function must be invoked with the correct number and type of `args` as specified b

NewEngine creates a new `Engine` with default configuration.

Type returns the type of this func

NewStore creates a new `Store` from the configuration provided in `engine`

Kind returns the kind of value that this `Val` contains.

NewConfig creates a new `Config` with all default options configured.

Close will deallocate this type's state explicitly. For more information see the documentation for engine.Close()

NewValType creates a new `ValType` with the `kind` provided

Returns the wasmtime context pointer this store is attached to.

Wat2Wasm converts the text format of WebAssembly to the binary format. Takes the text format in-memory as input, and returns either the binary encodi

See comments in `ffi.go` for what's going on here

WrapFunc wraps a native Go function, `f`, as a wasm `Func`. This function differs from `NewFunc` in that it will determine the type signature of the

NewModule compiles a new `Module` from the `wasm` provided with the given configuration in `engine`.

GetFunc attempts to find a function on this instance by `name`. May return `nil` if this instance has no function named `name`, it is not a function,

See `ffi.go` documentation about `ptr()` for what's going on here.

NewFuncType creates a new `FuncType` with the `kind` provided

Instantiate instantiates a module with all imports defined in this linker. Returns an error if the instance's imports couldn't be satisfied, had the

MemoryType returns the underlying `MemoryType` for this `ExternType` if it's a *memory* type. Otherwise returns `nil`.

NewInstance instantiates a WebAssembly `module` with the `imports` provided. This function will attempt to create a new wasm instance given the provi

Params returns the parameter types of this function type

Get returns the underlying 64-bit float if this is an `f64`, or panics.

newComponentEngine returns an Engine with the component-model proposal enabled, which is required to compile and instantiate components.

Name returns the name in the module this import type is importing. Note that the returned string may be `nil` with the module linking proposal where

newComponent compiles `wat` into a fresh [Component] for tests. The returned component must be closed by the caller.

ValExternref converts a go value to a externref Val Using `externref` is a way to pass arbitrary Go data into a WebAssembly module for it to store. L

FuncType returns the underlying `FuncType` for this `ExternType` if it's a function type. Otherwise returns `nil`.

Get gets an item from this table from the specified index. Returns an error if the index is out of bounds, or returns a value (which may be internall

Results returns the result types of this function type

Define defines a new item in this linker with the given module/name pair. Returns an error if shadowing is disallowed and the module/name is already d

GlobalType returns the underlying `GlobalType` for this `ExternType` if it's a *global* type. Otherwise returns `nil`.

Minimum returns the minimum size, in elements, of this table.

NewFunc creates a new `Func` with the given `ty` which, when called, will call `f` The `ty` given is the wasm type signature of the `Func` to create.

TableType returns the underlying `TableType` for this `ExternType` if it's a *table* type. Otherwise returns `nil`.

ValFuncref converts a Func to a funcref Val Note that `f` can be `nil` to represent a null `funcref`.

ValI32 converts a go int32 to a i32 Val

NewEngineWithConfig creates a new `Engine` with the `Config` provided Note that once a `Config` is passed to this method it cannot be used again.

NewGlobalType creates a new `GlobalType` with the `kind` provided and whether it's `mutable` or not

Returns the underlying `*storeData` that this store references in Go, used for inserting functions or storing panic data.

Content returns the type of value stored in this global

Element returns the type of value stored in this table

ExportNth returns the name and the [ComponentItem] for the `i`-th export. Returns `("", nil)` if `i` is out of range.

Func returns a Func if this export is a function or nil otherwise

FuncWrap defines a function in this linker in the same style as `WrapFunc` Note that this function does not require a `Storelike`, which is intention

GC will clean up any `externref` values that are no longer actually referenced. This function is not required to be called for correctness, it's only

Grow grows this table by the number of units specified, using the specified initializer value for new slots. Returns an error if the table failed to

Module returns the name in the module this import type is importing

Set sets an item in this table at the specified index. Returns an error if the index is out of bounds.

Table returns a Table if this export is a table or nil otherwise

ValI64 converts a go int64 to a i64 Val

AsExternType converts this type to an instance of `ExternType`

Implementation of the `Storelike` interface

Maximum returns the maximum size, in elements, of this table. If no maximum size is listed then `(false, 0)` is returned, otherwise `(true, N)` is re

Memory returns a Memory if this export is a memory or nil otherwise

NewGlobal creates a new `Global` in the given `Store` with the specified `ty` and initial value `val`.

NewMemoryType creates a new `MemoryType` with the limits on size provided The `min` value is the minimum size, in WebAssembly pages, of this memory.

NewTrap creates a new `Trap` with the `name` and the type provided.

Serialize will convert this in-memory compiled module into a list of bytes. The purpose of this method is to extract an artifact which can be stored

Set sets the value of this global

ValF32 converts a go float32 to a f32 Val

ValF64 converts a go float64 to a f64 Val

AsExternType converts this type to an instance of `ExternType`

AsExternType converts this type to an instance of `ExternType`

AsExternType converts this type to an instance of `ExternType`

Close will deallocate this engine's state explicitly. By default state is cleaned up automatically when an engine is garbage collected but the Go GC.

Close will deallocate this linker's state explicitly. For more information see the documentation for engine.Close()

Arbitrary data attached to the store. Embedders should cast this into an appropriate domain specific type. Note that this will return nil for a [Store

Funcref returns the underlying function if this is a `funcref`, or panics. Note that a null `funcref` is returned as `nil`.

Get gets the value of this global

GetExport attempts to find an export on this instance by `name` May return `nil` if this instance has no export named `name`

Global returns a Global if this export is a global or nil otherwise

I32 returns the underlying 32-bit integer if this is an `i32`, or panics.

I64 returns the underlying 64-bit integer if this is an `i64`, or panics.

Message returns the message of the `Trap`

NewStoreWithData creates a new [Store] from engine and associates data with it. Embedders can access data via [Storelike.Data]

NewTableType creates a new `TableType` with the `element` type provided as well as limits on its size. The `min` value is the minimum size, in elemen

TypeAlias returns the [ComponentValType] embedded in this item when its kind is [ComponentItemKindType] (a WIT `type X = ...` alias). Returns `nil` fo