wasi preview 2 support (#4027)

* all: wasip2 support

Co-authored-by: Randy Reddig <randy.reddig@fastly.com>

src/crypto/rand/rand_arc4random.go

@@ -1,4 +1,4 @@
-//go:build darwin || tinygo.wasm
+//go:build darwin || wasip1 || wasip2 || wasm
 
 // This implementation of crypto/rand uses the arc4random_buf function
 // (available on both MacOS and WASI) to generate random numbers.

src/crypto/rand/rand_urandom.go

@@ -1,4 +1,4 @@
-//go:build linux && !baremetal && !wasip1
+//go:build linux && !baremetal && !wasip1 && !wasip2
 
 // This implementation of crypto/rand uses the /dev/urandom pseudo-file to
 // generate random numbers.

src/internal/wasi/cli/v0.2.0/command/command.wit.go

@@ -0,0 +1,6 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package command represents the world "wasi:cli/command@0.2.0".
+package command

src/internal/wasi/cli/v0.2.0/environment/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/cli/v0.2.0/environment/environment.wit.go

@@ -0,0 +1,66 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package environment represents the imported interface "wasi:cli/environment@0.2.0".
+package environment
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+)
+
+// GetEnvironment represents the imported function "get-environment".
+//
+// Get the POSIX-style environment variables.
+//
+// Each environment variable is provided as a pair of string variable names
+// and string value.
+//
+// Morally, these are a value import, but until value imports are available
+// in the component model, this import function should return the same
+// values each time it is called.
+//
+//	get-environment: func() -> list<tuple<string, string>>
+//
+//go:nosplit
+func GetEnvironment() (result cm.List[[2]string]) {
+	wasmimport_GetEnvironment(&result)
+	return
+}
+
+//go:wasmimport wasi:cli/environment@0.2.0 get-environment
+//go:noescape
+func wasmimport_GetEnvironment(result *cm.List[[2]string])
+
+// GetArguments represents the imported function "get-arguments".
+//
+// Get the POSIX-style arguments to the program.
+//
+//	get-arguments: func() -> list<string>
+//
+//go:nosplit
+func GetArguments() (result cm.List[string]) {
+	wasmimport_GetArguments(&result)
+	return
+}
+
+//go:wasmimport wasi:cli/environment@0.2.0 get-arguments
+//go:noescape
+func wasmimport_GetArguments(result *cm.List[string])
+
+// InitialCWD represents the imported function "initial-cwd".
+//
+// Return a path that programs should use as their initial current working
+// directory, interpreting `.` as shorthand for this.
+//
+//	initial-cwd: func() -> option<string>
+//
+//go:nosplit
+func InitialCWD() (result cm.Option[string]) {
+	wasmimport_InitialCWD(&result)
+	return
+}
+
+//go:wasmimport wasi:cli/environment@0.2.0 initial-cwd
+//go:noescape
+func wasmimport_InitialCWD(result *cm.Option[string])

src/internal/wasi/cli/v0.2.0/exit/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/cli/v0.2.0/exit/exit.wit.go

@@ -0,0 +1,27 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package exit represents the imported interface "wasi:cli/exit@0.2.0".
+package exit
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+)
+
+// Exit represents the imported function "exit".
+//
+// Exit the current instance and any linked instances.
+//
+//	exit: func(status: result)
+//
+//go:nosplit
+func Exit(status cm.Result) {
+	status0 := cm.LowerResult(status)
+	wasmimport_Exit((uint32)(status0))
+	return
+}
+
+//go:wasmimport wasi:cli/exit@0.2.0 exit
+//go:noescape
+func wasmimport_Exit(status0 uint32)

src/internal/wasi/cli/v0.2.0/run/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/cli/v0.2.0/run/run.exports.go

@@ -0,0 +1,19 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+package run
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+)
+
+// Exports represents the caller-defined exports from "wasi:cli/run@0.2.0".
+var Exports struct {
+	// Run represents the caller-defined, exported function "run".
+	//
+	// Run the program.
+	//
+	//	run: func() -> result
+	Run func() (result cm.Result)
+}

src/internal/wasi/cli/v0.2.0/run/run.wit.go

@@ -0,0 +1,18 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package run represents the exported interface "wasi:cli/run@0.2.0".
+package run
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+)
+
+//go:wasmexport wasi:cli/run@0.2.0#run
+//export wasi:cli/run@0.2.0#run
+func wasmexport_Run() (result0 uint32) {
+	result := Exports.Run()
+	result0 = cm.LowerResult(result)
+	return
+}

src/internal/wasi/cli/v0.2.0/stderr/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/cli/v0.2.0/stderr/stderr.wit.go

@@ -0,0 +1,26 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package stderr represents the imported interface "wasi:cli/stderr@0.2.0".
+package stderr
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+	"internal/wasi/io/v0.2.0/streams"
+)
+
+// GetStderr represents the imported function "get-stderr".
+//
+//	get-stderr: func() -> output-stream
+//
+//go:nosplit
+func GetStderr() (result streams.OutputStream) {
+	result0 := wasmimport_GetStderr()
+	result = cm.Reinterpret[streams.OutputStream]((uint32)(result0))
+	return
+}
+
+//go:wasmimport wasi:cli/stderr@0.2.0 get-stderr
+//go:noescape
+func wasmimport_GetStderr() (result0 uint32)

src/internal/wasi/cli/v0.2.0/stdin/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/cli/v0.2.0/stdin/stdin.wit.go

@@ -0,0 +1,26 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package stdin represents the imported interface "wasi:cli/stdin@0.2.0".
+package stdin
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+	"internal/wasi/io/v0.2.0/streams"
+)
+
+// GetStdin represents the imported function "get-stdin".
+//
+//	get-stdin: func() -> input-stream
+//
+//go:nosplit
+func GetStdin() (result streams.InputStream) {
+	result0 := wasmimport_GetStdin()
+	result = cm.Reinterpret[streams.InputStream]((uint32)(result0))
+	return
+}
+
+//go:wasmimport wasi:cli/stdin@0.2.0 get-stdin
+//go:noescape
+func wasmimport_GetStdin() (result0 uint32)

src/internal/wasi/cli/v0.2.0/stdout/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/cli/v0.2.0/stdout/stdout.wit.go

@@ -0,0 +1,26 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package stdout represents the imported interface "wasi:cli/stdout@0.2.0".
+package stdout
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+	"internal/wasi/io/v0.2.0/streams"
+)
+
+// GetStdout represents the imported function "get-stdout".
+//
+//	get-stdout: func() -> output-stream
+//
+//go:nosplit
+func GetStdout() (result streams.OutputStream) {
+	result0 := wasmimport_GetStdout()
+	result = cm.Reinterpret[streams.OutputStream]((uint32)(result0))
+	return
+}
+
+//go:wasmimport wasi:cli/stdout@0.2.0 get-stdout
+//go:noescape
+func wasmimport_GetStdout() (result0 uint32)

src/internal/wasi/cli/v0.2.0/terminal-input/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/cli/v0.2.0/terminal-input/terminal-input.wit.go

@@ -0,0 +1,38 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package terminalinput represents the imported interface "wasi:cli/terminal-input@0.2.0".
+//
+// Terminal input.
+//
+// In the future, this may include functions for disabling echoing,
+// disabling input buffering so that keyboard events are sent through
+// immediately, querying supported features, and so on.
+package terminalinput
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+)
+
+// TerminalInput represents the imported resource "wasi:cli/terminal-input@0.2.0#terminal-input".
+//
+// The input side of a terminal.
+//
+//	resource terminal-input
+type TerminalInput cm.Resource
+
+// ResourceDrop represents the imported resource-drop for resource "terminal-input".
+//
+// Drops a resource handle.
+//
+//go:nosplit
+func (self TerminalInput) ResourceDrop() {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_TerminalInputResourceDrop((uint32)(self0))
+	return
+}
+
+//go:wasmimport wasi:cli/terminal-input@0.2.0 [resource-drop]terminal-input
+//go:noescape
+func wasmimport_TerminalInputResourceDrop(self0 uint32)

src/internal/wasi/cli/v0.2.0/terminal-output/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/cli/v0.2.0/terminal-output/terminal-output.wit.go

@@ -0,0 +1,38 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package terminaloutput represents the imported interface "wasi:cli/terminal-output@0.2.0".
+//
+// Terminal output.
+//
+// In the future, this may include functions for querying the terminal
+// size, being notified of terminal size changes, querying supported
+// features, and so on.
+package terminaloutput
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+)
+
+// TerminalOutput represents the imported resource "wasi:cli/terminal-output@0.2.0#terminal-output".
+//
+// The output side of a terminal.
+//
+//	resource terminal-output
+type TerminalOutput cm.Resource
+
+// ResourceDrop represents the imported resource-drop for resource "terminal-output".
+//
+// Drops a resource handle.
+//
+//go:nosplit
+func (self TerminalOutput) ResourceDrop() {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_TerminalOutputResourceDrop((uint32)(self0))
+	return
+}
+
+//go:wasmimport wasi:cli/terminal-output@0.2.0 [resource-drop]terminal-output
+//go:noescape
+func wasmimport_TerminalOutputResourceDrop(self0 uint32)

src/internal/wasi/cli/v0.2.0/terminal-stderr/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/cli/v0.2.0/terminal-stderr/terminal-stderr.wit.go

@@ -0,0 +1,31 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package terminalstderr represents the imported interface "wasi:cli/terminal-stderr@0.2.0".
+//
+// An interface providing an optional `terminal-output` for stderr as a
+// link-time authority.
+package terminalstderr
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+	terminaloutput "internal/wasi/cli/v0.2.0/terminal-output"
+)
+
+// GetTerminalStderr represents the imported function "get-terminal-stderr".
+//
+// If stderr is connected to a terminal, return a `terminal-output` handle
+// allowing further interaction with it.
+//
+//	get-terminal-stderr: func() -> option<terminal-output>
+//
+//go:nosplit
+func GetTerminalStderr() (result cm.Option[terminaloutput.TerminalOutput]) {
+	wasmimport_GetTerminalStderr(&result)
+	return
+}
+
+//go:wasmimport wasi:cli/terminal-stderr@0.2.0 get-terminal-stderr
+//go:noescape
+func wasmimport_GetTerminalStderr(result *cm.Option[terminaloutput.TerminalOutput])

src/internal/wasi/cli/v0.2.0/terminal-stdin/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/cli/v0.2.0/terminal-stdin/terminal-stdin.wit.go

@@ -0,0 +1,31 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package terminalstdin represents the imported interface "wasi:cli/terminal-stdin@0.2.0".
+//
+// An interface providing an optional `terminal-input` for stdin as a
+// link-time authority.
+package terminalstdin
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+	terminalinput "internal/wasi/cli/v0.2.0/terminal-input"
+)
+
+// GetTerminalStdin represents the imported function "get-terminal-stdin".
+//
+// If stdin is connected to a terminal, return a `terminal-input` handle
+// allowing further interaction with it.
+//
+//	get-terminal-stdin: func() -> option<terminal-input>
+//
+//go:nosplit
+func GetTerminalStdin() (result cm.Option[terminalinput.TerminalInput]) {
+	wasmimport_GetTerminalStdin(&result)
+	return
+}
+
+//go:wasmimport wasi:cli/terminal-stdin@0.2.0 get-terminal-stdin
+//go:noescape
+func wasmimport_GetTerminalStdin(result *cm.Option[terminalinput.TerminalInput])

src/internal/wasi/cli/v0.2.0/terminal-stdout/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/cli/v0.2.0/terminal-stdout/terminal-stdout.wit.go

@@ -0,0 +1,31 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package terminalstdout represents the imported interface "wasi:cli/terminal-stdout@0.2.0".
+//
+// An interface providing an optional `terminal-output` for stdout as a
+// link-time authority.
+package terminalstdout
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+	terminaloutput "internal/wasi/cli/v0.2.0/terminal-output"
+)
+
+// GetTerminalStdout represents the imported function "get-terminal-stdout".
+//
+// If stdout is connected to a terminal, return a `terminal-output` handle
+// allowing further interaction with it.
+//
+//	get-terminal-stdout: func() -> option<terminal-output>
+//
+//go:nosplit
+func GetTerminalStdout() (result cm.Option[terminaloutput.TerminalOutput]) {
+	wasmimport_GetTerminalStdout(&result)
+	return
+}
+
+//go:wasmimport wasi:cli/terminal-stdout@0.2.0 get-terminal-stdout
+//go:noescape
+func wasmimport_GetTerminalStdout(result *cm.Option[terminaloutput.TerminalOutput])

src/internal/wasi/clocks/v0.2.0/monotonic-clock/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/clocks/v0.2.0/monotonic-clock/monotonic-clock.wit.go

@@ -0,0 +1,115 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package monotonicclock represents the imported interface "wasi:clocks/monotonic-clock@0.2.0".
+//
+// WASI Monotonic Clock is a clock API intended to let users measure elapsed
+// time.
+//
+// It is intended to be portable at least between Unix-family platforms and
+// Windows.
+//
+// A monotonic clock is a clock which has an unspecified initial value, and
+// successive reads of the clock will produce non-decreasing values.
+//
+// It is intended for measuring elapsed time.
+package monotonicclock
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+	"internal/wasi/io/v0.2.0/poll"
+)
+
+// Instant represents the u64 "wasi:clocks/monotonic-clock@0.2.0#instant".
+//
+// An instant in time, in nanoseconds. An instant is relative to an
+// unspecified initial value, and can only be compared to instances from
+// the same monotonic-clock.
+//
+//	type instant = u64
+type Instant uint64
+
+// Duration represents the u64 "wasi:clocks/monotonic-clock@0.2.0#duration".
+//
+// A duration of time, in nanoseconds.
+//
+//	type duration = u64
+type Duration uint64
+
+// Now represents the imported function "now".
+//
+// Read the current value of the clock.
+//
+// The clock is monotonic, therefore calling this function repeatedly will
+// produce a sequence of non-decreasing values.
+//
+//	now: func() -> instant
+//
+//go:nosplit
+func Now() (result Instant) {
+	result0 := wasmimport_Now()
+	result = (Instant)((uint64)(result0))
+	return
+}
+
+//go:wasmimport wasi:clocks/monotonic-clock@0.2.0 now
+//go:noescape
+func wasmimport_Now() (result0 uint64)
+
+// Resolution represents the imported function "resolution".
+//
+// Query the resolution of the clock. Returns the duration of time
+// corresponding to a clock tick.
+//
+//	resolution: func() -> duration
+//
+//go:nosplit
+func Resolution() (result Duration) {
+	result0 := wasmimport_Resolution()
+	result = (Duration)((uint64)(result0))
+	return
+}
+
+//go:wasmimport wasi:clocks/monotonic-clock@0.2.0 resolution
+//go:noescape
+func wasmimport_Resolution() (result0 uint64)
+
+// SubscribeInstant represents the imported function "subscribe-instant".
+//
+// Create a `pollable` which will resolve once the specified instant
+// occured.
+//
+//	subscribe-instant: func(when: instant) -> pollable
+//
+//go:nosplit
+func SubscribeInstant(when Instant) (result poll.Pollable) {
+	when0 := (uint64)(when)
+	result0 := wasmimport_SubscribeInstant((uint64)(when0))
+	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
+	return
+}
+
+//go:wasmimport wasi:clocks/monotonic-clock@0.2.0 subscribe-instant
+//go:noescape
+func wasmimport_SubscribeInstant(when0 uint64) (result0 uint32)
+
+// SubscribeDuration represents the imported function "subscribe-duration".
+//
+// Create a `pollable` which will resolve once the given duration has
+// elapsed, starting at the time at which this function was called.
+// occured.
+//
+//	subscribe-duration: func(when: duration) -> pollable
+//
+//go:nosplit
+func SubscribeDuration(when Duration) (result poll.Pollable) {
+	when0 := (uint64)(when)
+	result0 := wasmimport_SubscribeDuration((uint64)(when0))
+	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
+	return
+}
+
+//go:wasmimport wasi:clocks/monotonic-clock@0.2.0 subscribe-duration
+//go:noescape
+func wasmimport_SubscribeDuration(when0 uint64) (result0 uint32)

src/internal/wasi/clocks/v0.2.0/wall-clock/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/clocks/v0.2.0/wall-clock/wall-clock.wit.go

@@ -0,0 +1,80 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package wallclock represents the imported interface "wasi:clocks/wall-clock@0.2.0".
+//
+// WASI Wall Clock is a clock API intended to let users query the current
+// time. The name "wall" makes an analogy to a "clock on the wall", which
+// is not necessarily monotonic as it may be reset.
+//
+// It is intended to be portable at least between Unix-family platforms and
+// Windows.
+//
+// A wall clock is a clock which measures the date and time according to
+// some external reference.
+//
+// External references may be reset, so this clock is not necessarily
+// monotonic, making it unsuitable for measuring elapsed time.
+//
+// It is intended for reporting the current date and time for humans.
+package wallclock
+
+// DateTime represents the record "wasi:clocks/wall-clock@0.2.0#datetime".
+//
+// A time and date in seconds plus nanoseconds.
+//
+//	record datetime {
+//		seconds: u64,
+//		nanoseconds: u32,
+//	}
+type DateTime struct {
+	Seconds     uint64
+	Nanoseconds uint32
+}
+
+// Now represents the imported function "now".
+//
+// Read the current value of the clock.
+//
+// This clock is not monotonic, therefore calling this function repeatedly
+// will not necessarily produce a sequence of non-decreasing values.
+//
+// The returned timestamps represent the number of seconds since
+// 1970-01-01T00:00:00Z, also known as [POSIX's Seconds Since the Epoch],
+// also known as [Unix Time].
+//
+// The nanoseconds field of the output is always less than 1000000000.
+//
+//	now: func() -> datetime
+//
+// [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16
+// [Unix Time]: https://en.wikipedia.org/wiki/Unix_time
+//
+//go:nosplit
+func Now() (result DateTime) {
+	wasmimport_Now(&result)
+	return
+}
+
+//go:wasmimport wasi:clocks/wall-clock@0.2.0 now
+//go:noescape
+func wasmimport_Now(result *DateTime)
+
+// Resolution represents the imported function "resolution".
+//
+// Query the resolution of the clock.
+//
+// The nanoseconds field of the output is always less than 1000000000.
+//
+//	resolution: func() -> datetime
+//
+//go:nosplit
+func Resolution() (result DateTime) {
+	wasmimport_Resolution(&result)
+	return
+}
+
+//go:wasmimport wasi:clocks/wall-clock@0.2.0 resolution
+//go:noescape
+func wasmimport_Resolution(result *DateTime)

src/internal/wasi/filesystem/v0.2.0/preopens/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/filesystem/v0.2.0/preopens/preopens.wit.go

@@ -0,0 +1,27 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package preopens represents the imported interface "wasi:filesystem/preopens@0.2.0".
+package preopens
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+	"internal/wasi/filesystem/v0.2.0/types"
+)
+
+// GetDirectories represents the imported function "get-directories".
+//
+// Return the set of preopened directories, and their path.
+//
+//	get-directories: func() -> list<tuple<descriptor, string>>
+//
+//go:nosplit
+func GetDirectories() (result cm.List[cm.Tuple[types.Descriptor, string]]) {
+	wasmimport_GetDirectories(&result)
+	return
+}
+
+//go:wasmimport wasi:filesystem/preopens@0.2.0 get-directories
+//go:noescape
+func wasmimport_GetDirectories(result *cm.List[cm.Tuple[types.Descriptor, string]])

src/internal/wasi/filesystem/v0.2.0/types/abi.go

@@ -0,0 +1,27 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+package types
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+	wallclock "internal/wasi/clocks/v0.2.0/wall-clock"
+)
+
+func lower_DateTime(v wallclock.DateTime) (f0 uint64, f1 uint32) {
+	f0 = (uint64)(v.Seconds)
+	f1 = (uint32)(v.Nanoseconds)
+	return
+}
+
+func lower_NewTimestamp(v NewTimestamp) (f0 uint32, f1 uint64, f2 uint32) {
+	f0 = (uint32)(cm.Tag(&v))
+	switch f0 {
+	case 2: // timestamp
+		v1, v2 := lower_DateTime(*v.Timestamp())
+		f1 = (uint64)(v1)
+		f2 = (uint32)(v2)
+	}
+	return
+}

src/internal/wasi/filesystem/v0.2.0/types/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/io/v0.2.0/error/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/io/v0.2.0/error/error.wit.go

@@ -0,0 +1,73 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package ioerror represents the imported interface "wasi:io/error@0.2.0".
+package ioerror
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+)
+
+// Error represents the imported resource "wasi:io/error@0.2.0#error".
+//
+// A resource which represents some error information.
+//
+// The only method provided by this resource is `to-debug-string`,
+// which provides some human-readable information about the error.
+//
+// In the `wasi:io` package, this resource is returned through the
+// `wasi:io/streams/stream-error` type.
+//
+// To provide more specific error information, other interfaces may
+// provide functions to further "downcast" this error into more specific
+// error information. For example, `error`s returned in streams derived
+// from filesystem types to be described using the filesystem's own
+// error-code type, using the function
+// `wasi:filesystem/types/filesystem-error-code`, which takes a parameter
+// `borrow<error>` and returns
+// `option<wasi:filesystem/types/error-code>`.
+//
+// The set of functions which can "downcast" an `error` into a more
+// concrete type is open.
+//
+//	resource error
+type Error cm.Resource
+
+// ResourceDrop represents the imported resource-drop for resource "error".
+//
+// Drops a resource handle.
+//
+//go:nosplit
+func (self Error) ResourceDrop() {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_ErrorResourceDrop((uint32)(self0))
+	return
+}
+
+//go:wasmimport wasi:io/error@0.2.0 [resource-drop]error
+//go:noescape
+func wasmimport_ErrorResourceDrop(self0 uint32)
+
+// ToDebugString represents the imported method "to-debug-string".
+//
+// Returns a string that is suitable to assist humans in debugging
+// this error.
+//
+// WARNING: The returned string should not be consumed mechanically!
+// It may change across platforms, hosts, or other implementation
+// details. Parsing this string is a major platform-compatibility
+// hazard.
+//
+//	to-debug-string: func() -> string
+//
+//go:nosplit
+func (self Error) ToDebugString() (result string) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_ErrorToDebugString((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:io/error@0.2.0 [method]error.to-debug-string
+//go:noescape
+func wasmimport_ErrorToDebugString(self0 uint32, result *string)

src/internal/wasi/io/v0.2.0/poll/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/io/v0.2.0/poll/poll.wit.go

@@ -0,0 +1,110 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package poll represents the imported interface "wasi:io/poll@0.2.0".
+//
+// A poll API intended to let users wait for I/O events on multiple handles
+// at once.
+package poll
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+)
+
+// Pollable represents the imported resource "wasi:io/poll@0.2.0#pollable".
+//
+// `pollable` represents a single I/O event which may be ready, or not.
+//
+//	resource pollable
+type Pollable cm.Resource
+
+// ResourceDrop represents the imported resource-drop for resource "pollable".
+//
+// Drops a resource handle.
+//
+//go:nosplit
+func (self Pollable) ResourceDrop() {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_PollableResourceDrop((uint32)(self0))
+	return
+}
+
+//go:wasmimport wasi:io/poll@0.2.0 [resource-drop]pollable
+//go:noescape
+func wasmimport_PollableResourceDrop(self0 uint32)
+
+// Block represents the imported method "block".
+//
+// `block` returns immediately if the pollable is ready, and otherwise
+// blocks until ready.
+//
+// This function is equivalent to calling `poll.poll` on a list
+// containing only this pollable.
+//
+//	block: func()
+//
+//go:nosplit
+func (self Pollable) Block() {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_PollableBlock((uint32)(self0))
+	return
+}
+
+//go:wasmimport wasi:io/poll@0.2.0 [method]pollable.block
+//go:noescape
+func wasmimport_PollableBlock(self0 uint32)
+
+// Ready represents the imported method "ready".
+//
+// Return the readiness of a pollable. This function never blocks.
+//
+// Returns `true` when the pollable is ready, and `false` otherwise.
+//
+//	ready: func() -> bool
+//
+//go:nosplit
+func (self Pollable) Ready() (result bool) {
+	self0 := cm.Reinterpret[uint32](self)
+	result0 := wasmimport_PollableReady((uint32)(self0))
+	result = cm.U32ToBool((uint32)(result0))
+	return
+}
+
+//go:wasmimport wasi:io/poll@0.2.0 [method]pollable.ready
+//go:noescape
+func wasmimport_PollableReady(self0 uint32) (result0 uint32)
+
+// Poll represents the imported function "poll".
+//
+// Poll for completion on a set of pollables.
+//
+// This function takes a list of pollables, which identify I/O sources of
+// interest, and waits until one or more of the events is ready for I/O.
+//
+// The result `list<u32>` contains one or more indices of handles in the
+// argument list that is ready for I/O.
+//
+// If the list contains more elements than can be indexed with a `u32`
+// value, this function traps.
+//
+// A timeout can be implemented by adding a pollable from the
+// wasi-clocks API to the list.
+//
+// This function does not return a `result`; polling in itself does not
+// do any I/O so it doesn't fail. If any of the I/O sources identified by
+// the pollables has an error, it is indicated by marking the source as
+// being reaedy for I/O.
+//
+//	poll: func(in: list<borrow<pollable>>) -> list<u32>
+//
+//go:nosplit
+func Poll(in cm.List[Pollable]) (result cm.List[uint32]) {
+	in0, in1 := cm.LowerList(in)
+	wasmimport_Poll((*Pollable)(in0), (uint32)(in1), &result)
+	return
+}
+
+//go:wasmimport wasi:io/poll@0.2.0 poll
+//go:noescape
+func wasmimport_Poll(in0 *Pollable, in1 uint32, result *cm.List[uint32])

src/internal/wasi/io/v0.2.0/streams/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/io/v0.2.0/streams/streams.wit.go

@@ -0,0 +1,521 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package streams represents the imported interface "wasi:io/streams@0.2.0".
+//
+// WASI I/O is an I/O abstraction API which is currently focused on providing
+// stream types.
+//
+// In the future, the component model is expected to add built-in stream types;
+// when it does, they are expected to subsume this API.
+package streams
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+	ioerror "internal/wasi/io/v0.2.0/error"
+	"internal/wasi/io/v0.2.0/poll"
+)
+
+// StreamError represents the imported variant "wasi:io/streams@0.2.0#stream-error".
+//
+// An error for input-stream and output-stream operations.
+//
+//	variant stream-error {
+//		last-operation-failed(error),
+//		closed,
+//	}
+type StreamError cm.Variant[uint8, ioerror.Error, ioerror.Error]
+
+// StreamErrorLastOperationFailed returns a [StreamError] of case "last-operation-failed".
+//
+// The last operation (a write or flush) failed before completion.
+//
+// More information is available in the `error` payload.
+func StreamErrorLastOperationFailed(data ioerror.Error) StreamError {
+	return cm.New[StreamError](0, data)
+}
+
+// LastOperationFailed returns a non-nil *[ioerror.Error] if [StreamError] represents the variant case "last-operation-failed".
+func (self *StreamError) LastOperationFailed() *ioerror.Error {
+	return cm.Case[ioerror.Error](self, 0)
+}
+
+// StreamErrorClosed returns a [StreamError] of case "closed".
+//
+// The stream is closed: no more input will be accepted by the
+// stream. A closed output-stream will return this error on all
+// future operations.
+func StreamErrorClosed() StreamError {
+	var data struct{}
+	return cm.New[StreamError](1, data)
+}
+
+// Closed returns true if [StreamError] represents the variant case "closed".
+func (self *StreamError) Closed() bool {
+	return cm.Tag(self) == 1
+}
+
+// InputStream represents the imported resource "wasi:io/streams@0.2.0#input-stream".
+//
+// An input bytestream.
+//
+// `input-stream`s are *non-blocking* to the extent practical on underlying
+// platforms. I/O operations always return promptly; if fewer bytes are
+// promptly available than requested, they return the number of bytes promptly
+// available, which could even be zero. To wait for data to be available,
+// use the `subscribe` function to obtain a `pollable` which can be polled
+// for using `wasi:io/poll`.
+//
+//	resource input-stream
+type InputStream cm.Resource
+
+// ResourceDrop represents the imported resource-drop for resource "input-stream".
+//
+// Drops a resource handle.
+//
+//go:nosplit
+func (self InputStream) ResourceDrop() {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_InputStreamResourceDrop((uint32)(self0))
+	return
+}
+
+//go:wasmimport wasi:io/streams@0.2.0 [resource-drop]input-stream
+//go:noescape
+func wasmimport_InputStreamResourceDrop(self0 uint32)
+
+// BlockingRead represents the imported method "blocking-read".
+//
+// Read bytes from a stream, after blocking until at least one byte can
+// be read. Except for blocking, behavior is identical to `read`.
+//
+//	blocking-read: func(len: u64) -> result<list<u8>, stream-error>
+//
+//go:nosplit
+func (self InputStream) BlockingRead(len_ uint64) (result cm.OKResult[cm.List[uint8], StreamError]) {
+	self0 := cm.Reinterpret[uint32](self)
+	len0 := (uint64)(len_)
+	wasmimport_InputStreamBlockingRead((uint32)(self0), (uint64)(len0), &result)
+	return
+}
+
+//go:wasmimport wasi:io/streams@0.2.0 [method]input-stream.blocking-read
+//go:noescape
+func wasmimport_InputStreamBlockingRead(self0 uint32, len0 uint64, result *cm.OKResult[cm.List[uint8], StreamError])
+
+// BlockingSkip represents the imported method "blocking-skip".
+//
+// Skip bytes from a stream, after blocking until at least one byte
+// can be skipped. Except for blocking behavior, identical to `skip`.
+//
+//	blocking-skip: func(len: u64) -> result<u64, stream-error>
+//
+//go:nosplit
+func (self InputStream) BlockingSkip(len_ uint64) (result cm.OKResult[uint64, StreamError]) {
+	self0 := cm.Reinterpret[uint32](self)
+	len0 := (uint64)(len_)
+	wasmimport_InputStreamBlockingSkip((uint32)(self0), (uint64)(len0), &result)
+	return
+}
+
+//go:wasmimport wasi:io/streams@0.2.0 [method]input-stream.blocking-skip
+//go:noescape
+func wasmimport_InputStreamBlockingSkip(self0 uint32, len0 uint64, result *cm.OKResult[uint64, StreamError])
+
+// Read represents the imported method "read".
+//
+// Perform a non-blocking read from the stream.
+//
+// When the source of a `read` is binary data, the bytes from the source
+// are returned verbatim. When the source of a `read` is known to the
+// implementation to be text, bytes containing the UTF-8 encoding of the
+// text are returned.
+//
+// This function returns a list of bytes containing the read data,
+// when successful. The returned list will contain up to `len` bytes;
+// it may return fewer than requested, but not more. The list is
+// empty when no bytes are available for reading at this time. The
+// pollable given by `subscribe` will be ready when more bytes are
+// available.
+//
+// This function fails with a `stream-error` when the operation
+// encounters an error, giving `last-operation-failed`, or when the
+// stream is closed, giving `closed`.
+//
+// When the caller gives a `len` of 0, it represents a request to
+// read 0 bytes. If the stream is still open, this call should
+// succeed and return an empty list, or otherwise fail with `closed`.
+//
+// The `len` parameter is a `u64`, which could represent a list of u8 which
+// is not possible to allocate in wasm32, or not desirable to allocate as
+// as a return value by the callee. The callee may return a list of bytes
+// less than `len` in size while more bytes are available for reading.
+//
+//	read: func(len: u64) -> result<list<u8>, stream-error>
+//
+//go:nosplit
+func (self InputStream) Read(len_ uint64) (result cm.OKResult[cm.List[uint8], StreamError]) {
+	self0 := cm.Reinterpret[uint32](self)
+	len0 := (uint64)(len_)
+	wasmimport_InputStreamRead((uint32)(self0), (uint64)(len0), &result)
+	return
+}
+
+//go:wasmimport wasi:io/streams@0.2.0 [method]input-stream.read
+//go:noescape
+func wasmimport_InputStreamRead(self0 uint32, len0 uint64, result *cm.OKResult[cm.List[uint8], StreamError])
+
+// Skip represents the imported method "skip".
+//
+// Skip bytes from a stream. Returns number of bytes skipped.
+//
+// Behaves identical to `read`, except instead of returning a list
+// of bytes, returns the number of bytes consumed from the stream.
+//
+//	skip: func(len: u64) -> result<u64, stream-error>
+//
+//go:nosplit
+func (self InputStream) Skip(len_ uint64) (result cm.OKResult[uint64, StreamError]) {
+	self0 := cm.Reinterpret[uint32](self)
+	len0 := (uint64)(len_)
+	wasmimport_InputStreamSkip((uint32)(self0), (uint64)(len0), &result)
+	return
+}
+
+//go:wasmimport wasi:io/streams@0.2.0 [method]input-stream.skip
+//go:noescape
+func wasmimport_InputStreamSkip(self0 uint32, len0 uint64, result *cm.OKResult[uint64, StreamError])
+
+// Subscribe represents the imported method "subscribe".
+//
+// Create a `pollable` which will resolve once either the specified stream
+// has bytes available to read or the other end of the stream has been
+// closed.
+// The created `pollable` is a child resource of the `input-stream`.
+// Implementations may trap if the `input-stream` is dropped before
+// all derived `pollable`s created with this function are dropped.
+//
+//	subscribe: func() -> pollable
+//
+//go:nosplit
+func (self InputStream) Subscribe() (result poll.Pollable) {
+	self0 := cm.Reinterpret[uint32](self)
+	result0 := wasmimport_InputStreamSubscribe((uint32)(self0))
+	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
+	return
+}
+
+//go:wasmimport wasi:io/streams@0.2.0 [method]input-stream.subscribe
+//go:noescape
+func wasmimport_InputStreamSubscribe(self0 uint32) (result0 uint32)
+
+// OutputStream represents the imported resource "wasi:io/streams@0.2.0#output-stream".
+//
+// An output bytestream.
+//
+// `output-stream`s are *non-blocking* to the extent practical on
+// underlying platforms. Except where specified otherwise, I/O operations also
+// always return promptly, after the number of bytes that can be written
+// promptly, which could even be zero. To wait for the stream to be ready to
+// accept data, the `subscribe` function to obtain a `pollable` which can be
+// polled for using `wasi:io/poll`.
+//
+//	resource output-stream
+type OutputStream cm.Resource
+
+// ResourceDrop represents the imported resource-drop for resource "output-stream".
+//
+// Drops a resource handle.
+//
+//go:nosplit
+func (self OutputStream) ResourceDrop() {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_OutputStreamResourceDrop((uint32)(self0))
+	return
+}
+
+//go:wasmimport wasi:io/streams@0.2.0 [resource-drop]output-stream
+//go:noescape
+func wasmimport_OutputStreamResourceDrop(self0 uint32)
+
+// BlockingFlush represents the imported method "blocking-flush".
+//
+// Request to flush buffered output, and block until flush completes
+// and stream is ready for writing again.
+//
+//	blocking-flush: func() -> result<_, stream-error>
+//
+//go:nosplit
+func (self OutputStream) BlockingFlush() (result cm.ErrResult[struct{}, StreamError]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_OutputStreamBlockingFlush((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.blocking-flush
+//go:noescape
+func wasmimport_OutputStreamBlockingFlush(self0 uint32, result *cm.ErrResult[struct{}, StreamError])
+
+// BlockingSplice represents the imported method "blocking-splice".
+//
+// Read from one stream and write to another, with blocking.
+//
+// This is similar to `splice`, except that it blocks until the
+// `output-stream` is ready for writing, and the `input-stream`
+// is ready for reading, before performing the `splice`.
+//
+//	blocking-splice: func(src: borrow<input-stream>, len: u64) -> result<u64, stream-error>
+//
+//go:nosplit
+func (self OutputStream) BlockingSplice(src InputStream, len_ uint64) (result cm.OKResult[uint64, StreamError]) {
+	self0 := cm.Reinterpret[uint32](self)
+	src0 := cm.Reinterpret[uint32](src)
+	len0 := (uint64)(len_)
+	wasmimport_OutputStreamBlockingSplice((uint32)(self0), (uint32)(src0), (uint64)(len0), &result)
+	return
+}
+
+//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.blocking-splice
+//go:noescape
+func wasmimport_OutputStreamBlockingSplice(self0 uint32, src0 uint32, len0 uint64, result *cm.OKResult[uint64, StreamError])
+
+// BlockingWriteAndFlush represents the imported method "blocking-write-and-flush".
+//
+// Perform a write of up to 4096 bytes, and then flush the stream. Block
+// until all of these operations are complete, or an error occurs.
+//
+// This is a convenience wrapper around the use of `check-write`,
+// `subscribe`, `write`, and `flush`, and is implemented with the
+// following pseudo-code:
+//
+//	let pollable = this.subscribe();
+//	while !contents.is_empty() {
+//	// Wait for the stream to become writable
+//	pollable.block();
+//	let Ok(n) = this.check-write(); // eliding error handling
+//	let len = min(n, contents.len());
+//	let (chunk, rest) = contents.split_at(len);
+//	this.write(chunk  );            // eliding error handling
+//	contents = rest;
+//	}
+//	this.flush();
+//	// Wait for completion of `flush`
+//	pollable.block();
+//	// Check for any errors that arose during `flush`
+//	let _ = this.check-write();         // eliding error handling
+//
+//	blocking-write-and-flush: func(contents: list<u8>) -> result<_, stream-error>
+//
+//go:nosplit
+func (self OutputStream) BlockingWriteAndFlush(contents cm.List[uint8]) (result cm.ErrResult[struct{}, StreamError]) {
+	self0 := cm.Reinterpret[uint32](self)
+	contents0, contents1 := cm.LowerList(contents)
+	wasmimport_OutputStreamBlockingWriteAndFlush((uint32)(self0), (*uint8)(contents0), (uint32)(contents1), &result)
+	return
+}
+
+//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.blocking-write-and-flush
+//go:noescape
+func wasmimport_OutputStreamBlockingWriteAndFlush(self0 uint32, contents0 *uint8, contents1 uint32, result *cm.ErrResult[struct{}, StreamError])
+
+// BlockingWriteZeroesAndFlush represents the imported method "blocking-write-zeroes-and-flush".
+//
+// Perform a write of up to 4096 zeroes, and then flush the stream.
+// Block until all of these operations are complete, or an error
+// occurs.
+//
+// This is a convenience wrapper around the use of `check-write`,
+// `subscribe`, `write-zeroes`, and `flush`, and is implemented with
+// the following pseudo-code:
+//
+//	let pollable = this.subscribe();
+//	while num_zeroes != 0 {
+//	// Wait for the stream to become writable
+//	pollable.block();
+//	let Ok(n) = this.check-write(); // eliding error handling
+//	let len = min(n, num_zeroes);
+//	this.write-zeroes(len);         // eliding error handling
+//	num_zeroes -= len;
+//	}
+//	this.flush();
+//	// Wait for completion of `flush`
+//	pollable.block();
+//	// Check for any errors that arose during `flush`
+//	let _ = this.check-write();         // eliding error handling
+//
+//	blocking-write-zeroes-and-flush: func(len: u64) -> result<_, stream-error>
+//
+//go:nosplit
+func (self OutputStream) BlockingWriteZeroesAndFlush(len_ uint64) (result cm.ErrResult[struct{}, StreamError]) {
+	self0 := cm.Reinterpret[uint32](self)
+	len0 := (uint64)(len_)
+	wasmimport_OutputStreamBlockingWriteZeroesAndFlush((uint32)(self0), (uint64)(len0), &result)
+	return
+}
+
+//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.blocking-write-zeroes-and-flush
+//go:noescape
+func wasmimport_OutputStreamBlockingWriteZeroesAndFlush(self0 uint32, len0 uint64, result *cm.ErrResult[struct{}, StreamError])
+
+// CheckWrite represents the imported method "check-write".
+//
+// Check readiness for writing. This function never blocks.
+//
+// Returns the number of bytes permitted for the next call to `write`,
+// or an error. Calling `write` with more bytes than this function has
+// permitted will trap.
+//
+// When this function returns 0 bytes, the `subscribe` pollable will
+// become ready when this function will report at least 1 byte, or an
+// error.
+//
+//	check-write: func() -> result<u64, stream-error>
+//
+//go:nosplit
+func (self OutputStream) CheckWrite() (result cm.OKResult[uint64, StreamError]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_OutputStreamCheckWrite((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.check-write
+//go:noescape
+func wasmimport_OutputStreamCheckWrite(self0 uint32, result *cm.OKResult[uint64, StreamError])
+
+// Flush represents the imported method "flush".
+//
+// Request to flush buffered output. This function never blocks.
+//
+// This tells the output-stream that the caller intends any buffered
+// output to be flushed. the output which is expected to be flushed
+// is all that has been passed to `write` prior to this call.
+//
+// Upon calling this function, the `output-stream` will not accept any
+// writes (`check-write` will return `ok(0)`) until the flush has
+// completed. The `subscribe` pollable will become ready when the
+// flush has completed and the stream can accept more writes.
+//
+//	flush: func() -> result<_, stream-error>
+//
+//go:nosplit
+func (self OutputStream) Flush() (result cm.ErrResult[struct{}, StreamError]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_OutputStreamFlush((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.flush
+//go:noescape
+func wasmimport_OutputStreamFlush(self0 uint32, result *cm.ErrResult[struct{}, StreamError])
+
+// Splice represents the imported method "splice".
+//
+// Read from one stream and write to another.
+//
+// The behavior of splice is equivelant to:
+// 1. calling `check-write` on the `output-stream`
+// 2. calling `read` on the `input-stream` with the smaller of the
+// `check-write` permitted length and the `len` provided to `splice`
+// 3. calling `write` on the `output-stream` with that read data.
+//
+// Any error reported by the call to `check-write`, `read`, or
+// `write` ends the splice and reports that error.
+//
+// This function returns the number of bytes transferred; it may be less
+// than `len`.
+//
+//	splice: func(src: borrow<input-stream>, len: u64) -> result<u64, stream-error>
+//
+//go:nosplit
+func (self OutputStream) Splice(src InputStream, len_ uint64) (result cm.OKResult[uint64, StreamError]) {
+	self0 := cm.Reinterpret[uint32](self)
+	src0 := cm.Reinterpret[uint32](src)
+	len0 := (uint64)(len_)
+	wasmimport_OutputStreamSplice((uint32)(self0), (uint32)(src0), (uint64)(len0), &result)
+	return
+}
+
+//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.splice
+//go:noescape
+func wasmimport_OutputStreamSplice(self0 uint32, src0 uint32, len0 uint64, result *cm.OKResult[uint64, StreamError])
+
+// Subscribe represents the imported method "subscribe".
+//
+// Create a `pollable` which will resolve once the output-stream
+// is ready for more writing, or an error has occured. When this
+// pollable is ready, `check-write` will return `ok(n)` with n>0, or an
+// error.
+//
+// If the stream is closed, this pollable is always ready immediately.
+//
+// The created `pollable` is a child resource of the `output-stream`.
+// Implementations may trap if the `output-stream` is dropped before
+// all derived `pollable`s created with this function are dropped.
+//
+//	subscribe: func() -> pollable
+//
+//go:nosplit
+func (self OutputStream) Subscribe() (result poll.Pollable) {
+	self0 := cm.Reinterpret[uint32](self)
+	result0 := wasmimport_OutputStreamSubscribe((uint32)(self0))
+	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
+	return
+}
+
+//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.subscribe
+//go:noescape
+func wasmimport_OutputStreamSubscribe(self0 uint32) (result0 uint32)
+
+// Write represents the imported method "write".
+//
+// Perform a write. This function never blocks.
+//
+// When the destination of a `write` is binary data, the bytes from
+// `contents` are written verbatim. When the destination of a `write` is
+// known to the implementation to be text, the bytes of `contents` are
+// transcoded from UTF-8 into the encoding of the destination and then
+// written.
+//
+// Precondition: check-write gave permit of Ok(n) and contents has a
+// length of less than or equal to n. Otherwise, this function will trap.
+//
+// returns Err(closed) without writing if the stream has closed since
+// the last call to check-write provided a permit.
+//
+//	write: func(contents: list<u8>) -> result<_, stream-error>
+//
+//go:nosplit
+func (self OutputStream) Write(contents cm.List[uint8]) (result cm.ErrResult[struct{}, StreamError]) {
+	self0 := cm.Reinterpret[uint32](self)
+	contents0, contents1 := cm.LowerList(contents)
+	wasmimport_OutputStreamWrite((uint32)(self0), (*uint8)(contents0), (uint32)(contents1), &result)
+	return
+}
+
+//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.write
+//go:noescape
+func wasmimport_OutputStreamWrite(self0 uint32, contents0 *uint8, contents1 uint32, result *cm.ErrResult[struct{}, StreamError])
+
+// WriteZeroes represents the imported method "write-zeroes".
+//
+// Write zeroes to a stream.
+//
+// This should be used precisely like `write` with the exact same
+// preconditions (must use check-write first), but instead of
+// passing a list of bytes, you simply pass the number of zero-bytes
+// that should be written.
+//
+//	write-zeroes: func(len: u64) -> result<_, stream-error>
+//
+//go:nosplit
+func (self OutputStream) WriteZeroes(len_ uint64) (result cm.ErrResult[struct{}, StreamError]) {
+	self0 := cm.Reinterpret[uint32](self)
+	len0 := (uint64)(len_)
+	wasmimport_OutputStreamWriteZeroes((uint32)(self0), (uint64)(len0), &result)
+	return
+}
+
+//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.write-zeroes
+//go:noescape
+func wasmimport_OutputStreamWriteZeroes(self0 uint32, len0 uint64, result *cm.ErrResult[struct{}, StreamError])

src/internal/wasi/random/v0.2.0/insecure-seed/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/random/v0.2.0/insecure-seed/insecure-seed.wit.go

@@ -0,0 +1,43 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package insecureseed represents the imported interface "wasi:random/insecure-seed@0.2.0".
+//
+// The insecure-seed interface for seeding hash-map DoS resistance.
+//
+// It is intended to be portable at least between Unix-family platforms and
+// Windows.
+package insecureseed
+
+// InsecureSeed represents the imported function "insecure-seed".
+//
+// Return a 128-bit value that may contain a pseudo-random value.
+//
+// The returned value is not required to be computed from a CSPRNG, and may
+// even be entirely deterministic. Host implementations are encouraged to
+// provide pseudo-random values to any program exposed to
+// attacker-controlled content, to enable DoS protection built into many
+// languages' hash-map implementations.
+//
+// This function is intended to only be called once, by a source language
+// to initialize Denial Of Service (DoS) protection in its hash-map
+// implementation.
+//
+// # Expected future evolution
+//
+// This will likely be changed to a value import, to prevent it from being
+// called multiple times and potentially used for purposes other than DoS
+// protection.
+//
+//	insecure-seed: func() -> tuple<u64, u64>
+//
+//go:nosplit
+func InsecureSeed() (result [2]uint64) {
+	wasmimport_InsecureSeed(&result)
+	return
+}
+
+//go:wasmimport wasi:random/insecure-seed@0.2.0 insecure-seed
+//go:noescape
+func wasmimport_InsecureSeed(result *[2]uint64)

src/internal/wasi/random/v0.2.0/insecure/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/random/v0.2.0/insecure/insecure.wit.go

@@ -0,0 +1,59 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package insecure represents the imported interface "wasi:random/insecure@0.2.0".
+//
+// The insecure interface for insecure pseudo-random numbers.
+//
+// It is intended to be portable at least between Unix-family platforms and
+// Windows.
+package insecure
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+)
+
+// GetInsecureRandomBytes represents the imported function "get-insecure-random-bytes".
+//
+// Return `len` insecure pseudo-random bytes.
+//
+// This function is not cryptographically secure. Do not use it for
+// anything related to security.
+//
+// There are no requirements on the values of the returned bytes, however
+// implementations are encouraged to return evenly distributed values with
+// a long period.
+//
+//	get-insecure-random-bytes: func(len: u64) -> list<u8>
+//
+//go:nosplit
+func GetInsecureRandomBytes(len_ uint64) (result cm.List[uint8]) {
+	len0 := (uint64)(len_)
+	wasmimport_GetInsecureRandomBytes((uint64)(len0), &result)
+	return
+}
+
+//go:wasmimport wasi:random/insecure@0.2.0 get-insecure-random-bytes
+//go:noescape
+func wasmimport_GetInsecureRandomBytes(len0 uint64, result *cm.List[uint8])
+
+// GetInsecureRandomU64 represents the imported function "get-insecure-random-u64".
+//
+// Return an insecure pseudo-random `u64` value.
+//
+// This function returns the same type of pseudo-random data as
+// `get-insecure-random-bytes`, represented as a `u64`.
+//
+//	get-insecure-random-u64: func() -> u64
+//
+//go:nosplit
+func GetInsecureRandomU64() (result uint64) {
+	result0 := wasmimport_GetInsecureRandomU64()
+	result = (uint64)((uint64)(result0))
+	return
+}
+
+//go:wasmimport wasi:random/insecure@0.2.0 get-insecure-random-u64
+//go:noescape
+func wasmimport_GetInsecureRandomU64() (result0 uint64)

src/internal/wasi/random/v0.2.0/random/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/random/v0.2.0/random/random.wit.go

@@ -0,0 +1,63 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package random represents the imported interface "wasi:random/random@0.2.0".
+//
+// WASI Random is a random data API.
+//
+// It is intended to be portable at least between Unix-family platforms and
+// Windows.
+package random
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+)
+
+// GetRandomBytes represents the imported function "get-random-bytes".
+//
+// Return `len` cryptographically-secure random or pseudo-random bytes.
+//
+// This function must produce data at least as cryptographically secure and
+// fast as an adequately seeded cryptographically-secure pseudo-random
+// number generator (CSPRNG). It must not block, from the perspective of
+// the calling program, under any circumstances, including on the first
+// request and on requests for numbers of bytes. The returned data must
+// always be unpredictable.
+//
+// This function must always return fresh data. Deterministic environments
+// must omit this function, rather than implementing it with deterministic
+// data.
+//
+//	get-random-bytes: func(len: u64) -> list<u8>
+//
+//go:nosplit
+func GetRandomBytes(len_ uint64) (result cm.List[uint8]) {
+	len0 := (uint64)(len_)
+	wasmimport_GetRandomBytes((uint64)(len0), &result)
+	return
+}
+
+//go:wasmimport wasi:random/random@0.2.0 get-random-bytes
+//go:noescape
+func wasmimport_GetRandomBytes(len0 uint64, result *cm.List[uint8])
+
+// GetRandomU64 represents the imported function "get-random-u64".
+//
+// Return a cryptographically-secure random or pseudo-random `u64` value.
+//
+// This function returns the same type of data as `get-random-bytes`,
+// represented as a `u64`.
+//
+//	get-random-u64: func() -> u64
+//
+//go:nosplit
+func GetRandomU64() (result uint64) {
+	result0 := wasmimport_GetRandomU64()
+	result = (uint64)((uint64)(result0))
+	return
+}
+
+//go:wasmimport wasi:random/random@0.2.0 get-random-u64
+//go:noescape
+func wasmimport_GetRandomU64() (result0 uint64)

src/internal/wasi/sockets/v0.2.0/instance-network/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/sockets/v0.2.0/instance-network/instance-network.wit.go

@@ -0,0 +1,30 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package instancenetwork represents the imported interface "wasi:sockets/instance-network@0.2.0".
+//
+// This interface provides a value-export of the default network handle..
+package instancenetwork
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+	"internal/wasi/sockets/v0.2.0/network"
+)
+
+// InstanceNetwork represents the imported function "instance-network".
+//
+// Get a handle to the default network.
+//
+//	instance-network: func() -> network
+//
+//go:nosplit
+func InstanceNetwork() (result network.Network) {
+	result0 := wasmimport_InstanceNetwork()
+	result = cm.Reinterpret[network.Network]((uint32)(result0))
+	return
+}
+
+//go:wasmimport wasi:sockets/instance-network@0.2.0 instance-network
+//go:noescape
+func wasmimport_InstanceNetwork() (result0 uint32)

src/internal/wasi/sockets/v0.2.0/ip-name-lookup/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/sockets/v0.2.0/ip-name-lookup/ip-name-lookup.wit.go

@@ -0,0 +1,123 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package ipnamelookup represents the imported interface "wasi:sockets/ip-name-lookup@0.2.0".
+package ipnamelookup
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+	"internal/wasi/io/v0.2.0/poll"
+	"internal/wasi/sockets/v0.2.0/network"
+)
+
+// ResolveAddressStream represents the imported resource "wasi:sockets/ip-name-lookup@0.2.0#resolve-address-stream".
+//
+//	resource resolve-address-stream
+type ResolveAddressStream cm.Resource
+
+// ResourceDrop represents the imported resource-drop for resource "resolve-address-stream".
+//
+// Drops a resource handle.
+//
+//go:nosplit
+func (self ResolveAddressStream) ResourceDrop() {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_ResolveAddressStreamResourceDrop((uint32)(self0))
+	return
+}
+
+//go:wasmimport wasi:sockets/ip-name-lookup@0.2.0 [resource-drop]resolve-address-stream
+//go:noescape
+func wasmimport_ResolveAddressStreamResourceDrop(self0 uint32)
+
+// ResolveNextAddress represents the imported method "resolve-next-address".
+//
+// Returns the next address from the resolver.
+//
+// This function should be called multiple times. On each call, it will
+// return the next address in connection order preference. If all
+// addresses have been exhausted, this function returns `none`.
+//
+// This function never returns IPv4-mapped IPv6 addresses.
+//
+// # Typical errors
+// - `name-unresolvable`:          Name does not exist or has no suitable associated
+// IP addresses. (EAI_NONAME, EAI_NODATA, EAI_ADDRFAMILY)
+// - `temporary-resolver-failure`: A temporary failure in name resolution occurred.
+// (EAI_AGAIN)
+// - `permanent-resolver-failure`: A permanent failure in name resolution occurred.
+// (EAI_FAIL)
+// - `would-block`:                A result is not available yet. (EWOULDBLOCK, EAGAIN)
+//
+//	resolve-next-address: func() -> result<option<ip-address>, error-code>
+//
+//go:nosplit
+func (self ResolveAddressStream) ResolveNextAddress() (result cm.OKResult[cm.Option[network.IPAddress], network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_ResolveAddressStreamResolveNextAddress((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/ip-name-lookup@0.2.0 [method]resolve-address-stream.resolve-next-address
+//go:noescape
+func wasmimport_ResolveAddressStreamResolveNextAddress(self0 uint32, result *cm.OKResult[cm.Option[network.IPAddress], network.ErrorCode])
+
+// Subscribe represents the imported method "subscribe".
+//
+// Create a `pollable` which will resolve once the stream is ready for I/O.
+//
+// Note: this function is here for WASI Preview2 only.
+// It's planned to be removed when `future` is natively supported in Preview3.
+//
+//	subscribe: func() -> pollable
+//
+//go:nosplit
+func (self ResolveAddressStream) Subscribe() (result poll.Pollable) {
+	self0 := cm.Reinterpret[uint32](self)
+	result0 := wasmimport_ResolveAddressStreamSubscribe((uint32)(self0))
+	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
+	return
+}
+
+//go:wasmimport wasi:sockets/ip-name-lookup@0.2.0 [method]resolve-address-stream.subscribe
+//go:noescape
+func wasmimport_ResolveAddressStreamSubscribe(self0 uint32) (result0 uint32)
+
+// ResolveAddresses represents the imported function "resolve-addresses".
+//
+// Resolve an internet host name to a list of IP addresses.
+//
+// Unicode domain names are automatically converted to ASCII using IDNA encoding.
+// If the input is an IP address string, the address is parsed and returned
+// as-is without making any external requests.
+//
+// See the wasi-socket proposal README.md for a comparison with getaddrinfo.
+//
+// This function never blocks. It either immediately fails or immediately
+// returns successfully with a `resolve-address-stream` that can be used
+// to (asynchronously) fetch the results.
+//
+// # Typical errors
+// - `invalid-argument`: `name` is a syntactically invalid domain name or IP address.
+//
+// # References:
+// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getaddrinfo.html>
+// - <https://man7.org/linux/man-pages/man3/getaddrinfo.3.html>
+// - <https://learn.microsoft.com/en-us/windows/win32/api/ws2tcpip/nf-ws2tcpip-getaddrinfo>
+// - <https://man.freebsd.org/cgi/man.cgi?query=getaddrinfo&sektion=3>
+//
+//	resolve-addresses: func(network: borrow<network>, name: string) -> result<resolve-address-stream,
+//	error-code>
+//
+//go:nosplit
+func ResolveAddresses(network_ network.Network, name string) (result cm.OKResult[ResolveAddressStream, network.ErrorCode]) {
+	network0 := cm.Reinterpret[uint32](network_)
+	name0, name1 := cm.LowerString(name)
+	wasmimport_ResolveAddresses((uint32)(network0), (*uint8)(name0), (uint32)(name1), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/ip-name-lookup@0.2.0 resolve-addresses
+//go:noescape
+func wasmimport_ResolveAddresses(network0 uint32, name0 *uint8, name1 uint32, result *cm.OKResult[ResolveAddressStream, network.ErrorCode])

src/internal/wasi/sockets/v0.2.0/network/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/sockets/v0.2.0/network/network.wit.go

@@ -0,0 +1,278 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package network represents the imported interface "wasi:sockets/network@0.2.0".
+package network
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+)
+
+// Network represents the imported resource "wasi:sockets/network@0.2.0#network".
+//
+// An opaque resource that represents access to (a subset of) the network.
+// This enables context-based security for networking.
+// There is no need for this to map 1:1 to a physical network interface.
+//
+//	resource network
+type Network cm.Resource
+
+// ResourceDrop represents the imported resource-drop for resource "network".
+//
+// Drops a resource handle.
+//
+//go:nosplit
+func (self Network) ResourceDrop() {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_NetworkResourceDrop((uint32)(self0))
+	return
+}
+
+//go:wasmimport wasi:sockets/network@0.2.0 [resource-drop]network
+//go:noescape
+func wasmimport_NetworkResourceDrop(self0 uint32)
+
+// ErrorCode represents the enum "wasi:sockets/network@0.2.0#error-code".
+//
+// Error codes.
+//
+// In theory, every API can return any error code.
+// In practice, API's typically only return the errors documented per API
+// combined with a couple of errors that are always possible:
+// - `unknown`
+// - `access-denied`
+// - `not-supported`
+// - `out-of-memory`
+// - `concurrency-conflict`
+//
+// See each individual API for what the POSIX equivalents are. They sometimes differ
+// per API.
+//
+//	enum error-code {
+//		unknown,
+//		access-denied,
+//		not-supported,
+//		invalid-argument,
+//		out-of-memory,
+//		timeout,
+//		concurrency-conflict,
+//		not-in-progress,
+//		would-block,
+//		invalid-state,
+//		new-socket-limit,
+//		address-not-bindable,
+//		address-in-use,
+//		remote-unreachable,
+//		connection-refused,
+//		connection-reset,
+//		connection-aborted,
+//		datagram-too-large,
+//		name-unresolvable,
+//		temporary-resolver-failure,
+//		permanent-resolver-failure
+//	}
+type ErrorCode uint8
+
+const (
+	// Unknown error
+	ErrorCodeUnknown ErrorCode = iota
+
+	// Access denied.
+	//
+	// POSIX equivalent: EACCES, EPERM
+	ErrorCodeAccessDenied
+
+	// The operation is not supported.
+	//
+	// POSIX equivalent: EOPNOTSUPP
+	ErrorCodeNotSupported
+
+	// One of the arguments is invalid.
+	//
+	// POSIX equivalent: EINVAL
+	ErrorCodeInvalidArgument
+
+	// Not enough memory to complete the operation.
+	//
+	// POSIX equivalent: ENOMEM, ENOBUFS, EAI_MEMORY
+	ErrorCodeOutOfMemory
+
+	// The operation timed out before it could finish completely.
+	ErrorCodeTimeout
+
+	// This operation is incompatible with another asynchronous operation that is already
+	// in progress.
+	//
+	// POSIX equivalent: EALREADY
+	ErrorCodeConcurrencyConflict
+
+	// Trying to finish an asynchronous operation that:
+	// - has not been started yet, or:
+	// - was already finished by a previous `finish-*` call.
+	//
+	// Note: this is scheduled to be removed when `future`s are natively supported.
+	ErrorCodeNotInProgress
+
+	// The operation has been aborted because it could not be completed immediately.
+	//
+	// Note: this is scheduled to be removed when `future`s are natively supported.
+	ErrorCodeWouldBlock
+
+	// The operation is not valid in the socket's current state.
+	ErrorCodeInvalidState
+
+	// A new socket resource could not be created because of a system limit.
+	ErrorCodeNewSocketLimit
+
+	// A bind operation failed because the provided address is not an address that the
+	// `network` can bind to.
+	ErrorCodeAddressNotBindable
+
+	// A bind operation failed because the provided address is already in use or because
+	// there are no ephemeral ports available.
+	ErrorCodeAddressInUse
+
+	// The remote address is not reachable
+	ErrorCodeRemoteUnreachable
+
+	// The TCP connection was forcefully rejected
+	ErrorCodeConnectionRefused
+
+	// The TCP connection was reset.
+	ErrorCodeConnectionReset
+
+	// A TCP connection was aborted.
+	ErrorCodeConnectionAborted
+
+	// The size of a datagram sent to a UDP socket exceeded the maximum
+	// supported size.
+	ErrorCodeDatagramTooLarge
+
+	// Name does not exist or has no suitable associated IP addresses.
+	ErrorCodeNameUnresolvable
+
+	// A temporary failure in name resolution occurred.
+	ErrorCodeTemporaryResolverFailure
+
+	// A permanent failure in name resolution occurred.
+	ErrorCodePermanentResolverFailure
+)
+
+// IPAddressFamily represents the enum "wasi:sockets/network@0.2.0#ip-address-family".
+//
+//	enum ip-address-family {
+//		ipv4,
+//		ipv6
+//	}
+type IPAddressFamily uint8
+
+const (
+	// Similar to `AF_INET` in POSIX.
+	IPAddressFamilyIPv4 IPAddressFamily = iota
+
+	// Similar to `AF_INET6` in POSIX.
+	IPAddressFamilyIPv6
+)
+
+// IPv4Address represents the tuple "wasi:sockets/network@0.2.0#ipv4-address".
+//
+//	type ipv4-address = tuple<u8, u8, u8, u8>
+type IPv4Address [4]uint8
+
+// IPv6Address represents the tuple "wasi:sockets/network@0.2.0#ipv6-address".
+//
+//	type ipv6-address = tuple<u16, u16, u16, u16, u16, u16, u16, u16>
+type IPv6Address [8]uint16
+
+// IPAddress represents the variant "wasi:sockets/network@0.2.0#ip-address".
+//
+//	variant ip-address {
+//		ipv4(ipv4-address),
+//		ipv6(ipv6-address),
+//	}
+type IPAddress cm.Variant[uint8, IPv6Address, IPv6Address]
+
+// IPAddressIPv4 returns a [IPAddress] of case "ipv4".
+func IPAddressIPv4(data IPv4Address) IPAddress {
+	return cm.New[IPAddress](0, data)
+}
+
+// IPv4 returns a non-nil *[IPv4Address] if [IPAddress] represents the variant case "ipv4".
+func (self *IPAddress) IPv4() *IPv4Address {
+	return cm.Case[IPv4Address](self, 0)
+}
+
+// IPAddressIPv6 returns a [IPAddress] of case "ipv6".
+func IPAddressIPv6(data IPv6Address) IPAddress {
+	return cm.New[IPAddress](1, data)
+}
+
+// IPv6 returns a non-nil *[IPv6Address] if [IPAddress] represents the variant case "ipv6".
+func (self *IPAddress) IPv6() *IPv6Address {
+	return cm.Case[IPv6Address](self, 1)
+}
+
+// IPv4SocketAddress represents the record "wasi:sockets/network@0.2.0#ipv4-socket-address".
+//
+//	record ipv4-socket-address {
+//		port: u16,
+//		address: ipv4-address,
+//	}
+type IPv4SocketAddress struct {
+	// sin_port
+	Port uint16
+
+	// sin_addr
+	Address IPv4Address
+}
+
+// IPv6SocketAddress represents the record "wasi:sockets/network@0.2.0#ipv6-socket-address".
+//
+//	record ipv6-socket-address {
+//		port: u16,
+//		flow-info: u32,
+//		address: ipv6-address,
+//		scope-id: u32,
+//	}
+type IPv6SocketAddress struct {
+	// sin6_port
+	Port uint16
+
+	// sin6_flowinfo
+	FlowInfo uint32
+
+	// sin6_addr
+	Address IPv6Address
+
+	// sin6_scope_id
+	ScopeID uint32
+}
+
+// IPSocketAddress represents the variant "wasi:sockets/network@0.2.0#ip-socket-address".
+//
+//	variant ip-socket-address {
+//		ipv4(ipv4-socket-address),
+//		ipv6(ipv6-socket-address),
+//	}
+type IPSocketAddress cm.Variant[uint8, IPv6SocketAddress, IPv6SocketAddress]
+
+// IPSocketAddressIPv4 returns a [IPSocketAddress] of case "ipv4".
+func IPSocketAddressIPv4(data IPv4SocketAddress) IPSocketAddress {
+	return cm.New[IPSocketAddress](0, data)
+}
+
+// IPv4 returns a non-nil *[IPv4SocketAddress] if [IPSocketAddress] represents the variant case "ipv4".
+func (self *IPSocketAddress) IPv4() *IPv4SocketAddress {
+	return cm.Case[IPv4SocketAddress](self, 0)
+}
+
+// IPSocketAddressIPv6 returns a [IPSocketAddress] of case "ipv6".
+func IPSocketAddressIPv6(data IPv6SocketAddress) IPSocketAddress {
+	return cm.New[IPSocketAddress](1, data)
+}
+
+// IPv6 returns a non-nil *[IPv6SocketAddress] if [IPSocketAddress] represents the variant case "ipv6".
+func (self *IPSocketAddress) IPv6() *IPv6SocketAddress {
+	return cm.Case[IPv6SocketAddress](self, 1)
+}

src/internal/wasi/sockets/v0.2.0/tcp-create-socket/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/sockets/v0.2.0/tcp-create-socket/tcp-create-socket.wit.go

@@ -0,0 +1,54 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package tcpcreatesocket represents the imported interface "wasi:sockets/tcp-create-socket@0.2.0".
+package tcpcreatesocket
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+	"internal/wasi/sockets/v0.2.0/network"
+	"internal/wasi/sockets/v0.2.0/tcp"
+)
+
+// CreateTCPSocket represents the imported function "create-tcp-socket".
+//
+// Create a new TCP socket.
+//
+// Similar to `socket(AF_INET or AF_INET6, SOCK_STREAM, IPPROTO_TCP)` in POSIX.
+// On IPv6 sockets, IPV6_V6ONLY is enabled by default and can't be configured otherwise.
+//
+// This function does not require a network capability handle. This is considered
+// to be safe because
+// at time of creation, the socket is not bound to any `network` yet. Up to the moment
+// `bind`/`connect`
+// is called, the socket is effectively an in-memory configuration object, unable
+// to communicate with the outside world.
+//
+// All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous
+// operations.
+//
+// # Typical errors
+// - `not-supported`:     The specified `address-family` is not supported. (EAFNOSUPPORT)
+// - `new-socket-limit`:  The new socket resource could not be created because of
+// a system limit. (EMFILE, ENFILE)
+//
+// # References
+// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html>
+// - <https://man7.org/linux/man-pages/man2/socket.2.html>
+// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw>
+// - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2>
+//
+//	create-tcp-socket: func(address-family: ip-address-family) -> result<tcp-socket,
+//	error-code>
+//
+//go:nosplit
+func CreateTCPSocket(addressFamily network.IPAddressFamily) (result cm.OKResult[tcp.TCPSocket, network.ErrorCode]) {
+	addressFamily0 := (uint32)(addressFamily)
+	wasmimport_CreateTCPSocket((uint32)(addressFamily0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp-create-socket@0.2.0 create-tcp-socket
+//go:noescape
+func wasmimport_CreateTCPSocket(addressFamily0 uint32, result *cm.OKResult[tcp.TCPSocket, network.ErrorCode])

src/internal/wasi/sockets/v0.2.0/tcp/abi.go

@@ -0,0 +1,71 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+package tcp
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+	"internal/wasi/sockets/v0.2.0/network"
+)
+
+func lower_IPv4Address(v network.IPv4Address) (f0 uint32, f1 uint32, f2 uint32, f3 uint32) {
+	f0 = (uint32)(v[0])
+	f1 = (uint32)(v[1])
+	f2 = (uint32)(v[2])
+	f3 = (uint32)(v[3])
+	return
+}
+
+func lower_IPv4SocketAddress(v network.IPv4SocketAddress) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32) {
+	f0 = (uint32)(v.Port)
+	f1, f2, f3, f4 = lower_IPv4Address(v.Address)
+	return
+}
+
+func lower_IPv6Address(v network.IPv6Address) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32, f5 uint32, f6 uint32, f7 uint32) {
+	f0 = (uint32)(v[0])
+	f1 = (uint32)(v[1])
+	f2 = (uint32)(v[2])
+	f3 = (uint32)(v[3])
+	f4 = (uint32)(v[4])
+	f5 = (uint32)(v[5])
+	f6 = (uint32)(v[6])
+	f7 = (uint32)(v[7])
+	return
+}
+
+func lower_IPv6SocketAddress(v network.IPv6SocketAddress) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32, f5 uint32, f6 uint32, f7 uint32, f8 uint32, f9 uint32, f10 uint32) {
+	f0 = (uint32)(v.Port)
+	f1 = (uint32)(v.FlowInfo)
+	f2, f3, f4, f5, f6, f7, f8, f9 = lower_IPv6Address(v.Address)
+	f10 = (uint32)(v.ScopeID)
+	return
+}
+
+func lower_IPSocketAddress(v network.IPSocketAddress) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32, f5 uint32, f6 uint32, f7 uint32, f8 uint32, f9 uint32, f10 uint32, f11 uint32) {
+	f0 = (uint32)(cm.Tag(&v))
+	switch f0 {
+	case 0: // ipv4
+		v1, v2, v3, v4, v5 := lower_IPv4SocketAddress(*v.IPv4())
+		f1 = (uint32)(v1)
+		f2 = (uint32)(v2)
+		f3 = (uint32)(v3)
+		f4 = (uint32)(v4)
+		f5 = (uint32)(v5)
+	case 1: // ipv6
+		v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11 := lower_IPv6SocketAddress(*v.IPv6())
+		f1 = (uint32)(v1)
+		f2 = (uint32)(v2)
+		f3 = (uint32)(v3)
+		f4 = (uint32)(v4)
+		f5 = (uint32)(v5)
+		f6 = (uint32)(v6)
+		f7 = (uint32)(v7)
+		f8 = (uint32)(v8)
+		f9 = (uint32)(v9)
+		f10 = (uint32)(v10)
+		f11 = (uint32)(v11)
+	}
+	return
+}

src/internal/wasi/sockets/v0.2.0/tcp/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/sockets/v0.2.0/tcp/tcp.wit.go

@@ -0,0 +1,839 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package tcp represents the imported interface "wasi:sockets/tcp@0.2.0".
+package tcp
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+	monotonicclock "internal/wasi/clocks/v0.2.0/monotonic-clock"
+	"internal/wasi/io/v0.2.0/poll"
+	"internal/wasi/io/v0.2.0/streams"
+	"internal/wasi/sockets/v0.2.0/network"
+)
+
+// ShutdownType represents the enum "wasi:sockets/tcp@0.2.0#shutdown-type".
+//
+//	enum shutdown-type {
+//		receive,
+//		send,
+//		both
+//	}
+type ShutdownType uint8
+
+const (
+	// Similar to `SHUT_RD` in POSIX.
+	ShutdownTypeReceive ShutdownType = iota
+
+	// Similar to `SHUT_WR` in POSIX.
+	ShutdownTypeSend
+
+	// Similar to `SHUT_RDWR` in POSIX.
+	ShutdownTypeBoth
+)
+
+// TCPSocket represents the imported resource "wasi:sockets/tcp@0.2.0#tcp-socket".
+//
+// A TCP socket resource.
+//
+// The socket can be in one of the following states:
+// - `unbound`
+// - `bind-in-progress`
+// - `bound` (See note below)
+// - `listen-in-progress`
+// - `listening`
+// - `connect-in-progress`
+// - `connected`
+// - `closed`
+// See <https://github.com/WebAssembly/wasi-sockets/TcpSocketOperationalSemantics.md>
+// for a more information.
+//
+// Note: Except where explicitly mentioned, whenever this documentation uses
+// the term "bound" without backticks it actually means: in the `bound` state *or
+// higher*.
+// (i.e. `bound`, `listen-in-progress`, `listening`, `connect-in-progress` or `connected`)
+//
+// In addition to the general error codes documented on the
+// `network::error-code` type, TCP socket methods may always return
+// `error(invalid-state)` when in the `closed` state.
+//
+//	resource tcp-socket
+type TCPSocket cm.Resource
+
+// ResourceDrop represents the imported resource-drop for resource "tcp-socket".
+//
+// Drops a resource handle.
+//
+//go:nosplit
+func (self TCPSocket) ResourceDrop() {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_TCPSocketResourceDrop((uint32)(self0))
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [resource-drop]tcp-socket
+//go:noescape
+func wasmimport_TCPSocketResourceDrop(self0 uint32)
+
+// Accept represents the imported method "accept".
+//
+// Accept a new client socket.
+//
+// The returned socket is bound and in the `connected` state. The following properties
+// are inherited from the listener socket:
+// - `address-family`
+// - `keep-alive-enabled`
+// - `keep-alive-idle-time`
+// - `keep-alive-interval`
+// - `keep-alive-count`
+// - `hop-limit`
+// - `receive-buffer-size`
+// - `send-buffer-size`
+//
+// On success, this function returns the newly accepted client socket along with
+// a pair of streams that can be used to read & write to the connection.
+//
+// # Typical errors
+// - `invalid-state`:      Socket is not in the `listening` state. (EINVAL)
+// - `would-block`:        No pending connections at the moment. (EWOULDBLOCK, EAGAIN)
+// - `connection-aborted`: An incoming connection was pending, but was terminated
+// by the client before this listener could accept it. (ECONNABORTED)
+// - `new-socket-limit`:   The new socket resource could not be created because of
+// a system limit. (EMFILE, ENFILE)
+//
+// # References
+// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/accept.html>
+// - <https://man7.org/linux/man-pages/man2/accept.2.html>
+// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-accept>
+// - <https://man.freebsd.org/cgi/man.cgi?query=accept&sektion=2>
+//
+//	accept: func() -> result<tuple<tcp-socket, input-stream, output-stream>, error-code>
+//
+//go:nosplit
+func (self TCPSocket) Accept() (result cm.OKResult[cm.Tuple3[TCPSocket, streams.InputStream, streams.OutputStream], network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_TCPSocketAccept((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.accept
+//go:noescape
+func wasmimport_TCPSocketAccept(self0 uint32, result *cm.OKResult[cm.Tuple3[TCPSocket, streams.InputStream, streams.OutputStream], network.ErrorCode])
+
+// AddressFamily represents the imported method "address-family".
+//
+// Whether this is a IPv4 or IPv6 socket.
+//
+// Equivalent to the SO_DOMAIN socket option.
+//
+//	address-family: func() -> ip-address-family
+//
+//go:nosplit
+func (self TCPSocket) AddressFamily() (result network.IPAddressFamily) {
+	self0 := cm.Reinterpret[uint32](self)
+	result0 := wasmimport_TCPSocketAddressFamily((uint32)(self0))
+	result = (network.IPAddressFamily)((uint32)(result0))
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.address-family
+//go:noescape
+func wasmimport_TCPSocketAddressFamily(self0 uint32) (result0 uint32)
+
+// FinishBind represents the imported method "finish-bind".
+//
+//	finish-bind: func() -> result<_, error-code>
+//
+//go:nosplit
+func (self TCPSocket) FinishBind() (result cm.ErrResult[struct{}, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_TCPSocketFinishBind((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.finish-bind
+//go:noescape
+func wasmimport_TCPSocketFinishBind(self0 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
+
+// FinishConnect represents the imported method "finish-connect".
+//
+//	finish-connect: func() -> result<tuple<input-stream, output-stream>, error-code>
+//
+//go:nosplit
+func (self TCPSocket) FinishConnect() (result cm.OKResult[cm.Tuple[streams.InputStream, streams.OutputStream], network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_TCPSocketFinishConnect((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.finish-connect
+//go:noescape
+func wasmimport_TCPSocketFinishConnect(self0 uint32, result *cm.OKResult[cm.Tuple[streams.InputStream, streams.OutputStream], network.ErrorCode])
+
+// FinishListen represents the imported method "finish-listen".
+//
+//	finish-listen: func() -> result<_, error-code>
+//
+//go:nosplit
+func (self TCPSocket) FinishListen() (result cm.ErrResult[struct{}, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_TCPSocketFinishListen((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.finish-listen
+//go:noescape
+func wasmimport_TCPSocketFinishListen(self0 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
+
+// HopLimit represents the imported method "hop-limit".
+//
+// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options.
+//
+// If the provided value is 0, an `invalid-argument` error is returned.
+//
+// # Typical errors
+// - `invalid-argument`:     (set) The TTL value must be 1 or higher.
+//
+//	hop-limit: func() -> result<u8, error-code>
+//
+//go:nosplit
+func (self TCPSocket) HopLimit() (result cm.OKResult[uint8, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_TCPSocketHopLimit((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.hop-limit
+//go:noescape
+func wasmimport_TCPSocketHopLimit(self0 uint32, result *cm.OKResult[uint8, network.ErrorCode])
+
+// IsListening represents the imported method "is-listening".
+//
+// Whether the socket is in the `listening` state.
+//
+// Equivalent to the SO_ACCEPTCONN socket option.
+//
+//	is-listening: func() -> bool
+//
+//go:nosplit
+func (self TCPSocket) IsListening() (result bool) {
+	self0 := cm.Reinterpret[uint32](self)
+	result0 := wasmimport_TCPSocketIsListening((uint32)(self0))
+	result = cm.U32ToBool((uint32)(result0))
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.is-listening
+//go:noescape
+func wasmimport_TCPSocketIsListening(self0 uint32) (result0 uint32)
+
+// KeepAliveCount represents the imported method "keep-alive-count".
+//
+// The maximum amount of keepalive packets TCP should send before aborting the connection.
+//
+// If the provided value is 0, an `invalid-argument` error is returned.
+// Any other value will never cause an error, but it might be silently clamped and/or
+// rounded.
+// I.e. after setting a value, reading the same setting back may return a different
+// value.
+//
+// Equivalent to the TCP_KEEPCNT socket option.
+//
+// # Typical errors
+// - `invalid-argument`:     (set) The provided value was 0.
+//
+//	keep-alive-count: func() -> result<u32, error-code>
+//
+//go:nosplit
+func (self TCPSocket) KeepAliveCount() (result cm.OKResult[uint32, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_TCPSocketKeepAliveCount((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.keep-alive-count
+//go:noescape
+func wasmimport_TCPSocketKeepAliveCount(self0 uint32, result *cm.OKResult[uint32, network.ErrorCode])
+
+// KeepAliveEnabled represents the imported method "keep-alive-enabled".
+//
+// Enables or disables keepalive.
+//
+// The keepalive behavior can be adjusted using:
+// - `keep-alive-idle-time`
+// - `keep-alive-interval`
+// - `keep-alive-count`
+// These properties can be configured while `keep-alive-enabled` is false, but only
+// come into effect when `keep-alive-enabled` is true.
+//
+// Equivalent to the SO_KEEPALIVE socket option.
+//
+//	keep-alive-enabled: func() -> result<bool, error-code>
+//
+//go:nosplit
+func (self TCPSocket) KeepAliveEnabled() (result cm.OKResult[bool, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_TCPSocketKeepAliveEnabled((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.keep-alive-enabled
+//go:noescape
+func wasmimport_TCPSocketKeepAliveEnabled(self0 uint32, result *cm.OKResult[bool, network.ErrorCode])
+
+// KeepAliveIdleTime represents the imported method "keep-alive-idle-time".
+//
+// Amount of time the connection has to be idle before TCP starts sending keepalive
+// packets.
+//
+// If the provided value is 0, an `invalid-argument` error is returned.
+// Any other value will never cause an error, but it might be silently clamped and/or
+// rounded.
+// I.e. after setting a value, reading the same setting back may return a different
+// value.
+//
+// Equivalent to the TCP_KEEPIDLE socket option. (TCP_KEEPALIVE on MacOS)
+//
+// # Typical errors
+// - `invalid-argument`:     (set) The provided value was 0.
+//
+//	keep-alive-idle-time: func() -> result<duration, error-code>
+//
+//go:nosplit
+func (self TCPSocket) KeepAliveIdleTime() (result cm.OKResult[monotonicclock.Duration, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_TCPSocketKeepAliveIdleTime((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.keep-alive-idle-time
+//go:noescape
+func wasmimport_TCPSocketKeepAliveIdleTime(self0 uint32, result *cm.OKResult[monotonicclock.Duration, network.ErrorCode])
+
+// KeepAliveInterval represents the imported method "keep-alive-interval".
+//
+// The time between keepalive packets.
+//
+// If the provided value is 0, an `invalid-argument` error is returned.
+// Any other value will never cause an error, but it might be silently clamped and/or
+// rounded.
+// I.e. after setting a value, reading the same setting back may return a different
+// value.
+//
+// Equivalent to the TCP_KEEPINTVL socket option.
+//
+// # Typical errors
+// - `invalid-argument`:     (set) The provided value was 0.
+//
+//	keep-alive-interval: func() -> result<duration, error-code>
+//
+//go:nosplit
+func (self TCPSocket) KeepAliveInterval() (result cm.OKResult[monotonicclock.Duration, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_TCPSocketKeepAliveInterval((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.keep-alive-interval
+//go:noescape
+func wasmimport_TCPSocketKeepAliveInterval(self0 uint32, result *cm.OKResult[monotonicclock.Duration, network.ErrorCode])
+
+// LocalAddress represents the imported method "local-address".
+//
+// Get the bound local address.
+//
+// POSIX mentions:
+// > If the socket has not been bound to a local name, the value
+// > stored in the object pointed to by `address` is unspecified.
+//
+// WASI is stricter and requires `local-address` to return `invalid-state` when the
+// socket hasn't been bound yet.
+//
+// # Typical errors
+// - `invalid-state`: The socket is not bound to any local address.
+//
+// # References
+// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html>
+// - <https://man7.org/linux/man-pages/man2/getsockname.2.html>
+// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getsockname>
+// - <https://man.freebsd.org/cgi/man.cgi?getsockname>
+//
+//	local-address: func() -> result<ip-socket-address, error-code>
+//
+//go:nosplit
+func (self TCPSocket) LocalAddress() (result cm.OKResult[network.IPSocketAddress, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_TCPSocketLocalAddress((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.local-address
+//go:noescape
+func wasmimport_TCPSocketLocalAddress(self0 uint32, result *cm.OKResult[network.IPSocketAddress, network.ErrorCode])
+
+// ReceiveBufferSize represents the imported method "receive-buffer-size".
+//
+// The kernel buffer space reserved for sends/receives on this socket.
+//
+// If the provided value is 0, an `invalid-argument` error is returned.
+// Any other value will never cause an error, but it might be silently clamped and/or
+// rounded.
+// I.e. after setting a value, reading the same setting back may return a different
+// value.
+//
+// Equivalent to the SO_RCVBUF and SO_SNDBUF socket options.
+//
+// # Typical errors
+// - `invalid-argument`:     (set) The provided value was 0.
+//
+//	receive-buffer-size: func() -> result<u64, error-code>
+//
+//go:nosplit
+func (self TCPSocket) ReceiveBufferSize() (result cm.OKResult[uint64, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_TCPSocketReceiveBufferSize((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.receive-buffer-size
+//go:noescape
+func wasmimport_TCPSocketReceiveBufferSize(self0 uint32, result *cm.OKResult[uint64, network.ErrorCode])
+
+// RemoteAddress represents the imported method "remote-address".
+//
+// Get the remote address.
+//
+// # Typical errors
+// - `invalid-state`: The socket is not connected to a remote address. (ENOTCONN)
+//
+// # References
+// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html>
+// - <https://man7.org/linux/man-pages/man2/getpeername.2.html>
+// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getpeername>
+// - <https://man.freebsd.org/cgi/man.cgi?query=getpeername&sektion=2&n=1>
+//
+//	remote-address: func() -> result<ip-socket-address, error-code>
+//
+//go:nosplit
+func (self TCPSocket) RemoteAddress() (result cm.OKResult[network.IPSocketAddress, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_TCPSocketRemoteAddress((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.remote-address
+//go:noescape
+func wasmimport_TCPSocketRemoteAddress(self0 uint32, result *cm.OKResult[network.IPSocketAddress, network.ErrorCode])
+
+// SendBufferSize represents the imported method "send-buffer-size".
+//
+//	send-buffer-size: func() -> result<u64, error-code>
+//
+//go:nosplit
+func (self TCPSocket) SendBufferSize() (result cm.OKResult[uint64, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_TCPSocketSendBufferSize((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.send-buffer-size
+//go:noescape
+func wasmimport_TCPSocketSendBufferSize(self0 uint32, result *cm.OKResult[uint64, network.ErrorCode])
+
+// SetHopLimit represents the imported method "set-hop-limit".
+//
+//	set-hop-limit: func(value: u8) -> result<_, error-code>
+//
+//go:nosplit
+func (self TCPSocket) SetHopLimit(value uint8) (result cm.ErrResult[struct{}, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	value0 := (uint32)(value)
+	wasmimport_TCPSocketSetHopLimit((uint32)(self0), (uint32)(value0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-hop-limit
+//go:noescape
+func wasmimport_TCPSocketSetHopLimit(self0 uint32, value0 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
+
+// SetKeepAliveCount represents the imported method "set-keep-alive-count".
+//
+//	set-keep-alive-count: func(value: u32) -> result<_, error-code>
+//
+//go:nosplit
+func (self TCPSocket) SetKeepAliveCount(value uint32) (result cm.ErrResult[struct{}, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	value0 := (uint32)(value)
+	wasmimport_TCPSocketSetKeepAliveCount((uint32)(self0), (uint32)(value0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-keep-alive-count
+//go:noescape
+func wasmimport_TCPSocketSetKeepAliveCount(self0 uint32, value0 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
+
+// SetKeepAliveEnabled represents the imported method "set-keep-alive-enabled".
+//
+//	set-keep-alive-enabled: func(value: bool) -> result<_, error-code>
+//
+//go:nosplit
+func (self TCPSocket) SetKeepAliveEnabled(value bool) (result cm.ErrResult[struct{}, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	value0 := cm.BoolToU32(value)
+	wasmimport_TCPSocketSetKeepAliveEnabled((uint32)(self0), (uint32)(value0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-keep-alive-enabled
+//go:noescape
+func wasmimport_TCPSocketSetKeepAliveEnabled(self0 uint32, value0 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
+
+// SetKeepAliveIdleTime represents the imported method "set-keep-alive-idle-time".
+//
+//	set-keep-alive-idle-time: func(value: duration) -> result<_, error-code>
+//
+//go:nosplit
+func (self TCPSocket) SetKeepAliveIdleTime(value monotonicclock.Duration) (result cm.ErrResult[struct{}, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	value0 := (uint64)(value)
+	wasmimport_TCPSocketSetKeepAliveIdleTime((uint32)(self0), (uint64)(value0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-keep-alive-idle-time
+//go:noescape
+func wasmimport_TCPSocketSetKeepAliveIdleTime(self0 uint32, value0 uint64, result *cm.ErrResult[struct{}, network.ErrorCode])
+
+// SetKeepAliveInterval represents the imported method "set-keep-alive-interval".
+//
+//	set-keep-alive-interval: func(value: duration) -> result<_, error-code>
+//
+//go:nosplit
+func (self TCPSocket) SetKeepAliveInterval(value monotonicclock.Duration) (result cm.ErrResult[struct{}, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	value0 := (uint64)(value)
+	wasmimport_TCPSocketSetKeepAliveInterval((uint32)(self0), (uint64)(value0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-keep-alive-interval
+//go:noescape
+func wasmimport_TCPSocketSetKeepAliveInterval(self0 uint32, value0 uint64, result *cm.ErrResult[struct{}, network.ErrorCode])
+
+// SetListenBacklogSize represents the imported method "set-listen-backlog-size".
+//
+// Hints the desired listen queue size. Implementations are free to ignore this.
+//
+// If the provided value is 0, an `invalid-argument` error is returned.
+// Any other value will never cause an error, but it might be silently clamped and/or
+// rounded.
+//
+// # Typical errors
+// - `not-supported`:        (set) The platform does not support changing the backlog
+// size after the initial listen.
+// - `invalid-argument`:     (set) The provided value was 0.
+// - `invalid-state`:        (set) The socket is in the `connect-in-progress` or `connected`
+// state.
+//
+//	set-listen-backlog-size: func(value: u64) -> result<_, error-code>
+//
+//go:nosplit
+func (self TCPSocket) SetListenBacklogSize(value uint64) (result cm.ErrResult[struct{}, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	value0 := (uint64)(value)
+	wasmimport_TCPSocketSetListenBacklogSize((uint32)(self0), (uint64)(value0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-listen-backlog-size
+//go:noescape
+func wasmimport_TCPSocketSetListenBacklogSize(self0 uint32, value0 uint64, result *cm.ErrResult[struct{}, network.ErrorCode])
+
+// SetReceiveBufferSize represents the imported method "set-receive-buffer-size".
+//
+//	set-receive-buffer-size: func(value: u64) -> result<_, error-code>
+//
+//go:nosplit
+func (self TCPSocket) SetReceiveBufferSize(value uint64) (result cm.ErrResult[struct{}, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	value0 := (uint64)(value)
+	wasmimport_TCPSocketSetReceiveBufferSize((uint32)(self0), (uint64)(value0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-receive-buffer-size
+//go:noescape
+func wasmimport_TCPSocketSetReceiveBufferSize(self0 uint32, value0 uint64, result *cm.ErrResult[struct{}, network.ErrorCode])
+
+// SetSendBufferSize represents the imported method "set-send-buffer-size".
+//
+//	set-send-buffer-size: func(value: u64) -> result<_, error-code>
+//
+//go:nosplit
+func (self TCPSocket) SetSendBufferSize(value uint64) (result cm.ErrResult[struct{}, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	value0 := (uint64)(value)
+	wasmimport_TCPSocketSetSendBufferSize((uint32)(self0), (uint64)(value0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-send-buffer-size
+//go:noescape
+func wasmimport_TCPSocketSetSendBufferSize(self0 uint32, value0 uint64, result *cm.ErrResult[struct{}, network.ErrorCode])
+
+// Shutdown represents the imported method "shutdown".
+//
+// Initiate a graceful shutdown.
+//
+// - `receive`: The socket is not expecting to receive any data from
+// the peer. The `input-stream` associated with this socket will be
+// closed. Any data still in the receive queue at time of calling
+// this method will be discarded.
+// - `send`: The socket has no more data to send to the peer. The `output-stream`
+// associated with this socket will be closed and a FIN packet will be sent.
+// - `both`: Same effect as `receive` & `send` combined.
+//
+// This function is idempotent. Shutting a down a direction more than once
+// has no effect and returns `ok`.
+//
+// The shutdown function does not close (drop) the socket.
+//
+// # Typical errors
+// - `invalid-state`: The socket is not in the `connected` state. (ENOTCONN)
+//
+// # References
+// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/shutdown.html>
+// - <https://man7.org/linux/man-pages/man2/shutdown.2.html>
+// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-shutdown>
+// - <https://man.freebsd.org/cgi/man.cgi?query=shutdown&sektion=2>
+//
+//	shutdown: func(shutdown-type: shutdown-type) -> result<_, error-code>
+//
+//go:nosplit
+func (self TCPSocket) Shutdown(shutdownType ShutdownType) (result cm.ErrResult[struct{}, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	shutdownType0 := (uint32)(shutdownType)
+	wasmimport_TCPSocketShutdown((uint32)(self0), (uint32)(shutdownType0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.shutdown
+//go:noescape
+func wasmimport_TCPSocketShutdown(self0 uint32, shutdownType0 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
+
+// StartBind represents the imported method "start-bind".
+//
+// Bind the socket to a specific network on the provided IP address and port.
+//
+// If the IP address is zero (`0.0.0.0` in IPv4, `::` in IPv6), it is left to the
+// implementation to decide which
+// network interface(s) to bind to.
+// If the TCP/UDP port is zero, the socket will be bound to a random free port.
+//
+// Bind can be attempted multiple times on the same socket, even with
+// different arguments on each iteration. But never concurrently and
+// only as long as the previous bind failed. Once a bind succeeds, the
+// binding can't be changed anymore.
+//
+// # Typical errors
+// - `invalid-argument`:          The `local-address` has the wrong address family.
+// (EAFNOSUPPORT, EFAULT on Windows)
+// - `invalid-argument`:          `local-address` is not a unicast address. (EINVAL)
+// - `invalid-argument`:          `local-address` is an IPv4-mapped IPv6 address.
+// (EINVAL)
+// - `invalid-state`:             The socket is already bound. (EINVAL)
+// - `address-in-use`:            No ephemeral ports available. (EADDRINUSE, ENOBUFS
+// on Windows)
+// - `address-in-use`:            Address is already in use. (EADDRINUSE)
+// - `address-not-bindable`:      `local-address` is not an address that the `network`
+// can bind to. (EADDRNOTAVAIL)
+// - `not-in-progress`:           A `bind` operation is not in progress.
+// - `would-block`:               Can't finish the operation, it is still in progress.
+// (EWOULDBLOCK, EAGAIN)
+//
+// # Implementors note
+// When binding to a non-zero port, this bind operation shouldn't be affected by the
+// TIME_WAIT
+// state of a recently closed socket on the same local address. In practice this means
+// that the SO_REUSEADDR
+// socket option should be set implicitly on all platforms, except on Windows where
+// this is the default behavior
+// and SO_REUSEADDR performs something different entirely.
+//
+// Unlike in POSIX, in WASI the bind operation is async. This enables
+// interactive WASI hosts to inject permission prompts. Runtimes that
+// don't want to make use of this ability can simply call the native
+// `bind` as part of either `start-bind` or `finish-bind`.
+//
+// # References
+// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html>
+// - <https://man7.org/linux/man-pages/man2/bind.2.html>
+// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-bind>
+// - <https://man.freebsd.org/cgi/man.cgi?query=bind&sektion=2&format=html>
+//
+//	start-bind: func(network: borrow<network>, local-address: ip-socket-address) ->
+//	result<_, error-code>
+//
+//go:nosplit
+func (self TCPSocket) StartBind(network_ network.Network, localAddress network.IPSocketAddress) (result cm.ErrResult[struct{}, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	network0 := cm.Reinterpret[uint32](network_)
+	localAddress0, localAddress1, localAddress2, localAddress3, localAddress4, localAddress5, localAddress6, localAddress7, localAddress8, localAddress9, localAddress10, localAddress11 := lower_IPSocketAddress(localAddress)
+	wasmimport_TCPSocketStartBind((uint32)(self0), (uint32)(network0), (uint32)(localAddress0), (uint32)(localAddress1), (uint32)(localAddress2), (uint32)(localAddress3), (uint32)(localAddress4), (uint32)(localAddress5), (uint32)(localAddress6), (uint32)(localAddress7), (uint32)(localAddress8), (uint32)(localAddress9), (uint32)(localAddress10), (uint32)(localAddress11), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.start-bind
+//go:noescape
+func wasmimport_TCPSocketStartBind(self0 uint32, network0 uint32, localAddress0 uint32, localAddress1 uint32, localAddress2 uint32, localAddress3 uint32, localAddress4 uint32, localAddress5 uint32, localAddress6 uint32, localAddress7 uint32, localAddress8 uint32, localAddress9 uint32, localAddress10 uint32, localAddress11 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
+
+// StartConnect represents the imported method "start-connect".
+//
+// Connect to a remote endpoint.
+//
+// On success:
+// - the socket is transitioned into the `connection` state.
+// - a pair of streams is returned that can be used to read & write to the connection
+//
+// After a failed connection attempt, the socket will be in the `closed`
+// state and the only valid action left is to `drop` the socket. A single
+// socket can not be used to connect more than once.
+//
+// # Typical errors
+// - `invalid-argument`:          The `remote-address` has the wrong address family.
+// (EAFNOSUPPORT)
+// - `invalid-argument`:          `remote-address` is not a unicast address. (EINVAL,
+// ENETUNREACH on Linux, EAFNOSUPPORT on MacOS)
+// - `invalid-argument`:          `remote-address` is an IPv4-mapped IPv6 address.
+// (EINVAL, EADDRNOTAVAIL on Illumos)
+// - `invalid-argument`:          The IP address in `remote-address` is set to INADDR_ANY
+// (`0.0.0.0` / `::`). (EADDRNOTAVAIL on Windows)
+// - `invalid-argument`:          The port in `remote-address` is set to 0. (EADDRNOTAVAIL
+// on Windows)
+// - `invalid-argument`:          The socket is already attached to a different network.
+// The `network` passed to `connect` must be identical to the one passed to `bind`.
+// - `invalid-state`:             The socket is already in the `connected` state.
+// (EISCONN)
+// - `invalid-state`:             The socket is already in the `listening` state.
+// (EOPNOTSUPP, EINVAL on Windows)
+// - `timeout`:                   Connection timed out. (ETIMEDOUT)
+// - `connection-refused`:        The connection was forcefully rejected. (ECONNREFUSED)
+// - `connection-reset`:          The connection was reset. (ECONNRESET)
+// - `connection-aborted`:        The connection was aborted. (ECONNABORTED)
+// - `remote-unreachable`:        The remote address is not reachable. (EHOSTUNREACH,
+// EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+// - `address-in-use`:            Tried to perform an implicit bind, but there were
+// no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD)
+// - `not-in-progress`:           A connect operation is not in progress.
+// - `would-block`:               Can't finish the operation, it is still in progress.
+// (EWOULDBLOCK, EAGAIN)
+//
+// # Implementors note
+// The POSIX equivalent of `start-connect` is the regular `connect` syscall.
+// Because all WASI sockets are non-blocking this is expected to return
+// EINPROGRESS, which should be translated to `ok()` in WASI.
+//
+// The POSIX equivalent of `finish-connect` is a `poll` for event `POLLOUT`
+// with a timeout of 0 on the socket descriptor. Followed by a check for
+// the `SO_ERROR` socket option, in case the poll signaled readiness.
+//
+// # References
+// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html>
+// - <https://man7.org/linux/man-pages/man2/connect.2.html>
+// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect>
+// - <https://man.freebsd.org/cgi/man.cgi?connect>
+//
+//	start-connect: func(network: borrow<network>, remote-address: ip-socket-address)
+//	-> result<_, error-code>
+//
+//go:nosplit
+func (self TCPSocket) StartConnect(network_ network.Network, remoteAddress network.IPSocketAddress) (result cm.ErrResult[struct{}, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	network0 := cm.Reinterpret[uint32](network_)
+	remoteAddress0, remoteAddress1, remoteAddress2, remoteAddress3, remoteAddress4, remoteAddress5, remoteAddress6, remoteAddress7, remoteAddress8, remoteAddress9, remoteAddress10, remoteAddress11 := lower_IPSocketAddress(remoteAddress)
+	wasmimport_TCPSocketStartConnect((uint32)(self0), (uint32)(network0), (uint32)(remoteAddress0), (uint32)(remoteAddress1), (uint32)(remoteAddress2), (uint32)(remoteAddress3), (uint32)(remoteAddress4), (uint32)(remoteAddress5), (uint32)(remoteAddress6), (uint32)(remoteAddress7), (uint32)(remoteAddress8), (uint32)(remoteAddress9), (uint32)(remoteAddress10), (uint32)(remoteAddress11), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.start-connect
+//go:noescape
+func wasmimport_TCPSocketStartConnect(self0 uint32, network0 uint32, remoteAddress0 uint32, remoteAddress1 uint32, remoteAddress2 uint32, remoteAddress3 uint32, remoteAddress4 uint32, remoteAddress5 uint32, remoteAddress6 uint32, remoteAddress7 uint32, remoteAddress8 uint32, remoteAddress9 uint32, remoteAddress10 uint32, remoteAddress11 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
+
+// StartListen represents the imported method "start-listen".
+//
+// Start listening for new connections.
+//
+// Transitions the socket into the `listening` state.
+//
+// Unlike POSIX, the socket must already be explicitly bound.
+//
+// # Typical errors
+// - `invalid-state`:             The socket is not bound to any local address. (EDESTADDRREQ)
+// - `invalid-state`:             The socket is already in the `connected` state.
+// (EISCONN, EINVAL on BSD)
+// - `invalid-state`:             The socket is already in the `listening` state.
+// - `address-in-use`:            Tried to perform an implicit bind, but there were
+// no ephemeral ports available. (EADDRINUSE)
+// - `not-in-progress`:           A listen operation is not in progress.
+// - `would-block`:               Can't finish the operation, it is still in progress.
+// (EWOULDBLOCK, EAGAIN)
+//
+// # Implementors note
+// Unlike in POSIX, in WASI the listen operation is async. This enables
+// interactive WASI hosts to inject permission prompts. Runtimes that
+// don't want to make use of this ability can simply call the native
+// `listen` as part of either `start-listen` or `finish-listen`.
+//
+// # References
+// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/listen.html>
+// - <https://man7.org/linux/man-pages/man2/listen.2.html>
+// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-listen>
+// - <https://man.freebsd.org/cgi/man.cgi?query=listen&sektion=2>
+//
+//	start-listen: func() -> result<_, error-code>
+//
+//go:nosplit
+func (self TCPSocket) StartListen() (result cm.ErrResult[struct{}, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_TCPSocketStartListen((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.start-listen
+//go:noescape
+func wasmimport_TCPSocketStartListen(self0 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
+
+// Subscribe represents the imported method "subscribe".
+//
+// Create a `pollable` which can be used to poll for, or block on,
+// completion of any of the asynchronous operations of this socket.
+//
+// When `finish-bind`, `finish-listen`, `finish-connect` or `accept`
+// return `error(would-block)`, this pollable can be used to wait for
+// their success or failure, after which the method can be retried.
+//
+// The pollable is not limited to the async operation that happens to be
+// in progress at the time of calling `subscribe` (if any). Theoretically,
+// `subscribe` only has to be called once per socket and can then be
+// (re)used for the remainder of the socket's lifetime.
+//
+// See <https://github.com/WebAssembly/wasi-sockets/TcpSocketOperationalSemantics.md#Pollable-readiness>
+// for a more information.
+//
+// Note: this function is here for WASI Preview2 only.
+// It's planned to be removed when `future` is natively supported in Preview3.
+//
+//	subscribe: func() -> pollable
+//
+//go:nosplit
+func (self TCPSocket) Subscribe() (result poll.Pollable) {
+	self0 := cm.Reinterpret[uint32](self)
+	result0 := wasmimport_TCPSocketSubscribe((uint32)(self0))
+	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
+	return
+}
+
+//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.subscribe
+//go:noescape
+func wasmimport_TCPSocketSubscribe(self0 uint32) (result0 uint32)

src/internal/wasi/sockets/v0.2.0/udp-create-socket/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/sockets/v0.2.0/udp-create-socket/udp-create-socket.wit.go

@@ -0,0 +1,54 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package udpcreatesocket represents the imported interface "wasi:sockets/udp-create-socket@0.2.0".
+package udpcreatesocket
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+	"internal/wasi/sockets/v0.2.0/network"
+	"internal/wasi/sockets/v0.2.0/udp"
+)
+
+// CreateUDPSocket represents the imported function "create-udp-socket".
+//
+// Create a new UDP socket.
+//
+// Similar to `socket(AF_INET or AF_INET6, SOCK_DGRAM, IPPROTO_UDP)` in POSIX.
+// On IPv6 sockets, IPV6_V6ONLY is enabled by default and can't be configured otherwise.
+//
+// This function does not require a network capability handle. This is considered
+// to be safe because
+// at time of creation, the socket is not bound to any `network` yet. Up to the moment
+// `bind` is called,
+// the socket is effectively an in-memory configuration object, unable to communicate
+// with the outside world.
+//
+// All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous
+// operations.
+//
+// # Typical errors
+// - `not-supported`:     The specified `address-family` is not supported. (EAFNOSUPPORT)
+// - `new-socket-limit`:  The new socket resource could not be created because of
+// a system limit. (EMFILE, ENFILE)
+//
+// # References:
+// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html>
+// - <https://man7.org/linux/man-pages/man2/socket.2.html>
+// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw>
+// - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2>
+//
+//	create-udp-socket: func(address-family: ip-address-family) -> result<udp-socket,
+//	error-code>
+//
+//go:nosplit
+func CreateUDPSocket(addressFamily network.IPAddressFamily) (result cm.OKResult[udp.UDPSocket, network.ErrorCode]) {
+	addressFamily0 := (uint32)(addressFamily)
+	wasmimport_CreateUDPSocket((uint32)(addressFamily0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/udp-create-socket@0.2.0 create-udp-socket
+//go:noescape
+func wasmimport_CreateUDPSocket(addressFamily0 uint32, result *cm.OKResult[udp.UDPSocket, network.ErrorCode])

src/internal/wasi/sockets/v0.2.0/udp/abi.go

@@ -0,0 +1,92 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+package udp
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+	"internal/wasi/sockets/v0.2.0/network"
+)
+
+func lower_IPv4Address(v network.IPv4Address) (f0 uint32, f1 uint32, f2 uint32, f3 uint32) {
+	f0 = (uint32)(v[0])
+	f1 = (uint32)(v[1])
+	f2 = (uint32)(v[2])
+	f3 = (uint32)(v[3])
+	return
+}
+
+func lower_IPv4SocketAddress(v network.IPv4SocketAddress) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32) {
+	f0 = (uint32)(v.Port)
+	f1, f2, f3, f4 = lower_IPv4Address(v.Address)
+	return
+}
+
+func lower_IPv6Address(v network.IPv6Address) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32, f5 uint32, f6 uint32, f7 uint32) {
+	f0 = (uint32)(v[0])
+	f1 = (uint32)(v[1])
+	f2 = (uint32)(v[2])
+	f3 = (uint32)(v[3])
+	f4 = (uint32)(v[4])
+	f5 = (uint32)(v[5])
+	f6 = (uint32)(v[6])
+	f7 = (uint32)(v[7])
+	return
+}
+
+func lower_IPv6SocketAddress(v network.IPv6SocketAddress) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32, f5 uint32, f6 uint32, f7 uint32, f8 uint32, f9 uint32, f10 uint32) {
+	f0 = (uint32)(v.Port)
+	f1 = (uint32)(v.FlowInfo)
+	f2, f3, f4, f5, f6, f7, f8, f9 = lower_IPv6Address(v.Address)
+	f10 = (uint32)(v.ScopeID)
+	return
+}
+
+func lower_IPSocketAddress(v network.IPSocketAddress) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32, f5 uint32, f6 uint32, f7 uint32, f8 uint32, f9 uint32, f10 uint32, f11 uint32) {
+	f0 = (uint32)(cm.Tag(&v))
+	switch f0 {
+	case 0: // ipv4
+		v1, v2, v3, v4, v5 := lower_IPv4SocketAddress(*v.IPv4())
+		f1 = (uint32)(v1)
+		f2 = (uint32)(v2)
+		f3 = (uint32)(v3)
+		f4 = (uint32)(v4)
+		f5 = (uint32)(v5)
+	case 1: // ipv6
+		v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11 := lower_IPv6SocketAddress(*v.IPv6())
+		f1 = (uint32)(v1)
+		f2 = (uint32)(v2)
+		f3 = (uint32)(v3)
+		f4 = (uint32)(v4)
+		f5 = (uint32)(v5)
+		f6 = (uint32)(v6)
+		f7 = (uint32)(v7)
+		f8 = (uint32)(v8)
+		f9 = (uint32)(v9)
+		f10 = (uint32)(v10)
+		f11 = (uint32)(v11)
+	}
+	return
+}
+
+func lower_OptionIPSocketAddress(v cm.Option[network.IPSocketAddress]) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32, f5 uint32, f6 uint32, f7 uint32, f8 uint32, f9 uint32, f10 uint32, f11 uint32, f12 uint32) {
+	some := v.Some()
+	if some != nil {
+		f0 = 1
+		v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12 := lower_IPSocketAddress(*some)
+		f1 = (uint32)(v1)
+		f2 = (uint32)(v2)
+		f3 = (uint32)(v3)
+		f4 = (uint32)(v4)
+		f5 = (uint32)(v5)
+		f6 = (uint32)(v6)
+		f7 = (uint32)(v7)
+		f8 = (uint32)(v8)
+		f9 = (uint32)(v9)
+		f10 = (uint32)(v10)
+		f11 = (uint32)(v11)
+		f12 = (uint32)(v12)
+	}
+	return
+}

src/internal/wasi/sockets/v0.2.0/udp/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/sockets/v0.2.0/udp/udp.wit.go

@@ -0,0 +1,643 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+//go:build !wasip1
+
+// Package udp represents the imported interface "wasi:sockets/udp@0.2.0".
+package udp
+
+import (
+	"github.com/ydnar/wasm-tools-go/cm"
+	"internal/wasi/io/v0.2.0/poll"
+	"internal/wasi/sockets/v0.2.0/network"
+)
+
+// IncomingDatagram represents the record "wasi:sockets/udp@0.2.0#incoming-datagram".
+//
+// A received datagram.
+//
+//	record incoming-datagram {
+//		data: list<u8>,
+//		remote-address: ip-socket-address,
+//	}
+type IncomingDatagram struct {
+	// The payload.
+	//
+	// Theoretical max size: ~64 KiB. In practice, typically less than 1500 bytes.
+	Data cm.List[uint8]
+
+	// The source address.
+	//
+	// This field is guaranteed to match the remote address the stream was initialized
+	// with, if any.
+	//
+	// Equivalent to the `src_addr` out parameter of `recvfrom`.
+	RemoteAddress network.IPSocketAddress
+}
+
+// OutgoingDatagram represents the record "wasi:sockets/udp@0.2.0#outgoing-datagram".
+//
+// A datagram to be sent out.
+//
+//	record outgoing-datagram {
+//		data: list<u8>,
+//		remote-address: option<ip-socket-address>,
+//	}
+type OutgoingDatagram struct {
+	// The payload.
+	Data cm.List[uint8]
+
+	// The destination address.
+	//
+	// The requirements on this field depend on how the stream was initialized:
+	// - with a remote address: this field must be None or match the stream's remote address
+	// exactly.
+	// - without a remote address: this field is required.
+	//
+	// If this value is None, the send operation is equivalent to `send` in POSIX. Otherwise
+	// it is equivalent to `sendto`.
+	RemoteAddress cm.Option[network.IPSocketAddress]
+}
+
+// UDPSocket represents the imported resource "wasi:sockets/udp@0.2.0#udp-socket".
+//
+// A UDP socket handle.
+//
+//	resource udp-socket
+type UDPSocket cm.Resource
+
+// ResourceDrop represents the imported resource-drop for resource "udp-socket".
+//
+// Drops a resource handle.
+//
+//go:nosplit
+func (self UDPSocket) ResourceDrop() {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_UDPSocketResourceDrop((uint32)(self0))
+	return
+}
+
+//go:wasmimport wasi:sockets/udp@0.2.0 [resource-drop]udp-socket
+//go:noescape
+func wasmimport_UDPSocketResourceDrop(self0 uint32)
+
+// AddressFamily represents the imported method "address-family".
+//
+// Whether this is a IPv4 or IPv6 socket.
+//
+// Equivalent to the SO_DOMAIN socket option.
+//
+//	address-family: func() -> ip-address-family
+//
+//go:nosplit
+func (self UDPSocket) AddressFamily() (result network.IPAddressFamily) {
+	self0 := cm.Reinterpret[uint32](self)
+	result0 := wasmimport_UDPSocketAddressFamily((uint32)(self0))
+	result = (network.IPAddressFamily)((uint32)(result0))
+	return
+}
+
+//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.address-family
+//go:noescape
+func wasmimport_UDPSocketAddressFamily(self0 uint32) (result0 uint32)
+
+// FinishBind represents the imported method "finish-bind".
+//
+//	finish-bind: func() -> result<_, error-code>
+//
+//go:nosplit
+func (self UDPSocket) FinishBind() (result cm.ErrResult[struct{}, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_UDPSocketFinishBind((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.finish-bind
+//go:noescape
+func wasmimport_UDPSocketFinishBind(self0 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
+
+// LocalAddress represents the imported method "local-address".
+//
+// Get the current bound address.
+//
+// POSIX mentions:
+// > If the socket has not been bound to a local name, the value
+// > stored in the object pointed to by `address` is unspecified.
+//
+// WASI is stricter and requires `local-address` to return `invalid-state` when the
+// socket hasn't been bound yet.
+//
+// # Typical errors
+// - `invalid-state`: The socket is not bound to any local address.
+//
+// # References
+// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html>
+// - <https://man7.org/linux/man-pages/man2/getsockname.2.html>
+// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getsockname>
+// - <https://man.freebsd.org/cgi/man.cgi?getsockname>
+//
+//	local-address: func() -> result<ip-socket-address, error-code>
+//
+//go:nosplit
+func (self UDPSocket) LocalAddress() (result cm.OKResult[network.IPSocketAddress, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_UDPSocketLocalAddress((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.local-address
+//go:noescape
+func wasmimport_UDPSocketLocalAddress(self0 uint32, result *cm.OKResult[network.IPSocketAddress, network.ErrorCode])
+
+// ReceiveBufferSize represents the imported method "receive-buffer-size".
+//
+// The kernel buffer space reserved for sends/receives on this socket.
+//
+// If the provided value is 0, an `invalid-argument` error is returned.
+// Any other value will never cause an error, but it might be silently clamped and/or
+// rounded.
+// I.e. after setting a value, reading the same setting back may return a different
+// value.
+//
+// Equivalent to the SO_RCVBUF and SO_SNDBUF socket options.
+//
+// # Typical errors
+// - `invalid-argument`:     (set) The provided value was 0.
+//
+//	receive-buffer-size: func() -> result<u64, error-code>
+//
+//go:nosplit
+func (self UDPSocket) ReceiveBufferSize() (result cm.OKResult[uint64, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_UDPSocketReceiveBufferSize((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.receive-buffer-size
+//go:noescape
+func wasmimport_UDPSocketReceiveBufferSize(self0 uint32, result *cm.OKResult[uint64, network.ErrorCode])
+
+// RemoteAddress represents the imported method "remote-address".
+//
+// Get the address the socket is currently streaming to.
+//
+// # Typical errors
+// - `invalid-state`: The socket is not streaming to a specific remote address. (ENOTCONN)
+//
+// # References
+// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html>
+// - <https://man7.org/linux/man-pages/man2/getpeername.2.html>
+// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getpeername>
+// - <https://man.freebsd.org/cgi/man.cgi?query=getpeername&sektion=2&n=1>
+//
+//	remote-address: func() -> result<ip-socket-address, error-code>
+//
+//go:nosplit
+func (self UDPSocket) RemoteAddress() (result cm.OKResult[network.IPSocketAddress, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_UDPSocketRemoteAddress((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.remote-address
+//go:noescape
+func wasmimport_UDPSocketRemoteAddress(self0 uint32, result *cm.OKResult[network.IPSocketAddress, network.ErrorCode])
+
+// SendBufferSize represents the imported method "send-buffer-size".
+//
+//	send-buffer-size: func() -> result<u64, error-code>
+//
+//go:nosplit
+func (self UDPSocket) SendBufferSize() (result cm.OKResult[uint64, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_UDPSocketSendBufferSize((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.send-buffer-size
+//go:noescape
+func wasmimport_UDPSocketSendBufferSize(self0 uint32, result *cm.OKResult[uint64, network.ErrorCode])
+
+// SetReceiveBufferSize represents the imported method "set-receive-buffer-size".
+//
+//	set-receive-buffer-size: func(value: u64) -> result<_, error-code>
+//
+//go:nosplit
+func (self UDPSocket) SetReceiveBufferSize(value uint64) (result cm.ErrResult[struct{}, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	value0 := (uint64)(value)
+	wasmimport_UDPSocketSetReceiveBufferSize((uint32)(self0), (uint64)(value0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.set-receive-buffer-size
+//go:noescape
+func wasmimport_UDPSocketSetReceiveBufferSize(self0 uint32, value0 uint64, result *cm.ErrResult[struct{}, network.ErrorCode])
+
+// SetSendBufferSize represents the imported method "set-send-buffer-size".
+//
+//	set-send-buffer-size: func(value: u64) -> result<_, error-code>
+//
+//go:nosplit
+func (self UDPSocket) SetSendBufferSize(value uint64) (result cm.ErrResult[struct{}, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	value0 := (uint64)(value)
+	wasmimport_UDPSocketSetSendBufferSize((uint32)(self0), (uint64)(value0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.set-send-buffer-size
+//go:noescape
+func wasmimport_UDPSocketSetSendBufferSize(self0 uint32, value0 uint64, result *cm.ErrResult[struct{}, network.ErrorCode])
+
+// SetUnicastHopLimit represents the imported method "set-unicast-hop-limit".
+//
+//	set-unicast-hop-limit: func(value: u8) -> result<_, error-code>
+//
+//go:nosplit
+func (self UDPSocket) SetUnicastHopLimit(value uint8) (result cm.ErrResult[struct{}, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	value0 := (uint32)(value)
+	wasmimport_UDPSocketSetUnicastHopLimit((uint32)(self0), (uint32)(value0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.set-unicast-hop-limit
+//go:noescape
+func wasmimport_UDPSocketSetUnicastHopLimit(self0 uint32, value0 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
+
+// StartBind represents the imported method "start-bind".
+//
+// Bind the socket to a specific network on the provided IP address and port.
+//
+// If the IP address is zero (`0.0.0.0` in IPv4, `::` in IPv6), it is left to the
+// implementation to decide which
+// network interface(s) to bind to.
+// If the port is zero, the socket will be bound to a random free port.
+//
+// # Typical errors
+// - `invalid-argument`:          The `local-address` has the wrong address family.
+// (EAFNOSUPPORT, EFAULT on Windows)
+// - `invalid-state`:             The socket is already bound. (EINVAL)
+// - `address-in-use`:            No ephemeral ports available. (EADDRINUSE, ENOBUFS
+// on Windows)
+// - `address-in-use`:            Address is already in use. (EADDRINUSE)
+// - `address-not-bindable`:      `local-address` is not an address that the `network`
+// can bind to. (EADDRNOTAVAIL)
+// - `not-in-progress`:           A `bind` operation is not in progress.
+// - `would-block`:               Can't finish the operation, it is still in progress.
+// (EWOULDBLOCK, EAGAIN)
+//
+// # Implementors note
+// Unlike in POSIX, in WASI the bind operation is async. This enables
+// interactive WASI hosts to inject permission prompts. Runtimes that
+// don't want to make use of this ability can simply call the native
+// `bind` as part of either `start-bind` or `finish-bind`.
+//
+// # References
+// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html>
+// - <https://man7.org/linux/man-pages/man2/bind.2.html>
+// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-bind>
+// - <https://man.freebsd.org/cgi/man.cgi?query=bind&sektion=2&format=html>
+//
+//	start-bind: func(network: borrow<network>, local-address: ip-socket-address) ->
+//	result<_, error-code>
+//
+//go:nosplit
+func (self UDPSocket) StartBind(network_ network.Network, localAddress network.IPSocketAddress) (result cm.ErrResult[struct{}, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	network0 := cm.Reinterpret[uint32](network_)
+	localAddress0, localAddress1, localAddress2, localAddress3, localAddress4, localAddress5, localAddress6, localAddress7, localAddress8, localAddress9, localAddress10, localAddress11 := lower_IPSocketAddress(localAddress)
+	wasmimport_UDPSocketStartBind((uint32)(self0), (uint32)(network0), (uint32)(localAddress0), (uint32)(localAddress1), (uint32)(localAddress2), (uint32)(localAddress3), (uint32)(localAddress4), (uint32)(localAddress5), (uint32)(localAddress6), (uint32)(localAddress7), (uint32)(localAddress8), (uint32)(localAddress9), (uint32)(localAddress10), (uint32)(localAddress11), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.start-bind
+//go:noescape
+func wasmimport_UDPSocketStartBind(self0 uint32, network0 uint32, localAddress0 uint32, localAddress1 uint32, localAddress2 uint32, localAddress3 uint32, localAddress4 uint32, localAddress5 uint32, localAddress6 uint32, localAddress7 uint32, localAddress8 uint32, localAddress9 uint32, localAddress10 uint32, localAddress11 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
+
+// Stream represents the imported method "stream".
+//
+// Set up inbound & outbound communication channels, optionally to a specific peer.
+//
+// This function only changes the local socket configuration and does not generate
+// any network traffic.
+// On success, the `remote-address` of the socket is updated. The `local-address`
+// may be updated as well,
+// based on the best network path to `remote-address`.
+//
+// When a `remote-address` is provided, the returned streams are limited to communicating
+// with that specific peer:
+// - `send` can only be used to send to this destination.
+// - `receive` will only return datagrams sent from the provided `remote-address`.
+//
+// This method may be called multiple times on the same socket to change its association,
+// but
+// only the most recently returned pair of streams will be operational. Implementations
+// may trap if
+// the streams returned by a previous invocation haven't been dropped yet before calling
+// `stream` again.
+//
+// The POSIX equivalent in pseudo-code is:
+//
+//	if (was previously connected) {
+//	connect(s, AF_UNSPEC)
+//	}
+//	if (remote_address is Some) {
+//	connect(s, remote_address)
+//	}
+//
+// Unlike in POSIX, the socket must already be explicitly bound.
+//
+// # Typical errors
+// - `invalid-argument`:          The `remote-address` has the wrong address family.
+// (EAFNOSUPPORT)
+// - `invalid-argument`:          The IP address in `remote-address` is set to INADDR_ANY
+// (`0.0.0.0` / `::`). (EDESTADDRREQ, EADDRNOTAVAIL)
+// - `invalid-argument`:          The port in `remote-address` is set to 0. (EDESTADDRREQ,
+// EADDRNOTAVAIL)
+// - `invalid-state`:             The socket is not bound.
+// - `address-in-use`:            Tried to perform an implicit bind, but there were
+// no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD)
+// - `remote-unreachable`:        The remote address is not reachable. (ECONNRESET,
+// ENETRESET, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+// - `connection-refused`:        The connection was refused. (ECONNREFUSED)
+//
+// # References
+// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html>
+// - <https://man7.org/linux/man-pages/man2/connect.2.html>
+// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect>
+// - <https://man.freebsd.org/cgi/man.cgi?connect>
+//
+//	%stream: func(remote-address: option<ip-socket-address>) -> result<tuple<incoming-datagram-stream,
+//	outgoing-datagram-stream>, error-code>
+//
+//go:nosplit
+func (self UDPSocket) Stream(remoteAddress cm.Option[network.IPSocketAddress]) (result cm.OKResult[cm.Tuple[IncomingDatagramStream, OutgoingDatagramStream], network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	remoteAddress0, remoteAddress1, remoteAddress2, remoteAddress3, remoteAddress4, remoteAddress5, remoteAddress6, remoteAddress7, remoteAddress8, remoteAddress9, remoteAddress10, remoteAddress11, remoteAddress12 := lower_OptionIPSocketAddress(remoteAddress)
+	wasmimport_UDPSocketStream((uint32)(self0), (uint32)(remoteAddress0), (uint32)(remoteAddress1), (uint32)(remoteAddress2), (uint32)(remoteAddress3), (uint32)(remoteAddress4), (uint32)(remoteAddress5), (uint32)(remoteAddress6), (uint32)(remoteAddress7), (uint32)(remoteAddress8), (uint32)(remoteAddress9), (uint32)(remoteAddress10), (uint32)(remoteAddress11), (uint32)(remoteAddress12), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.stream
+//go:noescape
+func wasmimport_UDPSocketStream(self0 uint32, remoteAddress0 uint32, remoteAddress1 uint32, remoteAddress2 uint32, remoteAddress3 uint32, remoteAddress4 uint32, remoteAddress5 uint32, remoteAddress6 uint32, remoteAddress7 uint32, remoteAddress8 uint32, remoteAddress9 uint32, remoteAddress10 uint32, remoteAddress11 uint32, remoteAddress12 uint32, result *cm.OKResult[cm.Tuple[IncomingDatagramStream, OutgoingDatagramStream], network.ErrorCode])
+
+// Subscribe represents the imported method "subscribe".
+//
+// Create a `pollable` which will resolve once the socket is ready for I/O.
+//
+// Note: this function is here for WASI Preview2 only.
+// It's planned to be removed when `future` is natively supported in Preview3.
+//
+//	subscribe: func() -> pollable
+//
+//go:nosplit
+func (self UDPSocket) Subscribe() (result poll.Pollable) {
+	self0 := cm.Reinterpret[uint32](self)
+	result0 := wasmimport_UDPSocketSubscribe((uint32)(self0))
+	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
+	return
+}
+
+//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.subscribe
+//go:noescape
+func wasmimport_UDPSocketSubscribe(self0 uint32) (result0 uint32)
+
+// UnicastHopLimit represents the imported method "unicast-hop-limit".
+//
+// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options.
+//
+// If the provided value is 0, an `invalid-argument` error is returned.
+//
+// # Typical errors
+// - `invalid-argument`:     (set) The TTL value must be 1 or higher.
+//
+//	unicast-hop-limit: func() -> result<u8, error-code>
+//
+//go:nosplit
+func (self UDPSocket) UnicastHopLimit() (result cm.OKResult[uint8, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_UDPSocketUnicastHopLimit((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.unicast-hop-limit
+//go:noescape
+func wasmimport_UDPSocketUnicastHopLimit(self0 uint32, result *cm.OKResult[uint8, network.ErrorCode])
+
+// IncomingDatagramStream represents the imported resource "wasi:sockets/udp@0.2.0#incoming-datagram-stream".
+//
+//	resource incoming-datagram-stream
+type IncomingDatagramStream cm.Resource
+
+// ResourceDrop represents the imported resource-drop for resource "incoming-datagram-stream".
+//
+// Drops a resource handle.
+//
+//go:nosplit
+func (self IncomingDatagramStream) ResourceDrop() {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_IncomingDatagramStreamResourceDrop((uint32)(self0))
+	return
+}
+
+//go:wasmimport wasi:sockets/udp@0.2.0 [resource-drop]incoming-datagram-stream
+//go:noescape
+func wasmimport_IncomingDatagramStreamResourceDrop(self0 uint32)
+
+// Receive represents the imported method "receive".
+//
+// Receive messages on the socket.
+//
+// This function attempts to receive up to `max-results` datagrams on the socket without
+// blocking.
+// The returned list may contain fewer elements than requested, but never more.
+//
+// This function returns successfully with an empty list when either:
+// - `max-results` is 0, or:
+// - `max-results` is greater than 0, but no results are immediately available.
+// This function never returns `error(would-block)`.
+//
+// # Typical errors
+// - `remote-unreachable`: The remote address is not reachable. (ECONNRESET, ENETRESET
+// on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+// - `connection-refused`: The connection was refused. (ECONNREFUSED)
+//
+// # References
+// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvfrom.html>
+// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvmsg.html>
+// - <https://man7.org/linux/man-pages/man2/recv.2.html>
+// - <https://man7.org/linux/man-pages/man2/recvmmsg.2.html>
+// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recv>
+// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recvfrom>
+// - <https://learn.microsoft.com/en-us/previous-versions/windows/desktop/legacy/ms741687(v=vs.85)>
+// - <https://man.freebsd.org/cgi/man.cgi?query=recv&sektion=2>
+//
+//	receive: func(max-results: u64) -> result<list<incoming-datagram>, error-code>
+//
+//go:nosplit
+func (self IncomingDatagramStream) Receive(maxResults uint64) (result cm.OKResult[cm.List[IncomingDatagram], network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	maxResults0 := (uint64)(maxResults)
+	wasmimport_IncomingDatagramStreamReceive((uint32)(self0), (uint64)(maxResults0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/udp@0.2.0 [method]incoming-datagram-stream.receive
+//go:noescape
+func wasmimport_IncomingDatagramStreamReceive(self0 uint32, maxResults0 uint64, result *cm.OKResult[cm.List[IncomingDatagram], network.ErrorCode])
+
+// Subscribe represents the imported method "subscribe".
+//
+// Create a `pollable` which will resolve once the stream is ready to receive again.
+//
+// Note: this function is here for WASI Preview2 only.
+// It's planned to be removed when `future` is natively supported in Preview3.
+//
+//	subscribe: func() -> pollable
+//
+//go:nosplit
+func (self IncomingDatagramStream) Subscribe() (result poll.Pollable) {
+	self0 := cm.Reinterpret[uint32](self)
+	result0 := wasmimport_IncomingDatagramStreamSubscribe((uint32)(self0))
+	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
+	return
+}
+
+//go:wasmimport wasi:sockets/udp@0.2.0 [method]incoming-datagram-stream.subscribe
+//go:noescape
+func wasmimport_IncomingDatagramStreamSubscribe(self0 uint32) (result0 uint32)
+
+// OutgoingDatagramStream represents the imported resource "wasi:sockets/udp@0.2.0#outgoing-datagram-stream".
+//
+//	resource outgoing-datagram-stream
+type OutgoingDatagramStream cm.Resource
+
+// ResourceDrop represents the imported resource-drop for resource "outgoing-datagram-stream".
+//
+// Drops a resource handle.
+//
+//go:nosplit
+func (self OutgoingDatagramStream) ResourceDrop() {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_OutgoingDatagramStreamResourceDrop((uint32)(self0))
+	return
+}
+
+//go:wasmimport wasi:sockets/udp@0.2.0 [resource-drop]outgoing-datagram-stream
+//go:noescape
+func wasmimport_OutgoingDatagramStreamResourceDrop(self0 uint32)
+
+// CheckSend represents the imported method "check-send".
+//
+// Check readiness for sending. This function never blocks.
+//
+// Returns the number of datagrams permitted for the next call to `send`,
+// or an error. Calling `send` with more datagrams than this function has
+// permitted will trap.
+//
+// When this function returns ok(0), the `subscribe` pollable will
+// become ready when this function will report at least ok(1), or an
+// error.
+//
+// Never returns `would-block`.
+//
+//	check-send: func() -> result<u64, error-code>
+//
+//go:nosplit
+func (self OutgoingDatagramStream) CheckSend() (result cm.OKResult[uint64, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	wasmimport_OutgoingDatagramStreamCheckSend((uint32)(self0), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/udp@0.2.0 [method]outgoing-datagram-stream.check-send
+//go:noescape
+func wasmimport_OutgoingDatagramStreamCheckSend(self0 uint32, result *cm.OKResult[uint64, network.ErrorCode])
+
+// Send represents the imported method "send".
+//
+// Send messages on the socket.
+//
+// This function attempts to send all provided `datagrams` on the socket without blocking
+// and
+// returns how many messages were actually sent (or queued for sending). This function
+// never
+// returns `error(would-block)`. If none of the datagrams were able to be sent, `ok(0)`
+// is returned.
+//
+// This function semantically behaves the same as iterating the `datagrams` list and
+// sequentially
+// sending each individual datagram until either the end of the list has been reached
+// or the first error occurred.
+// If at least one datagram has been sent successfully, this function never returns
+// an error.
+//
+// If the input list is empty, the function returns `ok(0)`.
+//
+// Each call to `send` must be permitted by a preceding `check-send`. Implementations
+// must trap if
+// either `check-send` was not called or `datagrams` contains more items than `check-send`
+// permitted.
+//
+// # Typical errors
+// - `invalid-argument`:        The `remote-address` has the wrong address family.
+// (EAFNOSUPPORT)
+// - `invalid-argument`:        The IP address in `remote-address` is set to INADDR_ANY
+// (`0.0.0.0` / `::`). (EDESTADDRREQ, EADDRNOTAVAIL)
+// - `invalid-argument`:        The port in `remote-address` is set to 0. (EDESTADDRREQ,
+// EADDRNOTAVAIL)
+// - `invalid-argument`:        The socket is in "connected" mode and `remote-address`
+// is `some` value that does not match the address passed to `stream`. (EISCONN)
+// - `invalid-argument`:        The socket is not "connected" and no value for `remote-address`
+// was provided. (EDESTADDRREQ)
+// - `remote-unreachable`:      The remote address is not reachable. (ECONNRESET,
+// ENETRESET on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+// - `connection-refused`:      The connection was refused. (ECONNREFUSED)
+// - `datagram-too-large`:      The datagram is too large. (EMSGSIZE)
+//
+// # References
+// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendto.html>
+// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendmsg.html>
+// - <https://man7.org/linux/man-pages/man2/send.2.html>
+// - <https://man7.org/linux/man-pages/man2/sendmmsg.2.html>
+// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-send>
+// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-sendto>
+// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasendmsg>
+// - <https://man.freebsd.org/cgi/man.cgi?query=send&sektion=2>
+//
+//	send: func(datagrams: list<outgoing-datagram>) -> result<u64, error-code>
+//
+//go:nosplit
+func (self OutgoingDatagramStream) Send(datagrams cm.List[OutgoingDatagram]) (result cm.OKResult[uint64, network.ErrorCode]) {
+	self0 := cm.Reinterpret[uint32](self)
+	datagrams0, datagrams1 := cm.LowerList(datagrams)
+	wasmimport_OutgoingDatagramStreamSend((uint32)(self0), (*OutgoingDatagram)(datagrams0), (uint32)(datagrams1), &result)
+	return
+}
+
+//go:wasmimport wasi:sockets/udp@0.2.0 [method]outgoing-datagram-stream.send
+//go:noescape
+func wasmimport_OutgoingDatagramStreamSend(self0 uint32, datagrams0 *OutgoingDatagram, datagrams1 uint32, result *cm.OKResult[uint64, network.ErrorCode])
+
+// Subscribe represents the imported method "subscribe".
+//
+// Create a `pollable` which will resolve once the stream is ready to send again.
+//
+// Note: this function is here for WASI Preview2 only.
+// It's planned to be removed when `future` is natively supported in Preview3.
+//
+//	subscribe: func() -> pollable
+//
+//go:nosplit
+func (self OutgoingDatagramStream) Subscribe() (result poll.Pollable) {
+	self0 := cm.Reinterpret[uint32](self)
+	result0 := wasmimport_OutgoingDatagramStreamSubscribe((uint32)(self0))
+	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
+	return
+}
+
+//go:wasmimport wasi:sockets/udp@0.2.0 [method]outgoing-datagram-stream.subscribe
+//go:noescape
+func wasmimport_OutgoingDatagramStreamSubscribe(self0 uint32) (result0 uint32)

src/os/dir_test.go

@@ -1,4 +1,4 @@
-//go:build darwin || (linux && !baremetal && !js && !wasip1 && !386 && !arm)
+//go:build darwin || (linux && !baremetal && !js && !wasip1 && !wasip2 && !386 && !arm)
 
 package os_test
 

src/os/dir_unix.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build linux && !baremetal && !wasip1 && !wasm_unknown
+//go:build linux && !baremetal && !wasip1 && !wasip2 && !wasm_unknown
 
 package os
 

src/os/dir_wasi.go

@@ -6,7 +6,7 @@
 // fairly similar: we use fdopendir, fdclosedir, and readdir from wasi-libc in
 // a similar way that the darwin code uses functions from libc.
 
-//go:build wasip1
+//go:build wasip1 || wasip2
 
 package os
 

src/os/dirent_linux.go

@@ -1,4 +1,4 @@
-//go:build !baremetal && !js && !wasip1 && !wasm_unknown
+//go:build !baremetal && !js && !wasip1 && !wasip2 && !wasm_unknown
 
 // Copyright 2020 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style

src/os/env_unix_test.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build darwin || linux || wasip1
+//go:build darwin || linux || wasip1 || wasip2
 
 package os_test
 

src/os/exec_posix.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris || wasip1 || windows
+//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris || wasip1 || wasip2 || windows
 
 package os
 

src/os/file_other.go

@@ -1,4 +1,4 @@
-//go:build baremetal || (tinygo.wasm && !wasip1)
+//go:build baremetal || (tinygo.wasm && !wasip1 && !wasip2)
 
 package os
 

src/os/file_unix.go

@@ -1,4 +1,4 @@
-//go:build darwin || (linux && !baremetal && !wasm_unknown) || wasip1
+//go:build darwin || (linux && !baremetal && !wasm_unknown) || wasip1 || wasip2
 
 // target wasi sets GOOS=linux and thus the +linux build tag,
 // even though it doesn't show up in "tinygo info target -wasi"

src/os/getpagesize_test.go

@@ -1,4 +1,4 @@
-//go:build windows || darwin || (linux && !baremetal) || wasip1
+//go:build windows || darwin || (linux && !baremetal) || wasip1 || wasip2
 
 package os_test
 

src/os/os_anyos_test.go

@@ -1,4 +1,4 @@
-//go:build windows || darwin || (linux && !baremetal) || wasip1
+//go:build windows || darwin || (linux && !baremetal) || wasip1 || wasip2
 
 package os_test
 
@@ -275,7 +275,7 @@ func TestDirFS(t *testing.T) {
 		t.Log("TODO: implement Readdir for Windows")
 		return
 	}
-	if runtime.GOOS == "wasip1" {
+	if runtime.GOOS == "wasip1" || runtime.GOOS == "wasip2" {
 		t.Log("TODO: allow foo/bar/. as synonym for path foo/bar on wasi?")
 		return
 	}
@@ -296,7 +296,7 @@ func TestDirFSPathsValid(t *testing.T) {
 		t.Log("skipping on Windows")
 		return
 	}
-	if runtime.GOOS == "wasip1" {
+	if runtime.GOOS == "wasip1" || runtime.GOOS == "wasip2" {
 		t.Log("skipping on wasi because it fails on wasi on windows")
 		return
 	}

src/os/os_chmod_test.go

@@ -1,4 +1,4 @@
-//go:build !baremetal && !js && !wasip1
+//go:build !baremetal && !js && !wasip1 && !wasip2
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style

src/os/os_hardlink_test.go

@@ -1,4 +1,4 @@
-//go:build !windows && !baremetal && !js && !wasi && !wasip1 && !wasm_unknown
+//go:build !windows && !baremetal && !js && !wasip1 && !wasm_unknown
 
 // Copyright 2024 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style

src/os/os_symlink_test.go

@@ -1,4 +1,4 @@
-//go:build !windows && !baremetal && !js && !wasip1
+//go:build !windows && !baremetal && !js && !wasip1 && !wasip2
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style

src/os/pipe_test.go

@@ -1,4 +1,4 @@
-//go:build windows || darwin || (linux && !baremetal && !wasi)
+//go:build windows || darwin || (linux && !baremetal && !wasip1 && !wasip2)
 
 // Copyright 2021 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style

src/os/read_test.go

@@ -1,4 +1,4 @@
-//go:build !baremetal && !js && !wasip1
+//go:build !baremetal && !js && !wasip1 && !wasip2
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style

src/os/removeall_noat.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build !baremetal && !js && !wasip1 && !wasm_unknown
+//go:build !baremetal && !js && !wasip1 && !wasip2 && !wasm_unknown
 
 package os
 

src/os/removeall_other.go

@@ -1,4 +1,4 @@
-//go:build baremetal || js || wasi || wasip1 || wasm_unknown
+//go:build baremetal || js || wasip1 || wasip2 || wasm_unknown
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style

src/os/removeall_test.go

@@ -1,4 +1,4 @@
-//go:build darwin || (linux && !baremetal && !js && !wasi)
+//go:build darwin || (linux && !baremetal && !js && !wasip1 && !wasip2)
 
 // TODO: implement ReadDir on windows
 

src/os/seek_unix_bad.go

@@ -1,4 +1,4 @@
-//go:build (linux && !baremetal && 386) || (linux && !baremetal && arm && !wasi)
+//go:build (linux && !baremetal && 386) || (linux && !baremetal && arm && !wasip1 && !wasip2)
 
 package os
 

src/os/stat_linuxlike.go

@@ -1,4 +1,4 @@
-//go:build (linux && !baremetal && !wasm_unknown) || wasip1
+//go:build (linux && !baremetal && !wasm_unknown) || wasip1 || wasip2
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style

src/os/stat_other.go

@@ -1,4 +1,4 @@
-//go:build baremetal || (tinygo.wasm && !wasip1)
+//go:build baremetal || (tinygo.wasm && !wasip1 && !wasip2)
 
 // Copyright 2016 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style

src/os/stat_unix.go

@@ -1,4 +1,4 @@
-//go:build darwin || (linux && !baremetal && !wasm_unknown) || wasip1
+//go:build darwin || (linux && !baremetal && !wasm_unknown) || wasip1 || wasip2
 
 // Copyright 2016 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style

src/os/tempfile_test.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build !baremetal && !js && !wasip1
+//go:build !baremetal && !js && !wasip1 && !wasip2
 
 package os_test
 

src/os/types_unix.go

@@ -1,4 +1,4 @@
-//go:build darwin || (linux && !baremetal && !wasm_unknown) || wasip1
+//go:build darwin || (linux && !baremetal && !wasm_unknown) || wasip1 || wasip2
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style

src/runtime/os_linux.go

@@ -1,4 +1,4 @@
-//go:build linux && !baremetal && !nintendoswitch && !wasip1 && !wasm_unknown
+//go:build linux && !baremetal && !nintendoswitch && !wasip1 && !wasm_unknown && !wasip2
 
 package runtime
 

src/runtime/os_other.go

@@ -1,4 +1,4 @@
-//go:build linux && (baremetal || nintendoswitch || wasi || wasm_unknown)
+//go:build linux && (baremetal || nintendoswitch || wasm_unknown)
 
 // Other systems that aren't operating systems supported by the Go toolchain
 // need to pretend to be an existing operating system. Linux seems like a good

src/runtime/os_wasip2.go

@@ -0,0 +1,5 @@
+//go:build wasip2
+
+package runtime
+
+const GOOS = "wasip2"

src/runtime/runtime_tinygowasm.go

@@ -1,4 +1,4 @@
-//go:build tinygo.wasm && !wasm_unknown
+//go:build tinygo.wasm && !wasm_unknown && !wasip2
 
 package runtime
 

src/runtime/runtime_tinygowasmp2.go

@@ -0,0 +1,76 @@
+//go:build wasip2
+
+package runtime
+
+import (
+	exit "internal/wasi/cli/v0.2.0/exit"
+	stdout "internal/wasi/cli/v0.2.0/stdout"
+	monotonicclock "internal/wasi/clocks/v0.2.0/monotonic-clock"
+	wallclock "internal/wasi/clocks/v0.2.0/wall-clock"
+	random "internal/wasi/random/v0.2.0/random"
+
+	"github.com/ydnar/wasm-tools-go/cm"
+)
+
+const putcharBufferSize = 120
+
+// Using global variables to avoid heap allocation.
+var (
+	putcharStdout        = stdout.GetStdout()
+	putcharBuffer        = [putcharBufferSize]byte{}
+	putcharPosition uint = 0
+)
+
+func putchar(c byte) {
+	putcharBuffer[putcharPosition] = c
+	putcharPosition++
+	if c == '\n' || putcharPosition >= putcharBufferSize {
+		list := cm.NewList(&putcharBuffer[0], putcharPosition)
+		putcharStdout.BlockingWriteAndFlush(list) // error return ignored; can't do anything anyways
+		putcharPosition = 0
+	}
+}
+
+func getchar() byte {
+	// dummy, TODO
+	return 0
+}
+
+func buffered() int {
+	// dummy, TODO
+	return 0
+}
+
+//go:linkname now time.now
+func now() (sec int64, nsec int32, mono int64) {
+	now := wallclock.Now()
+	sec = int64(now.Seconds)
+	nsec = int32(now.Nanoseconds)
+	mono = int64(monotonicclock.Now())
+	return
+}
+
+// Abort executes the wasm 'unreachable' instruction.
+func abort() {
+	trap()
+}
+
+//go:linkname syscall_Exit syscall.Exit
+func syscall_Exit(code int) {
+	exit.Exit(code != 0)
+}
+
+// TinyGo does not yet support any form of parallelism on WebAssembly, so these
+// can be left empty.
+
+//go:linkname procPin sync/atomic.runtime_procPin
+func procPin() {
+}
+
+//go:linkname procUnpin sync/atomic.runtime_procUnpin
+func procUnpin() {
+}
+
+func hardwareRand() (n uint64, ok bool) {
+	return random.GetRandomU64(), true
+}

src/runtime/runtime_unix.go

@@ -1,4 +1,4 @@
-//go:build (darwin || (linux && !baremetal && !wasip1 && !wasm_unknown)) && !nintendoswitch
+//go:build (darwin || (linux && !baremetal && !wasip1 && !wasm_unknown && !wasip2)) && !nintendoswitch
 
 package runtime
 

src/runtime/runtime_wasm_js_scheduler.go

@@ -1,4 +1,4 @@
-//go:build wasm && !wasi && !scheduler.none && !wasip1 && !wasm_unknown
+//go:build wasm && !wasi && !scheduler.none && !wasip1 && !wasip2 && !wasm_unknown
 
 package runtime
 

src/runtime/runtime_wasm_wasip2.go

@@ -0,0 +1,61 @@
+//go:build wasip2
+
+package runtime
+
+import (
+	"unsafe"
+
+	"internal/wasi/cli/v0.2.0/environment"
+	monotonicclock "internal/wasi/clocks/v0.2.0/monotonic-clock"
+)
+
+type timeUnit int64
+
+//export wasi:cli/run@0.2.0#run
+func __wasi_cli_run_run() uint32 {
+	_start()
+	return 0
+}
+
+//export _start
+func _start() {
+	// These need to be initialized early so that the heap can be initialized.
+	heapStart = uintptr(unsafe.Pointer(&heapStartSymbol))
+	heapEnd = uintptr(wasm_memory_size(0) * wasmPageSize)
+	run()
+}
+
+func init() {
+}
+
+var args []string
+
+//go:linkname os_runtime_args os.runtime_args
+func os_runtime_args() []string {
+	if args == nil {
+		args = environment.GetArguments().Slice()
+	}
+	return args
+}
+
+//export cabi_realloc
+func cabi_realloc(ptr, oldsize, align, newsize unsafe.Pointer) unsafe.Pointer {
+	return realloc(ptr, uintptr(newsize))
+}
+
+func ticksToNanoseconds(ticks timeUnit) int64 {
+	return int64(ticks)
+}
+
+func nanosecondsToTicks(ns int64) timeUnit {
+	return timeUnit(ns)
+}
+
+func sleepTicks(d timeUnit) {
+	p := monotonicclock.SubscribeDuration(monotonicclock.Duration(d))
+	p.Block()
+}
+
+func ticks() timeUnit {
+	return timeUnit(monotonicclock.Now())
+}

src/syscall/env_libc.go

@@ -0,0 +1,59 @@
+//go:build darwin || nintendoswitch || wasip1
+
+package syscall
+
+import (
+	"unsafe"
+)
+
+func Environ() []string {
+
+	// This function combines all the environment into a single allocation.
+	// While this optimizes for memory usage and garbage collector
+	// overhead, it does run the risk of potentially pinning a "large"
+	// allocation if a user holds onto a single environment variable or
+	// value.  Having each variable be its own allocation would make the
+	// trade-off in the other direction.
+
+	// calculate total memory required
+	var length uintptr
+	var vars int
+	for environ := libc_environ; *environ != nil; {
+		length += libc_strlen(*environ)
+		vars++
+		environ = (*unsafe.Pointer)(unsafe.Add(unsafe.Pointer(environ), unsafe.Sizeof(environ)))
+	}
+
+	// allocate our backing slice for the strings
+	b := make([]byte, length)
+	// and the slice we're going to return
+	envs := make([]string, 0, vars)
+
+	// loop over the environment again, this time copying over the data to the backing slice
+	for environ := libc_environ; *environ != nil; {
+		length = libc_strlen(*environ)
+		// construct a Go string pointing at the libc-allocated environment variable data
+		var envVar string
+		rawEnvVar := (*struct {
+			ptr    unsafe.Pointer
+			length uintptr
+		})(unsafe.Pointer(&envVar))
+		rawEnvVar.ptr = *environ
+		rawEnvVar.length = length
+		// pull off the number of bytes we need for this environment variable
+		var bs []byte
+		bs, b = b[:length], b[length:]
+		// copy over the bytes to the Go heap
+		copy(bs, envVar)
+		// convert trimmed slice to string
+		s := *(*string)(unsafe.Pointer(&bs))
+		// add s to our list of environment variables
+		envs = append(envs, s)
+		// environ++
+		environ = (*unsafe.Pointer)(unsafe.Add(unsafe.Pointer(environ), unsafe.Sizeof(environ)))
+	}
+	return envs
+}
+
+//go:extern environ
+var libc_environ *unsafe.Pointer

src/syscall/env_wasip2.go

@@ -0,0 +1,11 @@
+//go:build wasip2
+
+package syscall
+
+func Environ() []string {
+	var env []string
+	for k, v := range libc_envs {
+		env = append(env, k+"="+v)
+	}
+	return env
+}

src/syscall/errno_other.go

@@ -1,4 +1,4 @@
-//go:build !wasip1 && !darwin
+//go:build !wasip1 && !wasip2 && !darwin
 
 package syscall
 

src/syscall/errno_wasip1.go

@@ -0,0 +1,8 @@
+//go:build wasip1
+
+package syscall
+
+// Use a go:extern definition to access the errno from wasi-libc
+//
+//go:extern errno
+var libcErrno Errno

src/syscall/errno_wasip2.go

@@ -0,0 +1,7 @@
+//go:build wasip2
+
+package syscall
+
+// The errno for libc_wasip2.go
+
+var libcErrno Errno