internal/{cm,wasi}: regenerate WASI 0.2 bindings with wasm-tools-go v0.3.0

70 files changed, 3350 insertions, 684 deletions

diff --git a/src/internal/cm/abi.go b/src/internal/cm/abi.go
index 91ca1be32..4d6303678 100644
--- a/src/internal/cm/abi.go
+++ b/src/internal/cm/abi.go
@@ -2,6 +2,11 @@ package cm
 
 import "unsafe"
 
+// AnyInteger is a type constraint for any integer type.
+type AnyInteger interface {
+	~int | ~uint | ~uintptr | ~int8 | ~uint8 | ~int16 | ~uint16 | ~int32 | ~uint32 | ~int64 | ~uint64
+}
+
 // Reinterpret reinterprets the bits of type From into type T.
 // Will panic if the size of From is smaller than the size of To.
 func Reinterpret[T, From any](from From) (to T) {
@@ -19,19 +24,19 @@ func LowerString[S ~string](s S) (*byte, uint32) {
 }
 
 // LiftString lifts Core WebAssembly types into a [string].
-func LiftString[T ~string, Data unsafe.Pointer | uintptr | *uint8, Len uint | uintptr | uint32 | uint64](data Data, len Len) T {
+func LiftString[T ~string, Data unsafe.Pointer | uintptr | *uint8, Len AnyInteger](data Data, len Len) T {
 	return T(unsafe.String((*uint8)(unsafe.Pointer(data)), int(len)))
 }
 
 // LowerList lowers a [List] into a pair of Core WebAssembly types.
-func LowerList[L ~struct{ list[T] }, T any](list L) (*T, uint32) {
+func LowerList[L AnyList[T], T any](list L) (*T, uint32) {
 	l := (*List[T])(unsafe.Pointer(&list))
 	return l.data, uint32(l.len)
 }
 
 // LiftList lifts Core WebAssembly types into a [List].
-func LiftList[L List[T], T any, Data unsafe.Pointer | uintptr | *T, Len uint | uintptr | uint32 | uint64](data Data, len Len) L {
-	return L(NewList((*T)(unsafe.Pointer(data)), uint(len)))
+func LiftList[L AnyList[T], T any, Data unsafe.Pointer | uintptr | *T, Len AnyInteger](data Data, len Len) L {
+	return L(NewList((*T)(unsafe.Pointer(data)), len))
 }
 
 // BoolToU32 converts a value whose underlying type is [bool] into a [uint32].
@@ -84,6 +89,25 @@ func F64ToU64(v float64) uint64 { return *(*uint64)(unsafe.Pointer(&v)) }
 // [Canonical ABI]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/CanonicalABI.md
 func U64ToF64(v uint64) float64 { return *(*float64)(unsafe.Pointer(&v)) }
 
+// F32ToU64 maps the bits of a [float32] into a [uint64].
+// Used to lower a [float32] into a Core WebAssembly i64 when required by the [Canonical ABI].
+//
+// [float32]: https://pkg.go.dev/builtin#float32
+// [uint64]: https://pkg.go.dev/builtin#uint64
+// [Canonical ABI]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/CanonicalABI.md
+func F32ToU64(v float32) uint64 { return uint64(*(*uint32)(unsafe.Pointer(&v))) }
+
+// U64ToF32 maps the bits of a [uint64] into a [float32].
+// Used to lift a Core WebAssembly i64 into a [float32] when required by the [Canonical ABI].
+//
+// [uint64]: https://pkg.go.dev/builtin#uint64
+// [float32]: https://pkg.go.dev/builtin#float32
+// [Canonical ABI]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/CanonicalABI.md
+func U64ToF32(v uint64) float32 {
+	truncated := uint32(v)
+	return *(*float32)(unsafe.Pointer(&truncated))
+}
+
 // PointerToU32 converts a pointer of type *T into a [uint32].
 // Used to lower a pointer into a Core WebAssembly i32 as specified in the [Canonical ABI].
 //
diff --git a/src/internal/cm/hostlayout_go122.go b/src/internal/cm/hostlayout_go122.go
new file mode 100644
index 000000000..25c146976
--- /dev/null
+++ b/src/internal/cm/hostlayout_go122.go
@@ -0,0 +1,11 @@
+//go:build !go1.23
+
+package cm
+
+// HostLayout marks a struct as using host memory layout.
+// See [structs.HostLayout] in Go 1.23 or later.
+type HostLayout struct {
+	_ hostLayout // prevent accidental conversion with plain struct{}
+}
+
+type hostLayout struct{}
diff --git a/src/internal/cm/hostlayout_go123.go b/src/internal/cm/hostlayout_go123.go
new file mode 100644
index 000000000..4fc3a2bdf
--- /dev/null
+++ b/src/internal/cm/hostlayout_go123.go
@@ -0,0 +1,9 @@
+//go:build go1.23
+
+package cm
+
+import "structs"
+
+// HostLayout marks a struct as using host memory layout.
+// See [structs.HostLayout] in Go 1.23 or later.
+type HostLayout = structs.HostLayout
diff --git a/src/internal/cm/list.go b/src/internal/cm/list.go
index e170efbed..5c896d044 100644
--- a/src/internal/cm/list.go
+++ b/src/internal/cm/list.go
@@ -4,14 +4,25 @@ import "unsafe"
 
 // List represents a Component Model list.
 // The binary representation of list<T> is similar to a Go slice minus the cap field.
-type List[T any] struct{ list[T] }
+type List[T any] struct {
+	_ HostLayout
+	list[T]
+}
+
+// AnyList is a type constraint for generic functions that accept any [List] type.
+type AnyList[T any] interface {
+	~struct {
+		_ HostLayout
+		list[T]
+	}
+}
 
 // NewList returns a List[T] from data and len.
-func NewList[T any](data *T, len uint) List[T] {
+func NewList[T any, Len AnyInteger](data *T, len Len) List[T] {
 	return List[T]{
-		list[T]{
+		list: list[T]{
 			data: data,
-			len:  len,
+			len:  uintptr(len),
 		},
 	}
 }
@@ -20,15 +31,16 @@ func NewList[T any](data *T, len uint) List[T] {
 // The underlying slice data is not copied, and the resulting List points at the
 // same array storage as the slice.
 func ToList[S ~[]T, T any](s S) List[T] {
-	return NewList[T](unsafe.SliceData([]T(s)), uint(len(s)))
+	return NewList[T](unsafe.SliceData([]T(s)), uintptr(len(s)))
 }
 
 // list represents the internal representation of a Component Model list.
 // It is intended to be embedded in a [List], so embedding types maintain
 // the methods defined on this type.
 type list[T any] struct {
+	_    HostLayout
 	data *T
-	len  uint
+	len  uintptr
 }
 
 // Slice returns a Go slice representing the List.
@@ -42,7 +54,7 @@ func (l list[T]) Data() *T {
 }
 
 // Len returns the length of the list.
-// TODO: should this return an int instead of a uint?
-func (l list[T]) Len() uint {
+// TODO: should this return an int instead of a uintptr?
+func (l list[T]) Len() uintptr {
 	return l.len
 }
diff --git a/src/internal/cm/option.go b/src/internal/cm/option.go
index edc288b4c..cf7024aa6 100644
--- a/src/internal/cm/option.go
+++ b/src/internal/cm/option.go
@@ -3,7 +3,10 @@ package cm
 // Option represents a Component Model [option<T>] type.
 //
 // [option<T>]: https://component-model.bytecodealliance.org/design/wit.html#options
-type Option[T any] struct{ option[T] }
+type Option[T any] struct {
+	_ HostLayout
+	option[T]
+}
 
 // None returns an [Option] representing the none case,
 // equivalent to the zero value.
@@ -14,7 +17,7 @@ func None[T any]() Option[T] {
 // Some returns an [Option] representing the some case.
 func Some[T any](v T) Option[T] {
 	return Option[T]{
-		option[T]{
+		option: option[T]{
 			isSome: true,
 			some:   v,
 		},
@@ -25,6 +28,7 @@ func Some[T any](v T) Option[T] {
 // The first byte is a bool representing none or some,
 // followed by storage for the associated type T.
 type option[T any] struct {
+	_      HostLayout
 	isSome bool
 	some   T
 }
@@ -42,3 +46,14 @@ func (o *option[T]) Some() *T {
 	}
 	return nil
 }
+
+// Value returns T if o represents the some case,
+// or the zero value of T if o represents the none case.
+// This does not have a pointer receiver, so it can be chained.
+func (o option[T]) Value() T {
+	if !o.isSome {
+		var zero T
+		return zero
+	}
+	return o.some
+}
diff --git a/src/internal/cm/result.go b/src/internal/cm/result.go
index d21275612..82200e278 100644
--- a/src/internal/cm/result.go
+++ b/src/internal/cm/result.go
@@ -17,10 +17,22 @@ type BoolResult bool
 // Result represents a result sized to hold the Shape type.
 // The size of the Shape type must be greater than or equal to the size of OK and Err types.
 // For results with two zero-length types, use [BoolResult].
-type Result[Shape, OK, Err any] struct{ result[Shape, OK, Err] }
+type Result[Shape, OK, Err any] struct {
+	_ HostLayout
+	result[Shape, OK, Err]
+}
+
+// AnyResult is a type constraint for generic functions that accept any [Result] type.
+type AnyResult[Shape, OK, Err any] interface {
+	~struct {
+		_ HostLayout
+		result[Shape, OK, Err]
+	}
+}
 
 // result represents the internal representation of a Component Model result type.
 type result[Shape, OK, Err any] struct {
+	_     HostLayout
 	isErr bool
 	_     [0]OK
 	_     [0]Err
@@ -88,8 +100,8 @@ func (r *result[Shape, OK, Err]) validate() {
 
 // OK returns an OK result with shape Shape and type OK and Err.
 // Pass Result[OK, OK, Err] or Result[Err, OK, Err] as the first type argument.
-func OK[R ~struct{ result[Shape, OK, Err] }, Shape, OK, Err any](ok OK) R {
-	var r struct{ result[Shape, OK, Err] }
+func OK[R AnyResult[Shape, OK, Err], Shape, OK, Err any](ok OK) R {
+	var r Result[Shape, OK, Err]
 	r.validate()
 	r.isErr = ResultOK
 	*((*OK)(unsafe.Pointer(&r.data))) = ok
@@ -98,8 +110,8 @@ func OK[R ~struct{ result[Shape, OK, Err] }, Shape, OK, Err any](ok OK) R {
 
 // Err returns an error result with shape Shape and type OK and Err.
 // Pass Result[OK, OK, Err] or Result[Err, OK, Err] as the first type argument.
-func Err[R ~struct{ result[Shape, OK, Err] }, Shape, OK, Err any](err Err) R {
-	var r struct{ result[Shape, OK, Err] }
+func Err[R AnyResult[Shape, OK, Err], Shape, OK, Err any](err Err) R {
+	var r Result[Shape, OK, Err]
 	r.validate()
 	r.isErr = ResultErr
 	*((*Err)(unsafe.Pointer(&r.data))) = err
diff --git a/src/internal/cm/tuple.go b/src/internal/cm/tuple.go
index 7b0e535c0..610a19be5 100644
--- a/src/internal/cm/tuple.go
+++ b/src/internal/cm/tuple.go
@@ -4,6 +4,7 @@ package cm
 //
 // [Component Model tuple]: https://component-model.bytecodealliance.org/design/wit.html#tuples
 type Tuple[T0, T1 any] struct {
+	_  HostLayout
 	F0 T0
 	F1 T1
 }
@@ -12,6 +13,7 @@ type Tuple[T0, T1 any] struct {
 //
 // [Component Model tuple]: https://component-model.bytecodealliance.org/design/wit.html#tuples
 type Tuple3[T0, T1, T2 any] struct {
+	_  HostLayout
 	F0 T0
 	F1 T1
 	F2 T2
@@ -21,6 +23,7 @@ type Tuple3[T0, T1, T2 any] struct {
 //
 // [Component Model tuple]: https://component-model.bytecodealliance.org/design/wit.html#tuples
 type Tuple4[T0, T1, T2, T3 any] struct {
+	_  HostLayout
 	F0 T0
 	F1 T1
 	F2 T2
@@ -31,6 +34,7 @@ type Tuple4[T0, T1, T2, T3 any] struct {
 //
 // [Component Model tuple]: https://component-model.bytecodealliance.org/design/wit.html#tuples
 type Tuple5[T0, T1, T2, T3, T4 any] struct {
+	_  HostLayout
 	F0 T0
 	F1 T1
 	F2 T2
@@ -42,6 +46,7 @@ type Tuple5[T0, T1, T2, T3, T4 any] struct {
 //
 // [Component Model tuple]: https://component-model.bytecodealliance.org/design/wit.html#tuples
 type Tuple6[T0, T1, T2, T3, T4, T5 any] struct {
+	_  HostLayout
 	F0 T0
 	F1 T1
 	F2 T2
@@ -54,6 +59,7 @@ type Tuple6[T0, T1, T2, T3, T4, T5 any] struct {
 //
 // [Component Model tuple]: https://component-model.bytecodealliance.org/design/wit.html#tuples
 type Tuple7[T0, T1, T2, T3, T4, T5, T6 any] struct {
+	_  HostLayout
 	F0 T0
 	F1 T1
 	F2 T2
@@ -67,6 +73,7 @@ type Tuple7[T0, T1, T2, T3, T4, T5, T6 any] struct {
 //
 // [Component Model tuple]: https://component-model.bytecodealliance.org/design/wit.html#tuples
 type Tuple8[T0, T1, T2, T3, T4, T5, T6, T7 any] struct {
+	_  HostLayout
 	F0 T0
 	F1 T1
 	F2 T2
@@ -81,6 +88,7 @@ type Tuple8[T0, T1, T2, T3, T4, T5, T6, T7 any] struct {
 //
 // [Component Model tuple]: https://component-model.bytecodealliance.org/design/wit.html#tuples
 type Tuple9[T0, T1, T2, T3, T4, T5, T6, T7, T8 any] struct {
+	_  HostLayout
 	F0 T0
 	F1 T1
 	F2 T2
@@ -96,6 +104,7 @@ type Tuple9[T0, T1, T2, T3, T4, T5, T6, T7, T8 any] struct {
 //
 // [Component Model tuple]: https://component-model.bytecodealliance.org/design/wit.html#tuples
 type Tuple10[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 any] struct {
+	_  HostLayout
 	F0 T0
 	F1 T1
 	F2 T2
@@ -112,6 +121,7 @@ type Tuple10[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 any] struct {
 //
 // [Component Model tuple]: https://component-model.bytecodealliance.org/design/wit.html#tuples
 type Tuple11[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any] struct {
+	_   HostLayout
 	F0  T0
 	F1  T1
 	F2  T2
@@ -129,6 +139,7 @@ type Tuple11[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any] struct {
 //
 // [Component Model tuple]: https://component-model.bytecodealliance.org/design/wit.html#tuples
 type Tuple12[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any] struct {
+	_   HostLayout
 	F0  T0
 	F1  T1
 	F2  T2
@@ -147,6 +158,7 @@ type Tuple12[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any] struct {
 //
 // [Component Model tuple]: https://component-model.bytecodealliance.org/design/wit.html#tuples
 type Tuple13[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any] struct {
+	_   HostLayout
 	F0  T0
 	F1  T1
 	F2  T2
@@ -166,6 +178,7 @@ type Tuple13[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any] struct {
 //
 // [Component Model tuple]: https://component-model.bytecodealliance.org/design/wit.html#tuples
 type Tuple14[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any] struct {
+	_   HostLayout
 	F0  T0
 	F1  T1
 	F2  T2
@@ -186,6 +199,7 @@ type Tuple14[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any] str
 //
 // [Component Model tuple]: https://component-model.bytecodealliance.org/design/wit.html#tuples
 type Tuple15[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any] struct {
+	_   HostLayout
 	F0  T0
 	F1  T1
 	F2  T2
@@ -207,6 +221,7 @@ type Tuple15[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any
 //
 // [Component Model tuple]: https://component-model.bytecodealliance.org/design/wit.html#tuples
 type Tuple16[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any] struct {
+	_   HostLayout
 	F0  T0
 	F1  T1
 	F2  T2
diff --git a/src/internal/cm/variant.go b/src/internal/cm/variant.go
index 5ae5cf381..24703641d 100644
--- a/src/internal/cm/variant.go
+++ b/src/internal/cm/variant.go
@@ -12,7 +12,18 @@ type Discriminant interface {
 // Variant represents a loosely-typed Component Model variant.
 // Shape and Align must be non-zero sized types. To create a variant with no associated
 // types, use an enum.
-type Variant[Tag Discriminant, Shape, Align any] struct{ variant[Tag, Shape, Align] }
+type Variant[Tag Discriminant, Shape, Align any] struct {
+	_ HostLayout
+	variant[Tag, Shape, Align]
+}
+
+// AnyVariant is a type constraint for generic functions that accept any [Variant] type.
+type AnyVariant[Tag Discriminant, Shape, Align any] interface {
+	~struct {
+		_ HostLayout
+		variant[Tag, Shape, Align]
+	}
+}
 
 // NewVariant returns a [Variant] with tag of type Disc, storage and GC shape of type Shape,
 // aligned to type Align, with a value of type T.
@@ -26,7 +37,7 @@ func NewVariant[Tag Discriminant, Shape, Align any, T any](tag Tag, data T) Vari
 
 // New returns a [Variant] with tag of type Disc, storage and GC shape of type Shape,
 // aligned to type Align, with a value of type T.
-func New[V ~struct{ variant[Tag, Shape, Align] }, Tag Discriminant, Shape, Align any, T any](tag Tag, data T) V {
+func New[V AnyVariant[Tag, Shape, Align], Tag Discriminant, Shape, Align any, T any](tag Tag, data T) V {
 	validateVariant[Tag, Shape, Align, T]()
 	var v variant[Tag, Shape, Align]
 	v.tag = tag
@@ -35,7 +46,7 @@ func New[V ~struct{ variant[Tag, Shape, Align] }, Tag Discriminant, Shape, Align
 }
 
 // Case returns a non-nil *T if the [Variant] case is equal to tag, otherwise it returns nil.
-func Case[T any, V ~struct{ variant[Tag, Shape, Align] }, Tag Discriminant, Shape, Align any](v *V, tag Tag) *T {
+func Case[T any, V AnyVariant[Tag, Shape, Align], Tag Discriminant, Shape, Align any](v *V, tag Tag) *T {
 	validateVariant[Tag, Shape, Align, T]()
 	v2 := (*variant[Tag, Shape, Align])(unsafe.Pointer(v))
 	if v2.tag == tag {
@@ -47,6 +58,7 @@ func Case[T any, V ~struct{ variant[Tag, Shape, Align] }, Tag Discriminant, Shap
 // variant is the internal representation of a Component Model variant.
 // Shape and Align must be non-zero sized types.
 type variant[Tag Discriminant, Shape, Align any] struct {
+	_    HostLayout
 	tag  Tag
 	_    [0]Align
 	data Shape // [unsafe.Sizeof(*(*Shape)(unsafe.Pointer(nil)))]byte
diff --git a/src/internal/wasi/cli/v0.2.0/command/command.wit b/src/internal/wasi/cli/v0.2.0/command/command.wit
new file mode 100755
index 000000000..7b2af2ae9
--- /dev/null
+++ b/src/internal/wasi/cli/v0.2.0/command/command.wit
@@ -0,0 +1,2099 @@
+package wasi:[email protected];
+
+interface 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>>;
+
+	/// Get the POSIX-style arguments to the program.
+	get-arguments: func() -> list<string>;
+
+	/// Return a path that programs should use as their initial current working
+	/// directory, interpreting `.` as shorthand for this.
+	initial-cwd: func() -> option<string>;
+}
+
+interface exit {
+	/// Exit the current instance and any linked instances.
+	exit: func(status: result);
+}
+
+interface run {
+	/// Run the program.
+	run: func() -> result;
+}
+
+interface stdin {
+	use wasi:io/[email protected].{input-stream};
+	get-stdin: func() -> input-stream;
+}
+
+interface stdout {
+	use wasi:io/[email protected].{output-stream};
+	get-stdout: func() -> output-stream;
+}
+
+interface stderr {
+	use wasi:io/[email protected].{output-stream};
+	get-stderr: func() -> output-stream;
+}
+
+/// 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.
+interface terminal-input {
+	/// The input side of a terminal.
+	resource terminal-input;
+}
+
+/// 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.
+interface terminal-output {
+	/// The output side of a terminal.
+	resource terminal-output;
+}
+
+/// An interface providing an optional `terminal-input` for stdin as a
+/// link-time authority.
+interface terminal-stdin {
+	use terminal-input.{terminal-input};
+
+	/// If stdin is connected to a terminal, return a `terminal-input` handle
+	/// allowing further interaction with it.
+	get-terminal-stdin: func() -> option<terminal-input>;
+}
+
+/// An interface providing an optional `terminal-output` for stdout as a
+/// link-time authority.
+interface terminal-stdout {
+	use terminal-output.{terminal-output};
+
+	/// If stdout is connected to a terminal, return a `terminal-output` handle
+	/// allowing further interaction with it.
+	get-terminal-stdout: func() -> option<terminal-output>;
+}
+
+/// An interface providing an optional `terminal-output` for stderr as a
+/// link-time authority.
+interface terminal-stderr {
+	use terminal-output.{terminal-output};
+
+	/// If stderr is connected to a terminal, return a `terminal-output` handle
+	/// allowing further interaction with it.
+	get-terminal-stderr: func() -> option<terminal-output>;
+}
+
+world command {
+	import environment;
+	import exit;
+	import wasi:io/[email protected];
+	import wasi:io/[email protected];
+	import wasi:io/[email protected];
+	import stdin;
+	import stdout;
+	import stderr;
+	import terminal-input;
+	import terminal-output;
+	import terminal-stdin;
+	import terminal-stdout;
+	import terminal-stderr;
+	import wasi:clocks/[email protected];
+	import wasi:clocks/[email protected];
+	import wasi:filesystem/[email protected];
+	import wasi:filesystem/[email protected];
+	import wasi:sockets/[email protected];
+	import wasi:sockets/[email protected];
+	import wasi:sockets/[email protected];
+	import wasi:sockets/[email protected];
+	import wasi:sockets/[email protected];
+	import wasi:sockets/[email protected];
+	import wasi:sockets/[email protected];
+	import wasi:random/[email protected];
+	import wasi:random/[email protected];
+	import wasi:random/[email protected];
+	export run;
+}
+
+package wasi:[email protected] {
+	/// WASI filesystem is a filesystem API primarily intended to let users run WASI
+	/// programs that access their files on their existing filesystems, without
+	/// significant overhead.
+	///
+	/// It is intended to be roughly portable between Unix-family platforms and
+	/// Windows, though it does not hide many of the major differences.
+	///
+	/// Paths are passed as interface-type `string`s, meaning they must consist of
+	/// a sequence of Unicode Scalar Values (USVs). Some filesystems may contain
+	/// paths which are not accessible by this API.
+	///
+	/// The directory separator in WASI is always the forward-slash (`/`).
+	///
+	/// All paths in WASI are relative paths, and are interpreted relative to a
+	/// `descriptor` referring to a base directory. If a `path` argument to any WASI
+	/// function starts with `/`, or if any step of resolving a `path`, including
+	/// `..` and symbolic link steps, reaches a directory outside of the base
+	/// directory, or reaches a symlink to an absolute or rooted path in the
+	/// underlying filesystem, the function fails with `error-code::not-permitted`.
+	///
+	/// For more information about WASI path resolution and sandboxing, see
+	/// [WASI filesystem path resolution].
+	///
+	/// [WASI filesystem path resolution]: https://github.com/WebAssembly/wasi-filesystem/blob/main/path-resolution.md
+	interface types {
+		use wasi:io/[email protected].{input-stream};
+		use wasi:io/[email protected].{output-stream};
+		use wasi:io/[email protected].{error};
+		use wasi:clocks/[email protected].{datetime};
+
+		/// File size or length of a region within a file.
+		type filesize = u64;
+
+		/// The type of a filesystem object referenced by a descriptor.
+		///
+		/// Note: This was called `filetype` in earlier versions of WASI.
+		enum descriptor-type {
+			/// The type of the descriptor or file is unknown or is different from
+			/// any of the other types specified.
+			unknown,
+			/// The descriptor refers to a block device inode.
+			block-device,
+			/// The descriptor refers to a character device inode.
+			character-device,
+			/// The descriptor refers to a directory inode.
+			directory,
+			/// The descriptor refers to a named pipe.
+			fifo,
+			/// The file refers to a symbolic link inode.
+			symbolic-link,
+			/// The descriptor refers to a regular file inode.
+			regular-file,
+			/// The descriptor refers to a socket.
+			socket
+		}
+
+		/// Descriptor flags.
+		///
+		/// Note: This was called `fdflags` in earlier versions of WASI.
+		flags descriptor-flags {
+			/// Read mode: Data can be read.
+			read,
+			/// Write mode: Data can be written to.
+			write,
+			/// Request that writes be performed according to synchronized I/O file
+			/// integrity completion. The data stored in the file and the file's
+			/// metadata are synchronized. This is similar to `O_SYNC` in POSIX.
+			///
+			/// The precise semantics of this operation have not yet been defined for
+			/// WASI. At this time, it should be interpreted as a request, and not a
+			/// requirement.
+			file-integrity-sync,
+			/// Request that writes be performed according to synchronized I/O data
+			/// integrity completion. Only the data stored in the file is
+			/// synchronized. This is similar to `O_DSYNC` in POSIX.
+			///
+			/// The precise semantics of this operation have not yet been defined for
+			/// WASI. At this time, it should be interpreted as a request, and not a
+			/// requirement.
+			data-integrity-sync,
+			/// Requests that reads be performed at the same level of integrety
+			/// requested for writes. This is similar to `O_RSYNC` in POSIX.
+			///
+			/// The precise semantics of this operation have not yet been defined for
+			/// WASI. At this time, it should be interpreted as a request, and not a
+			/// requirement.
+			requested-write-sync,
+			/// Mutating directories mode: Directory contents may be mutated.
+			///
+			/// When this flag is unset on a descriptor, operations using the
+			/// descriptor which would create, rename, delete, modify the data or
+			/// metadata of filesystem objects, or obtain another handle which
+			/// would permit any of those, shall fail with `error-code::read-only` if
+			/// they would otherwise succeed.
+			///
+			/// This may only be set on directories.
+			mutate-directory,
+		}
+
+		/// Flags determining the method of how paths are resolved.
+		flags path-flags {
+			/// As long as the resolved path corresponds to a symbolic link, it is
+			/// expanded.
+			symlink-follow,
+		}
+
+		/// Open flags used by `open-at`.
+		flags open-flags {
+			/// Create file if it does not exist, similar to `O_CREAT` in POSIX.
+			create,
+			/// Fail if not a directory, similar to `O_DIRECTORY` in POSIX.
+			directory,
+			/// Fail if file already exists, similar to `O_EXCL` in POSIX.
+			exclusive,
+			/// Truncate file to size 0, similar to `O_TRUNC` in POSIX.
+			truncate,
+		}
+
+		/// Number of hard links to an inode.
+		type link-count = u64;
+
+		/// File attributes.
+		///
+		/// Note: This was called `filestat` in earlier versions of WASI.
+		record descriptor-stat {
+			/// File type.
+			%type: descriptor-type,
+			/// Number of hard links to the file.
+			link-count: link-count,
+			/// For regular files, the file size in bytes. For symbolic links, the
+			/// length in bytes of the pathname contained in the symbolic link.
+			size: filesize,
+			/// Last data access timestamp.
+			///
+			/// If the `option` is none, the platform doesn't maintain an access
+			/// timestamp for this file.
+			data-access-timestamp: option<datetime>,
+			/// Last data modification timestamp.
+			///
+			/// If the `option` is none, the platform doesn't maintain a
+			/// modification timestamp for this file.
+			data-modification-timestamp: option<datetime>,
+			/// Last file status-change timestamp.
+			///
+			/// If the `option` is none, the platform doesn't maintain a
+			/// status-change timestamp for this file.
+			status-change-timestamp: option<datetime>,
+		}
+
+		/// When setting a timestamp, this gives the value to set it to.
+		variant new-timestamp {
+			/// Leave the timestamp set to its previous value.
+			no-change,
+			/// Set the timestamp to the current time of the system clock associated
+			/// with the filesystem.
+			now,
+			/// Set the timestamp to the given value.
+			timestamp(datetime),
+		}
+
+		/// A directory entry.
+		record directory-entry {
+			/// The type of the file referred to by this directory entry.
+			%type: descriptor-type,
+			/// The name of the object.
+			name: string,
+		}
+
+		/// Error codes returned by functions, similar to `errno` in POSIX.
+		/// Not all of these error codes are returned by the functions provided by this
+		/// API; some are used in higher-level library layers, and others are provided
+		/// merely for alignment with POSIX.
+		enum error-code {
+			/// Permission denied, similar to `EACCES` in POSIX.
+			access,
+			/// Resource unavailable, or operation would block, similar to `EAGAIN` and `EWOULDBLOCK`
+			/// in POSIX.
+			would-block,
+			/// Connection already in progress, similar to `EALREADY` in POSIX.
+			already,
+			/// Bad descriptor, similar to `EBADF` in POSIX.
+			bad-descriptor,
+			/// Device or resource busy, similar to `EBUSY` in POSIX.
+			busy,
+			/// Resource deadlock would occur, similar to `EDEADLK` in POSIX.
+			deadlock,
+			/// Storage quota exceeded, similar to `EDQUOT` in POSIX.
+			quota,
+			/// File exists, similar to `EEXIST` in POSIX.
+			exist,
+			/// File too large, similar to `EFBIG` in POSIX.
+			file-too-large,
+			/// Illegal byte sequence, similar to `EILSEQ` in POSIX.
+			illegal-byte-sequence,
+			/// Operation in progress, similar to `EINPROGRESS` in POSIX.
+			in-progress,
+			/// Interrupted function, similar to `EINTR` in POSIX.
+			interrupted,
+			/// Invalid argument, similar to `EINVAL` in POSIX.
+			invalid,
+			/// I/O error, similar to `EIO` in POSIX.
+			io,
+			/// Is a directory, similar to `EISDIR` in POSIX.
+			is-directory,
+			/// Too many levels of symbolic links, similar to `ELOOP` in POSIX.
+			loop,
+			/// Too many links, similar to `EMLINK` in POSIX.
+			too-many-links,
+			/// Message too large, similar to `EMSGSIZE` in POSIX.
+			message-size,
+			/// Filename too long, similar to `ENAMETOOLONG` in POSIX.
+			name-too-long,
+			/// No such device, similar to `ENODEV` in POSIX.
+			no-device,
+			/// No such file or directory, similar to `ENOENT` in POSIX.
+			no-entry,
+			/// No locks available, similar to `ENOLCK` in POSIX.
+			no-lock,
+			/// Not enough space, similar to `ENOMEM` in POSIX.
+			insufficient-memory,
+			/// No space left on device, similar to `ENOSPC` in POSIX.
+			insufficient-space,
+			/// Not a directory or a symbolic link to a directory, similar to `ENOTDIR` in POSIX.
+			not-directory,
+			/// Directory not empty, similar to `ENOTEMPTY` in POSIX.
+			not-empty,
+			/// State not recoverable, similar to `ENOTRECOVERABLE` in POSIX.
+			not-recoverable,
+			/// Not supported, similar to `ENOTSUP` and `ENOSYS` in POSIX.
+			unsupported,
+			/// Inappropriate I/O control operation, similar to `ENOTTY` in POSIX.
+			no-tty,
+			/// No such device or address, similar to `ENXIO` in POSIX.
+			no-such-device,
+			/// Value too large to be stored in data type, similar to `EOVERFLOW` in POSIX.
+			overflow,
+			/// Operation not permitted, similar to `EPERM` in POSIX.
+			not-permitted,
+			/// Broken pipe, similar to `EPIPE` in POSIX.
+			pipe,
+			/// Read-only file system, similar to `EROFS` in POSIX.
+			read-only,
+			/// Invalid seek, similar to `ESPIPE` in POSIX.
+			invalid-seek,
+			/// Text file busy, similar to `ETXTBSY` in POSIX.
+			text-file-busy,
+			/// Cross-device link, similar to `EXDEV` in POSIX.
+			cross-device
+		}
+
+		/// File or memory access pattern advisory information.
+		enum advice {
+			/// The application has no advice to give on its behavior with respect
+			/// to the specified data.
+			normal,
+			/// The application expects to access the specified data sequentially
+			/// from lower offsets to higher offsets.
+			sequential,
+			/// The application expects to access the specified data in a random
+			/// order.
+			random,
+			/// The application expects to access the specified data in the near
+			/// future.
+			will-need,
+			/// The application expects that it will not access the specified data
+			/// in the near future.
+			dont-need,
+			/// The application expects to access the specified data once and then
+			/// not reuse it thereafter.
+			no-reuse
+		}
+
+		/// A 128-bit hash value, split into parts because wasm doesn't have a
+		/// 128-bit integer type.
+		record metadata-hash-value {
+			/// 64 bits of a 128-bit hash value.
+			lower: u64,
+			/// Another 64 bits of a 128-bit hash value.
+			upper: u64,
+		}
+
+		/// A descriptor is a reference to a filesystem object, which may be a file,
+		/// directory, named pipe, special file, or other object on which filesystem
+		/// calls may be made.
+		resource descriptor {
+
+			/// Provide file advisory information on a descriptor.
+			///
+			/// This is similar to `posix_fadvise` in POSIX.
+			advise: func(offset: filesize, length: filesize, advice: advice) -> result<_, error-code>;
+
+			/// Return a stream for appending to a file, if available.
+			///
+			/// May fail with an error-code describing why the file cannot be appended.
+			///
+			/// Note: This allows using `write-stream`, which is similar to `write` with
+			/// `O_APPEND` in in POSIX.
+			append-via-stream: func() -> result<output-stream, error-code>;
+
+			/// Create a directory.
+			///
+			/// Note: This is similar to `mkdirat` in POSIX.
+			create-directory-at: func(path: string) -> result<_, error-code>;
+
+			/// Get flags associated with a descriptor.
+			///
+			/// Note: This returns similar flags to `fcntl(fd, F_GETFL)` in POSIX.
+			///
+			/// Note: This returns the value that was the `fs_flags` value returned
+			/// from `fdstat_get` in earlier versions of WASI.
+			get-flags: func() -> result<descriptor-flags, error-code>;
+
+			/// Get the dynamic type of a descriptor.
+			///
+			/// Note: This returns the same value as the `type` field of the `fd-stat`
+			/// returned by `stat`, `stat-at` and similar.
+			///
+			/// Note: This returns similar flags to the `st_mode & S_IFMT` value provided
+			/// by `fstat` in POSIX.
+			///
+			/// Note: This returns the value that was the `fs_filetype` value returned
+			/// from `fdstat_get` in earlier versions of WASI.
+			get-type: func() -> result<descriptor-type, error-code>;
+
+			/// Test whether two descriptors refer to the same filesystem object.
+			///
+			/// In POSIX, this corresponds to testing whether the two descriptors have the
+			/// same device (`st_dev`) and inode (`st_ino` or `d_ino`) numbers.
+			/// wasi-filesystem does not expose device and inode numbers, so this function
+			/// may be used instead.
+			is-same-object: func(other: borrow<descriptor>) -> bool;
+
+			/// Create a hard link.
+			///
+			/// Note: This is similar to `linkat` in POSIX.
+			link-at: func(old-path-flags: path-flags, old-path: string, new-descriptor: borrow<descriptor>, new-path: string) -> result<_, error-code>;
+
+			/// Return a hash of the metadata associated with a filesystem object referred
+			/// to by a descriptor.
+			///
+			/// This returns a hash of the last-modification timestamp and file size, and
+			/// may also include the inode number, device number, birth timestamp, and
+			/// other metadata fields that may change when the file is modified or
+			/// replaced. It may also include a secret value chosen by the
+			/// implementation and not otherwise exposed.
+			///
+			/// Implementations are encourated to provide the following properties:
+			///
+			/// - If the file is not modified or replaced, the computed hash value should
+			/// usually not change.
+			/// - If the object is modified or replaced, the computed hash value should
+			/// usually change.
+			/// - The inputs to the hash should not be easily computable from the
+			/// computed hash.
+			///
+			/// However, none of these is required.
+			metadata-hash: func() -> result<metadata-hash-value, error-code>;
+
+			/// Return a hash of the metadata associated with a filesystem object referred
+			/// to by a directory descriptor and a relative path.
+			///
+			/// This performs the same hash computation as `metadata-hash`.
+			metadata-hash-at: func(path-flags: path-flags, path: string) -> result<metadata-hash-value, error-code>;
+
+			/// Open a file or directory.
+			///
+			/// The returned descriptor is not guaranteed to be the lowest-numbered
+			/// descriptor not currently open/ it is randomized to prevent applications
+			/// from depending on making assumptions about indexes, since this is
+			/// error-prone in multi-threaded contexts. The returned descriptor is
+			/// guaranteed to be less than 2**31.
+			///
+			/// If `flags` contains `descriptor-flags::mutate-directory`, and the base
+			/// descriptor doesn't have `descriptor-flags::mutate-directory` set,
+			/// `open-at` fails with `error-code::read-only`.
+			///
+			/// If `flags` contains `write` or `mutate-directory`, or `open-flags`
+			/// contains `truncate` or `create`, and the base descriptor doesn't have
+			/// `descriptor-flags::mutate-directory` set, `open-at` fails with
+			/// `error-code::read-only`.
+			///
+			/// Note: This is similar to `openat` in POSIX.
+			open-at: func(path-flags: path-flags, path: string, open-flags: open-flags, %flags: descriptor-flags) -> result<descriptor, error-code>;
+
+			/// Read from a descriptor, without using and updating the descriptor's offset.
+			///
+			/// This function returns a list of bytes containing the data that was
+			/// read, along with a bool which, when true, indicates that the end of the
+			/// file was reached. The returned list will contain up to `length` bytes; it
+			/// may return fewer than requested, if the end of the file is reached or
+			/// if the I/O operation is interrupted.
+			///
+			/// In the future, this may change to return a `stream<u8, error-code>`.
+			///
+			/// Note: This is similar to `pread` in POSIX.
+			read: func(length: filesize, offset: filesize) -> result<tuple<list<u8>, bool>, error-code>;
+
+			/// Read directory entries from a directory.
+			///
+			/// On filesystems where directories contain entries referring to themselves
+			/// and their parents, often named `.` and `..` respectively, these entries
+			/// are omitted.
+			///
+			/// This always returns a new stream which starts at the beginning of the
+			/// directory. Multiple streams may be active on the same directory, and they
+			/// do not interfere with each other.
+			read-directory: func() -> result<directory-entry-stream, error-code>;
+
+			/// Return a stream for reading from a file, if available.
+			///
+			/// May fail with an error-code describing why the file cannot be read.
+			///
+			/// Multiple read, write, and append streams may be active on the same open
+			/// file and they do not interfere with each other.
+			///
+			/// Note: This allows using `read-stream`, which is similar to `read` in POSIX.
+			read-via-stream: func(offset: filesize) -> result<input-stream, error-code>;
+
+			/// Read the contents of a symbolic link.
+			///
+			/// If the contents contain an absolute or rooted path in the underlying
+			/// filesystem, this function fails with `error-code::not-permitted`.
+			///
+			/// Note: This is similar to `readlinkat` in POSIX.
+			readlink-at: func(path: string) -> result<string, error-code>;
+
+			/// Remove a directory.
+			///
+			/// Return `error-code::not-empty` if the directory is not empty.
+			///
+			/// Note: This is similar to `unlinkat(fd, path, AT_REMOVEDIR)` in POSIX.
+			remove-directory-at: func(path: string) -> result<_, error-code>;
+
+			/// Rename a filesystem object.
+			///
+			/// Note: This is similar to `renameat` in POSIX.
+			rename-at: func(old-path: string, new-descriptor: borrow<descriptor>, new-path: string) -> result<_, error-code>;
+
+			/// Adjust the size of an open file. If this increases the file's size, the
+			/// extra bytes are filled with zeros.
+			///
+			/// Note: This was called `fd_filestat_set_size` in earlier versions of WASI.
+			set-size: func(size: filesize) -> result<_, error-code>;
+
+			/// Adjust the timestamps of an open file or directory.
+			///
+			/// Note: This is similar to `futimens` in POSIX.
+			///
+			/// Note: This was called `fd_filestat_set_times` in earlier versions of WASI.
+			set-times: func(data-access-timestamp: new-timestamp, data-modification-timestamp: new-timestamp) -> result<_, error-code>;
+
+			/// Adjust the timestamps of a file or directory.
+			///
+			/// Note: This is similar to `utimensat` in POSIX.
+			///
+			/// Note: This was called `path_filestat_set_times` in earlier versions of
+			/// WASI.
+			set-times-at: func(path-flags: path-flags, path: string, data-access-timestamp: new-timestamp, data-modification-timestamp: new-timestamp) -> result<_, error-code>;
+
+			/// Return the attributes of an open file or directory.
+			///
+			/// Note: This is similar to `fstat` in POSIX, except that it does not return
+			/// device and inode information. For testing whether two descriptors refer to
+			/// the same underlying filesystem object, use `is-same-object`. To obtain
+			/// additional data that can be used do determine whether a file has been
+			/// modified, use `metadata-hash`.
+			///
+			/// Note: This was called `fd_filestat_get` in earlier versions of WASI.
+			stat: func() -> result<descriptor-stat, error-code>;
+
+			/// Return the attributes of a file or directory.
+			///
+			/// Note: This is similar to `fstatat` in POSIX, except that it does not
+			/// return device and inode information. See the `stat` description for a
+			/// discussion of alternatives.
+			///
+			/// Note: This was called `path_filestat_get` in earlier versions of WASI.
+			stat-at: func(path-flags: path-flags, path: string) -> result<descriptor-stat, error-code>;
+
+			/// Create a symbolic link (also known as a "symlink").
+			///
+			/// If `old-path` starts with `/`, the function fails with
+			/// `error-code::not-permitted`.
+			///
+			/// Note: This is similar to `symlinkat` in POSIX.
+			symlink-at: func(old-path: string, new-path: string) -> result<_, error-code>;
+
+			/// Synchronize the data and metadata of a file to disk.
+			///
+			/// This function succeeds with no effect if the file descriptor is not
+			/// opened for writing.
+			///
+			/// Note: This is similar to `fsync` in POSIX.
+			sync: func() -> result<_, error-code>;
+
+			/// Synchronize the data of a file to disk.
+			///
+			/// This function succeeds with no effect if the file descriptor is not
+			/// opened for writing.
+			///
+			/// Note: This is similar to `fdatasync` in POSIX.
+			sync-data: func() -> result<_, error-code>;
+
+			/// Unlink a filesystem object that is not a directory.
+			///
+			/// Return `error-code::is-directory` if the path refers to a directory.
+			/// Note: This is similar to `unlinkat(fd, path, 0)` in POSIX.
+			unlink-file-at: func(path: string) -> result<_, error-code>;
+
+			/// Write to a descriptor, without using and updating the descriptor's offset.
+			///
+			/// It is valid to write past the end of a file; the file is extended to the
+			/// extent of the write, with bytes between the previous end and the start of
+			/// the write set to zero.
+			///
+			/// In the future, this may change to take a `stream<u8, error-code>`.
+			///
+			/// Note: This is similar to `pwrite` in POSIX.
+			write: func(buffer: list<u8>, offset: filesize) -> result<filesize, error-code>;
+
+			/// Return a stream for writing to a file, if available.
+			///
+			/// May fail with an error-code describing why the file cannot be written.
+			///
+			/// Note: This allows using `write-stream`, which is similar to `write` in
+			/// POSIX.
+			write-via-stream: func(offset: filesize) -> result<output-stream, error-code>;
+		}
+
+		/// A stream of directory entries.
+		resource directory-entry-stream {
+
+			/// Read a single directory entry from a `directory-entry-stream`.
+			read-directory-entry: func() -> result<option<directory-entry>, error-code>;
+		}
+
+		/// Attempts to extract a filesystem-related `error-code` from the stream
+		/// `error` provided.
+		///
+		/// Stream operations which return `stream-error::last-operation-failed`
+		/// have a payload with more information about the operation that failed.
+		/// This payload can be passed through to this function to see if there's
+		/// filesystem-related information about the error to return.
+		///
+		/// Note that this function is fallible because not all stream-related
+		/// errors are filesystem-related errors.
+		filesystem-error-code: func(err: borrow<error>) -> option<error-code>;
+	}
+
+	interface preopens {
+		use types.{descriptor};
+
+		/// Return the set of preopened directories, and their path.
+		get-directories: func() -> list<tuple<descriptor, string>>;
+	}
+}
+
+package wasi:[email protected] {
+	interface 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;
+
+		/// 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 error
+			unknown,
+			/// Access denied.
+			///
+			/// POSIX equivalent: EACCES, EPERM
+			access-denied,
+			/// The operation is not supported.
+			///
+			/// POSIX equivalent: EOPNOTSUPP
+			not-supported,
+			/// One of the arguments is invalid.
+			///
+			/// POSIX equivalent: EINVAL
+			invalid-argument,
+			/// Not enough memory to complete the operation.
+			///
+			/// POSIX equivalent: ENOMEM, ENOBUFS, EAI_MEMORY
+			out-of-memory,
+			/// The operation timed out before it could finish completely.
+			timeout,
+			/// This operation is incompatible with another asynchronous operation that is already
+			/// in progress.
+			///
+			/// POSIX equivalent: EALREADY
+			concurrency-conflict,
+			/// 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.
+			not-in-progress,
+			/// 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.
+			would-block,
+			/// The operation is not valid in the socket's current state.
+			invalid-state,
+			/// A new socket resource could not be created because of a system limit.
+			new-socket-limit,
+			/// A bind operation failed because the provided address is not an address that the
+			/// `network` can bind to.
+			address-not-bindable,
+			/// A bind operation failed because the provided address is already in use or because
+			/// there are no ephemeral ports available.
+			address-in-use,
+			/// The remote address is not reachable
+			remote-unreachable,
+			/// The TCP connection was forcefully rejected
+			connection-refused,
+			/// The TCP connection was reset.
+			connection-reset,
+			/// A TCP connection was aborted.
+			connection-aborted,
+			/// The size of a datagram sent to a UDP socket exceeded the maximum
+			/// supported size.
+			datagram-too-large,
+			/// Name does not exist or has no suitable associated IP addresses.
+			name-unresolvable,
+			/// A temporary failure in name resolution occurred.
+			temporary-resolver-failure,
+			/// A permanent failure in name resolution occurred.
+			permanent-resolver-failure
+		}
+		enum ip-address-family {
+			/// Similar to `AF_INET` in POSIX.
+			ipv4,
+			/// Similar to `AF_INET6` in POSIX.
+			ipv6
+		}
+		type ipv4-address = tuple<u8, u8, u8, u8>;
+		type ipv6-address = tuple<u16, u16, u16, u16, u16, u16, u16, u16>;
+		variant ip-address {
+			ipv4(ipv4-address),
+			ipv6(ipv6-address),
+		}
+		record ipv4-socket-address {
+			/// sin_port
+			port: u16,
+			/// sin_addr
+			address: ipv4-address,
+		}
+		record ipv6-socket-address {
+			/// sin6_port
+			port: u16,
+			/// sin6_flowinfo
+			flow-info: u32,
+			/// sin6_addr
+			address: ipv6-address,
+			/// sin6_scope_id
+			scope-id: u32,
+		}
+		variant ip-socket-address {
+			ipv4(ipv4-socket-address),
+			ipv6(ipv6-socket-address),
+		}
+	}
+
+	/// This interface provides a value-export of the default network handle..
+	interface instance-network {
+		use network.{network};
+
+		/// Get a handle to the default network.
+		instance-network: func() -> network;
+	}
+
+	interface ip-name-lookup {
+		use wasi:io/[email protected].{pollable};
+		use network.{network};
+		use network.{error-code};
+		use network.{ip-address};
+		resource resolve-address-stream {
+
+			/// 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>;
+
+			/// 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;
+		}
+
+		/// 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>;
+	}
+
+	interface tcp {
+		use wasi:io/[email protected].{input-stream};
+		use wasi:io/[email protected].{output-stream};
+		use wasi:io/[email protected].{pollable};
+		use wasi:clocks/[email protected].{duration};
+		use network.{network};
+		use network.{error-code};
+		use network.{ip-socket-address};
+		use network.{ip-address-family};
+		enum shutdown-type {
+			/// Similar to `SHUT_RD` in POSIX.
+			receive,
+			/// Similar to `SHUT_WR` in POSIX.
+			send,
+			/// Similar to `SHUT_RDWR` in POSIX.
+			both
+		}
+
+		/// 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 {
+
+			/// 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>;
+
+			/// Whether this is a IPv4 or IPv6 socket.
+			///
+			/// Equivalent to the SO_DOMAIN socket option.
+			address-family: func() -> ip-address-family;
+			finish-bind: func() -> result<_, error-code>;
+			finish-connect: func() -> result<tuple<input-stream, output-stream>, error-code>;
+			finish-listen: func() -> result<_, error-code>;
+
+			/// 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>;
+
+			/// Whether the socket is in the `listening` state.
+			///
+			/// Equivalent to the SO_ACCEPTCONN socket option.
+			is-listening: func() -> bool;
+
+			/// 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>;
+
+			/// 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>;
+
+			/// 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>;
+
+			/// 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>;
+
+			/// 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>;
+
+			/// 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>;
+
+			/// 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>;
+			send-buffer-size: func() -> result<u64, error-code>;
+			set-hop-limit: func(value: u8) -> result<_, error-code>;
+			set-keep-alive-count: func(value: u32) -> result<_, error-code>;
+			set-keep-alive-enabled: func(value: bool) -> result<_, error-code>;
+			set-keep-alive-idle-time: func(value: duration) -> result<_, error-code>;
+			set-keep-alive-interval: func(value: duration) -> result<_, error-code>;
+
+			/// 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>;
+			set-receive-buffer-size: func(value: u64) -> result<_, error-code>;
+			set-send-buffer-size: func(value: u64) -> result<_, error-code>;
+
+			/// 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>;
+
+			/// 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>;
+
+			/// 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>;
+
+			/// 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>;
+
+			/// 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;
+		}
+	}
+
+	interface tcp-create-socket {
+		use network.{network};
+		use network.{error-code};
+		use network.{ip-address-family};
+		use tcp.{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>;
+	}
+
+	interface udp {
+		use wasi:io/[email protected].{pollable};
+		use network.{network};
+		use network.{error-code};
+		use network.{ip-socket-address};
+		use network.{ip-address-family};
+
+		/// A received datagram.
+		record incoming-datagram {
+			/// The payload.
+			///
+			/// Theoretical max size: ~64 KiB. In practice, typically less than 1500 bytes.
+			data: list<u8>,
+			/// 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`.
+			remote-address: ip-socket-address,
+		}
+
+		/// A datagram to be sent out.
+		record outgoing-datagram {
+			/// The payload.
+			data: list<u8>,
+			/// 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`.
+			remote-address: option<ip-socket-address>,
+		}
+
+		/// A UDP socket handle.
+		resource udp-socket {
+
+			/// Whether this is a IPv4 or IPv6 socket.
+			///
+			/// Equivalent to the SO_DOMAIN socket option.
+			address-family: func() -> ip-address-family;
+			finish-bind: func() -> result<_, error-code>;
+
+			/// 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>;
+
+			/// 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>;
+
+			/// 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>;
+			send-buffer-size: func() -> result<u64, error-code>;
+			set-receive-buffer-size: func(value: u64) -> result<_, error-code>;
+			set-send-buffer-size: func(value: u64) -> result<_, error-code>;
+			set-unicast-hop-limit: func(value: u8) -> result<_, error-code>;
+
+			/// 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>;
+
+			/// 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:
+			/// ```text
+			/// 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>;
+
+			/// 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;
+
+			/// 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>;
+		}
+		resource incoming-datagram-stream {
+
+			/// 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>;
+
+			/// 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;
+		}
+		resource outgoing-datagram-stream {
+
+			/// 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>;
+
+			/// 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>;
+
+			/// 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;
+		}
+	}
+
+	interface udp-create-socket {
+		use network.{network};
+		use network.{error-code};
+		use network.{ip-address-family};
+		use udp.{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>;
+	}
+}
+
+package wasi:[email protected] {
+	/// 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.
+	interface monotonic-clock {
+		use wasi:io/[email protected].{pollable};
+
+		/// 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;
+
+		/// A duration of time, in nanoseconds.
+		type duration = u64;
+
+		/// 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;
+
+		/// Query the resolution of the clock. Returns the duration of time
+		/// corresponding to a clock tick.
+		resolution: func() -> duration;
+
+		/// Create a `pollable` which will resolve once the specified instant
+		/// occured.
+		subscribe-instant: func(when: instant) -> pollable;
+
+		/// 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;
+	}
+
+	/// 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.
+	interface wall-clock {
+		/// A time and date in seconds plus nanoseconds.
+		record datetime {
+			seconds: u64,
+			nanoseconds: u32,
+		}
+
+		/// 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.
+		///
+		/// [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
+		now: func() -> datetime;
+
+		/// Query the resolution of the clock.
+		///
+		/// The nanoseconds field of the output is always less than 1000000000.
+		resolution: func() -> datetime;
+	}
+}
+
+package wasi:[email protected] {
+	interface 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 {
+
+			/// 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;
+		}
+	}
+
+	/// A poll API intended to let users wait for I/O events on multiple handles
+	/// at once.
+	interface poll {
+		/// `pollable` represents a single I/O event which may be ready, or not.
+		resource pollable {
+
+			/// `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();
+
+			/// Return the readiness of a pollable. This function never blocks.
+			///
+			/// Returns `true` when the pollable is ready, and `false` otherwise.
+			ready: func() -> bool;
+		}
+
+		/// 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>;
+	}
+
+	/// 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.
+	interface streams {
+		use error.{error};
+		use poll.{pollable};
+
+		/// An error for input-stream and output-stream operations.
+		variant stream-error {
+			/// The last operation (a write or flush) failed before completion.
+			///
+			/// More information is available in the `error` payload.
+			last-operation-failed(error),
+			/// 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.
+			closed,
+		}
+
+		/// 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 {
+
+			/// 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>;
+
+			/// 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>;
+
+			/// 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>;
+
+			/// 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>;
+
+			/// 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;
+		}
+
+		/// 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 {
+
+			/// Request to flush buffered output, and block until flush completes
+			/// and stream is ready for writing again.
+			blocking-flush: func() -> result<_, stream-error>;
+
+			/// 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>;
+
+			/// 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:
+			///
+			/// ```text
+			/// 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>;
+
+			/// 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:
+			///
+			/// ```text
+			/// 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>;
+
+			/// 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>;
+
+			/// 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>;
+
+			/// 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>;
+
+			/// 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;
+
+			/// 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>;
+
+			/// 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>;
+		}
+	}
+}
+
+package wasi:[email protected] {
+	/// The insecure-seed interface for seeding hash-map DoS resistance.
+	///
+	/// It is intended to be portable at least between Unix-family platforms and
+	/// Windows.
+	interface 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>;
+	}
+
+	/// The insecure interface for insecure pseudo-random numbers.
+	///
+	/// It is intended to be portable at least between Unix-family platforms and
+	/// Windows.
+	interface insecure {
+		/// 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>;
+
+		/// 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;
+	}
+
+	/// WASI Random is a random data API.
+	///
+	/// It is intended to be portable at least between Unix-family platforms and
+	/// Windows.
+	interface random {
+		/// 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>;
+
+		/// 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;
+	}
+}
diff --git a/src/internal/wasi/cli/v0.2.0/environment/environment.wasm.go b/src/internal/wasi/cli/v0.2.0/environment/environment.wasm.go
new file mode 100755
index 000000000..07d9509af
--- /dev/null
+++ b/src/internal/wasi/cli/v0.2.0/environment/environment.wasm.go
@@ -0,0 +1,21 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package environment
+
+import (
+	"internal/cm"
+)
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:cli/[email protected] get-environment
+//go:noescape
+func wasmimport_GetEnvironment(result *cm.List[[2]string])
+
+//go:wasmimport wasi:cli/[email protected] get-arguments
+//go:noescape
+func wasmimport_GetArguments(result *cm.List[string])
+
+//go:wasmimport wasi:cli/[email protected] initial-cwd
+//go:noescape
+func wasmimport_InitialCWD(result *cm.Option[string])
diff --git a/src/internal/wasi/cli/v0.2.0/environment/environment.wit.go b/src/internal/wasi/cli/v0.2.0/environment/environment.wit.go
index a3cd386c2..0b8424515 100644
--- a/src/internal/wasi/cli/v0.2.0/environment/environment.wit.go
+++ b/src/internal/wasi/cli/v0.2.0/environment/environment.wit.go
@@ -26,10 +26,6 @@ func GetEnvironment() (result cm.List[[2]string]) {
 	return
 }
 
-//go:wasmimport wasi:cli/[email protected] 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.
@@ -42,10 +38,6 @@ func GetArguments() (result cm.List[string]) {
 	return
 }
 
-//go:wasmimport wasi:cli/[email protected] 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
@@ -58,7 +50,3 @@ func InitialCWD() (result cm.Option[string]) {
 	wasmimport_InitialCWD(&result)
 	return
 }
-
-//go:wasmimport wasi:cli/[email protected] initial-cwd
-//go:noescape
-func wasmimport_InitialCWD(result *cm.Option[string])
diff --git a/src/internal/wasi/cli/v0.2.0/exit/exit.wasm.go b/src/internal/wasi/cli/v0.2.0/exit/exit.wasm.go
new file mode 100755
index 000000000..849d5f503
--- /dev/null
+++ b/src/internal/wasi/cli/v0.2.0/exit/exit.wasm.go
@@ -0,0 +1,9 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package exit
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:cli/[email protected] exit
+//go:noescape
+func wasmimport_Exit(status0 uint32)
diff --git a/src/internal/wasi/cli/v0.2.0/exit/exit.wit.go b/src/internal/wasi/cli/v0.2.0/exit/exit.wit.go
index b506fa185..f3f172e68 100644
--- a/src/internal/wasi/cli/v0.2.0/exit/exit.wit.go
+++ b/src/internal/wasi/cli/v0.2.0/exit/exit.wit.go
@@ -19,7 +19,3 @@ func Exit(status cm.BoolResult) {
 	wasmimport_Exit((uint32)(status0))
 	return
 }
-
-//go:wasmimport wasi:cli/[email protected] exit
-//go:noescape
-func wasmimport_Exit(status0 uint32)
diff --git a/src/internal/wasi/cli/v0.2.0/run/run.wasm.go b/src/internal/wasi/cli/v0.2.0/run/run.wasm.go
new file mode 100755
index 000000000..d7e20574e
--- /dev/null
+++ b/src/internal/wasi/cli/v0.2.0/run/run.wasm.go
@@ -0,0 +1,17 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package run
+
+import (
+	"internal/cm"
+)
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmexport wasi:cli/[email protected]#run
+//export wasi:cli/[email protected]#run
+func wasmexport_Run() (result0 uint32) {
+	result := Exports.Run()
+	result0 = cm.BoolToU32(result)
+	return
+}
diff --git a/src/internal/wasi/cli/v0.2.0/run/run.wit.go b/src/internal/wasi/cli/v0.2.0/run/run.wit.go
index 51eb5fb31..4cea75d30 100644
--- a/src/internal/wasi/cli/v0.2.0/run/run.wit.go
+++ b/src/internal/wasi/cli/v0.2.0/run/run.wit.go
@@ -2,15 +2,3 @@
 
 // Package run represents the exported interface "wasi:cli/[email protected]".
 package run
-
-import (
-	"internal/cm"
-)
-
-//go:wasmexport wasi:cli/[email protected]#run
-//export wasi:cli/[email protected]#run
-func wasmexport_Run() (result0 uint32) {
-	result := Exports.Run()
-	result0 = cm.BoolToU32(result)
-	return
-}
diff --git a/src/internal/wasi/cli/v0.2.0/stderr/stderr.wasm.go b/src/internal/wasi/cli/v0.2.0/stderr/stderr.wasm.go
new file mode 100755
index 000000000..462cf172c
--- /dev/null
+++ b/src/internal/wasi/cli/v0.2.0/stderr/stderr.wasm.go
@@ -0,0 +1,9 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package stderr
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:cli/[email protected] get-stderr
+//go:noescape
+func wasmimport_GetStderr() (result0 uint32)
diff --git a/src/internal/wasi/cli/v0.2.0/stderr/stderr.wit.go b/src/internal/wasi/cli/v0.2.0/stderr/stderr.wit.go
index 448614753..8ebfdeed5 100644
--- a/src/internal/wasi/cli/v0.2.0/stderr/stderr.wit.go
+++ b/src/internal/wasi/cli/v0.2.0/stderr/stderr.wit.go
@@ -8,17 +8,18 @@ import (
 	"internal/wasi/io/v0.2.0/streams"
 )
 
+// OutputStream represents the imported type alias "wasi:cli/[email protected]#output-stream".
+//
+// See [streams.OutputStream] for more information.
+type OutputStream = streams.OutputStream
+
 // GetStderr represents the imported function "get-stderr".
 //
 //	get-stderr: func() -> output-stream
 //
 //go:nosplit
-func GetStderr() (result streams.OutputStream) {
+func GetStderr() (result OutputStream) {
 	result0 := wasmimport_GetStderr()
-	result = cm.Reinterpret[streams.OutputStream]((uint32)(result0))
+	result = cm.Reinterpret[OutputStream]((uint32)(result0))
 	return
 }
-
-//go:wasmimport wasi:cli/[email protected] get-stderr
-//go:noescape
-func wasmimport_GetStderr() (result0 uint32)
diff --git a/src/internal/wasi/cli/v0.2.0/stdin/stdin.wasm.go b/src/internal/wasi/cli/v0.2.0/stdin/stdin.wasm.go
new file mode 100755
index 000000000..374eb2531
--- /dev/null
+++ b/src/internal/wasi/cli/v0.2.0/stdin/stdin.wasm.go
@@ -0,0 +1,9 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package stdin
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:cli/[email protected] get-stdin
+//go:noescape
+func wasmimport_GetStdin() (result0 uint32)
diff --git a/src/internal/wasi/cli/v0.2.0/stdin/stdin.wit.go b/src/internal/wasi/cli/v0.2.0/stdin/stdin.wit.go
index c77717569..e697cd15d 100644
--- a/src/internal/wasi/cli/v0.2.0/stdin/stdin.wit.go
+++ b/src/internal/wasi/cli/v0.2.0/stdin/stdin.wit.go
@@ -8,17 +8,18 @@ import (
 	"internal/wasi/io/v0.2.0/streams"
 )
 
+// InputStream represents the imported type alias "wasi:cli/[email protected]#input-stream".
+//
+// See [streams.InputStream] for more information.
+type InputStream = streams.InputStream
+
 // GetStdin represents the imported function "get-stdin".
 //
 //	get-stdin: func() -> input-stream
 //
 //go:nosplit
-func GetStdin() (result streams.InputStream) {
+func GetStdin() (result InputStream) {
 	result0 := wasmimport_GetStdin()
-	result = cm.Reinterpret[streams.InputStream]((uint32)(result0))
+	result = cm.Reinterpret[InputStream]((uint32)(result0))
 	return
 }
-
-//go:wasmimport wasi:cli/[email protected] get-stdin
-//go:noescape
-func wasmimport_GetStdin() (result0 uint32)
diff --git a/src/internal/wasi/cli/v0.2.0/stdout/stdout.wasm.go b/src/internal/wasi/cli/v0.2.0/stdout/stdout.wasm.go
new file mode 100755
index 000000000..68e4a3dac
--- /dev/null
+++ b/src/internal/wasi/cli/v0.2.0/stdout/stdout.wasm.go
@@ -0,0 +1,9 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package stdout
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:cli/[email protected] get-stdout
+//go:noescape
+func wasmimport_GetStdout() (result0 uint32)
diff --git a/src/internal/wasi/cli/v0.2.0/stdout/stdout.wit.go b/src/internal/wasi/cli/v0.2.0/stdout/stdout.wit.go
index 4a7007f0e..a9934fe2f 100644
--- a/src/internal/wasi/cli/v0.2.0/stdout/stdout.wit.go
+++ b/src/internal/wasi/cli/v0.2.0/stdout/stdout.wit.go
@@ -8,17 +8,18 @@ import (
 	"internal/wasi/io/v0.2.0/streams"
 )
 
+// OutputStream represents the imported type alias "wasi:cli/[email protected]#output-stream".
+//
+// See [streams.OutputStream] for more information.
+type OutputStream = streams.OutputStream
+
 // GetStdout represents the imported function "get-stdout".
 //
 //	get-stdout: func() -> output-stream
 //
 //go:nosplit
-func GetStdout() (result streams.OutputStream) {
+func GetStdout() (result OutputStream) {
 	result0 := wasmimport_GetStdout()
-	result = cm.Reinterpret[streams.OutputStream]((uint32)(result0))
+	result = cm.Reinterpret[OutputStream]((uint32)(result0))
 	return
 }
-
-//go:wasmimport wasi:cli/[email protected] get-stdout
-//go:noescape
-func wasmimport_GetStdout() (result0 uint32)
diff --git a/src/internal/wasi/cli/v0.2.0/terminal-input/terminal-input.wit.go b/src/internal/wasi/cli/v0.2.0/terminal-input/terminal-input.wit.go
index 795be5d09..8313be74b 100644
--- a/src/internal/wasi/cli/v0.2.0/terminal-input/terminal-input.wit.go
+++ b/src/internal/wasi/cli/v0.2.0/terminal-input/terminal-input.wit.go
@@ -30,7 +30,3 @@ func (self TerminalInput) ResourceDrop() {
 	wasmimport_TerminalInputResourceDrop((uint32)(self0))
 	return
 }
-
-//go:wasmimport wasi:cli/[email protected] [resource-drop]terminal-input
-//go:noescape
-func wasmimport_TerminalInputResourceDrop(self0 uint32)
diff --git a/src/internal/wasi/cli/v0.2.0/terminal-input/terminalinput.wasm.go b/src/internal/wasi/cli/v0.2.0/terminal-input/terminalinput.wasm.go
new file mode 100755
index 000000000..1df3794f1
--- /dev/null
+++ b/src/internal/wasi/cli/v0.2.0/terminal-input/terminalinput.wasm.go
@@ -0,0 +1,9 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package terminalinput
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:cli/[email protected] [resource-drop]terminal-input
+//go:noescape
+func wasmimport_TerminalInputResourceDrop(self0 uint32)
diff --git a/src/internal/wasi/cli/v0.2.0/terminal-output/terminal-output.wit.go b/src/internal/wasi/cli/v0.2.0/terminal-output/terminal-output.wit.go
index eb97c9ee7..00d723156 100644
--- a/src/internal/wasi/cli/v0.2.0/terminal-output/terminal-output.wit.go
+++ b/src/internal/wasi/cli/v0.2.0/terminal-output/terminal-output.wit.go
@@ -30,7 +30,3 @@ func (self TerminalOutput) ResourceDrop() {
 	wasmimport_TerminalOutputResourceDrop((uint32)(self0))
 	return
 }
-
-//go:wasmimport wasi:cli/[email protected] [resource-drop]terminal-output
-//go:noescape
-func wasmimport_TerminalOutputResourceDrop(self0 uint32)
diff --git a/src/internal/wasi/cli/v0.2.0/terminal-output/terminaloutput.wasm.go b/src/internal/wasi/cli/v0.2.0/terminal-output/terminaloutput.wasm.go
new file mode 100755
index 000000000..fb35fc418
--- /dev/null
+++ b/src/internal/wasi/cli/v0.2.0/terminal-output/terminaloutput.wasm.go
@@ -0,0 +1,9 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package terminaloutput
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:cli/[email protected] [resource-drop]terminal-output
+//go:noescape
+func wasmimport_TerminalOutputResourceDrop(self0 uint32)
diff --git a/src/internal/wasi/cli/v0.2.0/terminal-stderr/terminal-stderr.wit.go b/src/internal/wasi/cli/v0.2.0/terminal-stderr/terminal-stderr.wit.go
index 72215a8b7..9f942f3ef 100644
--- a/src/internal/wasi/cli/v0.2.0/terminal-stderr/terminal-stderr.wit.go
+++ b/src/internal/wasi/cli/v0.2.0/terminal-stderr/terminal-stderr.wit.go
@@ -11,6 +11,11 @@ import (
 	terminaloutput "internal/wasi/cli/v0.2.0/terminal-output"
 )
 
+// TerminalOutput represents the imported type alias "wasi:cli/[email protected]#terminal-output".
+//
+// See [terminaloutput.TerminalOutput] for more information.
+type TerminalOutput = terminaloutput.TerminalOutput
+
 // GetTerminalStderr represents the imported function "get-terminal-stderr".
 //
 // If stderr is connected to a terminal, return a `terminal-output` handle
@@ -19,11 +24,7 @@ import (
 //	get-terminal-stderr: func() -> option<terminal-output>
 //
 //go:nosplit
-func GetTerminalStderr() (result cm.Option[terminaloutput.TerminalOutput]) {
+func GetTerminalStderr() (result cm.Option[TerminalOutput]) {
 	wasmimport_GetTerminalStderr(&result)
 	return
 }
-
-//go:wasmimport wasi:cli/[email protected] get-terminal-stderr
-//go:noescape
-func wasmimport_GetTerminalStderr(result *cm.Option[terminaloutput.TerminalOutput])
diff --git a/src/internal/wasi/cli/v0.2.0/terminal-stderr/terminalstderr.wasm.go b/src/internal/wasi/cli/v0.2.0/terminal-stderr/terminalstderr.wasm.go
new file mode 100755
index 000000000..ea8902ee8
--- /dev/null
+++ b/src/internal/wasi/cli/v0.2.0/terminal-stderr/terminalstderr.wasm.go
@@ -0,0 +1,13 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package terminalstderr
+
+import (
+	"internal/cm"
+)
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:cli/[email protected] get-terminal-stderr
+//go:noescape
+func wasmimport_GetTerminalStderr(result *cm.Option[TerminalOutput])
diff --git a/src/internal/wasi/cli/v0.2.0/terminal-stdin/terminal-stdin.wit.go b/src/internal/wasi/cli/v0.2.0/terminal-stdin/terminal-stdin.wit.go
index 1a6091d7c..33a35eff3 100644
--- a/src/internal/wasi/cli/v0.2.0/terminal-stdin/terminal-stdin.wit.go
+++ b/src/internal/wasi/cli/v0.2.0/terminal-stdin/terminal-stdin.wit.go
@@ -11,6 +11,11 @@ import (
 	terminalinput "internal/wasi/cli/v0.2.0/terminal-input"
 )
 
+// TerminalInput represents the imported type alias "wasi:cli/[email protected]#terminal-input".
+//
+// See [terminalinput.TerminalInput] for more information.
+type TerminalInput = terminalinput.TerminalInput
+
 // GetTerminalStdin represents the imported function "get-terminal-stdin".
 //
 // If stdin is connected to a terminal, return a `terminal-input` handle
@@ -19,11 +24,7 @@ import (
 //	get-terminal-stdin: func() -> option<terminal-input>
 //
 //go:nosplit
-func GetTerminalStdin() (result cm.Option[terminalinput.TerminalInput]) {
+func GetTerminalStdin() (result cm.Option[TerminalInput]) {
 	wasmimport_GetTerminalStdin(&result)
 	return
 }
-
-//go:wasmimport wasi:cli/[email protected] get-terminal-stdin
-//go:noescape
-func wasmimport_GetTerminalStdin(result *cm.Option[terminalinput.TerminalInput])
diff --git a/src/internal/wasi/cli/v0.2.0/terminal-stdin/terminalstdin.wasm.go b/src/internal/wasi/cli/v0.2.0/terminal-stdin/terminalstdin.wasm.go
new file mode 100755
index 000000000..d9417f353
--- /dev/null
+++ b/src/internal/wasi/cli/v0.2.0/terminal-stdin/terminalstdin.wasm.go
@@ -0,0 +1,13 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package terminalstdin
+
+import (
+	"internal/cm"
+)
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:cli/[email protected] get-terminal-stdin
+//go:noescape
+func wasmimport_GetTerminalStdin(result *cm.Option[TerminalInput])
diff --git a/src/internal/wasi/cli/v0.2.0/terminal-stdout/terminal-stdout.wit.go b/src/internal/wasi/cli/v0.2.0/terminal-stdout/terminal-stdout.wit.go
index 395144945..e6be82dd3 100644
--- a/src/internal/wasi/cli/v0.2.0/terminal-stdout/terminal-stdout.wit.go
+++ b/src/internal/wasi/cli/v0.2.0/terminal-stdout/terminal-stdout.wit.go
@@ -11,6 +11,11 @@ import (
 	terminaloutput "internal/wasi/cli/v0.2.0/terminal-output"
 )
 
+// TerminalOutput represents the imported type alias "wasi:cli/[email protected]#terminal-output".
+//
+// See [terminaloutput.TerminalOutput] for more information.
+type TerminalOutput = terminaloutput.TerminalOutput
+
 // GetTerminalStdout represents the imported function "get-terminal-stdout".
 //
 // If stdout is connected to a terminal, return a `terminal-output` handle
@@ -19,11 +24,7 @@ import (
 //	get-terminal-stdout: func() -> option<terminal-output>
 //
 //go:nosplit
-func GetTerminalStdout() (result cm.Option[terminaloutput.TerminalOutput]) {
+func GetTerminalStdout() (result cm.Option[TerminalOutput]) {
 	wasmimport_GetTerminalStdout(&result)
 	return
 }
-
-//go:wasmimport wasi:cli/[email protected] get-terminal-stdout
-//go:noescape
-func wasmimport_GetTerminalStdout(result *cm.Option[terminaloutput.TerminalOutput])
diff --git a/src/internal/wasi/cli/v0.2.0/terminal-stdout/terminalstdout.wasm.go b/src/internal/wasi/cli/v0.2.0/terminal-stdout/terminalstdout.wasm.go
new file mode 100755
index 000000000..1c9e3719b
--- /dev/null
+++ b/src/internal/wasi/cli/v0.2.0/terminal-stdout/terminalstdout.wasm.go
@@ -0,0 +1,13 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package terminalstdout
+
+import (
+	"internal/cm"
+)
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:cli/[email protected] get-terminal-stdout
+//go:noescape
+func wasmimport_GetTerminalStdout(result *cm.Option[TerminalOutput])
diff --git a/src/internal/wasi/clocks/v0.2.0/monotonic-clock/monotonic-clock.wit.go b/src/internal/wasi/clocks/v0.2.0/monotonic-clock/monotonic-clock.wit.go
index 580bd2b55..7cfa7d140 100644
--- a/src/internal/wasi/clocks/v0.2.0/monotonic-clock/monotonic-clock.wit.go
+++ b/src/internal/wasi/clocks/v0.2.0/monotonic-clock/monotonic-clock.wit.go
@@ -19,6 +19,11 @@ import (
 	"internal/wasi/io/v0.2.0/poll"
 )
 
+// Pollable represents the imported type alias "wasi:clocks/[email protected]#pollable".
+//
+// See [poll.Pollable] for more information.
+type Pollable = poll.Pollable
+
 // Instant represents the u64 "wasi:clocks/[email protected]#instant".
 //
 // An instant in time, in nanoseconds. An instant is relative to an
@@ -51,10 +56,6 @@ func Now() (result Instant) {
 	return
 }
 
-//go:wasmimport wasi:clocks/[email protected] 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
@@ -69,10 +70,6 @@ func Resolution() (result Duration) {
 	return
 }
 
-//go:wasmimport wasi:clocks/[email protected] 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
@@ -81,17 +78,13 @@ func wasmimport_Resolution() (result0 uint64)
 //	subscribe-instant: func(when: instant) -> pollable
 //
 //go:nosplit
-func SubscribeInstant(when Instant) (result poll.Pollable) {
+func SubscribeInstant(when Instant) (result Pollable) {
 	when0 := (uint64)(when)
 	result0 := wasmimport_SubscribeInstant((uint64)(when0))
-	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
+	result = cm.Reinterpret[Pollable]((uint32)(result0))
 	return
 }
 
-//go:wasmimport wasi:clocks/[email protected] 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
@@ -101,13 +94,9 @@ func wasmimport_SubscribeInstant(when0 uint64) (result0 uint32)
 //	subscribe-duration: func(when: duration) -> pollable
 //
 //go:nosplit
-func SubscribeDuration(when Duration) (result poll.Pollable) {
+func SubscribeDuration(when Duration) (result Pollable) {
 	when0 := (uint64)(when)
 	result0 := wasmimport_SubscribeDuration((uint64)(when0))
-	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
+	result = cm.Reinterpret[Pollable]((uint32)(result0))
 	return
 }
-
-//go:wasmimport wasi:clocks/[email protected] subscribe-duration
-//go:noescape
-func wasmimport_SubscribeDuration(when0 uint64) (result0 uint32)
diff --git a/src/internal/wasi/clocks/v0.2.0/monotonic-clock/monotonicclock.wasm.go b/src/internal/wasi/clocks/v0.2.0/monotonic-clock/monotonicclock.wasm.go
new file mode 100755
index 000000000..36a1720a6
--- /dev/null
+++ b/src/internal/wasi/clocks/v0.2.0/monotonic-clock/monotonicclock.wasm.go
@@ -0,0 +1,21 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package monotonicclock
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:clocks/[email protected] now
+//go:noescape
+func wasmimport_Now() (result0 uint64)
+
+//go:wasmimport wasi:clocks/[email protected] resolution
+//go:noescape
+func wasmimport_Resolution() (result0 uint64)
+
+//go:wasmimport wasi:clocks/[email protected] subscribe-instant
+//go:noescape
+func wasmimport_SubscribeInstant(when0 uint64) (result0 uint32)
+
+//go:wasmimport wasi:clocks/[email protected] subscribe-duration
+//go:noescape
+func wasmimport_SubscribeDuration(when0 uint64) (result0 uint32)
diff --git a/src/internal/wasi/clocks/v0.2.0/wall-clock/wall-clock.wit.go b/src/internal/wasi/clocks/v0.2.0/wall-clock/wall-clock.wit.go
index a59a313d2..7473c3e2c 100644
--- a/src/internal/wasi/clocks/v0.2.0/wall-clock/wall-clock.wit.go
+++ b/src/internal/wasi/clocks/v0.2.0/wall-clock/wall-clock.wit.go
@@ -18,6 +18,10 @@
 // It is intended for reporting the current date and time for humans.
 package wallclock
 
+import (
+	"internal/cm"
+)
+
 // DateTime represents the record "wasi:clocks/[email protected]#datetime".
 //
 // A time and date in seconds plus nanoseconds.
@@ -27,6 +31,7 @@ package wallclock
 //		nanoseconds: u32,
 //	}
 type DateTime struct {
+	_           cm.HostLayout
 	Seconds     uint64
 	Nanoseconds uint32
 }
@@ -55,10 +60,6 @@ func Now() (result DateTime) {
 	return
 }
 
-//go:wasmimport wasi:clocks/[email protected] now
-//go:noescape
-func wasmimport_Now(result *DateTime)
-
 // Resolution represents the imported function "resolution".
 //
 // Query the resolution of the clock.
@@ -72,7 +73,3 @@ func Resolution() (result DateTime) {
 	wasmimport_Resolution(&result)
 	return
 }
-
-//go:wasmimport wasi:clocks/[email protected] resolution
-//go:noescape
-func wasmimport_Resolution(result *DateTime)
diff --git a/src/internal/wasi/clocks/v0.2.0/wall-clock/wallclock.wasm.go b/src/internal/wasi/clocks/v0.2.0/wall-clock/wallclock.wasm.go
new file mode 100755
index 000000000..321ff3f1c
--- /dev/null
+++ b/src/internal/wasi/clocks/v0.2.0/wall-clock/wallclock.wasm.go
@@ -0,0 +1,13 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package wallclock
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:clocks/[email protected] now
+//go:noescape
+func wasmimport_Now(result *DateTime)
+
+//go:wasmimport wasi:clocks/[email protected] resolution
+//go:noescape
+func wasmimport_Resolution(result *DateTime)
diff --git a/src/internal/wasi/filesystem/v0.2.0/preopens/preopens.wasm.go b/src/internal/wasi/filesystem/v0.2.0/preopens/preopens.wasm.go
new file mode 100755
index 000000000..c5bae3059
--- /dev/null
+++ b/src/internal/wasi/filesystem/v0.2.0/preopens/preopens.wasm.go
@@ -0,0 +1,13 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package preopens
+
+import (
+	"internal/cm"
+)
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:filesystem/[email protected] get-directories
+//go:noescape
+func wasmimport_GetDirectories(result *cm.List[cm.Tuple[Descriptor, string]])
diff --git a/src/internal/wasi/filesystem/v0.2.0/preopens/preopens.wit.go b/src/internal/wasi/filesystem/v0.2.0/preopens/preopens.wit.go
index d57dea517..f655e854c 100644
--- a/src/internal/wasi/filesystem/v0.2.0/preopens/preopens.wit.go
+++ b/src/internal/wasi/filesystem/v0.2.0/preopens/preopens.wit.go
@@ -8,6 +8,11 @@ import (
 	"internal/wasi/filesystem/v0.2.0/types"
 )
 
+// Descriptor represents the imported type alias "wasi:filesystem/[email protected]#descriptor".
+//
+// See [types.Descriptor] for more information.
+type Descriptor = types.Descriptor
+
 // GetDirectories represents the imported function "get-directories".
 //
 // Return the set of preopened directories, and their path.
@@ -15,11 +20,7 @@ import (
 //	get-directories: func() -> list<tuple<descriptor, string>>
 //
 //go:nosplit
-func GetDirectories() (result cm.List[cm.Tuple[types.Descriptor, string]]) {
+func GetDirectories() (result cm.List[cm.Tuple[Descriptor, string]]) {
 	wasmimport_GetDirectories(&result)
 	return
 }
-
-//go:wasmimport wasi:filesystem/[email protected] get-directories
-//go:noescape
-func wasmimport_GetDirectories(result *cm.List[cm.Tuple[types.Descriptor, string]])
diff --git a/src/internal/wasi/filesystem/v0.2.0/types/abi.go b/src/internal/wasi/filesystem/v0.2.0/types/abi.go
index 4cf4f3280..40ee28aa8 100644
--- a/src/internal/wasi/filesystem/v0.2.0/types/abi.go
+++ b/src/internal/wasi/filesystem/v0.2.0/types/abi.go
@@ -8,18 +8,15 @@ import (
 	"unsafe"
 )
 
-// DateTimeShape is used for storage in variant or result types.
-type DateTimeShape struct {
-	shape [unsafe.Sizeof(wallclock.DateTime{})]byte
-}
-
 // MetadataHashValueShape is used for storage in variant or result types.
 type MetadataHashValueShape struct {
+	_     cm.HostLayout
 	shape [unsafe.Sizeof(MetadataHashValue{})]byte
 }
 
 // TupleListU8BoolShape is used for storage in variant or result types.
 type TupleListU8BoolShape struct {
+	_     cm.HostLayout
 	shape [unsafe.Sizeof(cm.Tuple[cm.List[uint8], bool]{})]byte
 }
 
@@ -42,10 +39,12 @@ func lower_NewTimestamp(v NewTimestamp) (f0 uint32, f1 uint64, f2 uint32) {
 
 // DescriptorStatShape is used for storage in variant or result types.
 type DescriptorStatShape struct {
+	_     cm.HostLayout
 	shape [unsafe.Sizeof(DescriptorStat{})]byte
 }
 
 // OptionDirectoryEntryShape is used for storage in variant or result types.
 type OptionDirectoryEntryShape struct {
+	_     cm.HostLayout
 	shape [unsafe.Sizeof(cm.Option[DirectoryEntry]{})]byte
 }
diff --git a/src/internal/wasi/filesystem/v0.2.0/types/types.wasm.go b/src/internal/wasi/filesystem/v0.2.0/types/types.wasm.go
new file mode 100755
index 000000000..d1a37fb2f
--- /dev/null
+++ b/src/internal/wasi/filesystem/v0.2.0/types/types.wasm.go
@@ -0,0 +1,133 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package types
+
+import (
+	"internal/cm"
+)
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:filesystem/[email protected] [resource-drop]descriptor
+//go:noescape
+func wasmimport_DescriptorResourceDrop(self0 uint32)
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.advise
+//go:noescape
+func wasmimport_DescriptorAdvise(self0 uint32, offset0 uint64, length0 uint64, advice0 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.append-via-stream
+//go:noescape
+func wasmimport_DescriptorAppendViaStream(self0 uint32, result *cm.Result[OutputStream, OutputStream, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.create-directory-at
+//go:noescape
+func wasmimport_DescriptorCreateDirectoryAt(self0 uint32, path0 *uint8, path1 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.get-flags
+//go:noescape
+func wasmimport_DescriptorGetFlags(self0 uint32, result *cm.Result[DescriptorFlags, DescriptorFlags, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.get-type
+//go:noescape
+func wasmimport_DescriptorGetType(self0 uint32, result *cm.Result[DescriptorType, DescriptorType, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.is-same-object
+//go:noescape
+func wasmimport_DescriptorIsSameObject(self0 uint32, other0 uint32) (result0 uint32)
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.link-at
+//go:noescape
+func wasmimport_DescriptorLinkAt(self0 uint32, oldPathFlags0 uint32, oldPath0 *uint8, oldPath1 uint32, newDescriptor0 uint32, newPath0 *uint8, newPath1 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.metadata-hash
+//go:noescape
+func wasmimport_DescriptorMetadataHash(self0 uint32, result *cm.Result[MetadataHashValueShape, MetadataHashValue, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.metadata-hash-at
+//go:noescape
+func wasmimport_DescriptorMetadataHashAt(self0 uint32, pathFlags0 uint32, path0 *uint8, path1 uint32, result *cm.Result[MetadataHashValueShape, MetadataHashValue, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.open-at
+//go:noescape
+func wasmimport_DescriptorOpenAt(self0 uint32, pathFlags0 uint32, path0 *uint8, path1 uint32, openFlags0 uint32, flags0 uint32, result *cm.Result[Descriptor, Descriptor, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.read
+//go:noescape
+func wasmimport_DescriptorRead(self0 uint32, length0 uint64, offset0 uint64, result *cm.Result[TupleListU8BoolShape, cm.Tuple[cm.List[uint8], bool], ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.read-directory
+//go:noescape
+func wasmimport_DescriptorReadDirectory(self0 uint32, result *cm.Result[DirectoryEntryStream, DirectoryEntryStream, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.read-via-stream
+//go:noescape
+func wasmimport_DescriptorReadViaStream(self0 uint32, offset0 uint64, result *cm.Result[InputStream, InputStream, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.readlink-at
+//go:noescape
+func wasmimport_DescriptorReadLinkAt(self0 uint32, path0 *uint8, path1 uint32, result *cm.Result[string, string, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.remove-directory-at
+//go:noescape
+func wasmimport_DescriptorRemoveDirectoryAt(self0 uint32, path0 *uint8, path1 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.rename-at
+//go:noescape
+func wasmimport_DescriptorRenameAt(self0 uint32, oldPath0 *uint8, oldPath1 uint32, newDescriptor0 uint32, newPath0 *uint8, newPath1 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.set-size
+//go:noescape
+func wasmimport_DescriptorSetSize(self0 uint32, size0 uint64, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.set-times
+//go:noescape
+func wasmimport_DescriptorSetTimes(self0 uint32, dataAccessTimestamp0 uint32, dataAccessTimestamp1 uint64, dataAccessTimestamp2 uint32, dataModificationTimestamp0 uint32, dataModificationTimestamp1 uint64, dataModificationTimestamp2 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.set-times-at
+//go:noescape
+func wasmimport_DescriptorSetTimesAt(self0 uint32, pathFlags0 uint32, path0 *uint8, path1 uint32, dataAccessTimestamp0 uint32, dataAccessTimestamp1 uint64, dataAccessTimestamp2 uint32, dataModificationTimestamp0 uint32, dataModificationTimestamp1 uint64, dataModificationTimestamp2 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.stat
+//go:noescape
+func wasmimport_DescriptorStat(self0 uint32, result *cm.Result[DescriptorStatShape, DescriptorStat, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.stat-at
+//go:noescape
+func wasmimport_DescriptorStatAt(self0 uint32, pathFlags0 uint32, path0 *uint8, path1 uint32, result *cm.Result[DescriptorStatShape, DescriptorStat, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.symlink-at
+//go:noescape
+func wasmimport_DescriptorSymlinkAt(self0 uint32, oldPath0 *uint8, oldPath1 uint32, newPath0 *uint8, newPath1 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.sync
+//go:noescape
+func wasmimport_DescriptorSync(self0 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.sync-data
+//go:noescape
+func wasmimport_DescriptorSyncData(self0 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.unlink-file-at
+//go:noescape
+func wasmimport_DescriptorUnlinkFileAt(self0 uint32, path0 *uint8, path1 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.write
+//go:noescape
+func wasmimport_DescriptorWrite(self0 uint32, buffer0 *uint8, buffer1 uint32, offset0 uint64, result *cm.Result[uint64, FileSize, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.write-via-stream
+//go:noescape
+func wasmimport_DescriptorWriteViaStream(self0 uint32, offset0 uint64, result *cm.Result[OutputStream, OutputStream, ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] [resource-drop]directory-entry-stream
+//go:noescape
+func wasmimport_DirectoryEntryStreamResourceDrop(self0 uint32)
+
+//go:wasmimport wasi:filesystem/[email protected] [method]directory-entry-stream.read-directory-entry
+//go:noescape
+func wasmimport_DirectoryEntryStreamReadDirectoryEntry(self0 uint32, result *cm.Result[OptionDirectoryEntryShape, cm.Option[DirectoryEntry], ErrorCode])
+
+//go:wasmimport wasi:filesystem/[email protected] filesystem-error-code
+//go:noescape
+func wasmimport_FilesystemErrorCode(err0 uint32, result *cm.Option[ErrorCode])
diff --git a/src/internal/wasi/filesystem/v0.2.0/types/types.wit.go b/src/internal/wasi/filesystem/v0.2.0/types/types.wit.go
index ecceefe92..cac7de958 100644
--- a/src/internal/wasi/filesystem/v0.2.0/types/types.wit.go
+++ b/src/internal/wasi/filesystem/v0.2.0/types/types.wit.go
@@ -31,10 +31,29 @@ package types
 import (
 	"internal/cm"
 	wallclock "internal/wasi/clocks/v0.2.0/wall-clock"
-	ioerror "internal/wasi/io/v0.2.0/error"
 	"internal/wasi/io/v0.2.0/streams"
 )
 
+// InputStream represents the imported type alias "wasi:filesystem/[email protected]#input-stream".
+//
+// See [streams.InputStream] for more information.
+type InputStream = streams.InputStream
+
+// OutputStream represents the imported type alias "wasi:filesystem/[email protected]#output-stream".
+//
+// See [streams.OutputStream] for more information.
+type OutputStream = streams.OutputStream
+
+// Error represents the imported type alias "wasi:filesystem/[email protected]#error".
+//
+// See [streams.Error] for more information.
+type Error = streams.Error
+
+// DateTime represents the type alias "wasi:filesystem/[email protected]#datetime".
+//
+// See [wallclock.DateTime] for more information.
+type DateTime = wallclock.DateTime
+
 // FileSize represents the u64 "wasi:filesystem/[email protected]#filesize".
 //
 // File size or length of a region within a file.
@@ -227,6 +246,7 @@ type LinkCount uint64
 //		status-change-timestamp: option<datetime>,
 //	}
 type DescriptorStat struct {
+	_ cm.HostLayout
 	// File type.
 	Type DescriptorType
 
@@ -241,19 +261,19 @@ type DescriptorStat struct {
 	//
 	// If the `option` is none, the platform doesn't maintain an access
 	// timestamp for this file.
-	DataAccessTimestamp cm.Option[wallclock.DateTime]
+	DataAccessTimestamp cm.Option[DateTime]
 
 	// Last data modification timestamp.
 	//
 	// If the `option` is none, the platform doesn't maintain a
 	// modification timestamp for this file.
-	DataModificationTimestamp cm.Option[wallclock.DateTime]
+	DataModificationTimestamp cm.Option[DateTime]
 
 	// Last file status-change timestamp.
 	//
 	// If the `option` is none, the platform doesn't maintain a
 	// status-change timestamp for this file.
-	StatusChangeTimestamp cm.Option[wallclock.DateTime]
+	StatusChangeTimestamp cm.Option[DateTime]
 }
 
 // NewTimestamp represents the variant "wasi:filesystem/[email protected]#new-timestamp".
@@ -265,7 +285,7 @@ type DescriptorStat struct {
 //		now,
 //		timestamp(datetime),
 //	}
-type NewTimestamp cm.Variant[uint8, wallclock.DateTime, wallclock.DateTime]
+type NewTimestamp cm.Variant[uint8, DateTime, DateTime]
 
 // NewTimestampNoChange returns a [NewTimestamp] of case "no-change".
 //
@@ -297,13 +317,24 @@ func (self *NewTimestamp) Now() bool {
 // NewTimestampTimestamp returns a [NewTimestamp] of case "timestamp".
 //
 // Set the timestamp to the given value.
-func NewTimestampTimestamp(data wallclock.DateTime) NewTimestamp {
+func NewTimestampTimestamp(data DateTime) NewTimestamp {
 	return cm.New[NewTimestamp](2, data)
 }
 
-// Timestamp returns a non-nil *[wallclock.DateTime] if [NewTimestamp] represents the variant case "timestamp".
-func (self *NewTimestamp) Timestamp() *wallclock.DateTime {
-	return cm.Case[wallclock.DateTime](self, 2)
+// Timestamp returns a non-nil *[DateTime] if [NewTimestamp] represents the variant case "timestamp".
+func (self *NewTimestamp) Timestamp() *DateTime {
+	return cm.Case[DateTime](self, 2)
+}
+
+var stringsNewTimestamp = [3]string{
+	"no-change",
+	"now",
+	"timestamp",
+}
+
+// String implements [fmt.Stringer], returning the variant case name of v.
+func (v NewTimestamp) String() string {
+	return stringsNewTimestamp[v.Tag()]
 }
 
 // DirectoryEntry represents the record "wasi:filesystem/[email protected]#directory-entry".
@@ -315,6 +346,7 @@ func (self *NewTimestamp) Timestamp() *wallclock.DateTime {
 //		name: string,
 //	}
 type DirectoryEntry struct {
+	_ cm.HostLayout
 	// The type of the file referred to by this directory entry.
 	Type DescriptorType
 
@@ -593,6 +625,7 @@ func (e Advice) String() string {
 //		upper: u64,
 //	}
 type MetadataHashValue struct {
+	_ cm.HostLayout
 	// 64 bits of a 128-bit hash value.
 	Lower uint64
 
@@ -620,10 +653,6 @@ func (self Descriptor) ResourceDrop() {
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [resource-drop]descriptor
-//go:noescape
-func wasmimport_DescriptorResourceDrop(self0 uint32)
-
 // Advise represents the imported method "advise".
 //
 // Provide file advisory information on a descriptor.
@@ -642,10 +671,6 @@ func (self Descriptor) Advise(offset FileSize, length FileSize, advice Advice) (
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.advise
-//go:noescape
-func wasmimport_DescriptorAdvise(self0 uint32, offset0 uint64, length0 uint64, advice0 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
-
 // AppendViaStream represents the imported method "append-via-stream".
 //
 // Return a stream for appending to a file, if available.
@@ -658,16 +683,12 @@ func wasmimport_DescriptorAdvise(self0 uint32, offset0 uint64, length0 uint64, a
 //	append-via-stream: func() -> result<output-stream, error-code>
 //
 //go:nosplit
-func (self Descriptor) AppendViaStream() (result cm.Result[streams.OutputStream, streams.OutputStream, ErrorCode]) {
+func (self Descriptor) AppendViaStream() (result cm.Result[OutputStream, OutputStream, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_DescriptorAppendViaStream((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.append-via-stream
-//go:noescape
-func wasmimport_DescriptorAppendViaStream(self0 uint32, result *cm.Result[streams.OutputStream, streams.OutputStream, ErrorCode])
-
 // CreateDirectoryAt represents the imported method "create-directory-at".
 //
 // Create a directory.
@@ -684,10 +705,6 @@ func (self Descriptor) CreateDirectoryAt(path string) (result cm.Result[ErrorCod
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.create-directory-at
-//go:noescape
-func wasmimport_DescriptorCreateDirectoryAt(self0 uint32, path0 *uint8, path1 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
-
 // GetFlags represents the imported method "get-flags".
 //
 // Get flags associated with a descriptor.
@@ -706,10 +723,6 @@ func (self Descriptor) GetFlags() (result cm.Result[DescriptorFlags, DescriptorF
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.get-flags
-//go:noescape
-func wasmimport_DescriptorGetFlags(self0 uint32, result *cm.Result[DescriptorFlags, DescriptorFlags, ErrorCode])
-
 // GetType represents the imported method "get-type".
 //
 // Get the dynamic type of a descriptor.
@@ -732,10 +745,6 @@ func (self Descriptor) GetType() (result cm.Result[DescriptorType, DescriptorTyp
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.get-type
-//go:noescape
-func wasmimport_DescriptorGetType(self0 uint32, result *cm.Result[DescriptorType, DescriptorType, ErrorCode])
-
 // IsSameObject represents the imported method "is-same-object".
 //
 // Test whether two descriptors refer to the same filesystem object.
@@ -756,10 +765,6 @@ func (self Descriptor) IsSameObject(other Descriptor) (result bool) {
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.is-same-object
-//go:noescape
-func wasmimport_DescriptorIsSameObject(self0 uint32, other0 uint32) (result0 uint32)
-
 // LinkAt represents the imported method "link-at".
 //
 // Create a hard link.
@@ -780,10 +785,6 @@ func (self Descriptor) LinkAt(oldPathFlags PathFlags, oldPath string, newDescrip
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.link-at
-//go:noescape
-func wasmimport_DescriptorLinkAt(self0 uint32, oldPathFlags0 uint32, oldPath0 *uint8, oldPath1 uint32, newDescriptor0 uint32, newPath0 *uint8, newPath1 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
-
 // MetadataHash represents the imported method "metadata-hash".
 //
 // Return a hash of the metadata associated with a filesystem object referred
@@ -815,10 +816,6 @@ func (self Descriptor) MetadataHash() (result cm.Result[MetadataHashValueShape,
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.metadata-hash
-//go:noescape
-func wasmimport_DescriptorMetadataHash(self0 uint32, result *cm.Result[MetadataHashValueShape, MetadataHashValue, ErrorCode])
-
 // MetadataHashAt represents the imported method "metadata-hash-at".
 //
 // Return a hash of the metadata associated with a filesystem object referred
@@ -838,10 +835,6 @@ func (self Descriptor) MetadataHashAt(pathFlags PathFlags, path string) (result
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.metadata-hash-at
-//go:noescape
-func wasmimport_DescriptorMetadataHashAt(self0 uint32, pathFlags0 uint32, path0 *uint8, path1 uint32, result *cm.Result[MetadataHashValueShape, MetadataHashValue, ErrorCode])
-
 // OpenAt represents the imported method "open-at".
 //
 // Open a file or directory.
@@ -877,10 +870,6 @@ func (self Descriptor) OpenAt(pathFlags PathFlags, path string, openFlags OpenFl
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.open-at
-//go:noescape
-func wasmimport_DescriptorOpenAt(self0 uint32, pathFlags0 uint32, path0 *uint8, path1 uint32, openFlags0 uint32, flags0 uint32, result *cm.Result[Descriptor, Descriptor, ErrorCode])
-
 // Read represents the imported method "read".
 //
 // Read from a descriptor, without using and updating the descriptor's offset.
@@ -907,10 +896,6 @@ func (self Descriptor) Read(length FileSize, offset FileSize) (result cm.Result[
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.read
-//go:noescape
-func wasmimport_DescriptorRead(self0 uint32, length0 uint64, offset0 uint64, result *cm.Result[TupleListU8BoolShape, cm.Tuple[cm.List[uint8], bool], ErrorCode])
-
 // ReadDirectory represents the imported method "read-directory".
 //
 // Read directory entries from a directory.
@@ -932,10 +917,6 @@ func (self Descriptor) ReadDirectory() (result cm.Result[DirectoryEntryStream, D
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.read-directory
-//go:noescape
-func wasmimport_DescriptorReadDirectory(self0 uint32, result *cm.Result[DirectoryEntryStream, DirectoryEntryStream, ErrorCode])
-
 // ReadViaStream represents the imported method "read-via-stream".
 //
 // Return a stream for reading from a file, if available.
@@ -950,17 +931,13 @@ func wasmimport_DescriptorReadDirectory(self0 uint32, result *cm.Result[Director
 //	read-via-stream: func(offset: filesize) -> result<input-stream, error-code>
 //
 //go:nosplit
-func (self Descriptor) ReadViaStream(offset FileSize) (result cm.Result[streams.InputStream, streams.InputStream, ErrorCode]) {
+func (self Descriptor) ReadViaStream(offset FileSize) (result cm.Result[InputStream, InputStream, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	offset0 := (uint64)(offset)
 	wasmimport_DescriptorReadViaStream((uint32)(self0), (uint64)(offset0), &result)
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.read-via-stream
-//go:noescape
-func wasmimport_DescriptorReadViaStream(self0 uint32, offset0 uint64, result *cm.Result[streams.InputStream, streams.InputStream, ErrorCode])
-
 // ReadLinkAt represents the imported method "readlink-at".
 //
 // Read the contents of a symbolic link.
@@ -980,10 +957,6 @@ func (self Descriptor) ReadLinkAt(path string) (result cm.Result[string, string,
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.readlink-at
-//go:noescape
-func wasmimport_DescriptorReadLinkAt(self0 uint32, path0 *uint8, path1 uint32, result *cm.Result[string, string, ErrorCode])
-
 // RemoveDirectoryAt represents the imported method "remove-directory-at".
 //
 // Remove a directory.
@@ -1002,10 +975,6 @@ func (self Descriptor) RemoveDirectoryAt(path string) (result cm.Result[ErrorCod
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.remove-directory-at
-//go:noescape
-func wasmimport_DescriptorRemoveDirectoryAt(self0 uint32, path0 *uint8, path1 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
-
 // RenameAt represents the imported method "rename-at".
 //
 // Rename a filesystem object.
@@ -1025,10 +994,6 @@ func (self Descriptor) RenameAt(oldPath string, newDescriptor Descriptor, newPat
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.rename-at
-//go:noescape
-func wasmimport_DescriptorRenameAt(self0 uint32, oldPath0 *uint8, oldPath1 uint32, newDescriptor0 uint32, newPath0 *uint8, newPath1 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
-
 // SetSize represents the imported method "set-size".
 //
 // Adjust the size of an open file. If this increases the file's size, the
@@ -1046,10 +1011,6 @@ func (self Descriptor) SetSize(size FileSize) (result cm.Result[ErrorCode, struc
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.set-size
-//go:noescape
-func wasmimport_DescriptorSetSize(self0 uint32, size0 uint64, result *cm.Result[ErrorCode, struct{}, ErrorCode])
-
 // SetTimes represents the imported method "set-times".
 //
 // Adjust the timestamps of an open file or directory.
@@ -1070,10 +1031,6 @@ func (self Descriptor) SetTimes(dataAccessTimestamp NewTimestamp, dataModificati
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.set-times
-//go:noescape
-func wasmimport_DescriptorSetTimes(self0 uint32, dataAccessTimestamp0 uint32, dataAccessTimestamp1 uint64, dataAccessTimestamp2 uint32, dataModificationTimestamp0 uint32, dataModificationTimestamp1 uint64, dataModificationTimestamp2 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
-
 // SetTimesAt represents the imported method "set-times-at".
 //
 // Adjust the timestamps of a file or directory.
@@ -1097,10 +1054,6 @@ func (self Descriptor) SetTimesAt(pathFlags PathFlags, path string, dataAccessTi
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.set-times-at
-//go:noescape
-func wasmimport_DescriptorSetTimesAt(self0 uint32, pathFlags0 uint32, path0 *uint8, path1 uint32, dataAccessTimestamp0 uint32, dataAccessTimestamp1 uint64, dataAccessTimestamp2 uint32, dataModificationTimestamp0 uint32, dataModificationTimestamp1 uint64, dataModificationTimestamp2 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
-
 // Stat represents the imported method "stat".
 //
 // Return the attributes of an open file or directory.
@@ -1122,10 +1075,6 @@ func (self Descriptor) Stat() (result cm.Result[DescriptorStatShape, DescriptorS
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.stat
-//go:noescape
-func wasmimport_DescriptorStat(self0 uint32, result *cm.Result[DescriptorStatShape, DescriptorStat, ErrorCode])
-
 // StatAt represents the imported method "stat-at".
 //
 // Return the attributes of a file or directory.
@@ -1148,10 +1097,6 @@ func (self Descriptor) StatAt(pathFlags PathFlags, path string) (result cm.Resul
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.stat-at
-//go:noescape
-func wasmimport_DescriptorStatAt(self0 uint32, pathFlags0 uint32, path0 *uint8, path1 uint32, result *cm.Result[DescriptorStatShape, DescriptorStat, ErrorCode])
-
 // SymlinkAt represents the imported method "symlink-at".
 //
 // Create a symbolic link (also known as a "symlink").
@@ -1172,10 +1117,6 @@ func (self Descriptor) SymlinkAt(oldPath string, newPath string) (result cm.Resu
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.symlink-at
-//go:noescape
-func wasmimport_DescriptorSymlinkAt(self0 uint32, oldPath0 *uint8, oldPath1 uint32, newPath0 *uint8, newPath1 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
-
 // Sync represents the imported method "sync".
 //
 // Synchronize the data and metadata of a file to disk.
@@ -1194,10 +1135,6 @@ func (self Descriptor) Sync() (result cm.Result[ErrorCode, struct{}, ErrorCode])
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.sync
-//go:noescape
-func wasmimport_DescriptorSync(self0 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
-
 // SyncData represents the imported method "sync-data".
 //
 // Synchronize the data of a file to disk.
@@ -1216,10 +1153,6 @@ func (self Descriptor) SyncData() (result cm.Result[ErrorCode, struct{}, ErrorCo
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.sync-data
-//go:noescape
-func wasmimport_DescriptorSyncData(self0 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
-
 // UnlinkFileAt represents the imported method "unlink-file-at".
 //
 // Unlink a filesystem object that is not a directory.
@@ -1237,10 +1170,6 @@ func (self Descriptor) UnlinkFileAt(path string) (result cm.Result[ErrorCode, st
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.unlink-file-at
-//go:noescape
-func wasmimport_DescriptorUnlinkFileAt(self0 uint32, path0 *uint8, path1 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
-
 // Write represents the imported method "write".
 //
 // Write to a descriptor, without using and updating the descriptor's offset.
@@ -1264,10 +1193,6 @@ func (self Descriptor) Write(buffer cm.List[uint8], offset FileSize) (result cm.
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.write
-//go:noescape
-func wasmimport_DescriptorWrite(self0 uint32, buffer0 *uint8, buffer1 uint32, offset0 uint64, result *cm.Result[uint64, FileSize, ErrorCode])
-
 // WriteViaStream represents the imported method "write-via-stream".
 //
 // Return a stream for writing to a file, if available.
@@ -1280,17 +1205,13 @@ func wasmimport_DescriptorWrite(self0 uint32, buffer0 *uint8, buffer1 uint32, of
 //	write-via-stream: func(offset: filesize) -> result<output-stream, error-code>
 //
 //go:nosplit
-func (self Descriptor) WriteViaStream(offset FileSize) (result cm.Result[streams.OutputStream, streams.OutputStream, ErrorCode]) {
+func (self Descriptor) WriteViaStream(offset FileSize) (result cm.Result[OutputStream, OutputStream, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	offset0 := (uint64)(offset)
 	wasmimport_DescriptorWriteViaStream((uint32)(self0), (uint64)(offset0), &result)
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]descriptor.write-via-stream
-//go:noescape
-func wasmimport_DescriptorWriteViaStream(self0 uint32, offset0 uint64, result *cm.Result[streams.OutputStream, streams.OutputStream, ErrorCode])
-
 // DirectoryEntryStream represents the imported resource "wasi:filesystem/[email protected]#directory-entry-stream".
 //
 // A stream of directory entries.
@@ -1309,10 +1230,6 @@ func (self DirectoryEntryStream) ResourceDrop() {
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [resource-drop]directory-entry-stream
-//go:noescape
-func wasmimport_DirectoryEntryStreamResourceDrop(self0 uint32)
-
 // ReadDirectoryEntry represents the imported method "read-directory-entry".
 //
 // Read a single directory entry from a `directory-entry-stream`.
@@ -1326,10 +1243,6 @@ func (self DirectoryEntryStream) ReadDirectoryEntry() (result cm.Result[OptionDi
 	return
 }
 
-//go:wasmimport wasi:filesystem/[email protected] [method]directory-entry-stream.read-directory-entry
-//go:noescape
-func wasmimport_DirectoryEntryStreamReadDirectoryEntry(self0 uint32, result *cm.Result[OptionDirectoryEntryShape, cm.Option[DirectoryEntry], ErrorCode])
-
 // FilesystemErrorCode represents the imported function "filesystem-error-code".
 //
 // Attempts to extract a filesystem-related `error-code` from the stream
@@ -1346,12 +1259,8 @@ func wasmimport_DirectoryEntryStreamReadDirectoryEntry(self0 uint32, result *cm.
 //	filesystem-error-code: func(err: borrow<error>) -> option<error-code>
 //
 //go:nosplit
-func FilesystemErrorCode(err ioerror.Error) (result cm.Option[ErrorCode]) {
+func FilesystemErrorCode(err Error) (result cm.Option[ErrorCode]) {
 	err0 := cm.Reinterpret[uint32](err)
 	wasmimport_FilesystemErrorCode((uint32)(err0), &result)
 	return
 }
-
-//go:wasmimport wasi:filesystem/[email protected] filesystem-error-code
-//go:noescape
-func wasmimport_FilesystemErrorCode(err0 uint32, result *cm.Option[ErrorCode])
diff --git a/src/internal/wasi/io/v0.2.0/error/error.wit.go b/src/internal/wasi/io/v0.2.0/error/error.wit.go
index e7f92a8d3..20827b053 100644
--- a/src/internal/wasi/io/v0.2.0/error/error.wit.go
+++ b/src/internal/wasi/io/v0.2.0/error/error.wit.go
@@ -43,10 +43,6 @@ func (self Error) ResourceDrop() {
 	return
 }
 
-//go:wasmimport wasi:io/[email protected] [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
@@ -65,7 +61,3 @@ func (self Error) ToDebugString() (result string) {
 	wasmimport_ErrorToDebugString((uint32)(self0), &result)
 	return
 }
-
-//go:wasmimport wasi:io/[email protected] [method]error.to-debug-string
-//go:noescape
-func wasmimport_ErrorToDebugString(self0 uint32, result *string)
diff --git a/src/internal/wasi/io/v0.2.0/error/ioerror.wasm.go b/src/internal/wasi/io/v0.2.0/error/ioerror.wasm.go
new file mode 100755
index 000000000..e254b5d86
--- /dev/null
+++ b/src/internal/wasi/io/v0.2.0/error/ioerror.wasm.go
@@ -0,0 +1,13 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package ioerror
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:io/[email protected] [resource-drop]error
+//go:noescape
+func wasmimport_ErrorResourceDrop(self0 uint32)
+
+//go:wasmimport wasi:io/[email protected] [method]error.to-debug-string
+//go:noescape
+func wasmimport_ErrorToDebugString(self0 uint32, result *string)
diff --git a/src/internal/wasi/io/v0.2.0/poll/poll.wasm.go b/src/internal/wasi/io/v0.2.0/poll/poll.wasm.go
new file mode 100755
index 000000000..d807d7728
--- /dev/null
+++ b/src/internal/wasi/io/v0.2.0/poll/poll.wasm.go
@@ -0,0 +1,25 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package poll
+
+import (
+	"internal/cm"
+)
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:io/[email protected] [resource-drop]pollable
+//go:noescape
+func wasmimport_PollableResourceDrop(self0 uint32)
+
+//go:wasmimport wasi:io/[email protected] [method]pollable.block
+//go:noescape
+func wasmimport_PollableBlock(self0 uint32)
+
+//go:wasmimport wasi:io/[email protected] [method]pollable.ready
+//go:noescape
+func wasmimport_PollableReady(self0 uint32) (result0 uint32)
+
+//go:wasmimport wasi:io/[email protected] poll
+//go:noescape
+func wasmimport_Poll(in0 *Pollable, in1 uint32, result *cm.List[uint32])
diff --git a/src/internal/wasi/io/v0.2.0/poll/poll.wit.go b/src/internal/wasi/io/v0.2.0/poll/poll.wit.go
index 626ac50e1..a3d516394 100644
--- a/src/internal/wasi/io/v0.2.0/poll/poll.wit.go
+++ b/src/internal/wasi/io/v0.2.0/poll/poll.wit.go
@@ -28,10 +28,6 @@ func (self Pollable) ResourceDrop() {
 	return
 }
 
-//go:wasmimport wasi:io/[email protected] [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
@@ -49,10 +45,6 @@ func (self Pollable) Block() {
 	return
 }
 
-//go:wasmimport wasi:io/[email protected] [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.
@@ -69,10 +61,6 @@ func (self Pollable) Ready() (result bool) {
 	return
 }
 
-//go:wasmimport wasi:io/[email protected] [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.
@@ -102,7 +90,3 @@ func Poll(in cm.List[Pollable]) (result cm.List[uint32]) {
 	wasmimport_Poll((*Pollable)(in0), (uint32)(in1), &result)
 	return
 }
-
-//go:wasmimport wasi:io/[email protected] poll
-//go:noescape
-func wasmimport_Poll(in0 *Pollable, in1 uint32, result *cm.List[uint32])
diff --git a/src/internal/wasi/io/v0.2.0/streams/streams.wasm.go b/src/internal/wasi/io/v0.2.0/streams/streams.wasm.go
new file mode 100755
index 000000000..c317ea5c1
--- /dev/null
+++ b/src/internal/wasi/io/v0.2.0/streams/streams.wasm.go
@@ -0,0 +1,77 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package streams
+
+import (
+	"internal/cm"
+)
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:io/[email protected] [resource-drop]input-stream
+//go:noescape
+func wasmimport_InputStreamResourceDrop(self0 uint32)
+
+//go:wasmimport wasi:io/[email protected] [method]input-stream.blocking-read
+//go:noescape
+func wasmimport_InputStreamBlockingRead(self0 uint32, len0 uint64, result *cm.Result[cm.List[uint8], cm.List[uint8], StreamError])
+
+//go:wasmimport wasi:io/[email protected] [method]input-stream.blocking-skip
+//go:noescape
+func wasmimport_InputStreamBlockingSkip(self0 uint32, len0 uint64, result *cm.Result[uint64, uint64, StreamError])
+
+//go:wasmimport wasi:io/[email protected] [method]input-stream.read
+//go:noescape
+func wasmimport_InputStreamRead(self0 uint32, len0 uint64, result *cm.Result[cm.List[uint8], cm.List[uint8], StreamError])
+
+//go:wasmimport wasi:io/[email protected] [method]input-stream.skip
+//go:noescape
+func wasmimport_InputStreamSkip(self0 uint32, len0 uint64, result *cm.Result[uint64, uint64, StreamError])
+
+//go:wasmimport wasi:io/[email protected] [method]input-stream.subscribe
+//go:noescape
+func wasmimport_InputStreamSubscribe(self0 uint32) (result0 uint32)
+
+//go:wasmimport wasi:io/[email protected] [resource-drop]output-stream
+//go:noescape
+func wasmimport_OutputStreamResourceDrop(self0 uint32)
+
+//go:wasmimport wasi:io/[email protected] [method]output-stream.blocking-flush
+//go:noescape
+func wasmimport_OutputStreamBlockingFlush(self0 uint32, result *cm.Result[StreamError, struct{}, StreamError])
+
+//go:wasmimport wasi:io/[email protected] [method]output-stream.blocking-splice
+//go:noescape
+func wasmimport_OutputStreamBlockingSplice(self0 uint32, src0 uint32, len0 uint64, result *cm.Result[uint64, uint64, StreamError])
+
+//go:wasmimport wasi:io/[email protected] [method]output-stream.blocking-write-and-flush
+//go:noescape
+func wasmimport_OutputStreamBlockingWriteAndFlush(self0 uint32, contents0 *uint8, contents1 uint32, result *cm.Result[StreamError, struct{}, StreamError])
+
+//go:wasmimport wasi:io/[email protected] [method]output-stream.blocking-write-zeroes-and-flush
+//go:noescape
+func wasmimport_OutputStreamBlockingWriteZeroesAndFlush(self0 uint32, len0 uint64, result *cm.Result[StreamError, struct{}, StreamError])
+
+//go:wasmimport wasi:io/[email protected] [method]output-stream.check-write
+//go:noescape
+func wasmimport_OutputStreamCheckWrite(self0 uint32, result *cm.Result[uint64, uint64, StreamError])
+
+//go:wasmimport wasi:io/[email protected] [method]output-stream.flush
+//go:noescape
+func wasmimport_OutputStreamFlush(self0 uint32, result *cm.Result[StreamError, struct{}, StreamError])
+
+//go:wasmimport wasi:io/[email protected] [method]output-stream.splice
+//go:noescape
+func wasmimport_OutputStreamSplice(self0 uint32, src0 uint32, len0 uint64, result *cm.Result[uint64, uint64, StreamError])
+
+//go:wasmimport wasi:io/[email protected] [method]output-stream.subscribe
+//go:noescape
+func wasmimport_OutputStreamSubscribe(self0 uint32) (result0 uint32)
+
+//go:wasmimport wasi:io/[email protected] [method]output-stream.write
+//go:noescape
+func wasmimport_OutputStreamWrite(self0 uint32, contents0 *uint8, contents1 uint32, result *cm.Result[StreamError, struct{}, StreamError])
+
+//go:wasmimport wasi:io/[email protected] [method]output-stream.write-zeroes
+//go:noescape
+func wasmimport_OutputStreamWriteZeroes(self0 uint32, len0 uint64, result *cm.Result[StreamError, struct{}, StreamError])
diff --git a/src/internal/wasi/io/v0.2.0/streams/streams.wit.go b/src/internal/wasi/io/v0.2.0/streams/streams.wit.go
index 01fc0288f..a4dcc970e 100644
--- a/src/internal/wasi/io/v0.2.0/streams/streams.wit.go
+++ b/src/internal/wasi/io/v0.2.0/streams/streams.wit.go
@@ -15,6 +15,16 @@ import (
 	"internal/wasi/io/v0.2.0/poll"
 )
 
+// Error represents the imported type alias "wasi:io/[email protected]#error".
+//
+// See [ioerror.Error] for more information.
+type Error = ioerror.Error
+
+// Pollable represents the imported type alias "wasi:io/[email protected]#pollable".
+//
+// See [poll.Pollable] for more information.
+type Pollable = poll.Pollable
+
 // StreamError represents the imported variant "wasi:io/[email protected]#stream-error".
 //
 // An error for input-stream and output-stream operations.
@@ -23,20 +33,20 @@ import (
 //		last-operation-failed(error),
 //		closed,
 //	}
-type StreamError cm.Variant[uint8, ioerror.Error, ioerror.Error]
+type StreamError cm.Variant[uint8, Error, 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 {
+func StreamErrorLastOperationFailed(data 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)
+// LastOperationFailed returns a non-nil *[Error] if [StreamError] represents the variant case "last-operation-failed".
+func (self *StreamError) LastOperationFailed() *Error {
+	return cm.Case[Error](self, 0)
 }
 
 // StreamErrorClosed returns a [StreamError] of case "closed".
@@ -54,6 +64,16 @@ func (self *StreamError) Closed() bool {
 	return self.Tag() == 1
 }
 
+var stringsStreamError = [2]string{
+	"last-operation-failed",
+	"closed",
+}
+
+// String implements [fmt.Stringer], returning the variant case name of v.
+func (v StreamError) String() string {
+	return stringsStreamError[v.Tag()]
+}
+
 // InputStream represents the imported resource "wasi:io/[email protected]#input-stream".
 //
 // An input bytestream.
@@ -79,10 +99,6 @@ func (self InputStream) ResourceDrop() {
 	return
 }
 
-//go:wasmimport wasi:io/[email protected] [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
@@ -98,10 +114,6 @@ func (self InputStream) BlockingRead(len_ uint64) (result cm.Result[cm.List[uint
 	return
 }
 
-//go:wasmimport wasi:io/[email protected] [method]input-stream.blocking-read
-//go:noescape
-func wasmimport_InputStreamBlockingRead(self0 uint32, len0 uint64, result *cm.Result[cm.List[uint8], cm.List[uint8], StreamError])
-
 // BlockingSkip represents the imported method "blocking-skip".
 //
 // Skip bytes from a stream, after blocking until at least one byte
@@ -117,10 +129,6 @@ func (self InputStream) BlockingSkip(len_ uint64) (result cm.Result[uint64, uint
 	return
 }
 
-//go:wasmimport wasi:io/[email protected] [method]input-stream.blocking-skip
-//go:noescape
-func wasmimport_InputStreamBlockingSkip(self0 uint32, len0 uint64, result *cm.Result[uint64, uint64, StreamError])
-
 // Read represents the imported method "read".
 //
 // Perform a non-blocking read from the stream.
@@ -160,10 +168,6 @@ func (self InputStream) Read(len_ uint64) (result cm.Result[cm.List[uint8], cm.L
 	return
 }
 
-//go:wasmimport wasi:io/[email protected] [method]input-stream.read
-//go:noescape
-func wasmimport_InputStreamRead(self0 uint32, len0 uint64, result *cm.Result[cm.List[uint8], cm.List[uint8], StreamError])
-
 // Skip represents the imported method "skip".
 //
 // Skip bytes from a stream. Returns number of bytes skipped.
@@ -181,10 +185,6 @@ func (self InputStream) Skip(len_ uint64) (result cm.Result[uint64, uint64, Stre
 	return
 }
 
-//go:wasmimport wasi:io/[email protected] [method]input-stream.skip
-//go:noescape
-func wasmimport_InputStreamSkip(self0 uint32, len0 uint64, result *cm.Result[uint64, uint64, StreamError])
-
 // Subscribe represents the imported method "subscribe".
 //
 // Create a `pollable` which will resolve once either the specified stream
@@ -197,17 +197,13 @@ func wasmimport_InputStreamSkip(self0 uint32, len0 uint64, result *cm.Result[uin
 //	subscribe: func() -> pollable
 //
 //go:nosplit
-func (self InputStream) Subscribe() (result poll.Pollable) {
+func (self InputStream) Subscribe() (result Pollable) {
 	self0 := cm.Reinterpret[uint32](self)
 	result0 := wasmimport_InputStreamSubscribe((uint32)(self0))
-	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
+	result = cm.Reinterpret[Pollable]((uint32)(result0))
 	return
 }
 
-//go:wasmimport wasi:io/[email protected] [method]input-stream.subscribe
-//go:noescape
-func wasmimport_InputStreamSubscribe(self0 uint32) (result0 uint32)
-
 // OutputStream represents the imported resource "wasi:io/[email protected]#output-stream".
 //
 // An output bytestream.
@@ -233,10 +229,6 @@ func (self OutputStream) ResourceDrop() {
 	return
 }
 
-//go:wasmimport wasi:io/[email protected] [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
@@ -251,10 +243,6 @@ func (self OutputStream) BlockingFlush() (result cm.Result[StreamError, struct{}
 	return
 }
 
-//go:wasmimport wasi:io/[email protected] [method]output-stream.blocking-flush
-//go:noescape
-func wasmimport_OutputStreamBlockingFlush(self0 uint32, result *cm.Result[StreamError, struct{}, StreamError])
-
 // BlockingSplice represents the imported method "blocking-splice".
 //
 // Read from one stream and write to another, with blocking.
@@ -274,10 +262,6 @@ func (self OutputStream) BlockingSplice(src InputStream, len_ uint64) (result cm
 	return
 }
 
-//go:wasmimport wasi:io/[email protected] [method]output-stream.blocking-splice
-//go:noescape
-func wasmimport_OutputStreamBlockingSplice(self0 uint32, src0 uint32, len0 uint64, result *cm.Result[uint64, 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
@@ -313,10 +297,6 @@ func (self OutputStream) BlockingWriteAndFlush(contents cm.List[uint8]) (result
 	return
 }
 
-//go:wasmimport wasi:io/[email protected] [method]output-stream.blocking-write-and-flush
-//go:noescape
-func wasmimport_OutputStreamBlockingWriteAndFlush(self0 uint32, contents0 *uint8, contents1 uint32, result *cm.Result[StreamError, 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.
@@ -352,10 +332,6 @@ func (self OutputStream) BlockingWriteZeroesAndFlush(len_ uint64) (result cm.Res
 	return
 }
 
-//go:wasmimport wasi:io/[email protected] [method]output-stream.blocking-write-zeroes-and-flush
-//go:noescape
-func wasmimport_OutputStreamBlockingWriteZeroesAndFlush(self0 uint32, len0 uint64, result *cm.Result[StreamError, struct{}, StreamError])
-
 // CheckWrite represents the imported method "check-write".
 //
 // Check readiness for writing. This function never blocks.
@@ -377,10 +353,6 @@ func (self OutputStream) CheckWrite() (result cm.Result[uint64, uint64, StreamEr
 	return
 }
 
-//go:wasmimport wasi:io/[email protected] [method]output-stream.check-write
-//go:noescape
-func wasmimport_OutputStreamCheckWrite(self0 uint32, result *cm.Result[uint64, uint64, StreamError])
-
 // Flush represents the imported method "flush".
 //
 // Request to flush buffered output. This function never blocks.
@@ -403,10 +375,6 @@ func (self OutputStream) Flush() (result cm.Result[StreamError, struct{}, Stream
 	return
 }
 
-//go:wasmimport wasi:io/[email protected] [method]output-stream.flush
-//go:noescape
-func wasmimport_OutputStreamFlush(self0 uint32, result *cm.Result[StreamError, struct{}, StreamError])
-
 // Splice represents the imported method "splice".
 //
 // Read from one stream and write to another.
@@ -434,10 +402,6 @@ func (self OutputStream) Splice(src InputStream, len_ uint64) (result cm.Result[
 	return
 }
 
-//go:wasmimport wasi:io/[email protected] [method]output-stream.splice
-//go:noescape
-func wasmimport_OutputStreamSplice(self0 uint32, src0 uint32, len0 uint64, result *cm.Result[uint64, uint64, StreamError])
-
 // Subscribe represents the imported method "subscribe".
 //
 // Create a `pollable` which will resolve once the output-stream
@@ -454,17 +418,13 @@ func wasmimport_OutputStreamSplice(self0 uint32, src0 uint32, len0 uint64, resul
 //	subscribe: func() -> pollable
 //
 //go:nosplit
-func (self OutputStream) Subscribe() (result poll.Pollable) {
+func (self OutputStream) Subscribe() (result Pollable) {
 	self0 := cm.Reinterpret[uint32](self)
 	result0 := wasmimport_OutputStreamSubscribe((uint32)(self0))
-	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
+	result = cm.Reinterpret[Pollable]((uint32)(result0))
 	return
 }
 
-//go:wasmimport wasi:io/[email protected] [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.
@@ -491,10 +451,6 @@ func (self OutputStream) Write(contents cm.List[uint8]) (result cm.Result[Stream
 	return
 }
 
-//go:wasmimport wasi:io/[email protected] [method]output-stream.write
-//go:noescape
-func wasmimport_OutputStreamWrite(self0 uint32, contents0 *uint8, contents1 uint32, result *cm.Result[StreamError, struct{}, StreamError])
-
 // WriteZeroes represents the imported method "write-zeroes".
 //
 // Write zeroes to a stream.
@@ -513,7 +469,3 @@ func (self OutputStream) WriteZeroes(len_ uint64) (result cm.Result[StreamError,
 	wasmimport_OutputStreamWriteZeroes((uint32)(self0), (uint64)(len0), &result)
 	return
 }
-
-//go:wasmimport wasi:io/[email protected] [method]output-stream.write-zeroes
-//go:noescape
-func wasmimport_OutputStreamWriteZeroes(self0 uint32, len0 uint64, result *cm.Result[StreamError, struct{}, StreamError])
diff --git a/src/internal/wasi/random/v0.2.0/insecure-seed/insecure-seed.wit.go b/src/internal/wasi/random/v0.2.0/insecure-seed/insecure-seed.wit.go
index 3b8f33c06..6f3636738 100644
--- a/src/internal/wasi/random/v0.2.0/insecure-seed/insecure-seed.wit.go
+++ b/src/internal/wasi/random/v0.2.0/insecure-seed/insecure-seed.wit.go
@@ -35,7 +35,3 @@ func InsecureSeed() (result [2]uint64) {
 	wasmimport_InsecureSeed(&result)
 	return
 }
-
-//go:wasmimport wasi:random/[email protected] insecure-seed
-//go:noescape
-func wasmimport_InsecureSeed(result *[2]uint64)
diff --git a/src/internal/wasi/random/v0.2.0/insecure-seed/insecureseed.wasm.go b/src/internal/wasi/random/v0.2.0/insecure-seed/insecureseed.wasm.go
new file mode 100755
index 000000000..e94356df0
--- /dev/null
+++ b/src/internal/wasi/random/v0.2.0/insecure-seed/insecureseed.wasm.go
@@ -0,0 +1,9 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package insecureseed
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:random/[email protected] insecure-seed
+//go:noescape
+func wasmimport_InsecureSeed(result *[2]uint64)
diff --git a/src/internal/wasi/random/v0.2.0/insecure/insecure.wasm.go b/src/internal/wasi/random/v0.2.0/insecure/insecure.wasm.go
new file mode 100755
index 000000000..ea62b8131
--- /dev/null
+++ b/src/internal/wasi/random/v0.2.0/insecure/insecure.wasm.go
@@ -0,0 +1,17 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package insecure
+
+import (
+	"internal/cm"
+)
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:random/[email protected] get-insecure-random-bytes
+//go:noescape
+func wasmimport_GetInsecureRandomBytes(len0 uint64, result *cm.List[uint8])
+
+//go:wasmimport wasi:random/[email protected] get-insecure-random-u64
+//go:noescape
+func wasmimport_GetInsecureRandomU64() (result0 uint64)
diff --git a/src/internal/wasi/random/v0.2.0/insecure/insecure.wit.go b/src/internal/wasi/random/v0.2.0/insecure/insecure.wit.go
index 44cdbd7cf..625ca5a90 100644
--- a/src/internal/wasi/random/v0.2.0/insecure/insecure.wit.go
+++ b/src/internal/wasi/random/v0.2.0/insecure/insecure.wit.go
@@ -32,10 +32,6 @@ func GetInsecureRandomBytes(len_ uint64) (result cm.List[uint8]) {
 	return
 }
 
-//go:wasmimport wasi:random/[email protected] 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.
@@ -51,7 +47,3 @@ func GetInsecureRandomU64() (result uint64) {
 	result = (uint64)((uint64)(result0))
 	return
 }
-
-//go:wasmimport wasi:random/[email protected] get-insecure-random-u64
-//go:noescape
-func wasmimport_GetInsecureRandomU64() (result0 uint64)
diff --git a/src/internal/wasi/random/v0.2.0/random/random.wasm.go b/src/internal/wasi/random/v0.2.0/random/random.wasm.go
new file mode 100755
index 000000000..1738d49ae
--- /dev/null
+++ b/src/internal/wasi/random/v0.2.0/random/random.wasm.go
@@ -0,0 +1,17 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package random
+
+import (
+	"internal/cm"
+)
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:random/[email protected] get-random-bytes
+//go:noescape
+func wasmimport_GetRandomBytes(len0 uint64, result *cm.List[uint8])
+
+//go:wasmimport wasi:random/[email protected] get-random-u64
+//go:noescape
+func wasmimport_GetRandomU64() (result0 uint64)
diff --git a/src/internal/wasi/random/v0.2.0/random/random.wit.go b/src/internal/wasi/random/v0.2.0/random/random.wit.go
index cf0929bf5..49b054bd2 100644
--- a/src/internal/wasi/random/v0.2.0/random/random.wit.go
+++ b/src/internal/wasi/random/v0.2.0/random/random.wit.go
@@ -36,10 +36,6 @@ func GetRandomBytes(len_ uint64) (result cm.List[uint8]) {
 	return
 }
 
-//go:wasmimport wasi:random/[email protected] 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.
@@ -55,7 +51,3 @@ func GetRandomU64() (result uint64) {
 	result = (uint64)((uint64)(result0))
 	return
 }
-
-//go:wasmimport wasi:random/[email protected] get-random-u64
-//go:noescape
-func wasmimport_GetRandomU64() (result0 uint64)
diff --git a/src/internal/wasi/sockets/v0.2.0/instance-network/instance-network.wit.go b/src/internal/wasi/sockets/v0.2.0/instance-network/instance-network.wit.go
index 474036017..378bba689 100644
--- a/src/internal/wasi/sockets/v0.2.0/instance-network/instance-network.wit.go
+++ b/src/internal/wasi/sockets/v0.2.0/instance-network/instance-network.wit.go
@@ -10,6 +10,11 @@ import (
 	"internal/wasi/sockets/v0.2.0/network"
 )
 
+// Network represents the imported type alias "wasi:sockets/[email protected]#network".
+//
+// See [network.Network] for more information.
+type Network = network.Network
+
 // InstanceNetwork represents the imported function "instance-network".
 //
 // Get a handle to the default network.
@@ -17,12 +22,8 @@ import (
 //	instance-network: func() -> network
 //
 //go:nosplit
-func InstanceNetwork() (result network.Network) {
+func InstanceNetwork() (result Network) {
 	result0 := wasmimport_InstanceNetwork()
-	result = cm.Reinterpret[network.Network]((uint32)(result0))
+	result = cm.Reinterpret[Network]((uint32)(result0))
 	return
 }
-
-//go:wasmimport wasi:sockets/[email protected] instance-network
-//go:noescape
-func wasmimport_InstanceNetwork() (result0 uint32)
diff --git a/src/internal/wasi/sockets/v0.2.0/instance-network/instancenetwork.wasm.go b/src/internal/wasi/sockets/v0.2.0/instance-network/instancenetwork.wasm.go
new file mode 100755
index 000000000..eb113e217
--- /dev/null
+++ b/src/internal/wasi/sockets/v0.2.0/instance-network/instancenetwork.wasm.go
@@ -0,0 +1,9 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package instancenetwork
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:sockets/[email protected] instance-network
+//go:noescape
+func wasmimport_InstanceNetwork() (result0 uint32)
diff --git a/src/internal/wasi/sockets/v0.2.0/ip-name-lookup/abi.go b/src/internal/wasi/sockets/v0.2.0/ip-name-lookup/abi.go
index fbc790e00..3d73f356a 100644
--- a/src/internal/wasi/sockets/v0.2.0/ip-name-lookup/abi.go
+++ b/src/internal/wasi/sockets/v0.2.0/ip-name-lookup/abi.go
@@ -4,11 +4,11 @@ package ipnamelookup
 
 import (
 	"internal/cm"
-	"internal/wasi/sockets/v0.2.0/network"
 	"unsafe"
 )
 
 // OptionIPAddressShape is used for storage in variant or result types.
 type OptionIPAddressShape struct {
-	shape [unsafe.Sizeof(cm.Option[network.IPAddress]{})]byte
+	_     cm.HostLayout
+	shape [unsafe.Sizeof(cm.Option[IPAddress]{})]byte
 }
diff --git a/src/internal/wasi/sockets/v0.2.0/ip-name-lookup/ip-name-lookup.wit.go b/src/internal/wasi/sockets/v0.2.0/ip-name-lookup/ip-name-lookup.wit.go
index f4c7632f7..6e982857d 100644
--- a/src/internal/wasi/sockets/v0.2.0/ip-name-lookup/ip-name-lookup.wit.go
+++ b/src/internal/wasi/sockets/v0.2.0/ip-name-lookup/ip-name-lookup.wit.go
@@ -9,6 +9,26 @@ import (
 	"internal/wasi/sockets/v0.2.0/network"
 )
 
+// Pollable represents the imported type alias "wasi:sockets/[email protected]#pollable".
+//
+// See [poll.Pollable] for more information.
+type Pollable = poll.Pollable
+
+// Network represents the imported type alias "wasi:sockets/[email protected]#network".
+//
+// See [network.Network] for more information.
+type Network = network.Network
+
+// ErrorCode represents the type alias "wasi:sockets/[email protected]#error-code".
+//
+// See [network.ErrorCode] for more information.
+type ErrorCode = network.ErrorCode
+
+// IPAddress represents the type alias "wasi:sockets/[email protected]#ip-address".
+//
+// See [network.IPAddress] for more information.
+type IPAddress = network.IPAddress
+
 // ResolveAddressStream represents the imported resource "wasi:sockets/[email protected]#resolve-address-stream".
 //
 //	resource resolve-address-stream
@@ -25,10 +45,6 @@ func (self ResolveAddressStream) ResourceDrop() {
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [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.
@@ -51,16 +67,12 @@ func wasmimport_ResolveAddressStreamResourceDrop(self0 uint32)
 //	resolve-next-address: func() -> result<option<ip-address>, error-code>
 //
 //go:nosplit
-func (self ResolveAddressStream) ResolveNextAddress() (result cm.Result[OptionIPAddressShape, cm.Option[network.IPAddress], network.ErrorCode]) {
+func (self ResolveAddressStream) ResolveNextAddress() (result cm.Result[OptionIPAddressShape, cm.Option[IPAddress], ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_ResolveAddressStreamResolveNextAddress((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]resolve-address-stream.resolve-next-address
-//go:noescape
-func wasmimport_ResolveAddressStreamResolveNextAddress(self0 uint32, result *cm.Result[OptionIPAddressShape, 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.
@@ -71,17 +83,13 @@ func wasmimport_ResolveAddressStreamResolveNextAddress(self0 uint32, result *cm.
 //	subscribe: func() -> pollable
 //
 //go:nosplit
-func (self ResolveAddressStream) Subscribe() (result poll.Pollable) {
+func (self ResolveAddressStream) Subscribe() (result Pollable) {
 	self0 := cm.Reinterpret[uint32](self)
 	result0 := wasmimport_ResolveAddressStreamSubscribe((uint32)(self0))
-	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
+	result = cm.Reinterpret[Pollable]((uint32)(result0))
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [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.
@@ -109,13 +117,9 @@ func wasmimport_ResolveAddressStreamSubscribe(self0 uint32) (result0 uint32)
 //	error-code>
 //
 //go:nosplit
-func ResolveAddresses(network_ network.Network, name string) (result cm.Result[ResolveAddressStream, ResolveAddressStream, network.ErrorCode]) {
+func ResolveAddresses(network_ Network, name string) (result cm.Result[ResolveAddressStream, ResolveAddressStream, 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/[email protected] resolve-addresses
-//go:noescape
-func wasmimport_ResolveAddresses(network0 uint32, name0 *uint8, name1 uint32, result *cm.Result[ResolveAddressStream, ResolveAddressStream, network.ErrorCode])
diff --git a/src/internal/wasi/sockets/v0.2.0/ip-name-lookup/ipnamelookup.wasm.go b/src/internal/wasi/sockets/v0.2.0/ip-name-lookup/ipnamelookup.wasm.go
new file mode 100755
index 000000000..6693408f6
--- /dev/null
+++ b/src/internal/wasi/sockets/v0.2.0/ip-name-lookup/ipnamelookup.wasm.go
@@ -0,0 +1,25 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package ipnamelookup
+
+import (
+	"internal/cm"
+)
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:sockets/[email protected] [resource-drop]resolve-address-stream
+//go:noescape
+func wasmimport_ResolveAddressStreamResourceDrop(self0 uint32)
+
+//go:wasmimport wasi:sockets/[email protected] [method]resolve-address-stream.resolve-next-address
+//go:noescape
+func wasmimport_ResolveAddressStreamResolveNextAddress(self0 uint32, result *cm.Result[OptionIPAddressShape, cm.Option[IPAddress], ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]resolve-address-stream.subscribe
+//go:noescape
+func wasmimport_ResolveAddressStreamSubscribe(self0 uint32) (result0 uint32)
+
+//go:wasmimport wasi:sockets/[email protected] resolve-addresses
+//go:noescape
+func wasmimport_ResolveAddresses(network0 uint32, name0 *uint8, name1 uint32, result *cm.Result[ResolveAddressStream, ResolveAddressStream, ErrorCode])
diff --git a/src/internal/wasi/sockets/v0.2.0/network/abi.go b/src/internal/wasi/sockets/v0.2.0/network/abi.go
index 54820be8a..0f42e109d 100644
--- a/src/internal/wasi/sockets/v0.2.0/network/abi.go
+++ b/src/internal/wasi/sockets/v0.2.0/network/abi.go
@@ -3,10 +3,12 @@
 package network
 
 import (
+	"internal/cm"
 	"unsafe"
 )
 
 // IPv6SocketAddressShape is used for storage in variant or result types.
 type IPv6SocketAddressShape struct {
+	_     cm.HostLayout
 	shape [unsafe.Sizeof(IPv6SocketAddress{})]byte
 }
diff --git a/src/internal/wasi/sockets/v0.2.0/network/network.wasm.go b/src/internal/wasi/sockets/v0.2.0/network/network.wasm.go
new file mode 100755
index 000000000..012a79ffc
--- /dev/null
+++ b/src/internal/wasi/sockets/v0.2.0/network/network.wasm.go
@@ -0,0 +1,9 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package network
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:sockets/[email protected] [resource-drop]network
+//go:noescape
+func wasmimport_NetworkResourceDrop(self0 uint32)
diff --git a/src/internal/wasi/sockets/v0.2.0/network/network.wit.go b/src/internal/wasi/sockets/v0.2.0/network/network.wit.go
index 58ad4e9b6..93a8e8200 100644
--- a/src/internal/wasi/sockets/v0.2.0/network/network.wit.go
+++ b/src/internal/wasi/sockets/v0.2.0/network/network.wit.go
@@ -27,10 +27,6 @@ func (self Network) ResourceDrop() {
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [resource-drop]network
-//go:noescape
-func wasmimport_NetworkResourceDrop(self0 uint32)
-
 // ErrorCode represents the enum "wasi:sockets/[email protected]#error-code".
 //
 // Error codes.
@@ -250,6 +246,16 @@ func (self *IPAddress) IPv6() *IPv6Address {
 	return cm.Case[IPv6Address](self, 1)
 }
 
+var stringsIPAddress = [2]string{
+	"ipv4",
+	"ipv6",
+}
+
+// String implements [fmt.Stringer], returning the variant case name of v.
+func (v IPAddress) String() string {
+	return stringsIPAddress[v.Tag()]
+}
+
 // IPv4SocketAddress represents the record "wasi:sockets/[email protected]#ipv4-socket-address".
 //
 //	record ipv4-socket-address {
@@ -257,6 +263,7 @@ func (self *IPAddress) IPv6() *IPv6Address {
 //		address: ipv4-address,
 //	}
 type IPv4SocketAddress struct {
+	_ cm.HostLayout
 	// sin_port
 	Port uint16
 
@@ -273,6 +280,7 @@ type IPv4SocketAddress struct {
 //		scope-id: u32,
 //	}
 type IPv6SocketAddress struct {
+	_ cm.HostLayout
 	// sin6_port
 	Port uint16
 
@@ -313,3 +321,13 @@ func IPSocketAddressIPv6(data IPv6SocketAddress) IPSocketAddress {
 func (self *IPSocketAddress) IPv6() *IPv6SocketAddress {
 	return cm.Case[IPv6SocketAddress](self, 1)
 }
+
+var stringsIPSocketAddress = [2]string{
+	"ipv4",
+	"ipv6",
+}
+
+// String implements [fmt.Stringer], returning the variant case name of v.
+func (v IPSocketAddress) String() string {
+	return stringsIPSocketAddress[v.Tag()]
+}
diff --git a/src/internal/wasi/sockets/v0.2.0/tcp-create-socket/tcp-create-socket.wit.go b/src/internal/wasi/sockets/v0.2.0/tcp-create-socket/tcp-create-socket.wit.go
index 44e24502b..4462a33c6 100644
--- a/src/internal/wasi/sockets/v0.2.0/tcp-create-socket/tcp-create-socket.wit.go
+++ b/src/internal/wasi/sockets/v0.2.0/tcp-create-socket/tcp-create-socket.wit.go
@@ -9,6 +9,26 @@ import (
 	"internal/wasi/sockets/v0.2.0/tcp"
 )
 
+// Network represents the imported type alias "wasi:sockets/[email protected]#network".
+//
+// See [network.Network] for more information.
+type Network = network.Network
+
+// ErrorCode represents the type alias "wasi:sockets/[email protected]#error-code".
+//
+// See [network.ErrorCode] for more information.
+type ErrorCode = network.ErrorCode
+
+// IPAddressFamily represents the type alias "wasi:sockets/[email protected]#ip-address-family".
+//
+// See [network.IPAddressFamily] for more information.
+type IPAddressFamily = network.IPAddressFamily
+
+// TCPSocket represents the imported type alias "wasi:sockets/[email protected]#tcp-socket".
+//
+// See [tcp.TCPSocket] for more information.
+type TCPSocket = tcp.TCPSocket
+
 // CreateTCPSocket represents the imported function "create-tcp-socket".
 //
 // Create a new TCP socket.
@@ -41,12 +61,8 @@ import (
 //	error-code>
 //
 //go:nosplit
-func CreateTCPSocket(addressFamily network.IPAddressFamily) (result cm.Result[tcp.TCPSocket, tcp.TCPSocket, network.ErrorCode]) {
+func CreateTCPSocket(addressFamily IPAddressFamily) (result cm.Result[TCPSocket, TCPSocket, ErrorCode]) {
 	addressFamily0 := (uint32)(addressFamily)
 	wasmimport_CreateTCPSocket((uint32)(addressFamily0), &result)
 	return
 }
-
-//go:wasmimport wasi:sockets/[email protected] create-tcp-socket
-//go:noescape
-func wasmimport_CreateTCPSocket(addressFamily0 uint32, result *cm.Result[tcp.TCPSocket, tcp.TCPSocket, network.ErrorCode])
diff --git a/src/internal/wasi/sockets/v0.2.0/tcp-create-socket/tcpcreatesocket.wasm.go b/src/internal/wasi/sockets/v0.2.0/tcp-create-socket/tcpcreatesocket.wasm.go
new file mode 100755
index 000000000..9adf8e415
--- /dev/null
+++ b/src/internal/wasi/sockets/v0.2.0/tcp-create-socket/tcpcreatesocket.wasm.go
@@ -0,0 +1,13 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package tcpcreatesocket
+
+import (
+	"internal/cm"
+)
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:sockets/[email protected] create-tcp-socket
+//go:noescape
+func wasmimport_CreateTCPSocket(addressFamily0 uint32, result *cm.Result[TCPSocket, TCPSocket, ErrorCode])
diff --git a/src/internal/wasi/sockets/v0.2.0/tcp/abi.go b/src/internal/wasi/sockets/v0.2.0/tcp/abi.go
index f6b37f118..8174d298f 100644
--- a/src/internal/wasi/sockets/v0.2.0/tcp/abi.go
+++ b/src/internal/wasi/sockets/v0.2.0/tcp/abi.go
@@ -4,23 +4,25 @@ package tcp
 
 import (
 	"internal/cm"
-	"internal/wasi/io/v0.2.0/streams"
 	"internal/wasi/sockets/v0.2.0/network"
 	"unsafe"
 )
 
 // TupleTCPSocketInputStreamOutputStreamShape is used for storage in variant or result types.
 type TupleTCPSocketInputStreamOutputStreamShape struct {
-	shape [unsafe.Sizeof(cm.Tuple3[TCPSocket, streams.InputStream, streams.OutputStream]{})]byte
+	_     cm.HostLayout
+	shape [unsafe.Sizeof(cm.Tuple3[TCPSocket, InputStream, OutputStream]{})]byte
 }
 
 // TupleInputStreamOutputStreamShape is used for storage in variant or result types.
 type TupleInputStreamOutputStreamShape struct {
-	shape [unsafe.Sizeof(cm.Tuple[streams.InputStream, streams.OutputStream]{})]byte
+	_     cm.HostLayout
+	shape [unsafe.Sizeof(cm.Tuple[InputStream, OutputStream]{})]byte
 }
 
 // IPSocketAddressShape is used for storage in variant or result types.
 type IPSocketAddressShape struct {
+	_     cm.HostLayout
 	shape [unsafe.Sizeof(network.IPSocketAddress{})]byte
 }
 
diff --git a/src/internal/wasi/sockets/v0.2.0/tcp/tcp.wasm.go b/src/internal/wasi/sockets/v0.2.0/tcp/tcp.wasm.go
new file mode 100755
index 000000000..1257fcb14
--- /dev/null
+++ b/src/internal/wasi/sockets/v0.2.0/tcp/tcp.wasm.go
@@ -0,0 +1,125 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package tcp
+
+import (
+	"internal/cm"
+)
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:sockets/[email protected] [resource-drop]tcp-socket
+//go:noescape
+func wasmimport_TCPSocketResourceDrop(self0 uint32)
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.accept
+//go:noescape
+func wasmimport_TCPSocketAccept(self0 uint32, result *cm.Result[TupleTCPSocketInputStreamOutputStreamShape, cm.Tuple3[TCPSocket, InputStream, OutputStream], ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.address-family
+//go:noescape
+func wasmimport_TCPSocketAddressFamily(self0 uint32) (result0 uint32)
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.finish-bind
+//go:noescape
+func wasmimport_TCPSocketFinishBind(self0 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.finish-connect
+//go:noescape
+func wasmimport_TCPSocketFinishConnect(self0 uint32, result *cm.Result[TupleInputStreamOutputStreamShape, cm.Tuple[InputStream, OutputStream], ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.finish-listen
+//go:noescape
+func wasmimport_TCPSocketFinishListen(self0 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.hop-limit
+//go:noescape
+func wasmimport_TCPSocketHopLimit(self0 uint32, result *cm.Result[uint8, uint8, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.is-listening
+//go:noescape
+func wasmimport_TCPSocketIsListening(self0 uint32) (result0 uint32)
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.keep-alive-count
+//go:noescape
+func wasmimport_TCPSocketKeepAliveCount(self0 uint32, result *cm.Result[uint32, uint32, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.keep-alive-enabled
+//go:noescape
+func wasmimport_TCPSocketKeepAliveEnabled(self0 uint32, result *cm.Result[bool, bool, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.keep-alive-idle-time
+//go:noescape
+func wasmimport_TCPSocketKeepAliveIdleTime(self0 uint32, result *cm.Result[uint64, Duration, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.keep-alive-interval
+//go:noescape
+func wasmimport_TCPSocketKeepAliveInterval(self0 uint32, result *cm.Result[uint64, Duration, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.local-address
+//go:noescape
+func wasmimport_TCPSocketLocalAddress(self0 uint32, result *cm.Result[IPSocketAddressShape, IPSocketAddress, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.receive-buffer-size
+//go:noescape
+func wasmimport_TCPSocketReceiveBufferSize(self0 uint32, result *cm.Result[uint64, uint64, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.remote-address
+//go:noescape
+func wasmimport_TCPSocketRemoteAddress(self0 uint32, result *cm.Result[IPSocketAddressShape, IPSocketAddress, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.send-buffer-size
+//go:noescape
+func wasmimport_TCPSocketSendBufferSize(self0 uint32, result *cm.Result[uint64, uint64, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.set-hop-limit
+//go:noescape
+func wasmimport_TCPSocketSetHopLimit(self0 uint32, value0 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.set-keep-alive-count
+//go:noescape
+func wasmimport_TCPSocketSetKeepAliveCount(self0 uint32, value0 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.set-keep-alive-enabled
+//go:noescape
+func wasmimport_TCPSocketSetKeepAliveEnabled(self0 uint32, value0 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.set-keep-alive-idle-time
+//go:noescape
+func wasmimport_TCPSocketSetKeepAliveIdleTime(self0 uint32, value0 uint64, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.set-keep-alive-interval
+//go:noescape
+func wasmimport_TCPSocketSetKeepAliveInterval(self0 uint32, value0 uint64, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.set-listen-backlog-size
+//go:noescape
+func wasmimport_TCPSocketSetListenBacklogSize(self0 uint32, value0 uint64, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.set-receive-buffer-size
+//go:noescape
+func wasmimport_TCPSocketSetReceiveBufferSize(self0 uint32, value0 uint64, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.set-send-buffer-size
+//go:noescape
+func wasmimport_TCPSocketSetSendBufferSize(self0 uint32, value0 uint64, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.shutdown
+//go:noescape
+func wasmimport_TCPSocketShutdown(self0 uint32, shutdownType0 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [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.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [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.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.start-listen
+//go:noescape
+func wasmimport_TCPSocketStartListen(self0 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.subscribe
+//go:noescape
+func wasmimport_TCPSocketSubscribe(self0 uint32) (result0 uint32)
diff --git a/src/internal/wasi/sockets/v0.2.0/tcp/tcp.wit.go b/src/internal/wasi/sockets/v0.2.0/tcp/tcp.wit.go
index 30eefbd87..5eb102cd3 100644
--- a/src/internal/wasi/sockets/v0.2.0/tcp/tcp.wit.go
+++ b/src/internal/wasi/sockets/v0.2.0/tcp/tcp.wit.go
@@ -11,6 +11,46 @@ import (
 	"internal/wasi/sockets/v0.2.0/network"
 )
 
+// InputStream represents the imported type alias "wasi:sockets/[email protected]#input-stream".
+//
+// See [streams.InputStream] for more information.
+type InputStream = streams.InputStream
+
+// OutputStream represents the imported type alias "wasi:sockets/[email protected]#output-stream".
+//
+// See [streams.OutputStream] for more information.
+type OutputStream = streams.OutputStream
+
+// Pollable represents the imported type alias "wasi:sockets/[email protected]#pollable".
+//
+// See [poll.Pollable] for more information.
+type Pollable = poll.Pollable
+
+// Duration represents the type alias "wasi:sockets/[email protected]#duration".
+//
+// See [monotonicclock.Duration] for more information.
+type Duration = monotonicclock.Duration
+
+// Network represents the imported type alias "wasi:sockets/[email protected]#network".
+//
+// See [network.Network] for more information.
+type Network = network.Network
+
+// ErrorCode represents the type alias "wasi:sockets/[email protected]#error-code".
+//
+// See [network.ErrorCode] for more information.
+type ErrorCode = network.ErrorCode
+
+// IPSocketAddress represents the type alias "wasi:sockets/[email protected]#ip-socket-address".
+//
+// See [network.IPSocketAddress] for more information.
+type IPSocketAddress = network.IPSocketAddress
+
+// IPAddressFamily represents the type alias "wasi:sockets/[email protected]#ip-address-family".
+//
+// See [network.IPAddressFamily] for more information.
+type IPAddressFamily = network.IPAddressFamily
+
 // ShutdownType represents the enum "wasi:sockets/[email protected]#shutdown-type".
 //
 //	enum shutdown-type {
@@ -81,10 +121,6 @@ func (self TCPSocket) ResourceDrop() {
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [resource-drop]tcp-socket
-//go:noescape
-func wasmimport_TCPSocketResourceDrop(self0 uint32)
-
 // Accept represents the imported method "accept".
 //
 // Accept a new client socket.
@@ -120,16 +156,12 @@ func wasmimport_TCPSocketResourceDrop(self0 uint32)
 //	accept: func() -> result<tuple<tcp-socket, input-stream, output-stream>, error-code>
 //
 //go:nosplit
-func (self TCPSocket) Accept() (result cm.Result[TupleTCPSocketInputStreamOutputStreamShape, cm.Tuple3[TCPSocket, streams.InputStream, streams.OutputStream], network.ErrorCode]) {
+func (self TCPSocket) Accept() (result cm.Result[TupleTCPSocketInputStreamOutputStreamShape, cm.Tuple3[TCPSocket, InputStream, OutputStream], ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_TCPSocketAccept((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.accept
-//go:noescape
-func wasmimport_TCPSocketAccept(self0 uint32, result *cm.Result[TupleTCPSocketInputStreamOutputStreamShape, cm.Tuple3[TCPSocket, streams.InputStream, streams.OutputStream], network.ErrorCode])
-
 // AddressFamily represents the imported method "address-family".
 //
 // Whether this is a IPv4 or IPv6 socket.
@@ -139,62 +171,46 @@ func wasmimport_TCPSocketAccept(self0 uint32, result *cm.Result[TupleTCPSocketIn
 //	address-family: func() -> ip-address-family
 //
 //go:nosplit
-func (self TCPSocket) AddressFamily() (result network.IPAddressFamily) {
+func (self TCPSocket) AddressFamily() (result IPAddressFamily) {
 	self0 := cm.Reinterpret[uint32](self)
 	result0 := wasmimport_TCPSocketAddressFamily((uint32)(self0))
 	result = (network.IPAddressFamily)((uint32)(result0))
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [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.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
+func (self TCPSocket) FinishBind() (result cm.Result[ErrorCode, struct{}, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_TCPSocketFinishBind((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.finish-bind
-//go:noescape
-func wasmimport_TCPSocketFinishBind(self0 uint32, result *cm.Result[network.ErrorCode, 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.Result[TupleInputStreamOutputStreamShape, cm.Tuple[streams.InputStream, streams.OutputStream], network.ErrorCode]) {
+func (self TCPSocket) FinishConnect() (result cm.Result[TupleInputStreamOutputStreamShape, cm.Tuple[InputStream, OutputStream], ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_TCPSocketFinishConnect((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.finish-connect
-//go:noescape
-func wasmimport_TCPSocketFinishConnect(self0 uint32, result *cm.Result[TupleInputStreamOutputStreamShape, 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.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
+func (self TCPSocket) FinishListen() (result cm.Result[ErrorCode, struct{}, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_TCPSocketFinishListen((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.finish-listen
-//go:noescape
-func wasmimport_TCPSocketFinishListen(self0 uint32, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
 // HopLimit represents the imported method "hop-limit".
 //
 // Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options.
@@ -207,16 +223,12 @@ func wasmimport_TCPSocketFinishListen(self0 uint32, result *cm.Result[network.Er
 //	hop-limit: func() -> result<u8, error-code>
 //
 //go:nosplit
-func (self TCPSocket) HopLimit() (result cm.Result[uint8, uint8, network.ErrorCode]) {
+func (self TCPSocket) HopLimit() (result cm.Result[uint8, uint8, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_TCPSocketHopLimit((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.hop-limit
-//go:noescape
-func wasmimport_TCPSocketHopLimit(self0 uint32, result *cm.Result[uint8, uint8, network.ErrorCode])
-
 // IsListening represents the imported method "is-listening".
 //
 // Whether the socket is in the `listening` state.
@@ -233,10 +245,6 @@ func (self TCPSocket) IsListening() (result bool) {
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [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.
@@ -255,16 +263,12 @@ func wasmimport_TCPSocketIsListening(self0 uint32) (result0 uint32)
 //	keep-alive-count: func() -> result<u32, error-code>
 //
 //go:nosplit
-func (self TCPSocket) KeepAliveCount() (result cm.Result[uint32, uint32, network.ErrorCode]) {
+func (self TCPSocket) KeepAliveCount() (result cm.Result[uint32, uint32, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_TCPSocketKeepAliveCount((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.keep-alive-count
-//go:noescape
-func wasmimport_TCPSocketKeepAliveCount(self0 uint32, result *cm.Result[uint32, uint32, network.ErrorCode])
-
 // KeepAliveEnabled represents the imported method "keep-alive-enabled".
 //
 // Enables or disables keepalive.
@@ -281,16 +285,12 @@ func wasmimport_TCPSocketKeepAliveCount(self0 uint32, result *cm.Result[uint32,
 //	keep-alive-enabled: func() -> result<bool, error-code>
 //
 //go:nosplit
-func (self TCPSocket) KeepAliveEnabled() (result cm.Result[bool, bool, network.ErrorCode]) {
+func (self TCPSocket) KeepAliveEnabled() (result cm.Result[bool, bool, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_TCPSocketKeepAliveEnabled((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.keep-alive-enabled
-//go:noescape
-func wasmimport_TCPSocketKeepAliveEnabled(self0 uint32, result *cm.Result[bool, 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
@@ -310,16 +310,12 @@ func wasmimport_TCPSocketKeepAliveEnabled(self0 uint32, result *cm.Result[bool,
 //	keep-alive-idle-time: func() -> result<duration, error-code>
 //
 //go:nosplit
-func (self TCPSocket) KeepAliveIdleTime() (result cm.Result[uint64, monotonicclock.Duration, network.ErrorCode]) {
+func (self TCPSocket) KeepAliveIdleTime() (result cm.Result[uint64, Duration, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_TCPSocketKeepAliveIdleTime((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.keep-alive-idle-time
-//go:noescape
-func wasmimport_TCPSocketKeepAliveIdleTime(self0 uint32, result *cm.Result[uint64, monotonicclock.Duration, network.ErrorCode])
-
 // KeepAliveInterval represents the imported method "keep-alive-interval".
 //
 // The time between keepalive packets.
@@ -338,16 +334,12 @@ func wasmimport_TCPSocketKeepAliveIdleTime(self0 uint32, result *cm.Result[uint6
 //	keep-alive-interval: func() -> result<duration, error-code>
 //
 //go:nosplit
-func (self TCPSocket) KeepAliveInterval() (result cm.Result[uint64, monotonicclock.Duration, network.ErrorCode]) {
+func (self TCPSocket) KeepAliveInterval() (result cm.Result[uint64, Duration, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_TCPSocketKeepAliveInterval((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.keep-alive-interval
-//go:noescape
-func wasmimport_TCPSocketKeepAliveInterval(self0 uint32, result *cm.Result[uint64, monotonicclock.Duration, network.ErrorCode])
-
 // LocalAddress represents the imported method "local-address".
 //
 // Get the bound local address.
@@ -371,16 +363,12 @@ func wasmimport_TCPSocketKeepAliveInterval(self0 uint32, result *cm.Result[uint6
 //	local-address: func() -> result<ip-socket-address, error-code>
 //
 //go:nosplit
-func (self TCPSocket) LocalAddress() (result cm.Result[IPSocketAddressShape, network.IPSocketAddress, network.ErrorCode]) {
+func (self TCPSocket) LocalAddress() (result cm.Result[IPSocketAddressShape, IPSocketAddress, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_TCPSocketLocalAddress((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.local-address
-//go:noescape
-func wasmimport_TCPSocketLocalAddress(self0 uint32, result *cm.Result[IPSocketAddressShape, network.IPSocketAddress, network.ErrorCode])
-
 // ReceiveBufferSize represents the imported method "receive-buffer-size".
 //
 // The kernel buffer space reserved for sends/receives on this socket.
@@ -399,16 +387,12 @@ func wasmimport_TCPSocketLocalAddress(self0 uint32, result *cm.Result[IPSocketAd
 //	receive-buffer-size: func() -> result<u64, error-code>
 //
 //go:nosplit
-func (self TCPSocket) ReceiveBufferSize() (result cm.Result[uint64, uint64, network.ErrorCode]) {
+func (self TCPSocket) ReceiveBufferSize() (result cm.Result[uint64, uint64, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_TCPSocketReceiveBufferSize((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.receive-buffer-size
-//go:noescape
-func wasmimport_TCPSocketReceiveBufferSize(self0 uint32, result *cm.Result[uint64, uint64, network.ErrorCode])
-
 // RemoteAddress represents the imported method "remote-address".
 //
 // Get the remote address.
@@ -425,111 +409,83 @@ func wasmimport_TCPSocketReceiveBufferSize(self0 uint32, result *cm.Result[uint6
 //	remote-address: func() -> result<ip-socket-address, error-code>
 //
 //go:nosplit
-func (self TCPSocket) RemoteAddress() (result cm.Result[IPSocketAddressShape, network.IPSocketAddress, network.ErrorCode]) {
+func (self TCPSocket) RemoteAddress() (result cm.Result[IPSocketAddressShape, IPSocketAddress, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_TCPSocketRemoteAddress((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.remote-address
-//go:noescape
-func wasmimport_TCPSocketRemoteAddress(self0 uint32, result *cm.Result[IPSocketAddressShape, 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.Result[uint64, uint64, network.ErrorCode]) {
+func (self TCPSocket) SendBufferSize() (result cm.Result[uint64, uint64, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_TCPSocketSendBufferSize((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.send-buffer-size
-//go:noescape
-func wasmimport_TCPSocketSendBufferSize(self0 uint32, result *cm.Result[uint64, 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.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
+func (self TCPSocket) SetHopLimit(value uint8) (result cm.Result[ErrorCode, struct{}, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	value0 := (uint32)(value)
 	wasmimport_TCPSocketSetHopLimit((uint32)(self0), (uint32)(value0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.set-hop-limit
-//go:noescape
-func wasmimport_TCPSocketSetHopLimit(self0 uint32, value0 uint32, result *cm.Result[network.ErrorCode, 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.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
+func (self TCPSocket) SetKeepAliveCount(value uint32) (result cm.Result[ErrorCode, struct{}, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	value0 := (uint32)(value)
 	wasmimport_TCPSocketSetKeepAliveCount((uint32)(self0), (uint32)(value0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.set-keep-alive-count
-//go:noescape
-func wasmimport_TCPSocketSetKeepAliveCount(self0 uint32, value0 uint32, result *cm.Result[network.ErrorCode, 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.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
+func (self TCPSocket) SetKeepAliveEnabled(value bool) (result cm.Result[ErrorCode, struct{}, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	value0 := cm.BoolToU32(value)
 	wasmimport_TCPSocketSetKeepAliveEnabled((uint32)(self0), (uint32)(value0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.set-keep-alive-enabled
-//go:noescape
-func wasmimport_TCPSocketSetKeepAliveEnabled(self0 uint32, value0 uint32, result *cm.Result[network.ErrorCode, 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.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
+func (self TCPSocket) SetKeepAliveIdleTime(value Duration) (result cm.Result[ErrorCode, struct{}, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	value0 := (uint64)(value)
 	wasmimport_TCPSocketSetKeepAliveIdleTime((uint32)(self0), (uint64)(value0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.set-keep-alive-idle-time
-//go:noescape
-func wasmimport_TCPSocketSetKeepAliveIdleTime(self0 uint32, value0 uint64, result *cm.Result[network.ErrorCode, 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.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
+func (self TCPSocket) SetKeepAliveInterval(value Duration) (result cm.Result[ErrorCode, struct{}, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	value0 := (uint64)(value)
 	wasmimport_TCPSocketSetKeepAliveInterval((uint32)(self0), (uint64)(value0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.set-keep-alive-interval
-//go:noescape
-func wasmimport_TCPSocketSetKeepAliveInterval(self0 uint32, value0 uint64, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
 // SetListenBacklogSize represents the imported method "set-listen-backlog-size".
 //
 // Hints the desired listen queue size. Implementations are free to ignore this.
@@ -548,49 +504,37 @@ func wasmimport_TCPSocketSetKeepAliveInterval(self0 uint32, value0 uint64, resul
 //	set-listen-backlog-size: func(value: u64) -> result<_, error-code>
 //
 //go:nosplit
-func (self TCPSocket) SetListenBacklogSize(value uint64) (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
+func (self TCPSocket) SetListenBacklogSize(value uint64) (result cm.Result[ErrorCode, struct{}, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	value0 := (uint64)(value)
 	wasmimport_TCPSocketSetListenBacklogSize((uint32)(self0), (uint64)(value0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.set-listen-backlog-size
-//go:noescape
-func wasmimport_TCPSocketSetListenBacklogSize(self0 uint32, value0 uint64, result *cm.Result[network.ErrorCode, 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.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
+func (self TCPSocket) SetReceiveBufferSize(value uint64) (result cm.Result[ErrorCode, struct{}, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	value0 := (uint64)(value)
 	wasmimport_TCPSocketSetReceiveBufferSize((uint32)(self0), (uint64)(value0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.set-receive-buffer-size
-//go:noescape
-func wasmimport_TCPSocketSetReceiveBufferSize(self0 uint32, value0 uint64, result *cm.Result[network.ErrorCode, 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.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
+func (self TCPSocket) SetSendBufferSize(value uint64) (result cm.Result[ErrorCode, struct{}, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	value0 := (uint64)(value)
 	wasmimport_TCPSocketSetSendBufferSize((uint32)(self0), (uint64)(value0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.set-send-buffer-size
-//go:noescape
-func wasmimport_TCPSocketSetSendBufferSize(self0 uint32, value0 uint64, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
 // Shutdown represents the imported method "shutdown".
 //
 // Initiate a graceful shutdown.
@@ -620,17 +564,13 @@ func wasmimport_TCPSocketSetSendBufferSize(self0 uint32, value0 uint64, result *
 //	shutdown: func(shutdown-type: shutdown-type) -> result<_, error-code>
 //
 //go:nosplit
-func (self TCPSocket) Shutdown(shutdownType ShutdownType) (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
+func (self TCPSocket) Shutdown(shutdownType ShutdownType) (result cm.Result[ErrorCode, struct{}, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	shutdownType0 := (uint32)(shutdownType)
 	wasmimport_TCPSocketShutdown((uint32)(self0), (uint32)(shutdownType0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.shutdown
-//go:noescape
-func wasmimport_TCPSocketShutdown(self0 uint32, shutdownType0 uint32, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
 // StartBind represents the imported method "start-bind".
 //
 // Bind the socket to a specific network on the provided IP address and port.
@@ -685,7 +625,7 @@ func wasmimport_TCPSocketShutdown(self0 uint32, shutdownType0 uint32, result *cm
 //	result<_, error-code>
 //
 //go:nosplit
-func (self TCPSocket) StartBind(network_ network.Network, localAddress network.IPSocketAddress) (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
+func (self TCPSocket) StartBind(network_ Network, localAddress IPSocketAddress) (result cm.Result[ErrorCode, struct{}, 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)
@@ -693,10 +633,6 @@ func (self TCPSocket) StartBind(network_ network.Network, localAddress network.I
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [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.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
 // StartConnect represents the imported method "start-connect".
 //
 // Connect to a remote endpoint.
@@ -757,7 +693,7 @@ func wasmimport_TCPSocketStartBind(self0 uint32, network0 uint32, localAddress0
 //	-> result<_, error-code>
 //
 //go:nosplit
-func (self TCPSocket) StartConnect(network_ network.Network, remoteAddress network.IPSocketAddress) (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
+func (self TCPSocket) StartConnect(network_ Network, remoteAddress IPSocketAddress) (result cm.Result[ErrorCode, struct{}, 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)
@@ -765,10 +701,6 @@ func (self TCPSocket) StartConnect(network_ network.Network, remoteAddress netwo
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [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.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
 // StartListen represents the imported method "start-listen".
 //
 // Start listening for new connections.
@@ -803,16 +735,12 @@ func wasmimport_TCPSocketStartConnect(self0 uint32, network0 uint32, remoteAddre
 //	start-listen: func() -> result<_, error-code>
 //
 //go:nosplit
-func (self TCPSocket) StartListen() (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
+func (self TCPSocket) StartListen() (result cm.Result[ErrorCode, struct{}, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_TCPSocketStartListen((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.start-listen
-//go:noescape
-func wasmimport_TCPSocketStartListen(self0 uint32, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
 // Subscribe represents the imported method "subscribe".
 //
 // Create a `pollable` which can be used to poll for, or block on,
@@ -836,13 +764,9 @@ func wasmimport_TCPSocketStartListen(self0 uint32, result *cm.Result[network.Err
 //	subscribe: func() -> pollable
 //
 //go:nosplit
-func (self TCPSocket) Subscribe() (result poll.Pollable) {
+func (self TCPSocket) Subscribe() (result Pollable) {
 	self0 := cm.Reinterpret[uint32](self)
 	result0 := wasmimport_TCPSocketSubscribe((uint32)(self0))
-	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
+	result = cm.Reinterpret[Pollable]((uint32)(result0))
 	return
 }
-
-//go:wasmimport wasi:sockets/[email protected] [method]tcp-socket.subscribe
-//go:noescape
-func wasmimport_TCPSocketSubscribe(self0 uint32) (result0 uint32)
diff --git a/src/internal/wasi/sockets/v0.2.0/udp-create-socket/udp-create-socket.wit.go b/src/internal/wasi/sockets/v0.2.0/udp-create-socket/udp-create-socket.wit.go
index dc21be4d9..c0f31d725 100644
--- a/src/internal/wasi/sockets/v0.2.0/udp-create-socket/udp-create-socket.wit.go
+++ b/src/internal/wasi/sockets/v0.2.0/udp-create-socket/udp-create-socket.wit.go
@@ -9,6 +9,26 @@ import (
 	"internal/wasi/sockets/v0.2.0/udp"
 )
 
+// Network represents the imported type alias "wasi:sockets/[email protected]#network".
+//
+// See [network.Network] for more information.
+type Network = network.Network
+
+// ErrorCode represents the type alias "wasi:sockets/[email protected]#error-code".
+//
+// See [network.ErrorCode] for more information.
+type ErrorCode = network.ErrorCode
+
+// IPAddressFamily represents the type alias "wasi:sockets/[email protected]#ip-address-family".
+//
+// See [network.IPAddressFamily] for more information.
+type IPAddressFamily = network.IPAddressFamily
+
+// UDPSocket represents the imported type alias "wasi:sockets/[email protected]#udp-socket".
+//
+// See [udp.UDPSocket] for more information.
+type UDPSocket = udp.UDPSocket
+
 // CreateUDPSocket represents the imported function "create-udp-socket".
 //
 // Create a new UDP socket.
@@ -41,12 +61,8 @@ import (
 //	error-code>
 //
 //go:nosplit
-func CreateUDPSocket(addressFamily network.IPAddressFamily) (result cm.Result[udp.UDPSocket, udp.UDPSocket, network.ErrorCode]) {
+func CreateUDPSocket(addressFamily IPAddressFamily) (result cm.Result[UDPSocket, UDPSocket, ErrorCode]) {
 	addressFamily0 := (uint32)(addressFamily)
 	wasmimport_CreateUDPSocket((uint32)(addressFamily0), &result)
 	return
 }
-
-//go:wasmimport wasi:sockets/[email protected] create-udp-socket
-//go:noescape
-func wasmimport_CreateUDPSocket(addressFamily0 uint32, result *cm.Result[udp.UDPSocket, udp.UDPSocket, network.ErrorCode])
diff --git a/src/internal/wasi/sockets/v0.2.0/udp-create-socket/udpcreatesocket.wasm.go b/src/internal/wasi/sockets/v0.2.0/udp-create-socket/udpcreatesocket.wasm.go
new file mode 100755
index 000000000..0f56e12bb
--- /dev/null
+++ b/src/internal/wasi/sockets/v0.2.0/udp-create-socket/udpcreatesocket.wasm.go
@@ -0,0 +1,13 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package udpcreatesocket
+
+import (
+	"internal/cm"
+)
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:sockets/[email protected] create-udp-socket
+//go:noescape
+func wasmimport_CreateUDPSocket(addressFamily0 uint32, result *cm.Result[UDPSocket, UDPSocket, ErrorCode])
diff --git a/src/internal/wasi/sockets/v0.2.0/udp/abi.go b/src/internal/wasi/sockets/v0.2.0/udp/abi.go
index 23a96c983..71d00f9d6 100644
--- a/src/internal/wasi/sockets/v0.2.0/udp/abi.go
+++ b/src/internal/wasi/sockets/v0.2.0/udp/abi.go
@@ -10,6 +10,7 @@ import (
 
 // IPSocketAddressShape is used for storage in variant or result types.
 type IPSocketAddressShape struct {
+	_     cm.HostLayout
 	shape [unsafe.Sizeof(network.IPSocketAddress{})]byte
 }
 
@@ -76,10 +77,11 @@ func lower_IPSocketAddress(v network.IPSocketAddress) (f0 uint32, f1 uint32, f2
 
 // TupleIncomingDatagramStreamOutgoingDatagramStreamShape is used for storage in variant or result types.
 type TupleIncomingDatagramStreamOutgoingDatagramStreamShape struct {
+	_     cm.HostLayout
 	shape [unsafe.Sizeof(cm.Tuple[IncomingDatagramStream, OutgoingDatagramStream]{})]byte
 }
 
-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) {
+func lower_OptionIPSocketAddress(v cm.Option[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
diff --git a/src/internal/wasi/sockets/v0.2.0/udp/udp.wasm.go b/src/internal/wasi/sockets/v0.2.0/udp/udp.wasm.go
new file mode 100755
index 000000000..3e3b9e554
--- /dev/null
+++ b/src/internal/wasi/sockets/v0.2.0/udp/udp.wasm.go
@@ -0,0 +1,93 @@
+// Code generated by wit-bindgen-go. DO NOT EDIT.
+
+package udp
+
+import (
+	"internal/cm"
+)
+
+// This file contains wasmimport and wasmexport declarations for "wasi:[email protected]".
+
+//go:wasmimport wasi:sockets/[email protected] [resource-drop]udp-socket
+//go:noescape
+func wasmimport_UDPSocketResourceDrop(self0 uint32)
+
+//go:wasmimport wasi:sockets/[email protected] [method]udp-socket.address-family
+//go:noescape
+func wasmimport_UDPSocketAddressFamily(self0 uint32) (result0 uint32)
+
+//go:wasmimport wasi:sockets/[email protected] [method]udp-socket.finish-bind
+//go:noescape
+func wasmimport_UDPSocketFinishBind(self0 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]udp-socket.local-address
+//go:noescape
+func wasmimport_UDPSocketLocalAddress(self0 uint32, result *cm.Result[IPSocketAddressShape, IPSocketAddress, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]udp-socket.receive-buffer-size
+//go:noescape
+func wasmimport_UDPSocketReceiveBufferSize(self0 uint32, result *cm.Result[uint64, uint64, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]udp-socket.remote-address
+//go:noescape
+func wasmimport_UDPSocketRemoteAddress(self0 uint32, result *cm.Result[IPSocketAddressShape, IPSocketAddress, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]udp-socket.send-buffer-size
+//go:noescape
+func wasmimport_UDPSocketSendBufferSize(self0 uint32, result *cm.Result[uint64, uint64, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]udp-socket.set-receive-buffer-size
+//go:noescape
+func wasmimport_UDPSocketSetReceiveBufferSize(self0 uint32, value0 uint64, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]udp-socket.set-send-buffer-size
+//go:noescape
+func wasmimport_UDPSocketSetSendBufferSize(self0 uint32, value0 uint64, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]udp-socket.set-unicast-hop-limit
+//go:noescape
+func wasmimport_UDPSocketSetUnicastHopLimit(self0 uint32, value0 uint32, result *cm.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [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.Result[ErrorCode, struct{}, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [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.Result[TupleIncomingDatagramStreamOutgoingDatagramStreamShape, cm.Tuple[IncomingDatagramStream, OutgoingDatagramStream], ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]udp-socket.subscribe
+//go:noescape
+func wasmimport_UDPSocketSubscribe(self0 uint32) (result0 uint32)
+
+//go:wasmimport wasi:sockets/[email protected] [method]udp-socket.unicast-hop-limit
+//go:noescape
+func wasmimport_UDPSocketUnicastHopLimit(self0 uint32, result *cm.Result[uint8, uint8, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [resource-drop]incoming-datagram-stream
+//go:noescape
+func wasmimport_IncomingDatagramStreamResourceDrop(self0 uint32)
+
+//go:wasmimport wasi:sockets/[email protected] [method]incoming-datagram-stream.receive
+//go:noescape
+func wasmimport_IncomingDatagramStreamReceive(self0 uint32, maxResults0 uint64, result *cm.Result[cm.List[IncomingDatagram], cm.List[IncomingDatagram], ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]incoming-datagram-stream.subscribe
+//go:noescape
+func wasmimport_IncomingDatagramStreamSubscribe(self0 uint32) (result0 uint32)
+
+//go:wasmimport wasi:sockets/[email protected] [resource-drop]outgoing-datagram-stream
+//go:noescape
+func wasmimport_OutgoingDatagramStreamResourceDrop(self0 uint32)
+
+//go:wasmimport wasi:sockets/[email protected] [method]outgoing-datagram-stream.check-send
+//go:noescape
+func wasmimport_OutgoingDatagramStreamCheckSend(self0 uint32, result *cm.Result[uint64, uint64, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]outgoing-datagram-stream.send
+//go:noescape
+func wasmimport_OutgoingDatagramStreamSend(self0 uint32, datagrams0 *OutgoingDatagram, datagrams1 uint32, result *cm.Result[uint64, uint64, ErrorCode])
+
+//go:wasmimport wasi:sockets/[email protected] [method]outgoing-datagram-stream.subscribe
+//go:noescape
+func wasmimport_OutgoingDatagramStreamSubscribe(self0 uint32) (result0 uint32)
diff --git a/src/internal/wasi/sockets/v0.2.0/udp/udp.wit.go b/src/internal/wasi/sockets/v0.2.0/udp/udp.wit.go
index 268a8f6c8..f773fa48d 100644
--- a/src/internal/wasi/sockets/v0.2.0/udp/udp.wit.go
+++ b/src/internal/wasi/sockets/v0.2.0/udp/udp.wit.go
@@ -9,6 +9,31 @@ import (
 	"internal/wasi/sockets/v0.2.0/network"
 )
 
+// Pollable represents the imported type alias "wasi:sockets/[email protected]#pollable".
+//
+// See [poll.Pollable] for more information.
+type Pollable = poll.Pollable
+
+// Network represents the imported type alias "wasi:sockets/[email protected]#network".
+//
+// See [network.Network] for more information.
+type Network = network.Network
+
+// ErrorCode represents the type alias "wasi:sockets/[email protected]#error-code".
+//
+// See [network.ErrorCode] for more information.
+type ErrorCode = network.ErrorCode
+
+// IPSocketAddress represents the type alias "wasi:sockets/[email protected]#ip-socket-address".
+//
+// See [network.IPSocketAddress] for more information.
+type IPSocketAddress = network.IPSocketAddress
+
+// IPAddressFamily represents the type alias "wasi:sockets/[email protected]#ip-address-family".
+//
+// See [network.IPAddressFamily] for more information.
+type IPAddressFamily = network.IPAddressFamily
+
 // IncomingDatagram represents the record "wasi:sockets/[email protected]#incoming-datagram".
 //
 // A received datagram.
@@ -18,6 +43,7 @@ import (
 //		remote-address: ip-socket-address,
 //	}
 type IncomingDatagram struct {
+	_ cm.HostLayout
 	// The payload.
 	//
 	// Theoretical max size: ~64 KiB. In practice, typically less than 1500 bytes.
@@ -29,7 +55,7 @@ type IncomingDatagram struct {
 	// with, if any.
 	//
 	// Equivalent to the `src_addr` out parameter of `recvfrom`.
-	RemoteAddress network.IPSocketAddress
+	RemoteAddress IPSocketAddress
 }
 
 // OutgoingDatagram represents the record "wasi:sockets/[email protected]#outgoing-datagram".
@@ -41,6 +67,7 @@ type IncomingDatagram struct {
 //		remote-address: option<ip-socket-address>,
 //	}
 type OutgoingDatagram struct {
+	_ cm.HostLayout
 	// The payload.
 	Data cm.List[uint8]
 
@@ -53,7 +80,7 @@ type OutgoingDatagram struct {
 	//
 	// 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]
+	RemoteAddress cm.Option[IPSocketAddress]
 }
 
 // UDPSocket represents the imported resource "wasi:sockets/[email protected]#udp-socket".
@@ -74,10 +101,6 @@ func (self UDPSocket) ResourceDrop() {
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [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.
@@ -87,32 +110,24 @@ func wasmimport_UDPSocketResourceDrop(self0 uint32)
 //	address-family: func() -> ip-address-family
 //
 //go:nosplit
-func (self UDPSocket) AddressFamily() (result network.IPAddressFamily) {
+func (self UDPSocket) AddressFamily() (result IPAddressFamily) {
 	self0 := cm.Reinterpret[uint32](self)
 	result0 := wasmimport_UDPSocketAddressFamily((uint32)(self0))
 	result = (network.IPAddressFamily)((uint32)(result0))
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [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.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
+func (self UDPSocket) FinishBind() (result cm.Result[ErrorCode, struct{}, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_UDPSocketFinishBind((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]udp-socket.finish-bind
-//go:noescape
-func wasmimport_UDPSocketFinishBind(self0 uint32, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
 // LocalAddress represents the imported method "local-address".
 //
 // Get the current bound address.
@@ -136,16 +151,12 @@ func wasmimport_UDPSocketFinishBind(self0 uint32, result *cm.Result[network.Erro
 //	local-address: func() -> result<ip-socket-address, error-code>
 //
 //go:nosplit
-func (self UDPSocket) LocalAddress() (result cm.Result[IPSocketAddressShape, network.IPSocketAddress, network.ErrorCode]) {
+func (self UDPSocket) LocalAddress() (result cm.Result[IPSocketAddressShape, IPSocketAddress, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_UDPSocketLocalAddress((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]udp-socket.local-address
-//go:noescape
-func wasmimport_UDPSocketLocalAddress(self0 uint32, result *cm.Result[IPSocketAddressShape, network.IPSocketAddress, network.ErrorCode])
-
 // ReceiveBufferSize represents the imported method "receive-buffer-size".
 //
 // The kernel buffer space reserved for sends/receives on this socket.
@@ -164,16 +175,12 @@ func wasmimport_UDPSocketLocalAddress(self0 uint32, result *cm.Result[IPSocketAd
 //	receive-buffer-size: func() -> result<u64, error-code>
 //
 //go:nosplit
-func (self UDPSocket) ReceiveBufferSize() (result cm.Result[uint64, uint64, network.ErrorCode]) {
+func (self UDPSocket) ReceiveBufferSize() (result cm.Result[uint64, uint64, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_UDPSocketReceiveBufferSize((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]udp-socket.receive-buffer-size
-//go:noescape
-func wasmimport_UDPSocketReceiveBufferSize(self0 uint32, result *cm.Result[uint64, uint64, network.ErrorCode])
-
 // RemoteAddress represents the imported method "remote-address".
 //
 // Get the address the socket is currently streaming to.
@@ -190,79 +197,59 @@ func wasmimport_UDPSocketReceiveBufferSize(self0 uint32, result *cm.Result[uint6
 //	remote-address: func() -> result<ip-socket-address, error-code>
 //
 //go:nosplit
-func (self UDPSocket) RemoteAddress() (result cm.Result[IPSocketAddressShape, network.IPSocketAddress, network.ErrorCode]) {
+func (self UDPSocket) RemoteAddress() (result cm.Result[IPSocketAddressShape, IPSocketAddress, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_UDPSocketRemoteAddress((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]udp-socket.remote-address
-//go:noescape
-func wasmimport_UDPSocketRemoteAddress(self0 uint32, result *cm.Result[IPSocketAddressShape, 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.Result[uint64, uint64, network.ErrorCode]) {
+func (self UDPSocket) SendBufferSize() (result cm.Result[uint64, uint64, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_UDPSocketSendBufferSize((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]udp-socket.send-buffer-size
-//go:noescape
-func wasmimport_UDPSocketSendBufferSize(self0 uint32, result *cm.Result[uint64, 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.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
+func (self UDPSocket) SetReceiveBufferSize(value uint64) (result cm.Result[ErrorCode, struct{}, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	value0 := (uint64)(value)
 	wasmimport_UDPSocketSetReceiveBufferSize((uint32)(self0), (uint64)(value0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]udp-socket.set-receive-buffer-size
-//go:noescape
-func wasmimport_UDPSocketSetReceiveBufferSize(self0 uint32, value0 uint64, result *cm.Result[network.ErrorCode, 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.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
+func (self UDPSocket) SetSendBufferSize(value uint64) (result cm.Result[ErrorCode, struct{}, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	value0 := (uint64)(value)
 	wasmimport_UDPSocketSetSendBufferSize((uint32)(self0), (uint64)(value0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]udp-socket.set-send-buffer-size
-//go:noescape
-func wasmimport_UDPSocketSetSendBufferSize(self0 uint32, value0 uint64, result *cm.Result[network.ErrorCode, 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.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
+func (self UDPSocket) SetUnicastHopLimit(value uint8) (result cm.Result[ErrorCode, struct{}, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	value0 := (uint32)(value)
 	wasmimport_UDPSocketSetUnicastHopLimit((uint32)(self0), (uint32)(value0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]udp-socket.set-unicast-hop-limit
-//go:noescape
-func wasmimport_UDPSocketSetUnicastHopLimit(self0 uint32, value0 uint32, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
 // StartBind represents the imported method "start-bind".
 //
 // Bind the socket to a specific network on the provided IP address and port.
@@ -301,7 +288,7 @@ func wasmimport_UDPSocketSetUnicastHopLimit(self0 uint32, value0 uint32, result
 //	result<_, error-code>
 //
 //go:nosplit
-func (self UDPSocket) StartBind(network_ network.Network, localAddress network.IPSocketAddress) (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
+func (self UDPSocket) StartBind(network_ Network, localAddress IPSocketAddress) (result cm.Result[ErrorCode, struct{}, 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)
@@ -309,10 +296,6 @@ func (self UDPSocket) StartBind(network_ network.Network, localAddress network.I
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [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.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
 // Stream represents the imported method "stream".
 //
 // Set up inbound & outbound communication channels, optionally to a specific peer.
@@ -370,17 +353,13 @@ func wasmimport_UDPSocketStartBind(self0 uint32, network0 uint32, localAddress0
 //	outgoing-datagram-stream>, error-code>
 //
 //go:nosplit
-func (self UDPSocket) Stream(remoteAddress cm.Option[network.IPSocketAddress]) (result cm.Result[TupleIncomingDatagramStreamOutgoingDatagramStreamShape, cm.Tuple[IncomingDatagramStream, OutgoingDatagramStream], network.ErrorCode]) {
+func (self UDPSocket) Stream(remoteAddress cm.Option[IPSocketAddress]) (result cm.Result[TupleIncomingDatagramStreamOutgoingDatagramStreamShape, cm.Tuple[IncomingDatagramStream, OutgoingDatagramStream], 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/[email protected] [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.Result[TupleIncomingDatagramStreamOutgoingDatagramStreamShape, 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.
@@ -391,17 +370,13 @@ func wasmimport_UDPSocketStream(self0 uint32, remoteAddress0 uint32, remoteAddre
 //	subscribe: func() -> pollable
 //
 //go:nosplit
-func (self UDPSocket) Subscribe() (result poll.Pollable) {
+func (self UDPSocket) Subscribe() (result Pollable) {
 	self0 := cm.Reinterpret[uint32](self)
 	result0 := wasmimport_UDPSocketSubscribe((uint32)(self0))
-	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
+	result = cm.Reinterpret[Pollable]((uint32)(result0))
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [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.
@@ -414,16 +389,12 @@ func wasmimport_UDPSocketSubscribe(self0 uint32) (result0 uint32)
 //	unicast-hop-limit: func() -> result<u8, error-code>
 //
 //go:nosplit
-func (self UDPSocket) UnicastHopLimit() (result cm.Result[uint8, uint8, network.ErrorCode]) {
+func (self UDPSocket) UnicastHopLimit() (result cm.Result[uint8, uint8, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_UDPSocketUnicastHopLimit((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]udp-socket.unicast-hop-limit
-//go:noescape
-func wasmimport_UDPSocketUnicastHopLimit(self0 uint32, result *cm.Result[uint8, uint8, network.ErrorCode])
-
 // IncomingDatagramStream represents the imported resource "wasi:sockets/[email protected]#incoming-datagram-stream".
 //
 //	resource incoming-datagram-stream
@@ -440,10 +411,6 @@ func (self IncomingDatagramStream) ResourceDrop() {
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [resource-drop]incoming-datagram-stream
-//go:noescape
-func wasmimport_IncomingDatagramStreamResourceDrop(self0 uint32)
-
 // Receive represents the imported method "receive".
 //
 // Receive messages on the socket.
@@ -475,17 +442,13 @@ func wasmimport_IncomingDatagramStreamResourceDrop(self0 uint32)
 //	receive: func(max-results: u64) -> result<list<incoming-datagram>, error-code>
 //
 //go:nosplit
-func (self IncomingDatagramStream) Receive(maxResults uint64) (result cm.Result[cm.List[IncomingDatagram], cm.List[IncomingDatagram], network.ErrorCode]) {
+func (self IncomingDatagramStream) Receive(maxResults uint64) (result cm.Result[cm.List[IncomingDatagram], cm.List[IncomingDatagram], ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	maxResults0 := (uint64)(maxResults)
 	wasmimport_IncomingDatagramStreamReceive((uint32)(self0), (uint64)(maxResults0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]incoming-datagram-stream.receive
-//go:noescape
-func wasmimport_IncomingDatagramStreamReceive(self0 uint32, maxResults0 uint64, result *cm.Result[cm.List[IncomingDatagram], 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.
@@ -496,17 +459,13 @@ func wasmimport_IncomingDatagramStreamReceive(self0 uint32, maxResults0 uint64,
 //	subscribe: func() -> pollable
 //
 //go:nosplit
-func (self IncomingDatagramStream) Subscribe() (result poll.Pollable) {
+func (self IncomingDatagramStream) Subscribe() (result Pollable) {
 	self0 := cm.Reinterpret[uint32](self)
 	result0 := wasmimport_IncomingDatagramStreamSubscribe((uint32)(self0))
-	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
+	result = cm.Reinterpret[Pollable]((uint32)(result0))
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]incoming-datagram-stream.subscribe
-//go:noescape
-func wasmimport_IncomingDatagramStreamSubscribe(self0 uint32) (result0 uint32)
-
 // OutgoingDatagramStream represents the imported resource "wasi:sockets/[email protected]#outgoing-datagram-stream".
 //
 //	resource outgoing-datagram-stream
@@ -523,10 +482,6 @@ func (self OutgoingDatagramStream) ResourceDrop() {
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [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.
@@ -544,16 +499,12 @@ func wasmimport_OutgoingDatagramStreamResourceDrop(self0 uint32)
 //	check-send: func() -> result<u64, error-code>
 //
 //go:nosplit
-func (self OutgoingDatagramStream) CheckSend() (result cm.Result[uint64, uint64, network.ErrorCode]) {
+func (self OutgoingDatagramStream) CheckSend() (result cm.Result[uint64, uint64, ErrorCode]) {
 	self0 := cm.Reinterpret[uint32](self)
 	wasmimport_OutgoingDatagramStreamCheckSend((uint32)(self0), &result)
 	return
 }
 
-//go:wasmimport wasi:sockets/[email protected] [method]outgoing-datagram-stream.check-send
-//go:noescape
-func wasmimport_OutgoingDatagramStreamCheckSend(self0 uint32, result *cm.Result[uint64, uint64, network.ErrorCode])
-
 // Send represents the imported method "send".
 //
 // Send messages on the socket.
@@ -608,17 +559,13 @@ func wasmimport_OutgoingDatagramStreamCheckSend(self0 uint32, result *cm.Result[
 //	send: func(datagrams: list<outgoing-datagram>) -> result<u64, error-code>
 //
 //go:nosplit
-func (self OutgoingDatagramStream) Send(datagrams cm.List[OutgoingDatagram]) (result cm.Result[uint64, uint64, network.ErrorCode]) {
+func (self OutgoingDatagramStream) Send(datagrams cm.List[OutgoingDatagram]) (result cm.Result[uint64, uint64, 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/[email protected] [method]outgoing-datagram-stream.send
-//go:noescape
-func wasmimport_OutgoingDatagramStreamSend(self0 uint32, datagrams0 *OutgoingDatagram, datagrams1 uint32, result *cm.Result[uint64, uint64, network.ErrorCode])
-
 // Subscribe represents the imported method "subscribe".
 //
 // Create a `pollable` which will resolve once the stream is ready to send again.
@@ -629,13 +576,9 @@ func wasmimport_OutgoingDatagramStreamSend(self0 uint32, datagrams0 *OutgoingDat
 //	subscribe: func() -> pollable
 //
 //go:nosplit
-func (self OutgoingDatagramStream) Subscribe() (result poll.Pollable) {
+func (self OutgoingDatagramStream) Subscribe() (result Pollable) {
 	self0 := cm.Reinterpret[uint32](self)
 	result0 := wasmimport_OutgoingDatagramStreamSubscribe((uint32)(self0))
-	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
+	result = cm.Reinterpret[Pollable]((uint32)(result0))
 	return
 }
-
-//go:wasmimport wasi:sockets/[email protected] [method]outgoing-datagram-stream.subscribe
-//go:noescape
-func wasmimport_OutgoingDatagramStreamSubscribe(self0 uint32) (result0 uint32)