wasi

type Config struct {
	Args, Env []string
	FS        *rootfs.FS
	// Mounts are further trees, each preopened under its own path after
	// "/" (fd 4 onwards), as wasmtime's --dir host::guest does: a guest
	// resolves an absolute path against the longest matching preopen.
	Mounts         []Mount
	Stdin          io.Reader
	Stdout, Stderr io.Writer
	// Now is the realtime clock (default time.Now).
	Now func() time.Time
	// Rand is the randomness source (default crypto/rand).
	Rand io.Reader
	// Net is the container's place on a network; nil means no network
	// (sock_open fails with ENOTSUP).
	Net netdriver.Endpoint
	// Modules are the host modules served beside wasi_snapshot_preview1,
	// in the order of the import table (Imports); an executor passes the
	// same list it defined the imports from.
	Modules []HostModule
	// Caps are the capabilities the process was started with ("gpu").
	Caps []string
	// Parent is the process that started this one, if any.
	Parent *Proc
}

type Func struct {
	Name   string
	Params string // one of I32/I64 per parameter
	// NoResult is set for proc_exit; every other function returns an errno.
	NoResult bool
}

type HostFunc struct {
	Name string
	// Params has one of I32, I64, F32, F64 per parameter.
	Params string
	// Result is "" (no result) or one of I32, I64, F32, F64. The value is
	// Result.Ret; an F32 or F64 travels as its IEEE-754 bits.
	Result string
}

type HostModule interface {
	// Module is the import module name, e.g. "wasi_ephemeral_nn".
	Module() string
	// Funcs lists the functions, in an order the module indexes by.
	Funcs() []HostFunc
	// Open makes the module's state for process p, at p's first call into
	// it. It never fails: a process denied the module (no capability) gets
	// an Instance that answers with the module's own error values.
	Open(p *Proc) Instance
}

type Import struct {
	Module, Name   string
	Params, Result string
}

type Instance interface {
	// Call runs function fn of Funcs with one value per parameter (I32
	// in the low 32 bits, F32/F64 as bits).
	Call(fn int, args []uint64, m Memory) Result
	// Close releases the state when the process ends. It may run while a
	// Wait the instance returned is still pending; a later Resume must
	// then fail rather than touch released state.
	Close()
}

type Memory interface {
	Read(off, n uint32) ([]byte, bool)
	Write(off uint32, b []byte) bool
}

type Mount struct {
	Path     string
	FS       *rootfs.FS
	ReadOnly bool
}

type Proc struct {
	// contains filtered or unexported fields
}

type Realloc struct {
	Align, Size uint32
	Then        func(ptr uint32, m Memory) Result
}

type Result struct {
	Errno uint32
	// Sleep asks the host to block the guest this long before returning
	// (poll_oneoff on clocks). The host may cut it short on a kill.
	Sleep time.Duration
	// Wait, when set, asks the host to block until Wait is closed, Sleep
	// (if not zero) has passed, or the process is killed, and then to
	// return what Resume returns instead (which may ask to wait again).
	// The call itself never blocks: sockets wait this way.
	Wait   <-chan struct{}
	Resume func(m Memory) Result
	// Exit is set by proc_exit, with Code.
	Exit bool
	Code uint32
	// Ret is a host-module function's result (HostFunc.Result); the
	// wasi_snapshot_preview1 functions return Errno instead.
	Ret uint64
	// Realloc, when set, asks the host to allocate in the guest first
	// (see Realloc); Wait and Realloc are never both set.
	Realloc *Realloc
	// Trap, when not empty, ends the guest with a trap of that message (a
	// host module's answer to a call the canonical ABI says must trap).
	Trap string
}