Adding upstream version 0.0~git20240411.9e8c542.upstream/0.0_git20240411.9e8c542upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

21 files changed, 7740 insertions, 1 deletions

diff --git a/libc-bottom-half/sources/__main_void.c b/libc-bottom-half/sources/__main_void.c
index cba22ef..9f46419 100644
--- a/libc-bottom-half/sources/__main_void.c
+++ b/libc-bottom-half/sources/__main_void.c
@@ -3,11 +3,22 @@
 #include <sysexits.h>
 
 // The user's `main` function, expecting arguments.
+//
+// Note that we make this a weak symbol so that it will have a
+// `WASM_SYM_BINDING_WEAK` flag in libc.so, which tells the dynamic linker that
+// it need not be defined (e.g. in reactor-style apps with no main function).
+// See also the TODO comment on `__main_void` below.
+__attribute__((__weak__))
 int __main_argc_argv(int argc, char *argv[]);
 
 // If the user's `main` function expects arguments, the compiler will rename
 // it to `__main_argc_argv`, and this version will get linked in, which
 // initializes the argument data and calls `__main_argc_argv`.
+//
+// TODO: Ideally this function would be defined in a crt*.o file and linked in
+// as necessary by the Clang driver.  However, moving it to crt1-command.c
+// breaks `--no-gc-sections`, so we'll probably need to create a new file
+// (e.g. crt0.o or crtend.o) and teach Clang to use it when needed.
 __attribute__((__weak__, nodebug))
 int __main_void(void) {
     __wasi_errno_t err;
diff --git a/libc-bottom-half/sources/__wasilibc_fd_renumber.c b/libc-bottom-half/sources/__wasilibc_fd_renumber.c
index 47992e9..7690d13 100644
--- a/libc-bottom-half/sources/__wasilibc_fd_renumber.c
+++ b/libc-bottom-half/sources/__wasilibc_fd_renumber.c
@@ -15,10 +15,85 @@ int __wasilibc_fd_renumber(int fd, int newfd) {
     return 0;
 }
 
+#ifdef __wasilibc_use_wasip2
+#include <wasi/descriptor_table.h>
+
+void drop_tcp_socket(tcp_socket_t socket) {
+    switch (socket.state.tag) {
+    case TCP_SOCKET_STATE_UNBOUND:
+    case TCP_SOCKET_STATE_BOUND:
+    case TCP_SOCKET_STATE_CONNECTING:
+    case TCP_SOCKET_STATE_LISTENING:
+    case TCP_SOCKET_STATE_CONNECT_FAILED:
+        // No additional resources to drop.
+        break;
+    case TCP_SOCKET_STATE_CONNECTED: {
+        tcp_socket_state_connected_t connection = socket.state.connected;
+
+        poll_pollable_drop_own(connection.input_pollable);
+        poll_pollable_drop_own(connection.output_pollable);
+        streams_input_stream_drop_own(connection.input);
+        streams_output_stream_drop_own(connection.output);
+        break;
+    }
+    default: /* unreachable */ abort();
+    }
+
+    poll_pollable_drop_own(socket.socket_pollable);
+    tcp_tcp_socket_drop_own(socket.socket);
+}
+
+void drop_udp_socket_streams(udp_socket_streams_t streams) {
+    poll_pollable_drop_own(streams.incoming_pollable);
+    poll_pollable_drop_own(streams.outgoing_pollable);
+    udp_incoming_datagram_stream_drop_own(streams.incoming);
+    udp_outgoing_datagram_stream_drop_own(streams.outgoing);
+}
+
+void drop_udp_socket(udp_socket_t socket) {
+    switch (socket.state.tag) {
+    case UDP_SOCKET_STATE_UNBOUND:
+    case UDP_SOCKET_STATE_BOUND_NOSTREAMS:
+        // No additional resources to drop.
+        break;
+    case UDP_SOCKET_STATE_BOUND_STREAMING:
+        drop_udp_socket_streams(socket.state.bound_streaming.streams);
+        break;
+    case UDP_SOCKET_STATE_CONNECTED: {
+        drop_udp_socket_streams(socket.state.connected.streams);
+        break;
+    }
+    default: /* unreachable */ abort();
+    }
+
+    poll_pollable_drop_own(socket.socket_pollable);
+    udp_udp_socket_drop_own(socket.socket);
+}
+#endif // __wasilibc_use_wasip2
+
 int close(int fd) {
     // Scan the preopen fds before making any changes.
     __wasilibc_populate_preopens();
 
+#ifdef __wasilibc_use_wasip2
+    descriptor_table_entry_t entry;
+    if (descriptor_table_remove(fd, &entry)) {
+
+        switch (entry.tag)
+        {
+        case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET:
+            drop_tcp_socket(entry.tcp_socket);
+            break;
+        case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET:
+            drop_udp_socket(entry.udp_socket);
+            break;
+        default: /* unreachable */ abort();
+        }
+        
+        return 0;
+    }
+#endif // __wasilibc_use_wasip2
+    
     __wasi_errno_t error = __wasi_fd_close(fd);
     if (error != 0) {
         errno = error;
diff --git a/libc-bottom-half/sources/accept.c b/libc-bottom-half/sources/accept-wasip1.c
index 902e731..902e731 100644
--- a/libc-bottom-half/sources/accept.c
+++ b/libc-bottom-half/sources/accept-wasip1.c
diff --git a/libc-bottom-half/sources/accept-wasip2.c b/libc-bottom-half/sources/accept-wasip2.c
new file mode 100644
index 0000000..3675958
--- /dev/null
+++ b/libc-bottom-half/sources/accept-wasip2.c
@@ -0,0 +1,143 @@
+#include <sys/socket.h>
+
+#include <errno.h>
+#include <netinet/in.h>
+#include <string.h>
+
+#include <wasi/api.h>
+#include <wasi/descriptor_table.h>
+#include <wasi/sockets_utils.h>
+
+int tcp_accept(tcp_socket_t *socket, bool client_blocking,
+	       struct sockaddr *addr, socklen_t *addrlen)
+{
+	output_sockaddr_t output_addr;
+	if (!__wasi_sockets_utils__output_addr_validate(
+		    socket->family, addr, addrlen, &output_addr)) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	tcp_socket_state_listening_t listener;
+	if (socket->state.tag == TCP_SOCKET_STATE_LISTENING) {
+		listener = socket->state.listening;
+	} else {
+		errno = EINVAL;
+		return -1;
+	}
+
+	tcp_borrow_tcp_socket_t socket_borrow =
+		tcp_borrow_tcp_socket(socket->socket);
+
+	tcp_tuple3_own_tcp_socket_own_input_stream_own_output_stream_t
+		client_and_io;
+	network_error_code_t error;
+	while (!tcp_method_tcp_socket_accept(socket_borrow, &client_and_io,
+					     &error)) {
+		if (error == NETWORK_ERROR_CODE_WOULD_BLOCK) {
+			if (socket->blocking) {
+				poll_borrow_pollable_t pollable_borrow =
+					poll_borrow_pollable(
+						socket->socket_pollable);
+				poll_method_pollable_block(pollable_borrow);
+			} else {
+				errno = EWOULDBLOCK;
+				return -1;
+			}
+		} else {
+			errno = __wasi_sockets_utils__map_error(error);
+			return -1;
+		}
+	}
+
+	tcp_own_tcp_socket_t client = client_and_io.f0;
+	tcp_borrow_tcp_socket_t client_borrow = tcp_borrow_tcp_socket(client);
+
+	poll_own_pollable_t client_pollable =
+		tcp_method_tcp_socket_subscribe(client_borrow);
+
+	streams_own_input_stream_t input = client_and_io.f1;
+	streams_borrow_input_stream_t input_borrow =
+		streams_borrow_input_stream(input);
+	poll_own_pollable_t input_pollable =
+		streams_method_input_stream_subscribe(input_borrow);
+
+	streams_own_output_stream_t output = client_and_io.f2;
+	streams_borrow_output_stream_t output_borrow =
+		streams_borrow_output_stream(output);
+	poll_own_pollable_t output_pollable =
+		streams_method_output_stream_subscribe(output_borrow);
+
+	if (output_addr.tag != OUTPUT_SOCKADDR_NULL) {
+		network_ip_socket_address_t remote_address;
+		if (!tcp_method_tcp_socket_remote_address(
+			    client_borrow, &remote_address, &error)) {
+			// TODO wasi-sockets: How to recover from this in a POSIX compatible way?
+			abort();
+		}
+
+		__wasi_sockets_utils__output_addr_write(remote_address,
+							&output_addr);
+	}
+
+	descriptor_table_entry_t client_entry = { .tag = DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET, .tcp_socket = {
+        .socket = client,
+        .socket_pollable = client_pollable,
+        .blocking = client_blocking,
+        .fake_nodelay = socket->fake_nodelay,
+        .family = socket->family,
+        .state = { .tag = TCP_SOCKET_STATE_CONNECTED, .connected = {
+            .input = input,
+            .input_pollable = input_pollable,
+            .output = output,
+            .output_pollable = output_pollable,
+        } },
+    } };
+
+	int client_fd;
+	if (!descriptor_table_insert(client_entry, &client_fd)) {
+		errno = EMFILE;
+		return -1;
+	}
+
+	return client_fd;
+}
+
+int udp_accept(udp_socket_t *socket, bool client_blocking,
+	       struct sockaddr *addr, socklen_t *addrlen)
+{
+	// UDP doesn't support accept
+	errno = EOPNOTSUPP;
+	return -1;
+}
+
+int accept(int socket, struct sockaddr *restrict addr,
+	   socklen_t *restrict addrlen)
+{
+	return accept4(socket, addr, addrlen, 0);
+}
+
+int accept4(int socket, struct sockaddr *restrict addr,
+	    socklen_t *restrict addrlen, int flags)
+{
+	descriptor_table_entry_t *entry;
+	if (!descriptor_table_get_ref(socket, &entry)) {
+		errno = EBADF;
+		return -1;
+	}
+
+	bool client_blocking = (flags & SOCK_NONBLOCK) == 0;
+	// Ignore SOCK_CLOEXEC flag. That concept does not exist in WASI.
+
+	switch (entry->tag) {
+	case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET:
+		return tcp_accept(&entry->tcp_socket, client_blocking, addr,
+				  addrlen);
+	case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET:
+		return udp_accept(&entry->udp_socket, client_blocking, addr,
+				  addrlen);
+	default:
+		errno = EOPNOTSUPP;
+		return -1;
+	}
+}
diff --git a/libc-bottom-half/sources/bind.c b/libc-bottom-half/sources/bind.c
new file mode 100644
index 0000000..6204691
--- /dev/null
+++ b/libc-bottom-half/sources/bind.c
@@ -0,0 +1,53 @@
+#include <errno.h>
+#include <netinet/in.h>
+
+#include <wasi/api.h>
+#include <wasi/descriptor_table.h>
+#include <wasi/sockets_utils.h>
+
+int tcp_bind(tcp_socket_t *socket, const struct sockaddr *addr,
+	     socklen_t addrlen)
+{
+	network_ip_socket_address_t local_address;
+	int parse_err;
+	if (!__wasi_sockets_utils__parse_address(socket->family, addr, addrlen,
+						 &local_address, &parse_err)) {
+		errno = parse_err;
+		return -1;
+	}
+
+	return __wasi_sockets_utils__tcp_bind(socket, &local_address);
+}
+
+int udp_bind(udp_socket_t *socket, const struct sockaddr *addr,
+	     socklen_t addrlen)
+{
+	network_ip_socket_address_t local_address;
+	int parse_err;
+	if (!__wasi_sockets_utils__parse_address(socket->family, addr, addrlen,
+						 &local_address, &parse_err)) {
+		errno = parse_err;
+		return -1;
+	}
+
+	return __wasi_sockets_utils__udp_bind(socket, &local_address);
+}
+
+int bind(int socket, const struct sockaddr *addr, socklen_t addrlen)
+{
+	descriptor_table_entry_t *entry;
+	if (!descriptor_table_get_ref(socket, &entry)) {
+		errno = EBADF;
+		return -1;
+	}
+
+	switch (entry->tag) {
+	case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET:
+		return tcp_bind(&entry->tcp_socket, addr, addrlen);
+	case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET:
+		return udp_bind(&entry->udp_socket, addr, addrlen);
+	default:
+		errno = EOPNOTSUPP;
+		return -1;
+	}
+}
diff --git a/libc-bottom-half/sources/connect.c b/libc-bottom-half/sources/connect.c
new file mode 100644
index 0000000..7ef6808
--- /dev/null
+++ b/libc-bottom-half/sources/connect.c
@@ -0,0 +1,197 @@
+#include <errno.h>
+#include <netinet/in.h>
+
+#include <wasi/descriptor_table.h>
+#include <wasi/sockets_utils.h>
+
+static int tcp_connect(tcp_socket_t *socket, const struct sockaddr *addr,
+		       socklen_t addrlen)
+{
+	network_ip_socket_address_t remote_address;
+	int parse_err;
+	if (!__wasi_sockets_utils__parse_address(socket->family, addr, addrlen,
+						 &remote_address, &parse_err)) {
+		errno = parse_err;
+		return -1;
+	}
+
+	switch (socket->state.tag) {
+	case TCP_SOCKET_STATE_UNBOUND:
+	case TCP_SOCKET_STATE_BOUND:
+		// These can initiate a connect.
+		break;
+	case TCP_SOCKET_STATE_CONNECTING:
+		errno = EALREADY;
+		return -1;
+	case TCP_SOCKET_STATE_CONNECTED:
+		errno = EISCONN;
+		return -1;
+	case TCP_SOCKET_STATE_CONNECT_FAILED: // POSIX: "If connect() fails, the state of the socket is unspecified. Conforming applications should close the file descriptor and create a new socket before attempting to reconnect."
+	case TCP_SOCKET_STATE_LISTENING:
+	default:
+		errno = EOPNOTSUPP;
+		return -1;
+	}
+
+	network_error_code_t error;
+	network_borrow_network_t network_borrow =
+		__wasi_sockets_utils__borrow_network();
+	tcp_borrow_tcp_socket_t socket_borrow =
+		tcp_borrow_tcp_socket(socket->socket);
+
+	if (!tcp_method_tcp_socket_start_connect(socket_borrow, network_borrow,
+						 &remote_address, &error)) {
+		errno = __wasi_sockets_utils__map_error(error);
+		return -1;
+	}
+
+	// Connect has successfully started.
+	socket->state = (tcp_socket_state_t){
+		.tag = TCP_SOCKET_STATE_CONNECTING,
+		.connecting = { /* No additional state */ }
+	};
+
+	// Attempt to finish it:
+	tcp_tuple2_own_input_stream_own_output_stream_t io;
+	while (!tcp_method_tcp_socket_finish_connect(socket_borrow, &io,
+						     &error)) {
+		if (error == NETWORK_ERROR_CODE_WOULD_BLOCK) {
+			if (socket->blocking) {
+				poll_borrow_pollable_t pollable_borrow =
+					poll_borrow_pollable(
+						socket->socket_pollable);
+				poll_method_pollable_block(pollable_borrow);
+			} else {
+				errno = EINPROGRESS;
+				return -1;
+			}
+		} else {
+			socket->state =
+				(tcp_socket_state_t){ .tag = TCP_SOCKET_STATE_CONNECT_FAILED,
+						      .connect_failed = {
+							      .error_code =
+								      error,
+						      } };
+
+			errno = __wasi_sockets_utils__map_error(error);
+			return -1;
+		}
+	}
+
+	// Connect successful.
+
+	streams_own_input_stream_t input = io.f0;
+	streams_borrow_input_stream_t input_borrow =
+		streams_borrow_input_stream(input);
+	poll_own_pollable_t input_pollable =
+		streams_method_input_stream_subscribe(input_borrow);
+
+	streams_own_output_stream_t output = io.f1;
+	streams_borrow_output_stream_t output_borrow =
+		streams_borrow_output_stream(output);
+	poll_own_pollable_t output_pollable =
+		streams_method_output_stream_subscribe(output_borrow);
+
+	socket->state =
+		(tcp_socket_state_t){ .tag = TCP_SOCKET_STATE_CONNECTED,
+				      .connected = {
+					      .input = input,
+					      .input_pollable = input_pollable,
+					      .output = output,
+					      .output_pollable =
+						      output_pollable,
+				      } };
+	return 0;
+}
+
+// When `connect` is called on a UDP socket with an AF_UNSPEC address, it is actually a "disconnect" request.
+static int udp_connect(udp_socket_t *socket, const struct sockaddr *addr,
+		       socklen_t addrlen)
+{
+	if (addr == NULL || addrlen < sizeof(struct sockaddr)) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	network_ip_socket_address_t remote_address;
+	bool has_remote_address = (addr->sa_family != AF_UNSPEC);
+	if (has_remote_address) {
+		int parse_err;
+		if (!__wasi_sockets_utils__parse_address(
+			    socket->family, addr, addrlen, &remote_address,
+			    &parse_err)) {
+			errno = parse_err;
+			return -1;
+		}
+	}
+
+	// Prepare the socket; binding it if not bound yet, and disconnecting it if connected.
+	switch (socket->state.tag) {
+	case UDP_SOCKET_STATE_UNBOUND: {
+		// Socket is not explicitly bound by the user. We'll do it for them:
+
+		network_ip_socket_address_t any =
+			__wasi_sockets_utils__any_addr(socket->family);
+		int result = __wasi_sockets_utils__udp_bind(socket, &any);
+		if (result != 0) {
+			return result;
+		}
+		break;
+	}
+	case UDP_SOCKET_STATE_BOUND_NOSTREAMS: {
+		// This is the state we want to be in.
+		break;
+	}
+	case UDP_SOCKET_STATE_BOUND_STREAMING: {
+		__wasi_sockets_utils__drop_streams(
+			socket->state.bound_streaming.streams);
+		socket->state = (udp_socket_state_t){
+			.tag = UDP_SOCKET_STATE_BOUND_NOSTREAMS,
+			.bound_nostreams = {}
+		};
+		break;
+	}
+	case UDP_SOCKET_STATE_CONNECTED: {
+		__wasi_sockets_utils__drop_streams(
+			socket->state.connected.streams);
+		socket->state = (udp_socket_state_t){
+			.tag = UDP_SOCKET_STATE_BOUND_NOSTREAMS,
+			.bound_nostreams = {}
+		};
+		break;
+	}
+	default: /* unreachable */
+		abort();
+	}
+
+	network_error_code_t error;
+	udp_socket_streams_t streams;
+
+	if (!__wasi_sockets_utils__stream(
+		    socket, has_remote_address ? &remote_address : NULL,
+		    &streams, &error)) {
+		errno = __wasi_sockets_utils__map_error(error);
+		return -1;
+	}
+
+	return 0;
+}
+
+int connect(int fd, const struct sockaddr *addr, socklen_t addrlen)
+{
+	descriptor_table_entry_t *entry;
+	if (!descriptor_table_get_ref(fd, &entry)) {
+		errno = EBADF;
+		return -1;
+	}
+
+	switch (entry->tag) {
+	case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET:
+		return tcp_connect(&entry->tcp_socket, addr, addrlen);
+	case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET:
+		return udp_connect(&entry->udp_socket, addr, addrlen);
+	default:
+		errno = EOPNOTSUPP;
+		return -1;
+	}
+}
diff --git a/libc-bottom-half/sources/descriptor_table.c b/libc-bottom-half/sources/descriptor_table.c
new file mode 100644
index 0000000..d45e7ce
--- /dev/null
+++ b/libc-bottom-half/sources/descriptor_table.c
@@ -0,0 +1,255 @@
+/*
+ * This file provides a global hashtable for tracking `wasi-libc`-managed file
+ * descriptors.
+ *
+ * WASI Preview 2 has no notion of file descriptors and instead uses unforgeable
+ * resource handles (which are currently represented as integers at the ABI
+ * level, used as indices into per-component tables managed by the host).
+ * Moreover, there's not necessarily a one-to-one correspondence between POSIX
+ * file descriptors and resource handles (e.g. a TCP connection may require
+ * separate handles for reading, writing, and polling the same connection).  We
+ * use this table to map each POSIX descriptor to a set of one or more handles.
+ *
+ * As of this writing, we still rely on the WASI Preview 1 adapter
+ * (https://github.com/bytecodealliance/wasmtime/tree/main/crates/wasi-preview1-component-adapter)
+ * to manage non-socket descriptors, so currently this table only tracks TCP and
+ * UDP sockets.  We use the adapter's `adapter_open_badfd` and
+ * `adapter_close_badfd` functions to reserve and later close descriptors to
+ * avoid confusion (e.g. if an application tries to use Preview 1 host functions
+ * directly for socket operations rather than go through `wasi-libc`).
+ * Eventually, we'll switch `wasi-libc` over to Preview 2 entirely, at which
+ * point we'll no longer need the adapter.  At that point, all file descriptors
+ * will be managed exclusively in this table.
+ */
+
+#include <wasi/descriptor_table.h>
+
+__attribute__((__import_module__("wasi_snapshot_preview1"),
+	       __import_name__("adapter_open_badfd"))) extern int32_t
+	__wasi_preview1_adapter_open_badfd(int32_t);
+
+static bool wasi_preview1_adapter_open_badfd(int *fd)
+{
+	return __wasi_preview1_adapter_open_badfd((int32_t)fd) == 0;
+}
+
+__attribute__((__import_module__("wasi_snapshot_preview1"),
+	       __import_name__("adapter_close_badfd"))) extern int32_t
+	__wasi_preview1_adapter_close_badfd(int32_t);
+
+static bool wasi_preview1_adapter_close_badfd(int fd)
+{
+	return __wasi_preview1_adapter_close_badfd(fd) == 0;
+}
+
+/*
+ * This hash table is based on the one in musl/src/search/hsearch.c, but uses
+ * integer keys and supports a `remove` operation.  Note that I've switched from
+ * quadratic to linear probing in order to make `remove` simple and efficient,
+ * with the tradeoff that clustering is more likely.  See also
+ * https://en.wikipedia.org/wiki/Open_addressing.
+ */
+
+#define MINSIZE 8
+#define MAXSIZE ((size_t)-1 / 2 + 1)
+
+typedef struct {
+	bool occupied;
+	int key;
+	descriptor_table_entry_t entry;
+} descriptor_table_item_t;
+
+typedef struct {
+	descriptor_table_item_t *entries;
+	size_t mask;
+	size_t used;
+} descriptor_table_t;
+
+static descriptor_table_t global_table = { .entries = NULL,
+					   .mask = 0,
+					   .used = 0 };
+
+static size_t keyhash(int key)
+{
+	// TODO: use a hash function here
+	return key;
+}
+
+static int resize(size_t nel, descriptor_table_t *table)
+{
+	size_t newsize;
+	size_t i;
+	descriptor_table_item_t *e, *newe;
+	descriptor_table_item_t *oldtab = table->entries;
+	descriptor_table_item_t *oldend = table->entries + table->mask + 1;
+
+	if (nel > MAXSIZE)
+		nel = MAXSIZE;
+	for (newsize = MINSIZE; newsize < nel; newsize *= 2)
+		;
+	table->entries = calloc(newsize, sizeof *table->entries);
+	if (!table->entries) {
+		table->entries = oldtab;
+		return 0;
+	}
+	table->mask = newsize - 1;
+	if (!oldtab)
+		return 1;
+	for (e = oldtab; e < oldend; e++)
+		if (e->occupied) {
+			for (i = keyhash(e->key);; ++i) {
+				newe = table->entries + (i & table->mask);
+				if (!newe->occupied)
+					break;
+			}
+			*newe = *e;
+		}
+	free(oldtab);
+	return 1;
+}
+
+static descriptor_table_item_t *lookup(int key, size_t hash,
+				       descriptor_table_t *table)
+{
+	size_t i;
+	descriptor_table_item_t *e;
+
+	for (i = hash;; ++i) {
+		e = table->entries + (i & table->mask);
+		if (!e->occupied || e->key == key)
+			break;
+	}
+	return e;
+}
+
+static bool insert(descriptor_table_entry_t entry, int fd,
+		   descriptor_table_t *table)
+{
+	if (!table->entries) {
+		if (!resize(MINSIZE, table)) {
+			return false;
+		}
+	}
+
+	size_t hash = keyhash(fd);
+	descriptor_table_item_t *e = lookup(fd, hash, table);
+
+	e->entry = entry;
+	if (!e->occupied) {
+		e->key = fd;
+		e->occupied = true;
+		if (++table->used > table->mask - table->mask / 4) {
+			if (!resize(2 * table->used, table)) {
+				table->used--;
+				e->occupied = false;
+				return false;
+			}
+		}
+	}
+	return true;
+}
+
+static bool get(int fd, descriptor_table_entry_t **entry,
+		descriptor_table_t *table)
+{
+	if (!table->entries) {
+		return false;
+	}
+
+	size_t hash = keyhash(fd);
+	descriptor_table_item_t *e = lookup(fd, hash, table);
+	if (e->occupied) {
+		*entry = &e->entry;
+		return true;
+	} else {
+		return false;
+	}
+}
+
+static bool remove(int fd, descriptor_table_entry_t *entry,
+		   descriptor_table_t *table)
+{
+	if (!table->entries) {
+		return false;
+	}
+
+	size_t hash = keyhash(fd);
+	size_t i;
+	descriptor_table_item_t *e;
+	for (i = hash;; ++i) {
+		e = table->entries + (i & table->mask);
+		if (!e->occupied || e->key == fd)
+			break;
+	}
+
+	if (e->occupied) {
+		*entry = e->entry;
+		e->occupied = false;
+
+		// Search for any occupied entries which would be lost (due to
+		// an interrupted linear probe) if we left this one unoccupied
+		// and move them as necessary.
+		i = i & table->mask;
+		size_t j = i;
+		while (true) {
+			j = (j + 1) & table->mask;
+			e = table->entries + j;
+			if (!e->occupied)
+				break;
+			size_t k = keyhash(e->key) & table->mask;
+			if (i <= j) {
+				if ((i < k) && (k <= j))
+					continue;
+			} else if ((i < k) || (k <= j)) {
+				continue;
+			}
+			table->entries[i] = *e;
+			e->occupied = false;
+			i = j;
+		}
+
+		// If the load factor has dropped below 25%, shrink the table to
+		// reduce memory footprint.
+		if (--table->used < table->mask / 4) {
+			resize(table->mask / 2, table);
+		}
+
+		return true;
+	} else {
+		return false;
+	}
+}
+
+bool descriptor_table_insert(descriptor_table_entry_t entry, int *fd)
+{
+	if (wasi_preview1_adapter_open_badfd(fd)) {
+		if (insert(entry, *fd, &global_table)) {
+			return true;
+		} else {
+			if (!wasi_preview1_adapter_close_badfd(*fd)) {
+				abort();
+			}
+			*fd = -1;
+			return false;
+		}
+	} else {
+		return false;
+	}
+}
+
+bool descriptor_table_get_ref(int fd, descriptor_table_entry_t **entry)
+{
+	return get(fd, entry, &global_table);
+}
+
+bool descriptor_table_remove(int fd, descriptor_table_entry_t *entry)
+{
+	if (remove(fd, entry, &global_table)) {
+		if (!wasi_preview1_adapter_close_badfd(fd)) {
+			abort();
+		}
+		return true;
+	} else {
+		return false;
+	}
+}
diff --git a/libc-bottom-half/sources/getsockpeername.c b/libc-bottom-half/sources/getsockpeername.c
new file mode 100644
index 0000000..463c233
--- /dev/null
+++ b/libc-bottom-half/sources/getsockpeername.c
@@ -0,0 +1,229 @@
+#include <errno.h>
+#include <netinet/in.h>
+
+#include <wasi/descriptor_table.h>
+#include <wasi/sockets_utils.h>
+
+int tcp_getsockname(tcp_socket_t *socket, struct sockaddr *addr,
+		    socklen_t *addrlen)
+{
+	output_sockaddr_t output_addr;
+	if (!__wasi_sockets_utils__output_addr_validate(
+		    socket->family, addr, addrlen, &output_addr)) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	if (output_addr.tag == OUTPUT_SOCKADDR_NULL) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	switch (socket->state.tag) {
+	case TCP_SOCKET_STATE_UNBOUND:
+		errno = EINVAL;
+		return -1;
+
+	case TCP_SOCKET_STATE_BOUND:
+	case TCP_SOCKET_STATE_CONNECTING:
+	case TCP_SOCKET_STATE_CONNECT_FAILED:
+	case TCP_SOCKET_STATE_LISTENING:
+	case TCP_SOCKET_STATE_CONNECTED:
+		// OK. Continue..
+		break;
+
+	default: /* unreachable */
+		abort();
+	}
+
+	network_error_code_t error;
+	network_ip_socket_address_t result;
+	tcp_borrow_tcp_socket_t socket_borrow =
+		tcp_borrow_tcp_socket(socket->socket);
+	if (!tcp_method_tcp_socket_local_address(socket_borrow, &result,
+						 &error)) {
+		errno = __wasi_sockets_utils__map_error(error);
+		return -1;
+	}
+
+	__wasi_sockets_utils__output_addr_write(result, &output_addr);
+
+	return 0;
+}
+
+int tcp_getpeername(tcp_socket_t *socket, struct sockaddr *addr,
+		    socklen_t *addrlen)
+{
+	output_sockaddr_t output_addr;
+	if (!__wasi_sockets_utils__output_addr_validate(
+		    socket->family, addr, addrlen, &output_addr)) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	if (output_addr.tag == OUTPUT_SOCKADDR_NULL) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	switch (socket->state.tag) {
+	case TCP_SOCKET_STATE_UNBOUND:
+	case TCP_SOCKET_STATE_BOUND:
+	case TCP_SOCKET_STATE_CONNECTING:
+	case TCP_SOCKET_STATE_CONNECT_FAILED:
+	case TCP_SOCKET_STATE_LISTENING:
+		errno = ENOTCONN;
+		return -1;
+
+	case TCP_SOCKET_STATE_CONNECTED:
+		// OK. Continue..
+		break;
+
+	default: /* unreachable */
+		abort();
+	}
+
+	network_error_code_t error;
+	network_ip_socket_address_t result;
+	tcp_borrow_tcp_socket_t socket_borrow =
+		tcp_borrow_tcp_socket(socket->socket);
+	if (!tcp_method_tcp_socket_remote_address(socket_borrow, &result,
+						  &error)) {
+		errno = __wasi_sockets_utils__map_error(error);
+		return -1;
+	}
+
+	__wasi_sockets_utils__output_addr_write(result, &output_addr);
+
+	return 0;
+}
+
+int udp_getsockname(udp_socket_t *socket, struct sockaddr *addr,
+		    socklen_t *addrlen)
+{
+	output_sockaddr_t output_addr;
+	if (!__wasi_sockets_utils__output_addr_validate(
+		    socket->family, addr, addrlen, &output_addr)) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	if (output_addr.tag == OUTPUT_SOCKADDR_NULL) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	switch (socket->state.tag) {
+	case UDP_SOCKET_STATE_UNBOUND:
+		errno = EINVAL;
+		return -1;
+
+	case UDP_SOCKET_STATE_BOUND_NOSTREAMS:
+	case UDP_SOCKET_STATE_BOUND_STREAMING:
+	case UDP_SOCKET_STATE_CONNECTED:
+		// OK. Continue..
+		break;
+
+	default: /* unreachable */
+		abort();
+	}
+
+	network_error_code_t error;
+	network_ip_socket_address_t result;
+	udp_borrow_udp_socket_t socket_borrow =
+		udp_borrow_udp_socket(socket->socket);
+	if (!udp_method_udp_socket_local_address(socket_borrow, &result,
+						 &error)) {
+		errno = __wasi_sockets_utils__map_error(error);
+		return -1;
+	}
+
+	__wasi_sockets_utils__output_addr_write(result, &output_addr);
+
+	return 0;
+}
+
+int udp_getpeername(udp_socket_t *socket, struct sockaddr *addr,
+		    socklen_t *addrlen)
+{
+	output_sockaddr_t output_addr;
+	if (!__wasi_sockets_utils__output_addr_validate(
+		    socket->family, addr, addrlen, &output_addr)) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	if (output_addr.tag == OUTPUT_SOCKADDR_NULL) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	switch (socket->state.tag) {
+	case UDP_SOCKET_STATE_UNBOUND:
+	case UDP_SOCKET_STATE_BOUND_NOSTREAMS:
+	case UDP_SOCKET_STATE_BOUND_STREAMING:
+		errno = ENOTCONN;
+		return -1;
+
+	case UDP_SOCKET_STATE_CONNECTED:
+		// OK. Continue..
+		break;
+
+	default: /* unreachable */
+		abort();
+	}
+
+	network_error_code_t error;
+	network_ip_socket_address_t result;
+	udp_borrow_udp_socket_t socket_borrow =
+		udp_borrow_udp_socket(socket->socket);
+	if (!udp_method_udp_socket_remote_address(socket_borrow, &result,
+						  &error)) {
+		errno = __wasi_sockets_utils__map_error(error);
+		return -1;
+	}
+
+	__wasi_sockets_utils__output_addr_write(result, &output_addr);
+
+	return 0;
+}
+
+int getsockname(int socket, struct sockaddr *__restrict addr,
+		socklen_t *__restrict addrlen)
+{
+	descriptor_table_entry_t *entry;
+	if (!descriptor_table_get_ref(socket, &entry)) {
+		errno = EBADF;
+		return -1;
+	}
+
+	switch (entry->tag) {
+	case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET:
+		return tcp_getsockname(&entry->tcp_socket, addr, addrlen);
+	case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET:
+		return udp_getsockname(&entry->udp_socket, addr, addrlen);
+	default:
+		errno = EOPNOTSUPP;
+		return -1;
+	}
+}
+
+int getpeername(int socket, struct sockaddr *__restrict addr,
+		socklen_t *__restrict addrlen)
+{
+	descriptor_table_entry_t *entry;
+	if (!descriptor_table_get_ref(socket, &entry)) {
+		errno = EBADF;
+		return -1;
+	}
+
+	switch (entry->tag) {
+	case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET:
+		return tcp_getpeername(&entry->tcp_socket, addr, addrlen);
+	case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET:
+		return udp_getpeername(&entry->udp_socket, addr, addrlen);
+	default:
+		errno = EOPNOTSUPP;
+		return -1;
+	}
+}
diff --git a/libc-bottom-half/sources/listen.c b/libc-bottom-half/sources/listen.c
new file mode 100644
index 0000000..29a064a
--- /dev/null
+++ b/libc-bottom-half/sources/listen.c
@@ -0,0 +1,115 @@
+#include <errno.h>
+#include <netinet/in.h>
+
+#include <wasi/api.h>
+#include <wasi/descriptor_table.h>
+#include <wasi/sockets_utils.h>
+
+int tcp_listen(tcp_socket_t *socket, int backlog)
+{
+	network_error_code_t error;
+	tcp_borrow_tcp_socket_t socket_borrow =
+		tcp_borrow_tcp_socket(socket->socket);
+
+	switch (socket->state.tag) {
+	case TCP_SOCKET_STATE_UNBOUND: {
+		// Socket is not explicitly bound by the user. We'll do it for them:
+
+		network_ip_socket_address_t any =
+			__wasi_sockets_utils__any_addr(socket->family);
+		int result = __wasi_sockets_utils__tcp_bind(socket, &any);
+		if (result != 0) {
+			return result;
+		}
+
+		if (socket->state.tag != TCP_SOCKET_STATE_BOUND) {
+			abort();
+		}
+		// Great! We'll continue below.
+		break;
+	}
+	case TCP_SOCKET_STATE_BOUND:
+		// Great! We'll continue below.
+		break;
+	case TCP_SOCKET_STATE_LISTENING:
+		// We can only update the backlog size.
+		break;
+	case TCP_SOCKET_STATE_CONNECTING:
+	case TCP_SOCKET_STATE_CONNECTED:
+	case TCP_SOCKET_STATE_CONNECT_FAILED:
+	default:
+		errno = EINVAL;
+		return -1;
+	}
+
+	if (!tcp_method_tcp_socket_set_listen_backlog_size(socket_borrow,
+							   backlog, &error)) {
+		abort(); // Our own state checks should've prevented this from happening.
+	}
+
+	if (socket->state.tag == TCP_SOCKET_STATE_LISTENING) {
+		// Updating the backlog is all we had to do.
+		return 0;
+	}
+
+	network_borrow_network_t network_borrow =
+		__wasi_sockets_utils__borrow_network();
+	if (!tcp_method_tcp_socket_start_listen(socket_borrow, &error)) {
+		errno = __wasi_sockets_utils__map_error(error);
+		return -1;
+	}
+
+	// Listen has successfully started. Attempt to finish it:
+	while (!tcp_method_tcp_socket_finish_listen(socket_borrow, &error)) {
+		if (error == NETWORK_ERROR_CODE_WOULD_BLOCK) {
+			poll_borrow_pollable_t pollable_borrow =
+				poll_borrow_pollable(socket->socket_pollable);
+			poll_method_pollable_block(pollable_borrow);
+		} else {
+			errno = __wasi_sockets_utils__map_error(error);
+			return -1;
+		}
+	}
+
+	// Listen successful.
+
+	socket->state = (tcp_socket_state_t){
+		.tag = TCP_SOCKET_STATE_LISTENING,
+		.listening = { /* No additional state */ }
+	};
+	return 0;
+}
+
+int udp_listen(udp_socket_t *socket, int backlog)
+{
+	// UDP doesn't support listen
+	errno = EOPNOTSUPP;
+	return -1;
+}
+
+int listen(int socket, int backlog)
+{
+	descriptor_table_entry_t *entry;
+	if (!descriptor_table_get_ref(socket, &entry)) {
+		errno = EBADF;
+		return -1;
+	}
+
+	if (backlog < 0) {
+		// POSIX:
+		// > If listen() is called with a backlog argument value that is
+		// > less than 0, the function behaves as if it had been called
+		// > with a backlog argument value of 0.
+		backlog = 0;
+	}
+
+	switch (entry->tag) {
+	case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET:
+		return tcp_listen(&entry->tcp_socket, backlog);
+	case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET:
+		return udp_listen(&entry->udp_socket, backlog);
+	default:
+		errno = EOPNOTSUPP;
+		return -1;
+	}
+}
diff --git a/libc-bottom-half/sources/netdb.c b/libc-bottom-half/sources/netdb.c
new file mode 100644
index 0000000..c30a396
--- /dev/null
+++ b/libc-bottom-half/sources/netdb.c
@@ -0,0 +1,238 @@
+#include <netdb.h>
+#include <errno.h>
+#include <stdlib.h>
+
+#include <wasi/sockets_utils.h>
+
+_Thread_local int h_errno = 0;
+
+static int map_error(ip_name_lookup_error_code_t error)
+{
+	switch (error) {
+	case NETWORK_ERROR_CODE_OUT_OF_MEMORY:
+		return EAI_MEMORY;
+	case NETWORK_ERROR_CODE_NAME_UNRESOLVABLE:
+		return EAI_NONAME;
+	case NETWORK_ERROR_CODE_TEMPORARY_RESOLVER_FAILURE:
+		return EAI_AGAIN;
+	case NETWORK_ERROR_CODE_PERMANENT_RESOLVER_FAILURE:
+		return EAI_FAIL;
+
+	default:
+		errno = __wasi_sockets_utils__map_error(error);
+		return EAI_SYSTEM;
+	}
+}
+
+static int add_addr(ip_name_lookup_option_ip_address_t address,
+		    const struct addrinfo *restrict hint,
+		    struct addrinfo **restrict current,
+		    struct addrinfo **restrict res)
+{
+	int family;
+	struct sockaddr *addr;
+	socklen_t addrlen;
+	switch (address.val.tag) {
+	case NETWORK_IP_ADDRESS_IPV4: {
+		if (hint && hint->ai_family != AF_UNSPEC &&
+		    hint->ai_family != AF_INET) {
+			return 0;
+		}
+
+		network_ipv4_address_t ip = address.val.val.ipv4;
+
+		family = PF_INET;
+		addrlen = sizeof(struct sockaddr_in);
+		addr = malloc(addrlen);
+		if (addr == NULL) {
+			freeaddrinfo(*res);
+			return EAI_MEMORY;
+		}
+
+		struct sockaddr_in sockaddr = {
+			.sin_family = AF_INET,
+			.sin_port = 0,
+			.sin_addr = { .s_addr = ip.f0 | (ip.f1 << 8) |
+						(ip.f2 << 16) | (ip.f3 << 24) },
+		};
+		memcpy(addr, &sockaddr, addrlen);
+		break;
+	}
+	case NETWORK_IP_ADDRESS_IPV6: {
+		if (hint && hint->ai_family != AF_UNSPEC &&
+		    hint->ai_family != AF_INET6) {
+			return 0;
+		}
+
+		network_ipv6_address_t ip = address.val.val.ipv6;
+
+		family = PF_INET6;
+		addrlen = sizeof(struct sockaddr_in6);
+		addr = malloc(addrlen);
+		if (addr == NULL) {
+			freeaddrinfo(*res);
+			return EAI_MEMORY;
+		}
+
+		struct sockaddr_in6 sockaddr = {
+		    .sin6_family = AF_INET6,
+		    .sin6_port = 0,
+		    .sin6_addr = {
+			.s6_addr = {
+			    ip.f0 >> 8,
+			    ip.f0 & 0xFF,
+			    ip.f1 >> 8,
+			    ip.f1 & 0xFF,
+			    ip.f2 >> 8,
+			    ip.f2 & 0xFF,
+			    ip.f3 >> 8,
+			    ip.f3 & 0xFF,
+			    ip.f4 >> 8,
+			    ip.f4 & 0xFF,
+			    ip.f5 >> 8,
+			    ip.f5 & 0xFF,
+			    ip.f6 >> 8,
+			    ip.f6 & 0xFF,
+			    ip.f7 >> 8,
+			    ip.f7 & 0xFF,
+			} },
+		    .sin6_flowinfo = 0,
+		    .sin6_scope_id = 0,
+		};
+		memcpy(addr, &sockaddr, addrlen);
+		break;
+	}
+	default: /* unreachable */
+		abort();
+	}
+
+	struct addrinfo *result = malloc(sizeof(struct addrinfo));
+	if (result == NULL) {
+		freeaddrinfo(*res);
+		return EAI_MEMORY;
+	}
+
+	*result = (struct addrinfo){
+		.ai_family = family,
+		.ai_flags = 0,
+		.ai_socktype = SOCK_STREAM,
+		.ai_protocol = 0,
+		.ai_addrlen = addrlen,
+		.ai_addr = addr,
+		.ai_canonname = NULL,
+		.ai_next = NULL,
+	};
+
+	if (*current) {
+		(*current)->ai_next = result;
+		*current = result;
+	} else {
+		*current = result;
+		*res = result;
+	}
+
+        return 0;
+}
+
+int getaddrinfo(const char *restrict host, const char *restrict serv,
+		const struct addrinfo *restrict hint,
+		struct addrinfo **restrict res)
+{
+	if (host == NULL) {
+		host = "localhost";
+	}
+
+	*res = NULL;
+	struct addrinfo *current = NULL;
+	wasip2_string_t name = { .ptr = (uint8_t *)host, .len = strlen(host) };
+	ip_name_lookup_own_resolve_address_stream_t stream;
+	ip_name_lookup_error_code_t error;
+	if (ip_name_lookup_resolve_addresses(
+		    __wasi_sockets_utils__borrow_network(), &name, &stream,
+		    &error)) {
+		ip_name_lookup_borrow_resolve_address_stream_t stream_borrow =
+			ip_name_lookup_borrow_resolve_address_stream(stream);
+		while (true) {
+			ip_name_lookup_option_ip_address_t address;
+			if (ip_name_lookup_method_resolve_address_stream_resolve_next_address(
+				    stream_borrow, &address, &error)) {
+				if (address.is_some) {
+					int error = add_addr(address, hint,
+							     &current, res);
+					if (error) {
+						return error;
+					}
+				} else {
+					return 0;
+				}
+			} else if (error == NETWORK_ERROR_CODE_WOULD_BLOCK) {
+				ip_name_lookup_own_pollable_t pollable =
+					ip_name_lookup_method_resolve_address_stream_subscribe(
+						stream_borrow);
+				poll_borrow_pollable_t pollable_borrow =
+					poll_borrow_pollable(pollable);
+				poll_method_pollable_block(pollable_borrow);
+				poll_pollable_drop_own(pollable);
+			} else {
+				freeaddrinfo(*res);
+				return map_error(error);
+			}
+		}
+	} else {
+		return map_error(error);
+	}
+}
+
+void freeaddrinfo(struct addrinfo *p)
+{
+	while (p) {
+		struct addrinfo *next = p->ai_next;
+		free(p->ai_addr);
+		free(p);
+		p = next;
+	}
+}
+
+int getnameinfo(const struct sockaddr *restrict sa, socklen_t salen,
+		char *restrict host, socklen_t hostlen, char *restrict serv,
+		socklen_t servlen, int flags)
+{
+	// TODO wasi-sockets
+	abort();
+}
+
+struct hostent *gethostbyname(const char *name)
+{
+	// TODO wasi-sockets
+	return NULL;
+}
+
+struct hostent *gethostbyaddr(const void *addr, socklen_t len, int type)
+{
+	// TODO wasi-sockets
+	return NULL;
+}
+
+const char *hstrerror(int err)
+{
+	// TODO wasi-sockets
+	return "hstrerror: TODO";
+}
+
+struct servent *getservbyname(const char *name, const char *proto)
+{
+	// TODO wasi-sockets
+	return NULL;
+}
+
+struct servent *getservbyport(int port, const char *proto)
+{
+	// TODO wasi-sockets
+	return NULL;
+}
+
+struct protoent *getprotobyname(const char *name)
+{
+	// TODO wasi-sockets
+	return NULL;
+}
diff --git a/libc-bottom-half/sources/poll-wasip2.c b/libc-bottom-half/sources/poll-wasip2.c
new file mode 100644
index 0000000..be7809c
--- /dev/null
+++ b/libc-bottom-half/sources/poll-wasip2.c
@@ -0,0 +1,257 @@
+#include <errno.h>
+#include <poll.h>
+
+#include <wasi/descriptor_table.h>
+
+typedef struct {
+	poll_own_pollable_t pollable;
+	struct pollfd *pollfd;
+	descriptor_table_entry_t *entry;
+	short events;
+} state_t;
+
+int poll_wasip2(struct pollfd *fds, size_t nfds, int timeout)
+{
+	int event_count = 0;
+	for (size_t i = 0; i < nfds; ++i) {
+		fds[i].revents = 0;
+	}
+
+	size_t max_pollables = (2 * nfds) + 1;
+	state_t states[max_pollables];
+	size_t state_index = 0;
+	for (size_t i = 0; i < nfds; ++i) {
+		struct pollfd *pollfd = fds + i;
+		descriptor_table_entry_t *entry;
+		if (descriptor_table_get_ref(pollfd->fd, &entry)) {
+			switch (entry->tag) {
+			case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET: {
+				tcp_socket_t *socket = &(entry->tcp_socket);
+				switch (socket->state.tag) {
+				case TCP_SOCKET_STATE_CONNECTING:
+				case TCP_SOCKET_STATE_LISTENING: {
+					if ((pollfd->events &
+					     (POLLRDNORM | POLLWRNORM)) != 0) {
+						states[state_index++] = (state_t){
+							.pollable =
+								socket->socket_pollable,
+							.pollfd = pollfd,
+							.entry = entry,
+							.events = pollfd->events
+						};
+					}
+					break;
+				}
+
+				case TCP_SOCKET_STATE_CONNECTED: {
+					if ((pollfd->events & POLLRDNORM) !=
+					    0) {
+						states[state_index++] = (state_t){
+							.pollable =
+								socket->state
+									.connected
+									.input_pollable,
+							.pollfd = pollfd,
+							.entry = entry,
+							.events = POLLRDNORM
+						};
+					}
+					if ((pollfd->events & POLLWRNORM) !=
+					    0) {
+						states[state_index++] = (state_t){
+							.pollable =
+								socket->state
+									.connected
+									.output_pollable,
+							.pollfd = pollfd,
+							.entry = entry,
+							.events = POLLWRNORM
+						};
+					}
+					break;
+				}
+
+				case TCP_SOCKET_STATE_CONNECT_FAILED: {
+					if (pollfd->revents == 0) {
+						++event_count;
+					}
+					pollfd->revents |= pollfd->events;
+					break;
+				}
+
+				default:
+					errno = ENOTSUP;
+					return -1;
+				}
+				break;
+			}
+
+			case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET: {
+				udp_socket_t *socket = &(entry->udp_socket);
+				switch (socket->state.tag) {
+				case UDP_SOCKET_STATE_UNBOUND:
+				case UDP_SOCKET_STATE_BOUND_NOSTREAMS: {
+					if (pollfd->revents == 0) {
+						++event_count;
+					}
+					pollfd->revents |= pollfd->events;
+					break;
+				}
+
+				case UDP_SOCKET_STATE_BOUND_STREAMING:
+				case UDP_SOCKET_STATE_CONNECTED: {
+					udp_socket_streams_t *streams;
+					if (socket->state.tag ==
+					    UDP_SOCKET_STATE_BOUND_STREAMING) {
+						streams = &(
+							socket->state
+								.bound_streaming
+								.streams);
+					} else {
+						streams = &(
+							socket->state.connected
+								.streams);
+					}
+					if ((pollfd->events & POLLRDNORM) !=
+					    0) {
+						states[state_index++] = (state_t){
+							.pollable =
+								streams->incoming_pollable,
+							.pollfd = pollfd,
+							.entry = entry,
+							.events = POLLRDNORM
+						};
+					}
+					if ((pollfd->events & POLLWRNORM) !=
+					    0) {
+						states[state_index++] = (state_t){
+							.pollable =
+								streams->outgoing_pollable,
+							.pollfd = pollfd,
+							.entry = entry,
+							.events = POLLWRNORM
+						};
+					}
+					break;
+				}
+
+				default:
+					errno = ENOTSUP;
+					return -1;
+				}
+				break;
+			}
+
+			default:
+				errno = ENOTSUP;
+				return -1;
+			}
+		} else {
+			abort();
+		}
+	}
+
+	if (event_count > 0 && timeout != 0) {
+		return event_count;
+	}
+
+	poll_borrow_pollable_t pollables[state_index + 1];
+	for (size_t i = 0; i < state_index; ++i) {
+		pollables[i] = poll_borrow_pollable(states[i].pollable);
+	}
+
+	poll_own_pollable_t timeout_pollable;
+	size_t pollable_count = state_index;
+	if (timeout >= 0) {
+		timeout_pollable = monotonic_clock_subscribe_duration(
+			((monotonic_clock_duration_t)timeout) * 1000000);
+		pollables[pollable_count++] =
+			poll_borrow_pollable(timeout_pollable);
+	}
+
+	wasip2_list_u32_t ready;
+	poll_list_borrow_pollable_t list = {
+		.ptr = (poll_borrow_pollable_t *)&pollables,
+		.len = pollable_count
+	};
+	poll_poll(&list, &ready);
+
+	for (size_t i = 0; i < ready.len; ++i) {
+		size_t index = ready.ptr[i];
+		if (index < state_index) {
+			state_t *state = &states[index];
+			if (state->entry->tag ==
+				    DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET &&
+			    state->entry->tcp_socket.state.tag ==
+				    TCP_SOCKET_STATE_CONNECTING) {
+				tcp_socket_t *socket =
+					&(state->entry->tcp_socket);
+				tcp_borrow_tcp_socket_t borrow =
+					tcp_borrow_tcp_socket(socket->socket);
+				tcp_tuple2_own_input_stream_own_output_stream_t
+					tuple;
+				tcp_error_code_t error;
+				if (tcp_method_tcp_socket_finish_connect(
+					    borrow, &tuple, &error)) {
+					streams_borrow_input_stream_t
+						input_stream_borrow =
+							streams_borrow_input_stream(
+								tuple.f0);
+					streams_own_pollable_t input_pollable =
+						streams_method_input_stream_subscribe(
+							input_stream_borrow);
+					streams_borrow_output_stream_t
+						output_stream_borrow =
+							streams_borrow_output_stream(
+								tuple.f1);
+					streams_own_pollable_t output_pollable =
+						streams_method_output_stream_subscribe(
+							output_stream_borrow);
+					socket->state =
+						(tcp_socket_state_t){ .tag = TCP_SOCKET_STATE_CONNECTED,
+								      .connected = {
+									      .input_pollable =
+										      input_pollable,
+									      .input =
+										      tuple.f0,
+									      .output_pollable =
+										      output_pollable,
+									      .output =
+										      tuple.f1,
+								      } };
+					if (state->pollfd->revents == 0) {
+						++event_count;
+					}
+					state->pollfd->revents |= state->events;
+				} else if (error ==
+					   NETWORK_ERROR_CODE_WOULD_BLOCK) {
+					// No events yet -- application will need to poll again
+				} else {
+					socket->state =
+						(tcp_socket_state_t){ .tag = TCP_SOCKET_STATE_CONNECT_FAILED,
+								      .connect_failed = {
+									      .error_code =
+										      error,
+								      } };
+					if (state->pollfd->revents == 0) {
+						++event_count;
+					}
+					state->pollfd->revents |= state->events;
+				}
+			} else {
+				if (state->pollfd->revents == 0) {
+					++event_count;
+				}
+				state->pollfd->revents |= state->events;
+			}
+		}
+	}
+
+	wasip2_list_u32_free(&ready);
+
+	if (timeout >= 0) {
+		poll_pollable_drop_own(timeout_pollable);
+	}
+
+	return event_count;
+}
diff --git a/libc-bottom-half/sources/posix.c b/libc-bottom-half/sources/posix.c
index b3e59ec..7da6a3d 100644
--- a/libc-bottom-half/sources/posix.c
+++ b/libc-bottom-half/sources/posix.c
@@ -6,6 +6,7 @@
 #include <fcntl.h>
 #include <stdlib.h>
 #include <sys/stat.h>
+#include <sys/statvfs.h>
 #include <unistd.h>
 #include <utime.h>
 #include <wasi/libc.h>
@@ -310,6 +311,46 @@ int rename(const char *old, const char *new) {
     return -1;
 }
 
+int chmod(const char *path, mode_t mode) {
+    // TODO: We plan to support this eventually in WASI, but not yet.
+    // Meanwhile, we provide a stub so that libc++'s `<filesystem>`
+    // implementation will build unmodified.
+    errno = ENOSYS;
+    return -1;
+}
+
+int fchmod(int fd, mode_t mode) {
+    // TODO: We plan to support this eventually in WASI, but not yet.
+    // Meanwhile, we provide a stub so that libc++'s `<filesystem>`
+    // implementation will build unmodified.
+    errno = ENOSYS;
+    return -1;
+}
+
+int fchmodat(int fd, const char *path, mode_t mode, int flag) {
+    // TODO: We plan to support this eventually in WASI, but not yet.
+    // Meanwhile, we provide a stub so that libc++'s `<filesystem>`
+    // implementation will build unmodified.
+    errno = ENOSYS;
+    return -1;
+}
+
+int statvfs(const char *__restrict path, struct statvfs *__restrict buf) {
+    // TODO: We plan to support this eventually in WASI, but not yet.
+    // Meanwhile, we provide a stub so that libc++'s `<filesystem>`
+    // implementation will build unmodified.
+    errno = ENOSYS;
+    return -1;
+}
+
+int fstatvfs(int fd, struct statvfs *buf) {
+    // TODO: We plan to support this eventually in WASI, but not yet.
+    // Meanwhile, we provide a stub so that libc++'s `<filesystem>`
+    // implementation will build unmodified.
+    errno = ENOSYS;
+    return -1;
+}
+
 // Like `access`, but with `faccessat`'s flags argument.
 int
 __wasilibc_access(const char *path, int mode, int flags)
diff --git a/libc-bottom-half/sources/preopens.c b/libc-bottom-half/sources/preopens.c
index b495433..3386ca4 100644
--- a/libc-bottom-half/sources/preopens.c
+++ b/libc-bottom-half/sources/preopens.c
@@ -260,7 +260,7 @@ void __wasilibc_populate_preopens(void) {
             if (prefix == NULL)
                 goto software;
 
-            // TODO: Remove the cast on `path` once the witx is updated with
+            // TODO: Remove the cast on `prefix` once the witx is updated with
             // char8 support.
             ret = __wasi_fd_prestat_dir_name(fd, (uint8_t *)prefix,
                                              prestat.u.dir.pr_name_len);
@@ -290,3 +290,23 @@ oserr:
 software:
     _Exit(EX_SOFTWARE);
 }
+
+void __wasilibc_reset_preopens(void) {
+    LOCK(lock);
+
+    if (num_preopens) {
+        for (int i = 0; i < num_preopens; ++i) {
+            free((void*) preopens[i].prefix);
+        }
+        free(preopens);
+    }
+    
+    preopens_populated = false;
+    preopens = NULL;
+    num_preopens = 0;
+    preopen_capacity = 0;
+    
+    assert_invariants();
+    
+    UNLOCK(lock);
+}
diff --git a/libc-bottom-half/sources/recv.c b/libc-bottom-half/sources/recv.c
new file mode 100644
index 0000000..b9c3f4c
--- /dev/null
+++ b/libc-bottom-half/sources/recv.c
@@ -0,0 +1,198 @@
+#include <sys/socket.h>
+
+#include <errno.h>
+#include <stdint.h>
+
+#include <wasi/api.h>
+#include <wasi/descriptor_table.h>
+#include <wasi/sockets_utils.h>
+
+static ssize_t tcp_recvfrom(tcp_socket_t *socket, uint8_t *buffer,
+			    size_t length, int flags, struct sockaddr *addr,
+			    socklen_t *addrlen)
+{
+	// TODO wasi-sockets: flags:
+	// - MSG_WAITALL: we can probably support these relatively easy.
+	// - MSG_OOB: could be shimmed by always responding that no OOB data is available.
+	// - MSG_PEEK: could be shimmed by performing the receive into a local socket-specific buffer. And on subsequent receives first check that buffer.
+
+	const int supported_flags = MSG_DONTWAIT;
+	if ((flags & supported_flags) != flags) {
+		errno = EOPNOTSUPP;
+		return -1;
+	}
+
+	if (addr != NULL || addrlen != NULL) {
+		errno = EISCONN;
+		return -1;
+	}
+
+	tcp_socket_state_connected_t connection;
+	if (socket->state.tag == TCP_SOCKET_STATE_CONNECTED) {
+		connection = socket->state.connected;
+	} else {
+		errno = ENOTCONN;
+		return -1;
+	}
+
+	bool should_block = socket->blocking;
+	if ((flags & MSG_DONTWAIT) != 0) {
+		should_block = false;
+	}
+
+	streams_borrow_input_stream_t rx_borrow =
+		streams_borrow_input_stream(connection.input);
+	while (true) {
+		wasip2_list_u8_t result;
+		streams_stream_error_t error;
+		if (!streams_method_input_stream_read(rx_borrow, length,
+						      &result, &error)) {
+			if (error.tag == STREAMS_STREAM_ERROR_CLOSED) {
+				return 0;
+			} else {
+				// TODO wasi-sockets: wasi-sockets has no way to recover TCP stream errors yet.
+				errno = EPIPE;
+				return -1;
+			}
+		}
+
+		if (result.len) {
+			memcpy(buffer, result.ptr, result.len);
+			wasip2_list_u8_free(&result);
+			return result.len;
+		} else if (should_block) {
+			poll_borrow_pollable_t pollable_borrow =
+				poll_borrow_pollable(connection.input_pollable);
+			poll_method_pollable_block(pollable_borrow);
+		} else {
+			errno = EWOULDBLOCK;
+			return -1;
+		}
+	}
+}
+
+static ssize_t udp_recvfrom(udp_socket_t *socket, uint8_t *buffer,
+			    size_t length, int flags, struct sockaddr *addr,
+			    socklen_t *addrlen)
+{
+	// TODO wasi-sockets: flags:
+	// - MSG_PEEK: could be shimmed by performing the receive into a local socket-specific buffer. And on subsequent receives first check that buffer.
+
+	const int supported_flags = MSG_DONTWAIT | MSG_TRUNC;
+	if ((flags & supported_flags) != flags) {
+		errno = EOPNOTSUPP;
+		return -1;
+	}
+
+	output_sockaddr_t output_addr;
+	if (!__wasi_sockets_utils__output_addr_validate(
+		    socket->family, addr, addrlen, &output_addr)) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	network_error_code_t error;
+	udp_borrow_udp_socket_t socket_borrow =
+		udp_borrow_udp_socket(socket->socket);
+
+	udp_socket_streams_t streams;
+	switch (socket->state.tag) {
+	case UDP_SOCKET_STATE_UNBOUND: {
+		// Unlike `send`, `recv` should _not_ perform an implicit bind.
+		errno = EINVAL;
+		return -1;
+	}
+	case UDP_SOCKET_STATE_BOUND_NOSTREAMS: {
+		if (!__wasi_sockets_utils__stream(socket, NULL, &streams,
+						  &error)) {
+			errno = __wasi_sockets_utils__map_error(error);
+			return -1;
+		}
+		break;
+	}
+	case UDP_SOCKET_STATE_BOUND_STREAMING:
+		streams = socket->state.bound_streaming.streams;
+		break;
+
+	case UDP_SOCKET_STATE_CONNECTED:
+		streams = socket->state.connected.streams;
+		break;
+
+	default: /* unreachable */
+		abort();
+	}
+
+	bool return_real_size = (flags & MSG_TRUNC) != 0;
+	bool should_block = socket->blocking;
+	if ((flags & MSG_DONTWAIT) != 0) {
+		should_block = false;
+	}
+
+	udp_borrow_incoming_datagram_stream_t incoming_borrow =
+		udp_borrow_incoming_datagram_stream(streams.incoming);
+	while (true) {
+		udp_list_incoming_datagram_t datagrams;
+		if (!udp_method_incoming_datagram_stream_receive(
+			    incoming_borrow, 1, &datagrams, &error)) {
+			errno = __wasi_sockets_utils__map_error(error);
+			return -1;
+		}
+
+		if (datagrams.len) {
+			udp_incoming_datagram_t datagram = datagrams.ptr[0];
+			size_t datagram_size = datagram.data.len;
+			size_t bytes_to_copy =
+				datagram_size < length ? datagram_size : length;
+
+			if (output_addr.tag != OUTPUT_SOCKADDR_NULL) {
+				__wasi_sockets_utils__output_addr_write(
+					datagram.remote_address, &output_addr);
+			}
+
+			memcpy(buffer, datagram.data.ptr, bytes_to_copy);
+			udp_list_incoming_datagram_free(&datagrams);
+			return return_real_size ? datagram_size : bytes_to_copy;
+
+		} else if (should_block) {
+			poll_borrow_pollable_t pollable_borrow =
+				poll_borrow_pollable(streams.incoming_pollable);
+			poll_method_pollable_block(pollable_borrow);
+		} else {
+			errno = EWOULDBLOCK;
+			return -1;
+		}
+	}
+}
+
+ssize_t recv(int socket, void *restrict buffer, size_t length, int flags)
+{
+	return recvfrom(socket, buffer, length, flags, NULL, NULL);
+}
+
+ssize_t recvfrom(int socket, void *__restrict buffer, size_t length, int flags,
+		 struct sockaddr *__restrict addr,
+		 socklen_t *__restrict addrlen)
+{
+	descriptor_table_entry_t *entry;
+	if (!descriptor_table_get_ref(socket, &entry)) {
+		errno = EBADF;
+		return -1;
+	}
+
+	if (buffer == NULL) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	switch (entry->tag) {
+	case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET:
+		return tcp_recvfrom(&entry->tcp_socket, buffer, length, flags,
+				    addr, addrlen);
+	case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET:
+		return udp_recvfrom(&entry->udp_socket, buffer, length, flags,
+				    addr, addrlen);
+	default:
+		errno = EOPNOTSUPP;
+		return -1;
+	}
+}
diff --git a/libc-bottom-half/sources/send.c b/libc-bottom-half/sources/send.c
new file mode 100644
index 0000000..42f653b
--- /dev/null
+++ b/libc-bottom-half/sources/send.c
@@ -0,0 +1,249 @@
+#include <sys/socket.h>
+
+#include <errno.h>
+
+#include <wasi/api.h>
+#include <wasi/descriptor_table.h>
+#include <wasi/sockets_utils.h>
+
+static ssize_t tcp_sendto(tcp_socket_t *socket, const uint8_t *buffer,
+			  size_t length, int flags, const struct sockaddr *addr,
+			  socklen_t addrlen)
+{
+	const int supported_flags = MSG_DONTWAIT | MSG_NOSIGNAL;
+	if ((flags & supported_flags) != flags) {
+		errno = EOPNOTSUPP;
+		return -1;
+	}
+
+	if (addr != NULL || addrlen != 0) {
+		errno = EISCONN;
+		return -1;
+	}
+
+	tcp_socket_state_connected_t connection;
+	if (socket->state.tag == TCP_SOCKET_STATE_CONNECTED) {
+		connection = socket->state.connected;
+	} else {
+		errno = ENOTCONN;
+		return -1;
+	}
+
+	bool should_block = socket->blocking;
+	if ((flags & MSG_DONTWAIT) != 0) {
+		should_block = false;
+	}
+
+	if ((flags & MSG_NOSIGNAL) != 0) {
+		// Ignore it. WASI has no Unix-style signals. So effectively,
+		// MSG_NOSIGNAL is always the case, whether it was explicitly
+		// requested or not.
+	}
+
+	streams_borrow_output_stream_t tx_borrow =
+		streams_borrow_output_stream(connection.output);
+	while (true) {
+		streams_stream_error_t error;
+		uint64_t count;
+		if (!streams_method_output_stream_check_write(tx_borrow, &count,
+							      &error)) {
+			// TODO wasi-sockets: wasi-sockets has no way to recover stream errors yet.
+			errno = EPIPE;
+			return -1;
+		}
+
+		if (count) {
+			count = count < length ? count : length;
+			wasip2_list_u8_t list = { .ptr = (uint8_t *)buffer,
+						    .len = count };
+			if (!streams_method_output_stream_write(
+				    tx_borrow, &list, &error)) {
+				// TODO wasi-sockets: wasi-sockets has no way to recover TCP stream errors yet.
+				errno = EPIPE;
+				return -1;
+			} else {
+				return count;
+			}
+		} else if (should_block) {
+			poll_borrow_pollable_t pollable_borrow =
+				poll_borrow_pollable(
+					connection.output_pollable);
+			poll_method_pollable_block(pollable_borrow);
+		} else {
+			errno = EWOULDBLOCK;
+			return -1;
+		}
+	}
+}
+
+static ssize_t udp_sendto(udp_socket_t *socket, const uint8_t *buffer,
+			  size_t length, int flags, const struct sockaddr *addr,
+			  socklen_t addrlen)
+{
+	const int supported_flags = MSG_DONTWAIT;
+	if ((flags & supported_flags) != flags) {
+		errno = EOPNOTSUPP;
+		return -1;
+	}
+
+	network_ip_socket_address_t remote_address;
+	bool has_remote_address = (addr != NULL);
+
+	if (has_remote_address) {
+		if (socket->state.tag == UDP_SOCKET_STATE_CONNECTED) {
+			errno = EISCONN;
+			return -1;
+		}
+
+		int parse_err;
+		if (!__wasi_sockets_utils__parse_address(
+			    socket->family, addr, addrlen, &remote_address,
+			    &parse_err)) {
+			errno = parse_err;
+			return -1;
+		}
+	} else {
+		if (addrlen != 0) {
+			errno = EINVAL;
+			return -1;
+		}
+
+		if (socket->state.tag != UDP_SOCKET_STATE_CONNECTED) {
+			errno = EDESTADDRREQ;
+			return -1;
+		}
+	}
+
+	network_error_code_t error;
+	udp_borrow_udp_socket_t socket_borrow =
+		udp_borrow_udp_socket(socket->socket);
+
+	udp_socket_streams_t streams;
+	switch (socket->state.tag) {
+	case UDP_SOCKET_STATE_UNBOUND: {
+		// Socket is not explicitly bound by the user. We'll do it for them:
+
+		network_ip_socket_address_t any =
+			__wasi_sockets_utils__any_addr(socket->family);
+		int result = __wasi_sockets_utils__udp_bind(socket, &any);
+		if (result != 0) {
+			return result;
+		}
+
+		if (!__wasi_sockets_utils__stream(socket, NULL, &streams,
+						  &error)) {
+			errno = __wasi_sockets_utils__map_error(error);
+			return -1;
+		}
+		break;
+	}
+	case UDP_SOCKET_STATE_BOUND_NOSTREAMS: {
+		if (!__wasi_sockets_utils__stream(socket, NULL, &streams,
+						  &error)) {
+			errno = __wasi_sockets_utils__map_error(error);
+			return -1;
+		}
+		break;
+	}
+	case UDP_SOCKET_STATE_BOUND_STREAMING:
+		streams = socket->state.bound_streaming.streams;
+		break;
+
+	case UDP_SOCKET_STATE_CONNECTED:
+		streams = socket->state.connected.streams;
+		break;
+
+	default: /* unreachable */
+		abort();
+	}
+
+	bool should_block = socket->blocking;
+	if ((flags & MSG_DONTWAIT) != 0) {
+		should_block = false;
+	}
+
+	udp_outgoing_datagram_t datagrams[1] = {{
+        .remote_address = {
+            .is_some = has_remote_address,
+            .val = remote_address,
+        },
+        .data = {
+            .len = length,
+            .ptr = (uint8_t*)buffer,
+        },
+    }};
+	udp_list_outgoing_datagram_t list = {
+		.len = 1,
+		.ptr = datagrams,
+	};
+
+	udp_borrow_outgoing_datagram_stream_t outgoing_borrow =
+		udp_borrow_outgoing_datagram_stream(streams.outgoing);
+	while (true) {
+		uint64_t allowed;
+		if (!udp_method_outgoing_datagram_stream_check_send(
+			    outgoing_borrow, &allowed, &error)) {
+			errno = __wasi_sockets_utils__map_error(error);
+			return -1;
+		}
+
+		if (allowed) {
+			uint64_t datagrams_sent;
+			if (!udp_method_outgoing_datagram_stream_send(
+				    outgoing_borrow, &list, &datagrams_sent,
+				    &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			if (datagrams_sent != 0 && datagrams_sent != 1) {
+                            abort();
+                        }
+
+			if (datagrams_sent == 1) {
+				return length;
+			}
+		}
+
+		if (should_block) {
+			poll_borrow_pollable_t pollable_borrow =
+				poll_borrow_pollable(streams.outgoing_pollable);
+			poll_method_pollable_block(pollable_borrow);
+		} else {
+			errno = EWOULDBLOCK;
+			return -1;
+		}
+	}
+}
+
+ssize_t send(int socket, const void *buffer, size_t length, int flags)
+{
+	return sendto(socket, buffer, length, flags, NULL, 0);
+}
+
+ssize_t sendto(int socket, const void *buffer, size_t length, int flags,
+	       const struct sockaddr *addr, socklen_t addrlen)
+{
+	descriptor_table_entry_t *entry;
+	if (!descriptor_table_get_ref(socket, &entry)) {
+		errno = EBADF;
+		return -1;
+	}
+
+	if (buffer == NULL) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	switch (entry->tag) {
+	case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET:
+		return tcp_sendto(&entry->tcp_socket, buffer, length, flags,
+				  addr, addrlen);
+	case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET:
+		return udp_sendto(&entry->udp_socket, buffer, length, flags,
+				  addr, addrlen);
+	default:
+		errno = EOPNOTSUPP;
+		return -1;
+	}
+}
diff --git a/libc-bottom-half/sources/shutdown.c b/libc-bottom-half/sources/shutdown.c
new file mode 100644
index 0000000..3ffd479
--- /dev/null
+++ b/libc-bottom-half/sources/shutdown.c
@@ -0,0 +1,80 @@
+#include <sys/socket.h>
+
+#include <errno.h>
+
+#include <wasi/api.h>
+#include <wasi/descriptor_table.h>
+#include <wasi/sockets_utils.h>
+
+int tcp_shutdown(tcp_socket_t *socket, int posix_how)
+{
+	tcp_shutdown_type_t wasi_how;
+	switch (posix_how) {
+	case SHUT_RD:
+		wasi_how = TCP_SHUTDOWN_TYPE_RECEIVE;
+		break;
+	case SHUT_WR:
+		wasi_how = TCP_SHUTDOWN_TYPE_SEND;
+		break;
+	case SHUT_RDWR:
+		wasi_how = TCP_SHUTDOWN_TYPE_BOTH;
+		break;
+	default:
+		errno = EINVAL;
+		return -1;
+	}
+
+	tcp_socket_state_connected_t connection;
+	if (socket->state.tag == TCP_SOCKET_STATE_CONNECTED) {
+		connection = socket->state.connected;
+	} else {
+		errno = ENOTCONN;
+		return -1;
+	}
+
+	network_error_code_t error;
+	tcp_borrow_tcp_socket_t socket_borrow =
+		tcp_borrow_tcp_socket(socket->socket);
+	if (!tcp_method_tcp_socket_shutdown(socket_borrow, wasi_how, &error)) {
+		errno = __wasi_sockets_utils__map_error(error);
+		return -1;
+	}
+
+	if (posix_how == SHUT_RD || posix_how == SHUT_RDWR) {
+		// TODO wasi-sockets: drop input stream (if not already). And
+		// update `recv` to take dropped input streams into account.
+	}
+
+	if (posix_how == SHUT_WR || posix_how == SHUT_RDWR) {
+		// TODO wasi-sockets: drop output stream (if not already). And
+		// update `send` to take dropped output streams into account.
+	}
+
+	return 0;
+}
+
+int udp_shutdown(udp_socket_t *socket, int posix_how)
+{
+	// UDP has nothing to shut down.
+	errno = EOPNOTSUPP;
+	return -1;
+}
+
+int shutdown(int socket, int how)
+{
+	descriptor_table_entry_t *entry;
+	if (!descriptor_table_get_ref(socket, &entry)) {
+		errno = EBADF;
+		return -1;
+	}
+
+	switch (entry->tag) {
+	case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET:
+		return tcp_shutdown(&entry->tcp_socket, how);
+	case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET:
+		return udp_shutdown(&entry->udp_socket, how);
+	default:
+		errno = EOPNOTSUPP;
+		return -1;
+	}
+}
diff --git a/libc-bottom-half/sources/socket.c b/libc-bottom-half/sources/socket.c
new file mode 100644
index 0000000..3e61638
--- /dev/null
+++ b/libc-bottom-half/sources/socket.c
@@ -0,0 +1,107 @@
+#include <errno.h>
+#include <netinet/in.h>
+
+#include <wasi/descriptor_table.h>
+#include <wasi/sockets_utils.h>
+
+static int tcp_socket(network_ip_address_family_t family, bool blocking)
+{
+	tcp_create_socket_error_code_t error;
+	tcp_own_tcp_socket_t socket;
+	if (!tcp_create_socket_create_tcp_socket(family, &socket, &error)) {
+		errno = __wasi_sockets_utils__map_error(error);
+		return -1;
+	}
+
+	tcp_borrow_tcp_socket_t socket_borrow = tcp_borrow_tcp_socket(socket);
+	poll_own_pollable_t socket_pollable =
+		tcp_method_tcp_socket_subscribe(socket_borrow);
+
+	descriptor_table_entry_t
+		entry = { .tag = DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET,
+			  .tcp_socket = {
+				  .socket = socket,
+				  .socket_pollable = socket_pollable,
+				  .blocking = blocking,
+				  .fake_nodelay = false,
+				  .family = family,
+				  .state = { .tag = TCP_SOCKET_STATE_UNBOUND,
+					     .unbound = {
+						     /* No additional state. */ } },
+			  } };
+
+	int fd;
+	if (!descriptor_table_insert(entry, &fd)) {
+		errno = EMFILE;
+		return -1;
+	}
+	return fd;
+}
+
+static int udp_socket(network_ip_address_family_t family, bool blocking)
+{
+	udp_create_socket_error_code_t error;
+	udp_own_udp_socket_t socket;
+	if (!udp_create_socket_create_udp_socket(family, &socket, &error)) {
+		errno = __wasi_sockets_utils__map_error(error);
+		return -1;
+	}
+
+	udp_borrow_udp_socket_t socket_borrow = udp_borrow_udp_socket(socket);
+	poll_own_pollable_t socket_pollable =
+		udp_method_udp_socket_subscribe(socket_borrow);
+
+	descriptor_table_entry_t
+		entry = { .tag = DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET,
+			  .udp_socket = {
+				  .socket = socket,
+				  .socket_pollable = socket_pollable,
+				  .blocking = blocking,
+				  .family = family,
+				  .state = { .tag = UDP_SOCKET_STATE_UNBOUND,
+					     .unbound = {
+						     /* No additional state. */ } },
+			  } };
+
+	int fd;
+	if (!descriptor_table_insert(entry, &fd)) {
+		errno = EMFILE;
+		return -1;
+	}
+	return fd;
+}
+
+int socket(int domain, int type, int protocol)
+{
+	network_ip_address_family_t family;
+	switch (domain) {
+	case PF_INET:
+		family = NETWORK_IP_ADDRESS_FAMILY_IPV4;
+		break;
+
+	case PF_INET6:
+		family = NETWORK_IP_ADDRESS_FAMILY_IPV6;
+		break;
+
+	default:
+		errno = EAFNOSUPPORT;
+		return -1;
+	}
+
+	int real_type = type & ~(SOCK_NONBLOCK | SOCK_CLOEXEC);
+	bool blocking = (type & SOCK_NONBLOCK) == 0;
+	// Ignore SOCK_CLOEXEC flag. That concept does not exist in WASI.
+
+	if (real_type == SOCK_STREAM &&
+	    (protocol == 0 || protocol == IPPROTO_TCP)) {
+		return tcp_socket(family, blocking);
+
+	} else if (real_type == SOCK_DGRAM &&
+		   (protocol == 0 || protocol == IPPROTO_UDP)) {
+		return udp_socket(family, blocking);
+
+	} else {
+		errno = EPROTONOSUPPORT;
+		return -1;
+	}
+}
diff --git a/libc-bottom-half/sources/sockets_utils.c b/libc-bottom-half/sources/sockets_utils.c
new file mode 100644
index 0000000..4f5658a
--- /dev/null
+++ b/libc-bottom-half/sources/sockets_utils.c
@@ -0,0 +1,462 @@
+#include <errno.h>
+
+#include <wasi/sockets_utils.h>
+
+static network_own_network_t global_network;
+static bool global_network_initialized = false;
+
+network_borrow_network_t __wasi_sockets_utils__borrow_network()
+{
+	if (!global_network_initialized) {
+		global_network = instance_network_instance_network();
+		global_network_initialized = true;
+	}
+
+	return network_borrow_network(global_network);
+}
+
+int __wasi_sockets_utils__map_error(network_error_code_t wasi_error)
+{
+	switch (wasi_error) {
+	case NETWORK_ERROR_CODE_ACCESS_DENIED:
+		return EACCES;
+	case NETWORK_ERROR_CODE_NOT_SUPPORTED:
+		return EOPNOTSUPP;
+	case NETWORK_ERROR_CODE_INVALID_ARGUMENT:
+		return EINVAL;
+	case NETWORK_ERROR_CODE_OUT_OF_MEMORY:
+		return ENOMEM;
+	case NETWORK_ERROR_CODE_TIMEOUT:
+		return ETIMEDOUT;
+	case NETWORK_ERROR_CODE_CONCURRENCY_CONFLICT:
+		return EALREADY;
+	case NETWORK_ERROR_CODE_WOULD_BLOCK:
+		return EWOULDBLOCK;
+	case NETWORK_ERROR_CODE_NEW_SOCKET_LIMIT:
+		return EMFILE;
+	case NETWORK_ERROR_CODE_ADDRESS_NOT_BINDABLE:
+		return EADDRNOTAVAIL;
+	case NETWORK_ERROR_CODE_ADDRESS_IN_USE:
+		return EADDRINUSE;
+	case NETWORK_ERROR_CODE_REMOTE_UNREACHABLE:
+		return EHOSTUNREACH;
+	case NETWORK_ERROR_CODE_CONNECTION_REFUSED:
+		return ECONNREFUSED;
+	case NETWORK_ERROR_CODE_CONNECTION_RESET:
+		return ECONNRESET;
+	case NETWORK_ERROR_CODE_CONNECTION_ABORTED:
+		return ECONNABORTED;
+	case NETWORK_ERROR_CODE_DATAGRAM_TOO_LARGE:
+		return EMSGSIZE;
+
+	case NETWORK_ERROR_CODE_INVALID_STATE:
+	case NETWORK_ERROR_CODE_NOT_IN_PROGRESS:
+		abort(); // If our internal state checks are working right, these errors should never show up.
+		break;
+
+	case NETWORK_ERROR_CODE_NAME_UNRESOLVABLE:
+	case NETWORK_ERROR_CODE_TEMPORARY_RESOLVER_FAILURE:
+	case NETWORK_ERROR_CODE_PERMANENT_RESOLVER_FAILURE:
+		abort(); // These errors are specific to getaddrinfo, which should have filtered these errors out before calling this generic method
+		break;
+
+	case NETWORK_ERROR_CODE_UNKNOWN:
+	default:
+		return EOPNOTSUPP;
+	}
+}
+
+bool __wasi_sockets_utils__parse_address(
+	network_ip_address_family_t expected_family,
+	const struct sockaddr *address, socklen_t len,
+	network_ip_socket_address_t *result, int *error)
+{
+	if (address == NULL || len < sizeof(struct sockaddr)) {
+		*error = EINVAL;
+		return false;
+	}
+
+	switch (expected_family) {
+	case NETWORK_IP_ADDRESS_FAMILY_IPV4: {
+		if (address->sa_family != AF_INET) {
+			*error = EAFNOSUPPORT;
+			return false;
+		}
+
+		if (len < sizeof(struct sockaddr_in)) {
+			*error = EINVAL;
+			return false;
+		}
+
+		struct sockaddr_in *ipv4 = (struct sockaddr_in *)address;
+		unsigned ip = ipv4->sin_addr.s_addr;
+		unsigned short port = ipv4->sin_port;
+		*result = (network_ip_socket_address_t){
+            .tag = NETWORK_IP_SOCKET_ADDRESS_IPV4,
+            .val = { .ipv4 = {
+                .port = ntohs(port), // (port << 8) | (port >> 8),
+                .address = { ip & 0xFF, (ip >> 8) & 0xFF, (ip >> 16) & 0xFF, ip >> 24 },
+            } },
+        };
+		return true;
+	}
+	case NETWORK_IP_ADDRESS_FAMILY_IPV6: {
+		if (address->sa_family != AF_INET6) {
+			*error = EAFNOSUPPORT;
+			return false;
+		}
+
+		if (len < sizeof(struct sockaddr_in6)) {
+			*error = EINVAL;
+			return false;
+		}
+
+		struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)address;
+		unsigned char *ip = (unsigned char *)&(ipv6->sin6_addr.s6_addr);
+		unsigned short port = ipv6->sin6_port;
+		*result = (network_ip_socket_address_t){
+            .tag = NETWORK_IP_SOCKET_ADDRESS_IPV6,
+            .val = { .ipv6 = {
+                .port = ntohs(port),
+                .address = {
+                    (((unsigned short)ip[0]) << 8) | ip[1],
+                    (((unsigned short)ip[2]) << 8) | ip[3],
+                    (((unsigned short)ip[4]) << 8) | ip[5],
+                    (((unsigned short)ip[6]) << 8) | ip[7],
+                    (((unsigned short)ip[8]) << 8) | ip[9],
+                    (((unsigned short)ip[10]) << 8) | ip[11],
+                    (((unsigned short)ip[12]) << 8) | ip[13],
+                    (((unsigned short)ip[14]) << 8) | ip[15],
+                },
+                // TODO wasi-sockets: do these need to be endian-reversed?
+                .flow_info = ipv6->sin6_flowinfo,
+                .scope_id = ipv6->sin6_scope_id,
+            } }
+        };
+		return true;
+	}
+	default: /* unreachable */
+		abort();
+	}
+}
+
+bool __wasi_sockets_utils__output_addr_validate(
+	network_ip_address_family_t expected_family, struct sockaddr *addr,
+	socklen_t *addrlen, output_sockaddr_t *result)
+{
+	// The address parameters must be either both null or both _not_ null.
+
+	if (addr == NULL && addrlen == NULL) {
+		*result = (output_sockaddr_t){ .tag = OUTPUT_SOCKADDR_NULL,
+					       .null = {} };
+		return true;
+
+	} else if (addr != NULL && addrlen != NULL) {
+		if (expected_family == NETWORK_IP_ADDRESS_FAMILY_IPV4) {
+			if (*addrlen < sizeof(struct sockaddr_in)) {
+				return false;
+			}
+
+			*result =
+				(output_sockaddr_t){ .tag = OUTPUT_SOCKADDR_V4,
+						     .v4 = {
+							     .addr = (struct sockaddr_in
+									      *)
+								     addr,
+							     .addrlen = addrlen,
+						     } };
+			return true;
+
+		} else if (expected_family == NETWORK_IP_ADDRESS_FAMILY_IPV6) {
+			if (*addrlen < sizeof(struct sockaddr_in6)) {
+				return false;
+			}
+
+			*result =
+				(output_sockaddr_t){ .tag = OUTPUT_SOCKADDR_V6,
+						     .v6 = {
+							     .addr = (struct sockaddr_in6
+									      *)
+								     addr,
+							     .addrlen = addrlen,
+						     } };
+			return true;
+
+		} else {
+			abort();
+		}
+
+	} else {
+		return false;
+	}
+}
+
+void __wasi_sockets_utils__output_addr_write(
+	const network_ip_socket_address_t input, output_sockaddr_t *output)
+{
+	switch (input.tag) {
+	case NETWORK_IP_SOCKET_ADDRESS_IPV4: {
+		if (output->tag != OUTPUT_SOCKADDR_V4) {
+			abort();
+		}
+
+		network_ipv4_socket_address_t input_v4 = input.val.ipv4;
+		network_ipv4_address_t ip = input_v4.address;
+
+		*output->v4.addrlen = sizeof(struct sockaddr_in);
+		*output->v4.addr = (struct sockaddr_in){
+			.sin_family = AF_INET,
+			.sin_port = htons(input_v4.port),
+			.sin_addr = { .s_addr = ip.f0 | (ip.f1 << 8) |
+						(ip.f2 << 16) | (ip.f3 << 24) },
+		};
+		return;
+	}
+	case NETWORK_IP_SOCKET_ADDRESS_IPV6: {
+		if (output->tag != OUTPUT_SOCKADDR_V6) {
+			abort();
+		}
+
+		network_ipv6_socket_address_t input_v6 = input.val.ipv6;
+		network_ipv6_address_t ip = input_v6.address;
+
+		*output->v6.addrlen = sizeof(struct sockaddr_in6);
+		*output->v6.addr = (struct sockaddr_in6) {
+            .sin6_family = AF_INET6,
+            .sin6_port = htons(input_v6.port),
+            .sin6_addr = { .s6_addr = {
+                ip.f0 >> 8, ip.f0 & 0xFF,
+                ip.f1 >> 8, ip.f1 & 0xFF,
+                ip.f2 >> 8, ip.f2 & 0xFF,
+                ip.f3 >> 8, ip.f3 & 0xFF,
+                ip.f4 >> 8, ip.f4 & 0xFF,
+                ip.f5 >> 8, ip.f5 & 0xFF,
+                ip.f6 >> 8, ip.f6 & 0xFF,
+                ip.f7 >> 8, ip.f7 & 0xFF,
+            } },
+            // TODO wasi-sockets: do these need to be endian-reversed?
+            .sin6_flowinfo = input_v6.flow_info,
+            .sin6_scope_id = input_v6.scope_id,
+        };
+		return;
+	}
+	default: /* unreachable */
+		abort();
+	}
+}
+
+int __wasi_sockets_utils__posix_family(network_ip_address_family_t wasi_family)
+{
+	switch (wasi_family) {
+	case NETWORK_IP_ADDRESS_FAMILY_IPV4:
+		return AF_INET;
+	case NETWORK_IP_ADDRESS_FAMILY_IPV6:
+		return AF_INET6;
+	default: /* unreachable */
+		abort();
+	}
+}
+
+network_ip_socket_address_t
+__wasi_sockets_utils__any_addr(network_ip_address_family_t family)
+{
+	switch (family) {
+	case NETWORK_IP_ADDRESS_FAMILY_IPV4:
+		return (network_ip_socket_address_t){ .tag = NETWORK_IP_SOCKET_ADDRESS_IPV4,
+						      .val = {
+							      .ipv4 = {
+								      .port = 0,
+								      .address = { 0,
+										   0,
+										   0,
+										   0 },
+							      } } };
+	case NETWORK_IP_ADDRESS_FAMILY_IPV6:
+		return (network_ip_socket_address_t){ .tag = NETWORK_IP_SOCKET_ADDRESS_IPV6,
+						      .val = {
+							      .ipv6 = {
+								      .port = 0,
+								      .address = { 0,
+										   0,
+										   0,
+										   0,
+										   0,
+										   0,
+										   0,
+										   0 },
+								      .flow_info =
+									      0,
+								      .scope_id =
+									      0,
+							      } } };
+	default: /* unreachable */
+		abort();
+	}
+}
+
+int __wasi_sockets_utils__tcp_bind(tcp_socket_t *socket,
+				   network_ip_socket_address_t *address)
+{
+	tcp_socket_state_unbound_t unbound;
+	if (socket->state.tag == TCP_SOCKET_STATE_UNBOUND) {
+		unbound = socket->state.unbound;
+	} else {
+		errno = EINVAL;
+		return -1;
+	}
+
+	network_error_code_t error;
+	network_borrow_network_t network_borrow =
+		__wasi_sockets_utils__borrow_network();
+	tcp_borrow_tcp_socket_t socket_borrow =
+		tcp_borrow_tcp_socket(socket->socket);
+
+	if (!tcp_method_tcp_socket_start_bind(socket_borrow, network_borrow,
+					      address, &error)) {
+		errno = __wasi_sockets_utils__map_error(error);
+		return -1;
+	}
+
+	// Bind has successfully started. Attempt to finish it:
+	while (!tcp_method_tcp_socket_finish_bind(socket_borrow, &error)) {
+		if (error == NETWORK_ERROR_CODE_WOULD_BLOCK) {
+			poll_borrow_pollable_t pollable_borrow =
+				poll_borrow_pollable(socket->socket_pollable);
+			poll_method_pollable_block(pollable_borrow);
+		} else {
+			errno = __wasi_sockets_utils__map_error(error);
+			return -1;
+		}
+	}
+
+	// Bind successful.
+
+	socket->state =
+		(tcp_socket_state_t){ .tag = TCP_SOCKET_STATE_BOUND,
+				      .bound = { /* No additional state */ } };
+	return 0;
+}
+
+int __wasi_sockets_utils__udp_bind(udp_socket_t *socket,
+				   network_ip_socket_address_t *address)
+{
+	udp_socket_state_unbound_t unbound;
+	if (socket->state.tag == UDP_SOCKET_STATE_UNBOUND) {
+		unbound = socket->state.unbound;
+	} else {
+		errno = EINVAL;
+		return -1;
+	}
+
+	network_error_code_t error;
+	network_borrow_network_t network_borrow =
+		__wasi_sockets_utils__borrow_network();
+	udp_borrow_udp_socket_t socket_borrow =
+		udp_borrow_udp_socket(socket->socket);
+
+	if (!udp_method_udp_socket_start_bind(socket_borrow, network_borrow,
+					      address, &error)) {
+		errno = __wasi_sockets_utils__map_error(error);
+		return -1;
+	}
+
+	// Bind has successfully started. Attempt to finish it:
+	while (!udp_method_udp_socket_finish_bind(socket_borrow, &error)) {
+		if (error == NETWORK_ERROR_CODE_WOULD_BLOCK) {
+			poll_borrow_pollable_t pollable_borrow =
+				poll_borrow_pollable(socket->socket_pollable);
+			poll_method_pollable_block(pollable_borrow);
+		} else {
+			errno = __wasi_sockets_utils__map_error(error);
+			return -1;
+		}
+	}
+
+	// Bind successful.
+
+	socket->state =
+		(udp_socket_state_t){ .tag = UDP_SOCKET_STATE_BOUND_NOSTREAMS,
+				      .bound_nostreams = {} };
+	return 0;
+}
+
+bool __wasi_sockets_utils__create_streams(
+	udp_borrow_udp_socket_t socket_borrow,
+	network_ip_socket_address_t *remote_address,
+	udp_socket_streams_t *result, network_error_code_t *error)
+{
+	udp_tuple2_own_incoming_datagram_stream_own_outgoing_datagram_stream_t
+		io;
+	if (!udp_method_udp_socket_stream(socket_borrow, remote_address, &io,
+					  error)) {
+		return false;
+	}
+
+	udp_own_incoming_datagram_stream_t incoming = io.f0;
+	udp_borrow_incoming_datagram_stream_t incoming_borrow =
+		udp_borrow_incoming_datagram_stream(incoming);
+	poll_own_pollable_t incoming_pollable =
+		udp_method_incoming_datagram_stream_subscribe(incoming_borrow);
+
+	udp_own_outgoing_datagram_stream_t outgoing = io.f1;
+	udp_borrow_outgoing_datagram_stream_t outgoing_borrow =
+		udp_borrow_outgoing_datagram_stream(outgoing);
+	poll_own_pollable_t outgoing_pollable =
+		udp_method_outgoing_datagram_stream_subscribe(outgoing_borrow);
+
+	*result = (udp_socket_streams_t){
+		.incoming = incoming,
+		.incoming_pollable = incoming_pollable,
+		.outgoing = outgoing,
+		.outgoing_pollable = outgoing_pollable,
+	};
+	return true;
+}
+
+void __wasi_sockets_utils__drop_streams(udp_socket_streams_t streams)
+{
+	poll_pollable_drop_own(streams.incoming_pollable);
+	poll_pollable_drop_own(streams.outgoing_pollable);
+	udp_incoming_datagram_stream_drop_own(streams.incoming);
+	udp_outgoing_datagram_stream_drop_own(streams.outgoing);
+}
+
+bool __wasi_sockets_utils__stream(
+	udp_socket_t *socket,
+	network_ip_socket_address_t
+		*remote_address, // May be null to "disconnect"
+	udp_socket_streams_t *result, network_error_code_t *error)
+{
+	// Assert that:
+	// - We're already bound. This is required by WASI.
+	// - We have no active streams. From WASI:
+	//   > Implementations may trap if the streams returned by a previous
+	//   > invocation haven't been dropped yet before calling `stream` again.
+	if (socket->state.tag != UDP_SOCKET_STATE_BOUND_NOSTREAMS) {
+		abort();
+	}
+
+	udp_borrow_udp_socket_t socket_borrow =
+		udp_borrow_udp_socket(socket->socket);
+
+	if (!__wasi_sockets_utils__create_streams(socket_borrow, remote_address,
+						  result, error)) {
+		return false;
+	}
+
+	if (remote_address != NULL) {
+		socket->state =
+			(udp_socket_state_t){ .tag = UDP_SOCKET_STATE_CONNECTED,
+					      .connected = {
+						      .streams = *result,
+					      } };
+	} else {
+		socket->state =
+			(udp_socket_state_t){ .tag = UDP_SOCKET_STATE_BOUND_STREAMING,
+					      .bound_streaming = {
+						      .streams = *result,
+					      } };
+	}
+
+	return true;
+}
diff --git a/libc-bottom-half/sources/sockopt.c b/libc-bottom-half/sources/sockopt.c
new file mode 100644
index 0000000..863d115
--- /dev/null
+++ b/libc-bottom-half/sources/sockopt.c
@@ -0,0 +1,683 @@
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+
+#include <errno.h>
+#include <limits.h>
+#include <string.h>
+
+#include <wasi/api.h>
+#include <wasi/descriptor_table.h>
+#include <wasi/sockets_utils.h>
+
+const uint64_t NS_PER_S = 1000000000;
+
+int tcp_getsockopt(tcp_socket_t *socket, int level, int optname,
+		   void *restrict optval, socklen_t *restrict optlen)
+{
+	int value = 0;
+
+	network_error_code_t error;
+	tcp_borrow_tcp_socket_t socket_borrow =
+		tcp_borrow_tcp_socket(socket->socket);
+
+	switch (level) {
+	case SOL_SOCKET:
+		switch (optname) {
+		case SO_TYPE: {
+			value = SOCK_STREAM;
+			break;
+		}
+		case SO_PROTOCOL: {
+			value = IPPROTO_TCP;
+			break;
+		}
+		case SO_DOMAIN: {
+			value = __wasi_sockets_utils__posix_family(
+				socket->family);
+			break;
+		}
+		case SO_ERROR: {
+			if (socket->state.tag ==
+			    TCP_SOCKET_STATE_CONNECT_FAILED) {
+				value = __wasi_sockets_utils__map_error(
+					socket->state.connect_failed.error_code);
+				socket->state.connect_failed.error_code = 0;
+			} else {
+				value = 0;
+			}
+			break;
+		}
+		case SO_ACCEPTCONN: {
+			bool is_listening = socket->state.tag ==
+					    TCP_SOCKET_STATE_LISTENING;
+			if (is_listening !=
+			    tcp_method_tcp_socket_is_listening(
+				    socket_borrow)) { // Sanity check.
+				abort();
+			}
+			value = is_listening;
+			break;
+		}
+		case SO_KEEPALIVE: {
+			bool result;
+			if (!tcp_method_tcp_socket_keep_alive_enabled(
+				    socket_borrow, &result, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			value = result;
+			break;
+		}
+		case SO_RCVBUF: {
+			uint64_t result;
+			if (!tcp_method_tcp_socket_receive_buffer_size(
+				    socket_borrow, &result, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			if (result > INT_MAX) {
+				abort();
+			}
+
+			value = result;
+			break;
+		}
+		case SO_SNDBUF: {
+			uint64_t result;
+			if (!tcp_method_tcp_socket_send_buffer_size(
+				    socket_borrow, &result, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			if (result > INT_MAX) {
+				abort();
+			}
+
+			value = result;
+			break;
+		}
+		case SO_REUSEADDR: {
+			value = socket->fake_reuseaddr;
+			break;
+		}
+		case SO_RCVTIMEO: // TODO wasi-sockets: emulate in wasi-libc itself
+		case SO_SNDTIMEO: // TODO wasi-sockets: emulate in wasi-libc itself
+		default:
+			errno = ENOPROTOOPT;
+			return -1;
+		}
+		break;
+
+	case SOL_IP:
+		switch (optname) {
+		case IP_TTL: {
+			if (socket->family != NETWORK_IP_ADDRESS_FAMILY_IPV4) {
+				errno = EAFNOSUPPORT;
+				return -1;
+			}
+
+			uint8_t result;
+			if (!tcp_method_tcp_socket_hop_limit(socket_borrow,
+							     &result, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			value = result;
+			break;
+		}
+		default:
+			errno = ENOPROTOOPT;
+			return -1;
+		}
+		break;
+
+	case SOL_IPV6:
+		switch (optname) {
+		case IPV6_UNICAST_HOPS: {
+			if (socket->family != NETWORK_IP_ADDRESS_FAMILY_IPV6) {
+				errno = EAFNOSUPPORT;
+				return -1;
+			}
+
+			uint8_t result;
+			if (!tcp_method_tcp_socket_hop_limit(socket_borrow,
+							     &result, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			value = result;
+			break;
+		}
+		default:
+			errno = ENOPROTOOPT;
+			return -1;
+		}
+		break;
+
+	case SOL_TCP:
+		switch (optname) {
+		case TCP_NODELAY: {
+			value = socket->fake_nodelay;
+			break;
+		}
+		case TCP_KEEPIDLE: {
+			tcp_duration_t result_ns;
+			if (!tcp_method_tcp_socket_keep_alive_idle_time(
+				    socket_borrow, &result_ns, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			uint64_t result_s = result_ns / NS_PER_S;
+			if (result_s == 0) {
+				result_s =
+					1; // Value was rounded down to zero. Round it up instead, because 0 is an invalid value for this socket option.
+			}
+
+			if (result_s > INT_MAX) {
+				abort();
+			}
+
+			value = result_s;
+			break;
+		}
+		case TCP_KEEPINTVL: {
+			tcp_duration_t result_ns;
+			if (!tcp_method_tcp_socket_keep_alive_interval(
+				    socket_borrow, &result_ns, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			uint64_t result_s = result_ns / NS_PER_S;
+			if (result_s == 0) {
+				result_s =
+					1; // Value was rounded down to zero. Round it up instead, because 0 is an invalid value for this socket option.
+			}
+
+			if (result_s > INT_MAX) {
+				abort();
+			}
+
+			value = result_s;
+			break;
+		}
+		case TCP_KEEPCNT: {
+			uint32_t result;
+			if (!tcp_method_tcp_socket_keep_alive_count(
+				    socket_borrow, &result, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			if (result > INT_MAX) {
+				abort();
+			}
+
+			value = result;
+			break;
+			break;
+		}
+		default:
+			errno = ENOPROTOOPT;
+			return -1;
+		}
+		break;
+
+	default:
+		errno = ENOPROTOOPT;
+		return -1;
+	}
+
+	// Copy out integer value.
+	memcpy(optval, &value, *optlen < sizeof(int) ? *optlen : sizeof(int));
+	*optlen = sizeof(int);
+	return 0;
+}
+
+int tcp_setsockopt(tcp_socket_t *socket, int level, int optname,
+		   const void *optval, socklen_t optlen)
+{
+	int intval = *(int *)optval;
+
+	network_error_code_t error;
+	tcp_borrow_tcp_socket_t socket_borrow =
+		tcp_borrow_tcp_socket(socket->socket);
+
+	switch (level) {
+	case SOL_SOCKET:
+		switch (optname) {
+		case SO_KEEPALIVE: {
+			if (!tcp_method_tcp_socket_set_keep_alive_enabled(
+				    socket_borrow, intval != 0, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			return 0;
+		}
+		case SO_RCVBUF: {
+			if (!tcp_method_tcp_socket_set_receive_buffer_size(
+				    socket_borrow, intval, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			return 0;
+		}
+		case SO_SNDBUF: {
+			if (!tcp_method_tcp_socket_set_send_buffer_size(
+				    socket_borrow, intval, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			return 0;
+		}
+		case SO_REUSEADDR: {
+			// As of this writing, WASI has no support for changing SO_REUSEADDR
+			// -- it's enabled by default and cannot be disabled.  To keep
+			// applications happy, we pretend to support enabling and disabling
+			// it.
+			socket->fake_reuseaddr = (intval != 0);
+			return 0;
+		}
+		case SO_RCVTIMEO: // TODO wasi-sockets: emulate in wasi-libc itself
+		case SO_SNDTIMEO: // TODO wasi-sockets: emulate in wasi-libc itself
+		default:
+			errno = ENOPROTOOPT;
+			return -1;
+		}
+		break;
+
+	case SOL_IP:
+		switch (optname) {
+		case IP_TTL: {
+			if (socket->family != NETWORK_IP_ADDRESS_FAMILY_IPV4) {
+				errno = EAFNOSUPPORT;
+				return -1;
+			}
+
+			if (intval < 0 || intval > UINT8_MAX) {
+				errno = EINVAL;
+				return -1;
+			}
+
+			if (!tcp_method_tcp_socket_set_hop_limit(
+				    socket_borrow, intval, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			return 0;
+		}
+		default:
+			errno = ENOPROTOOPT;
+			return -1;
+		}
+		break;
+
+	case SOL_IPV6:
+		switch (optname) {
+		case IPV6_UNICAST_HOPS: {
+			if (socket->family != NETWORK_IP_ADDRESS_FAMILY_IPV6) {
+				errno = EAFNOSUPPORT;
+				return -1;
+			}
+
+			if (intval < 0 || intval > UINT8_MAX) {
+				errno = EINVAL;
+				return -1;
+			}
+
+			if (!tcp_method_tcp_socket_set_hop_limit(
+				    socket_borrow, intval, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			return 0;
+		}
+		default:
+			errno = ENOPROTOOPT;
+			return -1;
+		}
+		break;
+
+	case SOL_TCP:
+		switch (optname) {
+		case TCP_NODELAY: {
+			// At the time of writing, WASI has no support for TCP_NODELAY.
+			// Yet, many applications expect this option to be implemented.
+			// To ensure those applications can run on WASI at all, we fake
+			// support for it by recording the value, but not doing anything
+			// with it.
+			// If/when WASI adds true support, we can remove this workaround
+			// and implement it properly. From the application's perspective
+			// the "worst" thing that can then happen is that it automagically
+			// becomes faster.
+			socket->fake_nodelay = (intval != 0);
+			return 0;
+		}
+		case TCP_KEEPIDLE: {
+			tcp_duration_t duration = intval * NS_PER_S;
+			if (!tcp_method_tcp_socket_set_keep_alive_idle_time(
+				    socket_borrow, duration, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			return 0;
+		}
+		case TCP_KEEPINTVL: {
+			tcp_duration_t duration = intval * NS_PER_S;
+			if (!tcp_method_tcp_socket_set_keep_alive_interval(
+				    socket_borrow, duration, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			return 0;
+		}
+		case TCP_KEEPCNT: {
+			if (!tcp_method_tcp_socket_set_keep_alive_count(
+				    socket_borrow, intval, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			return 0;
+		}
+		default:
+			errno = ENOPROTOOPT;
+			return -1;
+		}
+		break;
+
+	default:
+		errno = ENOPROTOOPT;
+		return -1;
+	}
+}
+
+int udp_getsockopt(udp_socket_t *socket, int level, int optname,
+		   void *restrict optval, socklen_t *restrict optlen)
+{
+	int value;
+
+	network_error_code_t error;
+	udp_borrow_udp_socket_t socket_borrow =
+		udp_borrow_udp_socket(socket->socket);
+
+	switch (level) {
+	case SOL_SOCKET:
+		switch (optname) {
+		case SO_TYPE: {
+			value = SOCK_DGRAM;
+			break;
+		}
+		case SO_PROTOCOL: {
+			value = IPPROTO_UDP;
+			break;
+		}
+		case SO_DOMAIN: {
+			value = __wasi_sockets_utils__posix_family(
+				socket->family);
+			break;
+		}
+		case SO_RCVBUF: {
+			uint64_t result;
+			if (!udp_method_udp_socket_receive_buffer_size(
+				    socket_borrow, &result, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			if (result > INT_MAX) {
+				abort();
+			}
+
+			value = result;
+			break;
+		}
+		case SO_SNDBUF: {
+			uint64_t result;
+			if (!udp_method_udp_socket_send_buffer_size(
+				    socket_borrow, &result, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			if (result > INT_MAX) {
+				abort();
+			}
+
+			value = result;
+			break;
+		}
+		case SO_RCVTIMEO: // TODO wasi-sockets: emulate in wasi-libc itself
+		case SO_SNDTIMEO: // TODO wasi-sockets: emulate in wasi-libc itself
+		default:
+			errno = ENOPROTOOPT;
+			return -1;
+		}
+		break;
+
+	case SOL_IP:
+		switch (optname) {
+		case IP_TTL: {
+			if (socket->family != NETWORK_IP_ADDRESS_FAMILY_IPV4) {
+				errno = EAFNOSUPPORT;
+				return -1;
+			}
+
+			uint8_t result;
+			if (!udp_method_udp_socket_unicast_hop_limit(
+				    socket_borrow, &result, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			value = result;
+			break;
+		}
+		default:
+			errno = ENOPROTOOPT;
+			return -1;
+		}
+		break;
+
+	case SOL_IPV6:
+		switch (optname) {
+		case IPV6_UNICAST_HOPS: {
+			if (socket->family != NETWORK_IP_ADDRESS_FAMILY_IPV6) {
+				errno = EAFNOSUPPORT;
+				return -1;
+			}
+
+			uint8_t result;
+			if (!udp_method_udp_socket_unicast_hop_limit(
+				    socket_borrow, &result, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			value = result;
+			break;
+		}
+		default:
+			errno = ENOPROTOOPT;
+			return -1;
+		}
+		break;
+
+	default:
+		errno = ENOPROTOOPT;
+		return -1;
+	}
+
+	// Copy out integer value.
+	memcpy(optval, &value, *optlen < sizeof(int) ? *optlen : sizeof(int));
+	*optlen = sizeof(int);
+	return 0;
+}
+
+int udp_setsockopt(udp_socket_t *socket, int level, int optname,
+		   const void *optval, socklen_t optlen)
+{
+	int intval = *(int *)optval;
+
+	network_error_code_t error;
+	udp_borrow_udp_socket_t socket_borrow =
+		udp_borrow_udp_socket(socket->socket);
+
+	switch (level) {
+	case SOL_SOCKET:
+		switch (optname) {
+		case SO_RCVBUF: {
+			if (!udp_method_udp_socket_set_receive_buffer_size(
+				    socket_borrow, intval, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			return 0;
+		}
+		case SO_SNDBUF: {
+			if (!udp_method_udp_socket_set_send_buffer_size(
+				    socket_borrow, intval, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			return 0;
+		}
+		case SO_RCVTIMEO: // TODO wasi-sockets: emulate in wasi-libc itself
+		case SO_SNDTIMEO: // TODO wasi-sockets: emulate in wasi-libc itself
+		default:
+			errno = ENOPROTOOPT;
+			return -1;
+		}
+		break;
+
+	case SOL_IP:
+		switch (optname) {
+		case IP_TTL: {
+			if (socket->family != NETWORK_IP_ADDRESS_FAMILY_IPV4) {
+				errno = EAFNOSUPPORT;
+				return -1;
+			}
+
+			if (intval < 0 || intval > UINT8_MAX) {
+				errno = EINVAL;
+				return -1;
+			}
+
+			if (!udp_method_udp_socket_set_unicast_hop_limit(
+				    socket_borrow, intval, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			return 0;
+		}
+		default:
+			errno = ENOPROTOOPT;
+			return -1;
+		}
+		break;
+
+	case SOL_IPV6:
+		switch (optname) {
+		case IPV6_UNICAST_HOPS: {
+			if (socket->family != NETWORK_IP_ADDRESS_FAMILY_IPV6) {
+				errno = EAFNOSUPPORT;
+				return -1;
+			}
+
+			if (intval < 0 || intval > UINT8_MAX) {
+				errno = EINVAL;
+				return -1;
+			}
+
+			if (!udp_method_udp_socket_set_unicast_hop_limit(
+				    socket_borrow, intval, &error)) {
+				errno = __wasi_sockets_utils__map_error(error);
+				return -1;
+			}
+
+			return 0;
+		}
+		default:
+			errno = ENOPROTOOPT;
+			return -1;
+		}
+		break;
+
+	default:
+		errno = ENOPROTOOPT;
+		return -1;
+	}
+}
+
+int getsockopt(int sockfd, int level, int optname, void *restrict optval,
+	       socklen_t *restrict optlen)
+{
+	descriptor_table_entry_t *entry;
+	if (!descriptor_table_get_ref(sockfd, &entry)) {
+		errno = EBADF;
+		return -1;
+	}
+
+	if (optval == NULL || optlen == NULL || *optlen < sizeof(int)) {
+		// FYI, the protocol-specific implementations implicitly depend on these checks.
+		errno = EINVAL;
+		return -1;
+	}
+
+	switch (entry->tag) {
+	case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET:
+		return tcp_getsockopt(&entry->tcp_socket, level, optname,
+				      optval, optlen);
+	case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET:
+		return udp_getsockopt(&entry->udp_socket, level, optname,
+				      optval, optlen);
+	default:
+		errno = ENOPROTOOPT;
+		return -1;
+	}
+}
+
+int setsockopt(int sockfd, int level, int optname, const void *optval,
+	       socklen_t optlen)
+{
+	descriptor_table_entry_t *entry;
+	if (!descriptor_table_get_ref(sockfd, &entry)) {
+		errno = EBADF;
+		return -1;
+	}
+
+	if (optval == NULL || optlen < sizeof(int)) {
+		// FYI, the protocol-specific implementations implicitly depend on these checks.
+		errno = EINVAL;
+		return -1;
+	}
+
+	switch (entry->tag) {
+	case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET:
+		return tcp_setsockopt(&entry->tcp_socket, level, optname,
+				      optval, optlen);
+	case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET:
+		return udp_setsockopt(&entry->udp_socket, level, optname,
+				      optval, optlen);
+	default:
+		errno = ENOPROTOOPT;
+		return -1;
+	}
+}
diff --git a/libc-bottom-half/sources/wasip2.c b/libc-bottom-half/sources/wasip2.c
new file mode 100644
index 0000000..c55c3b0
--- /dev/null
+++ b/libc-bottom-half/sources/wasip2.c
@@ -0,0 +1,4326 @@
+// Generated by `wit-bindgen` 0.17.0. DO NOT EDIT!
+#include "wasi/wasip2.h"
+
+
+__attribute__((__import_module__("wasi:cli/environment@0.2.0"), __import_name__("get-environment")))
+extern void __wasm_import_environment_get_environment(int32_t);
+
+__attribute__((__import_module__("wasi:cli/environment@0.2.0"), __import_name__("get-arguments")))
+extern void __wasm_import_environment_get_arguments(int32_t);
+
+__attribute__((__import_module__("wasi:cli/environment@0.2.0"), __import_name__("initial-cwd")))
+extern void __wasm_import_environment_initial_cwd(int32_t);
+
+__attribute__((__import_module__("wasi:cli/exit@0.2.0"), __import_name__("exit")))
+extern void __wasm_import_exit_exit(int32_t);
+
+__attribute__((__import_module__("wasi:io/error@0.2.0"), __import_name__("[method]error.to-debug-string")))
+extern void __wasm_import_io_error_method_error_to_debug_string(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:io/poll@0.2.0"), __import_name__("[method]pollable.ready")))
+extern int32_t __wasm_import_poll_method_pollable_ready(int32_t);
+
+__attribute__((__import_module__("wasi:io/poll@0.2.0"), __import_name__("[method]pollable.block")))
+extern void __wasm_import_poll_method_pollable_block(int32_t);
+
+__attribute__((__import_module__("wasi:io/poll@0.2.0"), __import_name__("poll")))
+extern void __wasm_import_poll_poll(int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]input-stream.read")))
+extern void __wasm_import_streams_method_input_stream_read(int32_t, int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]input-stream.blocking-read")))
+extern void __wasm_import_streams_method_input_stream_blocking_read(int32_t, int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]input-stream.skip")))
+extern void __wasm_import_streams_method_input_stream_skip(int32_t, int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]input-stream.blocking-skip")))
+extern void __wasm_import_streams_method_input_stream_blocking_skip(int32_t, int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]input-stream.subscribe")))
+extern int32_t __wasm_import_streams_method_input_stream_subscribe(int32_t);
+
+__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]output-stream.check-write")))
+extern void __wasm_import_streams_method_output_stream_check_write(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]output-stream.write")))
+extern void __wasm_import_streams_method_output_stream_write(int32_t, int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]output-stream.blocking-write-and-flush")))
+extern void __wasm_import_streams_method_output_stream_blocking_write_and_flush(int32_t, int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]output-stream.flush")))
+extern void __wasm_import_streams_method_output_stream_flush(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]output-stream.blocking-flush")))
+extern void __wasm_import_streams_method_output_stream_blocking_flush(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]output-stream.subscribe")))
+extern int32_t __wasm_import_streams_method_output_stream_subscribe(int32_t);
+
+__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]output-stream.write-zeroes")))
+extern void __wasm_import_streams_method_output_stream_write_zeroes(int32_t, int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]output-stream.blocking-write-zeroes-and-flush")))
+extern void __wasm_import_streams_method_output_stream_blocking_write_zeroes_and_flush(int32_t, int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]output-stream.splice")))
+extern void __wasm_import_streams_method_output_stream_splice(int32_t, int32_t, int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]output-stream.blocking-splice")))
+extern void __wasm_import_streams_method_output_stream_blocking_splice(int32_t, int32_t, int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:cli/stdin@0.2.0"), __import_name__("get-stdin")))
+extern int32_t __wasm_import_stdin_get_stdin(void);
+
+__attribute__((__import_module__("wasi:cli/stdout@0.2.0"), __import_name__("get-stdout")))
+extern int32_t __wasm_import_stdout_get_stdout(void);
+
+__attribute__((__import_module__("wasi:cli/stderr@0.2.0"), __import_name__("get-stderr")))
+extern int32_t __wasm_import_stderr_get_stderr(void);
+
+__attribute__((__import_module__("wasi:cli/terminal-stdin@0.2.0"), __import_name__("get-terminal-stdin")))
+extern void __wasm_import_terminal_stdin_get_terminal_stdin(int32_t);
+
+__attribute__((__import_module__("wasi:cli/terminal-stdout@0.2.0"), __import_name__("get-terminal-stdout")))
+extern void __wasm_import_terminal_stdout_get_terminal_stdout(int32_t);
+
+__attribute__((__import_module__("wasi:cli/terminal-stderr@0.2.0"), __import_name__("get-terminal-stderr")))
+extern void __wasm_import_terminal_stderr_get_terminal_stderr(int32_t);
+
+__attribute__((__import_module__("wasi:clocks/monotonic-clock@0.2.0"), __import_name__("now")))
+extern int64_t __wasm_import_monotonic_clock_now(void);
+
+__attribute__((__import_module__("wasi:clocks/monotonic-clock@0.2.0"), __import_name__("resolution")))
+extern int64_t __wasm_import_monotonic_clock_resolution(void);
+
+__attribute__((__import_module__("wasi:clocks/monotonic-clock@0.2.0"), __import_name__("subscribe-instant")))
+extern int32_t __wasm_import_monotonic_clock_subscribe_instant(int64_t);
+
+__attribute__((__import_module__("wasi:clocks/monotonic-clock@0.2.0"), __import_name__("subscribe-duration")))
+extern int32_t __wasm_import_monotonic_clock_subscribe_duration(int64_t);
+
+__attribute__((__import_module__("wasi:clocks/wall-clock@0.2.0"), __import_name__("now")))
+extern void __wasm_import_wall_clock_now(int32_t);
+
+__attribute__((__import_module__("wasi:clocks/wall-clock@0.2.0"), __import_name__("resolution")))
+extern void __wasm_import_wall_clock_resolution(int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.read-via-stream")))
+extern void __wasm_import_filesystem_method_descriptor_read_via_stream(int32_t, int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.write-via-stream")))
+extern void __wasm_import_filesystem_method_descriptor_write_via_stream(int32_t, int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.append-via-stream")))
+extern void __wasm_import_filesystem_method_descriptor_append_via_stream(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.advise")))
+extern void __wasm_import_filesystem_method_descriptor_advise(int32_t, int64_t, int64_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.sync-data")))
+extern void __wasm_import_filesystem_method_descriptor_sync_data(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.get-flags")))
+extern void __wasm_import_filesystem_method_descriptor_get_flags(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.get-type")))
+extern void __wasm_import_filesystem_method_descriptor_get_type(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.set-size")))
+extern void __wasm_import_filesystem_method_descriptor_set_size(int32_t, int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.set-times")))
+extern void __wasm_import_filesystem_method_descriptor_set_times(int32_t, int32_t, int64_t, int32_t, int32_t, int64_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.read")))
+extern void __wasm_import_filesystem_method_descriptor_read(int32_t, int64_t, int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.write")))
+extern void __wasm_import_filesystem_method_descriptor_write(int32_t, int32_t, int32_t, int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.read-directory")))
+extern void __wasm_import_filesystem_method_descriptor_read_directory(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.sync")))
+extern void __wasm_import_filesystem_method_descriptor_sync(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.create-directory-at")))
+extern void __wasm_import_filesystem_method_descriptor_create_directory_at(int32_t, int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.stat")))
+extern void __wasm_import_filesystem_method_descriptor_stat(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.stat-at")))
+extern void __wasm_import_filesystem_method_descriptor_stat_at(int32_t, int32_t, int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.set-times-at")))
+extern void __wasm_import_filesystem_method_descriptor_set_times_at(int32_t, int32_t, int32_t, int32_t, int32_t, int64_t, int32_t, int32_t, int64_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.link-at")))
+extern void __wasm_import_filesystem_method_descriptor_link_at(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.open-at")))
+extern void __wasm_import_filesystem_method_descriptor_open_at(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.readlink-at")))
+extern void __wasm_import_filesystem_method_descriptor_readlink_at(int32_t, int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.remove-directory-at")))
+extern void __wasm_import_filesystem_method_descriptor_remove_directory_at(int32_t, int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.rename-at")))
+extern void __wasm_import_filesystem_method_descriptor_rename_at(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.symlink-at")))
+extern void __wasm_import_filesystem_method_descriptor_symlink_at(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.unlink-file-at")))
+extern void __wasm_import_filesystem_method_descriptor_unlink_file_at(int32_t, int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.is-same-object")))
+extern int32_t __wasm_import_filesystem_method_descriptor_is_same_object(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.metadata-hash")))
+extern void __wasm_import_filesystem_method_descriptor_metadata_hash(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.metadata-hash-at")))
+extern void __wasm_import_filesystem_method_descriptor_metadata_hash_at(int32_t, int32_t, int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]directory-entry-stream.read-directory-entry")))
+extern void __wasm_import_filesystem_method_directory_entry_stream_read_directory_entry(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("filesystem-error-code")))
+extern void __wasm_import_filesystem_filesystem_error_code(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:filesystem/preopens@0.2.0"), __import_name__("get-directories")))
+extern void __wasm_import_filesystem_preopens_get_directories(int32_t);
+
+__attribute__((__import_module__("wasi:sockets/instance-network@0.2.0"), __import_name__("instance-network")))
+extern int32_t __wasm_import_instance_network_instance_network(void);
+
+__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.start-bind")))
+extern void __wasm_import_udp_method_udp_socket_start_bind(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.finish-bind")))
+extern void __wasm_import_udp_method_udp_socket_finish_bind(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.stream")))
+extern void __wasm_import_udp_method_udp_socket_stream(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.local-address")))
+extern void __wasm_import_udp_method_udp_socket_local_address(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.remote-address")))
+extern void __wasm_import_udp_method_udp_socket_remote_address(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.address-family")))
+extern int32_t __wasm_import_udp_method_udp_socket_address_family(int32_t);
+
+__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.unicast-hop-limit")))
+extern void __wasm_import_udp_method_udp_socket_unicast_hop_limit(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.set-unicast-hop-limit")))
+extern void __wasm_import_udp_method_udp_socket_set_unicast_hop_limit(int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.receive-buffer-size")))
+extern void __wasm_import_udp_method_udp_socket_receive_buffer_size(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.set-receive-buffer-size")))
+extern void __wasm_import_udp_method_udp_socket_set_receive_buffer_size(int32_t, int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.send-buffer-size")))
+extern void __wasm_import_udp_method_udp_socket_send_buffer_size(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.set-send-buffer-size")))
+extern void __wasm_import_udp_method_udp_socket_set_send_buffer_size(int32_t, int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.subscribe")))
+extern int32_t __wasm_import_udp_method_udp_socket_subscribe(int32_t);
+
+__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]incoming-datagram-stream.receive")))
+extern void __wasm_import_udp_method_incoming_datagram_stream_receive(int32_t, int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]incoming-datagram-stream.subscribe")))
+extern int32_t __wasm_import_udp_method_incoming_datagram_stream_subscribe(int32_t);
+
+__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]outgoing-datagram-stream.check-send")))
+extern void __wasm_import_udp_method_outgoing_datagram_stream_check_send(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]outgoing-datagram-stream.send")))
+extern void __wasm_import_udp_method_outgoing_datagram_stream_send(int32_t, int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]outgoing-datagram-stream.subscribe")))
+extern int32_t __wasm_import_udp_method_outgoing_datagram_stream_subscribe(int32_t);
+
+__attribute__((__import_module__("wasi:sockets/udp-create-socket@0.2.0"), __import_name__("create-udp-socket")))
+extern void __wasm_import_udp_create_socket_create_udp_socket(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.start-bind")))
+extern void __wasm_import_tcp_method_tcp_socket_start_bind(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.finish-bind")))
+extern void __wasm_import_tcp_method_tcp_socket_finish_bind(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.start-connect")))
+extern void __wasm_import_tcp_method_tcp_socket_start_connect(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.finish-connect")))
+extern void __wasm_import_tcp_method_tcp_socket_finish_connect(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.start-listen")))
+extern void __wasm_import_tcp_method_tcp_socket_start_listen(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.finish-listen")))
+extern void __wasm_import_tcp_method_tcp_socket_finish_listen(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.accept")))
+extern void __wasm_import_tcp_method_tcp_socket_accept(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.local-address")))
+extern void __wasm_import_tcp_method_tcp_socket_local_address(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.remote-address")))
+extern void __wasm_import_tcp_method_tcp_socket_remote_address(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.is-listening")))
+extern int32_t __wasm_import_tcp_method_tcp_socket_is_listening(int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.address-family")))
+extern int32_t __wasm_import_tcp_method_tcp_socket_address_family(int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.set-listen-backlog-size")))
+extern void __wasm_import_tcp_method_tcp_socket_set_listen_backlog_size(int32_t, int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.keep-alive-enabled")))
+extern void __wasm_import_tcp_method_tcp_socket_keep_alive_enabled(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.set-keep-alive-enabled")))
+extern void __wasm_import_tcp_method_tcp_socket_set_keep_alive_enabled(int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.keep-alive-idle-time")))
+extern void __wasm_import_tcp_method_tcp_socket_keep_alive_idle_time(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.set-keep-alive-idle-time")))
+extern void __wasm_import_tcp_method_tcp_socket_set_keep_alive_idle_time(int32_t, int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.keep-alive-interval")))
+extern void __wasm_import_tcp_method_tcp_socket_keep_alive_interval(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.set-keep-alive-interval")))
+extern void __wasm_import_tcp_method_tcp_socket_set_keep_alive_interval(int32_t, int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.keep-alive-count")))
+extern void __wasm_import_tcp_method_tcp_socket_keep_alive_count(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.set-keep-alive-count")))
+extern void __wasm_import_tcp_method_tcp_socket_set_keep_alive_count(int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.hop-limit")))
+extern void __wasm_import_tcp_method_tcp_socket_hop_limit(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.set-hop-limit")))
+extern void __wasm_import_tcp_method_tcp_socket_set_hop_limit(int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.receive-buffer-size")))
+extern void __wasm_import_tcp_method_tcp_socket_receive_buffer_size(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.set-receive-buffer-size")))
+extern void __wasm_import_tcp_method_tcp_socket_set_receive_buffer_size(int32_t, int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.send-buffer-size")))
+extern void __wasm_import_tcp_method_tcp_socket_send_buffer_size(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.set-send-buffer-size")))
+extern void __wasm_import_tcp_method_tcp_socket_set_send_buffer_size(int32_t, int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.subscribe")))
+extern int32_t __wasm_import_tcp_method_tcp_socket_subscribe(int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.shutdown")))
+extern void __wasm_import_tcp_method_tcp_socket_shutdown(int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/tcp-create-socket@0.2.0"), __import_name__("create-tcp-socket")))
+extern void __wasm_import_tcp_create_socket_create_tcp_socket(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/ip-name-lookup@0.2.0"), __import_name__("resolve-addresses")))
+extern void __wasm_import_ip_name_lookup_resolve_addresses(int32_t, int32_t, int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/ip-name-lookup@0.2.0"), __import_name__("[method]resolve-address-stream.resolve-next-address")))
+extern void __wasm_import_ip_name_lookup_method_resolve_address_stream_resolve_next_address(int32_t, int32_t);
+
+__attribute__((__import_module__("wasi:sockets/ip-name-lookup@0.2.0"), __import_name__("[method]resolve-address-stream.subscribe")))
+extern int32_t __wasm_import_ip_name_lookup_method_resolve_address_stream_subscribe(int32_t);
+
+__attribute__((__import_module__("wasi:random/random@0.2.0"), __import_name__("get-random-bytes")))
+extern void __wasm_import_random_get_random_bytes(int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:random/random@0.2.0"), __import_name__("get-random-u64")))
+extern int64_t __wasm_import_random_get_random_u64(void);
+
+__attribute__((__import_module__("wasi:random/insecure@0.2.0"), __import_name__("get-insecure-random-bytes")))
+extern void __wasm_import_random_insecure_get_insecure_random_bytes(int64_t, int32_t);
+
+__attribute__((__import_module__("wasi:random/insecure@0.2.0"), __import_name__("get-insecure-random-u64")))
+extern int64_t __wasm_import_random_insecure_get_insecure_random_u64(void);
+
+__attribute__((__import_module__("wasi:random/insecure-seed@0.2.0"), __import_name__("insecure-seed")))
+extern void __wasm_import_random_insecure_seed_insecure_seed(int32_t);
+
+__attribute__((__weak__, __export_name__("cabi_realloc")))
+void *cabi_realloc(void *ptr, size_t old_size, size_t align, size_t new_size) {
+  (void) old_size;
+  if (new_size == 0) return (void*) align;
+  void *ret = realloc(ptr, new_size);
+  if (!ret) abort();
+  return ret;
+}
+
+// Helper Functions
+
+void wasip2_tuple2_string_string_free(wasip2_tuple2_string_string_t *ptr) {
+  wasip2_string_free(&ptr->f0);
+  wasip2_string_free(&ptr->f1);
+}
+
+void wasip2_list_tuple2_string_string_free(wasip2_list_tuple2_string_string_t *ptr) {
+  for (size_t i = 0; i < ptr->len; i++) {
+    wasip2_tuple2_string_string_free(&ptr->ptr[i]);
+  }
+  if (ptr->len > 0) {
+    free(ptr->ptr);
+  }
+}
+
+void wasip2_list_string_free(wasip2_list_string_t *ptr) {
+  for (size_t i = 0; i < ptr->len; i++) {
+    wasip2_string_free(&ptr->ptr[i]);
+  }
+  if (ptr->len > 0) {
+    free(ptr->ptr);
+  }
+}
+
+void wasip2_option_string_free(wasip2_option_string_t *ptr) {
+  if (ptr->is_some) {
+    wasip2_string_free(&ptr->val);
+  }
+}
+
+void exit_result_void_void_free(exit_result_void_void_t *ptr) {
+  if (!ptr->is_err) {
+  }
+}
+
+__attribute__((__import_module__("wasi:io/error@0.2.0"), __import_name__("[resource-drop]error")))
+extern void __wasm_import_io_error_error_drop(int32_t handle);
+
+void io_error_error_drop_own(io_error_own_error_t handle) {
+  __wasm_import_io_error_error_drop(handle.__handle);
+}
+
+void io_error_error_drop_borrow(io_error_borrow_error_t handle) {
+  __wasm_import_io_error_error_drop(handle.__handle);
+}
+
+io_error_borrow_error_t io_error_borrow_error(io_error_own_error_t arg) {
+  return (io_error_borrow_error_t) { arg.__handle };
+}
+
+__attribute__((__import_module__("wasi:io/poll@0.2.0"), __import_name__("[resource-drop]pollable")))
+extern void __wasm_import_poll_pollable_drop(int32_t handle);
+
+void poll_pollable_drop_own(poll_own_pollable_t handle) {
+  __wasm_import_poll_pollable_drop(handle.__handle);
+}
+
+void poll_pollable_drop_borrow(poll_borrow_pollable_t handle) {
+  __wasm_import_poll_pollable_drop(handle.__handle);
+}
+
+poll_borrow_pollable_t poll_borrow_pollable(poll_own_pollable_t arg) {
+  return (poll_borrow_pollable_t) { arg.__handle };
+}
+
+void poll_list_borrow_pollable_free(poll_list_borrow_pollable_t *ptr) {
+  for (size_t i = 0; i < ptr->len; i++) {
+  }
+  if (ptr->len > 0) {
+    free(ptr->ptr);
+  }
+}
+
+void wasip2_list_u32_free(wasip2_list_u32_t *ptr) {
+  for (size_t i = 0; i < ptr->len; i++) {
+  }
+  if (ptr->len > 0) {
+    free(ptr->ptr);
+  }
+}
+
+void streams_stream_error_free(streams_stream_error_t *ptr) {
+  switch ((int32_t) ptr->tag) {
+    case 0: {
+      break;
+    }
+  }
+}
+
+__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[resource-drop]input-stream")))
+extern void __wasm_import_streams_input_stream_drop(int32_t handle);
+
+void streams_input_stream_drop_own(streams_own_input_stream_t handle) {
+  __wasm_import_streams_input_stream_drop(handle.__handle);
+}
+
+void streams_input_stream_drop_borrow(streams_borrow_input_stream_t handle) {
+  __wasm_import_streams_input_stream_drop(handle.__handle);
+}
+
+streams_borrow_input_stream_t streams_borrow_input_stream(streams_own_input_stream_t arg) {
+  return (streams_borrow_input_stream_t) { arg.__handle };
+}
+
+__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[resource-drop]output-stream")))
+extern void __wasm_import_streams_output_stream_drop(int32_t handle);
+
+void streams_output_stream_drop_own(streams_own_output_stream_t handle) {
+  __wasm_import_streams_output_stream_drop(handle.__handle);
+}
+
+void streams_output_stream_drop_borrow(streams_borrow_output_stream_t handle) {
+  __wasm_import_streams_output_stream_drop(handle.__handle);
+}
+
+streams_borrow_output_stream_t streams_borrow_output_stream(streams_own_output_stream_t arg) {
+  return (streams_borrow_output_stream_t) { arg.__handle };
+}
+
+void wasip2_list_u8_free(wasip2_list_u8_t *ptr) {
+  for (size_t i = 0; i < ptr->len; i++) {
+  }
+  if (ptr->len > 0) {
+    free(ptr->ptr);
+  }
+}
+
+void streams_result_list_u8_stream_error_free(streams_result_list_u8_stream_error_t *ptr) {
+  if (!ptr->is_err) {
+    wasip2_list_u8_free(&ptr->val.ok);
+  } else {
+    streams_stream_error_free(&ptr->val.err);
+  }
+}
+
+void streams_result_u64_stream_error_free(streams_result_u64_stream_error_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+    streams_stream_error_free(&ptr->val.err);
+  }
+}
+
+void streams_result_void_stream_error_free(streams_result_void_stream_error_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+    streams_stream_error_free(&ptr->val.err);
+  }
+}
+
+__attribute__((__import_module__("wasi:cli/terminal-input@0.2.0"), __import_name__("[resource-drop]terminal-input")))
+extern void __wasm_import_terminal_input_terminal_input_drop(int32_t handle);
+
+void terminal_input_terminal_input_drop_own(terminal_input_own_terminal_input_t handle) {
+  __wasm_import_terminal_input_terminal_input_drop(handle.__handle);
+}
+
+void terminal_input_terminal_input_drop_borrow(terminal_input_borrow_terminal_input_t handle) {
+  __wasm_import_terminal_input_terminal_input_drop(handle.__handle);
+}
+
+terminal_input_borrow_terminal_input_t terminal_input_borrow_terminal_input(terminal_input_own_terminal_input_t arg) {
+  return (terminal_input_borrow_terminal_input_t) { arg.__handle };
+}
+
+__attribute__((__import_module__("wasi:cli/terminal-output@0.2.0"), __import_name__("[resource-drop]terminal-output")))
+extern void __wasm_import_terminal_output_terminal_output_drop(int32_t handle);
+
+void terminal_output_terminal_output_drop_own(terminal_output_own_terminal_output_t handle) {
+  __wasm_import_terminal_output_terminal_output_drop(handle.__handle);
+}
+
+void terminal_output_terminal_output_drop_borrow(terminal_output_borrow_terminal_output_t handle) {
+  __wasm_import_terminal_output_terminal_output_drop(handle.__handle);
+}
+
+terminal_output_borrow_terminal_output_t terminal_output_borrow_terminal_output(terminal_output_own_terminal_output_t arg) {
+  return (terminal_output_borrow_terminal_output_t) { arg.__handle };
+}
+
+void terminal_stdin_option_own_terminal_input_free(terminal_stdin_option_own_terminal_input_t *ptr) {
+  if (ptr->is_some) {
+  }
+}
+
+void terminal_stdout_option_own_terminal_output_free(terminal_stdout_option_own_terminal_output_t *ptr) {
+  if (ptr->is_some) {
+  }
+}
+
+void terminal_stderr_option_own_terminal_output_free(terminal_stderr_option_own_terminal_output_t *ptr) {
+  if (ptr->is_some) {
+  }
+}
+
+void filesystem_option_datetime_free(filesystem_option_datetime_t *ptr) {
+  if (ptr->is_some) {
+  }
+}
+
+void filesystem_descriptor_stat_free(filesystem_descriptor_stat_t *ptr) {
+  filesystem_option_datetime_free(&ptr->data_access_timestamp);
+  filesystem_option_datetime_free(&ptr->data_modification_timestamp);
+  filesystem_option_datetime_free(&ptr->status_change_timestamp);
+}
+
+void filesystem_new_timestamp_free(filesystem_new_timestamp_t *ptr) {
+  switch ((int32_t) ptr->tag) {
+    case 2: {
+      break;
+    }
+  }
+}
+
+void filesystem_directory_entry_free(filesystem_directory_entry_t *ptr) {
+  wasip2_string_free(&ptr->name);
+}
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[resource-drop]descriptor")))
+extern void __wasm_import_filesystem_descriptor_drop(int32_t handle);
+
+void filesystem_descriptor_drop_own(filesystem_own_descriptor_t handle) {
+  __wasm_import_filesystem_descriptor_drop(handle.__handle);
+}
+
+void filesystem_descriptor_drop_borrow(filesystem_borrow_descriptor_t handle) {
+  __wasm_import_filesystem_descriptor_drop(handle.__handle);
+}
+
+filesystem_borrow_descriptor_t filesystem_borrow_descriptor(filesystem_own_descriptor_t arg) {
+  return (filesystem_borrow_descriptor_t) { arg.__handle };
+}
+
+__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[resource-drop]directory-entry-stream")))
+extern void __wasm_import_filesystem_directory_entry_stream_drop(int32_t handle);
+
+void filesystem_directory_entry_stream_drop_own(filesystem_own_directory_entry_stream_t handle) {
+  __wasm_import_filesystem_directory_entry_stream_drop(handle.__handle);
+}
+
+void filesystem_directory_entry_stream_drop_borrow(filesystem_borrow_directory_entry_stream_t handle) {
+  __wasm_import_filesystem_directory_entry_stream_drop(handle.__handle);
+}
+
+filesystem_borrow_directory_entry_stream_t filesystem_borrow_directory_entry_stream(filesystem_own_directory_entry_stream_t arg) {
+  return (filesystem_borrow_directory_entry_stream_t) { arg.__handle };
+}
+
+void filesystem_result_own_input_stream_error_code_free(filesystem_result_own_input_stream_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void filesystem_result_own_output_stream_error_code_free(filesystem_result_own_output_stream_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void filesystem_result_void_error_code_free(filesystem_result_void_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void filesystem_result_descriptor_flags_error_code_free(filesystem_result_descriptor_flags_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void filesystem_result_descriptor_type_error_code_free(filesystem_result_descriptor_type_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void filesystem_result_tuple2_list_u8_bool_error_code_free(filesystem_result_tuple2_list_u8_bool_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void filesystem_result_filesize_error_code_free(filesystem_result_filesize_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void filesystem_result_own_directory_entry_stream_error_code_free(filesystem_result_own_directory_entry_stream_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void filesystem_result_descriptor_stat_error_code_free(filesystem_result_descriptor_stat_error_code_t *ptr) {
+  if (!ptr->is_err) {
+    filesystem_descriptor_stat_free(&ptr->val.ok);
+  } else {
+  }
+}
+
+void filesystem_result_own_descriptor_error_code_free(filesystem_result_own_descriptor_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void filesystem_result_string_error_code_free(filesystem_result_string_error_code_t *ptr) {
+  if (!ptr->is_err) {
+    wasip2_string_free(&ptr->val.ok);
+  } else {
+  }
+}
+
+void filesystem_result_metadata_hash_value_error_code_free(filesystem_result_metadata_hash_value_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void filesystem_option_directory_entry_free(filesystem_option_directory_entry_t *ptr) {
+  if (ptr->is_some) {
+    filesystem_directory_entry_free(&ptr->val);
+  }
+}
+
+void filesystem_result_option_directory_entry_error_code_free(filesystem_result_option_directory_entry_error_code_t *ptr) {
+  if (!ptr->is_err) {
+    filesystem_option_directory_entry_free(&ptr->val.ok);
+  } else {
+  }
+}
+
+void filesystem_option_error_code_free(filesystem_option_error_code_t *ptr) {
+  if (ptr->is_some) {
+  }
+}
+
+void filesystem_preopens_tuple2_own_descriptor_string_free(filesystem_preopens_tuple2_own_descriptor_string_t *ptr) {
+  wasip2_string_free(&ptr->f1);
+}
+
+void filesystem_preopens_list_tuple2_own_descriptor_string_free(filesystem_preopens_list_tuple2_own_descriptor_string_t *ptr) {
+  for (size_t i = 0; i < ptr->len; i++) {
+    filesystem_preopens_tuple2_own_descriptor_string_free(&ptr->ptr[i]);
+  }
+  if (ptr->len > 0) {
+    free(ptr->ptr);
+  }
+}
+
+__attribute__((__import_module__("wasi:sockets/network@0.2.0"), __import_name__("[resource-drop]network")))
+extern void __wasm_import_network_network_drop(int32_t handle);
+
+void network_network_drop_own(network_own_network_t handle) {
+  __wasm_import_network_network_drop(handle.__handle);
+}
+
+void network_network_drop_borrow(network_borrow_network_t handle) {
+  __wasm_import_network_network_drop(handle.__handle);
+}
+
+network_borrow_network_t network_borrow_network(network_own_network_t arg) {
+  return (network_borrow_network_t) { arg.__handle };
+}
+
+void network_ip_address_free(network_ip_address_t *ptr) {
+  switch ((int32_t) ptr->tag) {
+    case 0: {
+      break;
+    }
+    case 1: {
+      break;
+    }
+  }
+}
+
+void network_ip_socket_address_free(network_ip_socket_address_t *ptr) {
+  switch ((int32_t) ptr->tag) {
+    case 0: {
+      break;
+    }
+    case 1: {
+      break;
+    }
+  }
+}
+
+void udp_ip_socket_address_free(udp_ip_socket_address_t *ptr) {
+  network_ip_socket_address_free(ptr);
+}
+
+void udp_incoming_datagram_free(udp_incoming_datagram_t *ptr) {
+  udp_ip_socket_address_free(&ptr->remote_address);
+}
+
+void udp_option_ip_socket_address_free(udp_option_ip_socket_address_t *ptr) {
+  if (ptr->is_some) {
+    udp_ip_socket_address_free(&ptr->val);
+  }
+}
+
+void udp_outgoing_datagram_free(udp_outgoing_datagram_t *ptr) {
+  udp_option_ip_socket_address_free(&ptr->remote_address);
+}
+
+__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[resource-drop]udp-socket")))
+extern void __wasm_import_udp_udp_socket_drop(int32_t handle);
+
+void udp_udp_socket_drop_own(udp_own_udp_socket_t handle) {
+  __wasm_import_udp_udp_socket_drop(handle.__handle);
+}
+
+void udp_udp_socket_drop_borrow(udp_borrow_udp_socket_t handle) {
+  __wasm_import_udp_udp_socket_drop(handle.__handle);
+}
+
+udp_borrow_udp_socket_t udp_borrow_udp_socket(udp_own_udp_socket_t arg) {
+  return (udp_borrow_udp_socket_t) { arg.__handle };
+}
+
+__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[resource-drop]incoming-datagram-stream")))
+extern void __wasm_import_udp_incoming_datagram_stream_drop(int32_t handle);
+
+void udp_incoming_datagram_stream_drop_own(udp_own_incoming_datagram_stream_t handle) {
+  __wasm_import_udp_incoming_datagram_stream_drop(handle.__handle);
+}
+
+void udp_incoming_datagram_stream_drop_borrow(udp_borrow_incoming_datagram_stream_t handle) {
+  __wasm_import_udp_incoming_datagram_stream_drop(handle.__handle);
+}
+
+udp_borrow_incoming_datagram_stream_t udp_borrow_incoming_datagram_stream(udp_own_incoming_datagram_stream_t arg) {
+  return (udp_borrow_incoming_datagram_stream_t) { arg.__handle };
+}
+
+__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[resource-drop]outgoing-datagram-stream")))
+extern void __wasm_import_udp_outgoing_datagram_stream_drop(int32_t handle);
+
+void udp_outgoing_datagram_stream_drop_own(udp_own_outgoing_datagram_stream_t handle) {
+  __wasm_import_udp_outgoing_datagram_stream_drop(handle.__handle);
+}
+
+void udp_outgoing_datagram_stream_drop_borrow(udp_borrow_outgoing_datagram_stream_t handle) {
+  __wasm_import_udp_outgoing_datagram_stream_drop(handle.__handle);
+}
+
+udp_borrow_outgoing_datagram_stream_t udp_borrow_outgoing_datagram_stream(udp_own_outgoing_datagram_stream_t arg) {
+  return (udp_borrow_outgoing_datagram_stream_t) { arg.__handle };
+}
+
+void udp_result_void_error_code_free(udp_result_void_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void udp_result_tuple2_own_incoming_datagram_stream_own_outgoing_datagram_stream_error_code_free(udp_result_tuple2_own_incoming_datagram_stream_own_outgoing_datagram_stream_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void udp_result_ip_socket_address_error_code_free(udp_result_ip_socket_address_error_code_t *ptr) {
+  if (!ptr->is_err) {
+    udp_ip_socket_address_free(&ptr->val.ok);
+  } else {
+  }
+}
+
+void udp_result_u8_error_code_free(udp_result_u8_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void udp_result_u64_error_code_free(udp_result_u64_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void udp_list_incoming_datagram_free(udp_list_incoming_datagram_t *ptr) {
+  for (size_t i = 0; i < ptr->len; i++) {
+    udp_incoming_datagram_free(&ptr->ptr[i]);
+  }
+  if (ptr->len > 0) {
+    free(ptr->ptr);
+  }
+}
+
+void udp_result_list_incoming_datagram_error_code_free(udp_result_list_incoming_datagram_error_code_t *ptr) {
+  if (!ptr->is_err) {
+    udp_list_incoming_datagram_free(&ptr->val.ok);
+  } else {
+  }
+}
+
+void udp_list_outgoing_datagram_free(udp_list_outgoing_datagram_t *ptr) {
+  for (size_t i = 0; i < ptr->len; i++) {
+    udp_outgoing_datagram_free(&ptr->ptr[i]);
+  }
+  if (ptr->len > 0) {
+    free(ptr->ptr);
+  }
+}
+
+void udp_create_socket_result_own_udp_socket_error_code_free(udp_create_socket_result_own_udp_socket_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void tcp_ip_socket_address_free(tcp_ip_socket_address_t *ptr) {
+  network_ip_socket_address_free(ptr);
+}
+
+__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[resource-drop]tcp-socket")))
+extern void __wasm_import_tcp_tcp_socket_drop(int32_t handle);
+
+void tcp_tcp_socket_drop_own(tcp_own_tcp_socket_t handle) {
+  __wasm_import_tcp_tcp_socket_drop(handle.__handle);
+}
+
+void tcp_tcp_socket_drop_borrow(tcp_borrow_tcp_socket_t handle) {
+  __wasm_import_tcp_tcp_socket_drop(handle.__handle);
+}
+
+tcp_borrow_tcp_socket_t tcp_borrow_tcp_socket(tcp_own_tcp_socket_t arg) {
+  return (tcp_borrow_tcp_socket_t) { arg.__handle };
+}
+
+void tcp_result_void_error_code_free(tcp_result_void_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void tcp_result_tuple2_own_input_stream_own_output_stream_error_code_free(tcp_result_tuple2_own_input_stream_own_output_stream_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void tcp_result_tuple3_own_tcp_socket_own_input_stream_own_output_stream_error_code_free(tcp_result_tuple3_own_tcp_socket_own_input_stream_own_output_stream_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void tcp_result_ip_socket_address_error_code_free(tcp_result_ip_socket_address_error_code_t *ptr) {
+  if (!ptr->is_err) {
+    tcp_ip_socket_address_free(&ptr->val.ok);
+  } else {
+  }
+}
+
+void tcp_result_bool_error_code_free(tcp_result_bool_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void tcp_result_duration_error_code_free(tcp_result_duration_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void tcp_result_u32_error_code_free(tcp_result_u32_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void tcp_result_u8_error_code_free(tcp_result_u8_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void tcp_result_u64_error_code_free(tcp_result_u64_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void tcp_create_socket_result_own_tcp_socket_error_code_free(tcp_create_socket_result_own_tcp_socket_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void ip_name_lookup_ip_address_free(ip_name_lookup_ip_address_t *ptr) {
+  network_ip_address_free(ptr);
+}
+
+__attribute__((__import_module__("wasi:sockets/ip-name-lookup@0.2.0"), __import_name__("[resource-drop]resolve-address-stream")))
+extern void __wasm_import_ip_name_lookup_resolve_address_stream_drop(int32_t handle);
+
+void ip_name_lookup_resolve_address_stream_drop_own(ip_name_lookup_own_resolve_address_stream_t handle) {
+  __wasm_import_ip_name_lookup_resolve_address_stream_drop(handle.__handle);
+}
+
+void ip_name_lookup_resolve_address_stream_drop_borrow(ip_name_lookup_borrow_resolve_address_stream_t handle) {
+  __wasm_import_ip_name_lookup_resolve_address_stream_drop(handle.__handle);
+}
+
+ip_name_lookup_borrow_resolve_address_stream_t ip_name_lookup_borrow_resolve_address_stream(ip_name_lookup_own_resolve_address_stream_t arg) {
+  return (ip_name_lookup_borrow_resolve_address_stream_t) { arg.__handle };
+}
+
+void ip_name_lookup_result_own_resolve_address_stream_error_code_free(ip_name_lookup_result_own_resolve_address_stream_error_code_t *ptr) {
+  if (!ptr->is_err) {
+  } else {
+  }
+}
+
+void ip_name_lookup_option_ip_address_free(ip_name_lookup_option_ip_address_t *ptr) {
+  if (ptr->is_some) {
+    ip_name_lookup_ip_address_free(&ptr->val);
+  }
+}
+
+void ip_name_lookup_result_option_ip_address_error_code_free(ip_name_lookup_result_option_ip_address_error_code_t *ptr) {
+  if (!ptr->is_err) {
+    ip_name_lookup_option_ip_address_free(&ptr->val.ok);
+  } else {
+  }
+}
+
+void wasip2_string_set(wasip2_string_t *ret, char*s) {
+  ret->ptr = (uint8_t*) s;
+  ret->len = strlen(s);
+}
+
+void wasip2_string_dup(wasip2_string_t *ret, const char*s) {
+  ret->len = strlen(s);
+  ret->ptr = cabi_realloc(NULL, 0, 1, ret->len * 1);
+  memcpy(ret->ptr, s, ret->len * 1);
+}
+
+void wasip2_string_free(wasip2_string_t *ret) {
+  if (ret->len > 0) {
+    free(ret->ptr);
+  }
+  ret->ptr = NULL;
+  ret->len = 0;
+}
+
+// Component Adapters
+
+void environment_get_environment(wasip2_list_tuple2_string_string_t *ret) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[8];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_environment_get_environment(ptr);
+  *ret = (wasip2_list_tuple2_string_string_t) { (wasip2_tuple2_string_string_t*)(*((int32_t*) (ptr + 0))), (size_t)(*((int32_t*) (ptr + 4))) };
+}
+
+void environment_get_arguments(wasip2_list_string_t *ret) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[8];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_environment_get_arguments(ptr);
+  *ret = (wasip2_list_string_t) { (wasip2_string_t*)(*((int32_t*) (ptr + 0))), (size_t)(*((int32_t*) (ptr + 4))) };
+}
+
+bool environment_initial_cwd(wasip2_string_t *ret) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[12];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_environment_initial_cwd(ptr);
+  wasip2_option_string_t option;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      option.is_some = false;
+      break;
+    }
+    case 1: {
+      option.is_some = true;
+      option.val = (wasip2_string_t) { (uint8_t*)(*((int32_t*) (ptr + 4))), (size_t)(*((int32_t*) (ptr + 8))) };
+      break;
+    }
+  }
+  *ret = option.val;
+  return option.is_some;
+}
+
+void exit_exit(exit_result_void_void_t *status) {
+  int32_t result;
+  if ((*status).is_err) {
+    result = 1;
+  } else {
+    result = 0;
+  }
+  __wasm_import_exit_exit(result);
+}
+
+void io_error_method_error_to_debug_string(io_error_borrow_error_t self, wasip2_string_t *ret) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[8];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_io_error_method_error_to_debug_string((self).__handle, ptr);
+  *ret = (wasip2_string_t) { (uint8_t*)(*((int32_t*) (ptr + 0))), (size_t)(*((int32_t*) (ptr + 4))) };
+}
+
+bool poll_method_pollable_ready(poll_borrow_pollable_t self) {
+  int32_t ret = __wasm_import_poll_method_pollable_ready((self).__handle);
+  return ret;
+}
+
+void poll_method_pollable_block(poll_borrow_pollable_t self) {
+  __wasm_import_poll_method_pollable_block((self).__handle);
+}
+
+void poll_poll(poll_list_borrow_pollable_t *in, wasip2_list_u32_t *ret) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[8];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_poll_poll((int32_t) (*in).ptr, (int32_t) (*in).len, ptr);
+  *ret = (wasip2_list_u32_t) { (uint32_t*)(*((int32_t*) (ptr + 0))), (size_t)(*((int32_t*) (ptr + 4))) };
+}
+
+bool streams_method_input_stream_read(streams_borrow_input_stream_t self, uint64_t len, wasip2_list_u8_t *ret, streams_stream_error_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[12];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_streams_method_input_stream_read((self).__handle, (int64_t) (len), ptr);
+  streams_result_list_u8_stream_error_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (wasip2_list_u8_t) { (uint8_t*)(*((int32_t*) (ptr + 4))), (size_t)(*((int32_t*) (ptr + 8))) };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      streams_stream_error_t variant;
+      variant.tag = (int32_t) (*((uint8_t*) (ptr + 4)));
+      switch ((int32_t) variant.tag) {
+        case 0: {
+          variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 8)) };
+          break;
+        }
+        case 1: {
+          break;
+        }
+      }
+      
+      result.val.err = variant;
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool streams_method_input_stream_blocking_read(streams_borrow_input_stream_t self, uint64_t len, wasip2_list_u8_t *ret, streams_stream_error_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[12];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_streams_method_input_stream_blocking_read((self).__handle, (int64_t) (len), ptr);
+  streams_result_list_u8_stream_error_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (wasip2_list_u8_t) { (uint8_t*)(*((int32_t*) (ptr + 4))), (size_t)(*((int32_t*) (ptr + 8))) };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      streams_stream_error_t variant;
+      variant.tag = (int32_t) (*((uint8_t*) (ptr + 4)));
+      switch ((int32_t) variant.tag) {
+        case 0: {
+          variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 8)) };
+          break;
+        }
+        case 1: {
+          break;
+        }
+      }
+      
+      result.val.err = variant;
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool streams_method_input_stream_skip(streams_borrow_input_stream_t self, uint64_t len, uint64_t *ret, streams_stream_error_t *err) {
+  __attribute__((__aligned__(8)))
+  uint8_t ret_area[16];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_streams_method_input_stream_skip((self).__handle, (int64_t) (len), ptr);
+  streams_result_u64_stream_error_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8)));
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      streams_stream_error_t variant;
+      variant.tag = (int32_t) (*((uint8_t*) (ptr + 8)));
+      switch ((int32_t) variant.tag) {
+        case 0: {
+          variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 12)) };
+          break;
+        }
+        case 1: {
+          break;
+        }
+      }
+      
+      result.val.err = variant;
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool streams_method_input_stream_blocking_skip(streams_borrow_input_stream_t self, uint64_t len, uint64_t *ret, streams_stream_error_t *err) {
+  __attribute__((__aligned__(8)))
+  uint8_t ret_area[16];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_streams_method_input_stream_blocking_skip((self).__handle, (int64_t) (len), ptr);
+  streams_result_u64_stream_error_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8)));
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      streams_stream_error_t variant;
+      variant.tag = (int32_t) (*((uint8_t*) (ptr + 8)));
+      switch ((int32_t) variant.tag) {
+        case 0: {
+          variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 12)) };
+          break;
+        }
+        case 1: {
+          break;
+        }
+      }
+      
+      result.val.err = variant;
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+streams_own_pollable_t streams_method_input_stream_subscribe(streams_borrow_input_stream_t self) {
+  int32_t ret = __wasm_import_streams_method_input_stream_subscribe((self).__handle);
+  return (streams_own_pollable_t) { ret };
+}
+
+bool streams_method_output_stream_check_write(streams_borrow_output_stream_t self, uint64_t *ret, streams_stream_error_t *err) {
+  __attribute__((__aligned__(8)))
+  uint8_t ret_area[16];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_streams_method_output_stream_check_write((self).__handle, ptr);
+  streams_result_u64_stream_error_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8)));
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      streams_stream_error_t variant;
+      variant.tag = (int32_t) (*((uint8_t*) (ptr + 8)));
+      switch ((int32_t) variant.tag) {
+        case 0: {
+          variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 12)) };
+          break;
+        }
+        case 1: {
+          break;
+        }
+      }
+      
+      result.val.err = variant;
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool streams_method_output_stream_write(streams_borrow_output_stream_t self, wasip2_list_u8_t *contents, streams_stream_error_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[12];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_streams_method_output_stream_write((self).__handle, (int32_t) (*contents).ptr, (int32_t) (*contents).len, ptr);
+  streams_result_void_stream_error_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      streams_stream_error_t variant;
+      variant.tag = (int32_t) (*((uint8_t*) (ptr + 4)));
+      switch ((int32_t) variant.tag) {
+        case 0: {
+          variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 8)) };
+          break;
+        }
+        case 1: {
+          break;
+        }
+      }
+      
+      result.val.err = variant;
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool streams_method_output_stream_blocking_write_and_flush(streams_borrow_output_stream_t self, wasip2_list_u8_t *contents, streams_stream_error_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[12];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_streams_method_output_stream_blocking_write_and_flush((self).__handle, (int32_t) (*contents).ptr, (int32_t) (*contents).len, ptr);
+  streams_result_void_stream_error_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      streams_stream_error_t variant;
+      variant.tag = (int32_t) (*((uint8_t*) (ptr + 4)));
+      switch ((int32_t) variant.tag) {
+        case 0: {
+          variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 8)) };
+          break;
+        }
+        case 1: {
+          break;
+        }
+      }
+      
+      result.val.err = variant;
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool streams_method_output_stream_flush(streams_borrow_output_stream_t self, streams_stream_error_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[12];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_streams_method_output_stream_flush((self).__handle, ptr);
+  streams_result_void_stream_error_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      streams_stream_error_t variant;
+      variant.tag = (int32_t) (*((uint8_t*) (ptr + 4)));
+      switch ((int32_t) variant.tag) {
+        case 0: {
+          variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 8)) };
+          break;
+        }
+        case 1: {
+          break;
+        }
+      }
+      
+      result.val.err = variant;
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool streams_method_output_stream_blocking_flush(streams_borrow_output_stream_t self, streams_stream_error_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[12];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_streams_method_output_stream_blocking_flush((self).__handle, ptr);
+  streams_result_void_stream_error_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      streams_stream_error_t variant;
+      variant.tag = (int32_t) (*((uint8_t*) (ptr + 4)));
+      switch ((int32_t) variant.tag) {
+        case 0: {
+          variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 8)) };
+          break;
+        }
+        case 1: {
+          break;
+        }
+      }
+      
+      result.val.err = variant;
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+streams_own_pollable_t streams_method_output_stream_subscribe(streams_borrow_output_stream_t self) {
+  int32_t ret = __wasm_import_streams_method_output_stream_subscribe((self).__handle);
+  return (streams_own_pollable_t) { ret };
+}
+
+bool streams_method_output_stream_write_zeroes(streams_borrow_output_stream_t self, uint64_t len, streams_stream_error_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[12];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_streams_method_output_stream_write_zeroes((self).__handle, (int64_t) (len), ptr);
+  streams_result_void_stream_error_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      streams_stream_error_t variant;
+      variant.tag = (int32_t) (*((uint8_t*) (ptr + 4)));
+      switch ((int32_t) variant.tag) {
+        case 0: {
+          variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 8)) };
+          break;
+        }
+        case 1: {
+          break;
+        }
+      }
+      
+      result.val.err = variant;
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool streams_method_output_stream_blocking_write_zeroes_and_flush(streams_borrow_output_stream_t self, uint64_t len, streams_stream_error_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[12];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_streams_method_output_stream_blocking_write_zeroes_and_flush((self).__handle, (int64_t) (len), ptr);
+  streams_result_void_stream_error_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      streams_stream_error_t variant;
+      variant.tag = (int32_t) (*((uint8_t*) (ptr + 4)));
+      switch ((int32_t) variant.tag) {
+        case 0: {
+          variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 8)) };
+          break;
+        }
+        case 1: {
+          break;
+        }
+      }
+      
+      result.val.err = variant;
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool streams_method_output_stream_splice(streams_borrow_output_stream_t self, streams_borrow_input_stream_t src, uint64_t len, uint64_t *ret, streams_stream_error_t *err) {
+  __attribute__((__aligned__(8)))
+  uint8_t ret_area[16];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_streams_method_output_stream_splice((self).__handle, (src).__handle, (int64_t) (len), ptr);
+  streams_result_u64_stream_error_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8)));
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      streams_stream_error_t variant;
+      variant.tag = (int32_t) (*((uint8_t*) (ptr + 8)));
+      switch ((int32_t) variant.tag) {
+        case 0: {
+          variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 12)) };
+          break;
+        }
+        case 1: {
+          break;
+        }
+      }
+      
+      result.val.err = variant;
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool streams_method_output_stream_blocking_splice(streams_borrow_output_stream_t self, streams_borrow_input_stream_t src, uint64_t len, uint64_t *ret, streams_stream_error_t *err) {
+  __attribute__((__aligned__(8)))
+  uint8_t ret_area[16];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_streams_method_output_stream_blocking_splice((self).__handle, (src).__handle, (int64_t) (len), ptr);
+  streams_result_u64_stream_error_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8)));
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      streams_stream_error_t variant;
+      variant.tag = (int32_t) (*((uint8_t*) (ptr + 8)));
+      switch ((int32_t) variant.tag) {
+        case 0: {
+          variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 12)) };
+          break;
+        }
+        case 1: {
+          break;
+        }
+      }
+      
+      result.val.err = variant;
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+stdin_own_input_stream_t stdin_get_stdin(void) {
+  int32_t ret = __wasm_import_stdin_get_stdin();
+  return (stdin_own_input_stream_t) { ret };
+}
+
+stdout_own_output_stream_t stdout_get_stdout(void) {
+  int32_t ret = __wasm_import_stdout_get_stdout();
+  return (stdout_own_output_stream_t) { ret };
+}
+
+stderr_own_output_stream_t stderr_get_stderr(void) {
+  int32_t ret = __wasm_import_stderr_get_stderr();
+  return (stderr_own_output_stream_t) { ret };
+}
+
+bool terminal_stdin_get_terminal_stdin(terminal_stdin_own_terminal_input_t *ret) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[8];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_terminal_stdin_get_terminal_stdin(ptr);
+  terminal_stdin_option_own_terminal_input_t option;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      option.is_some = false;
+      break;
+    }
+    case 1: {
+      option.is_some = true;
+      option.val = (terminal_stdin_own_terminal_input_t) { *((int32_t*) (ptr + 4)) };
+      break;
+    }
+  }
+  *ret = option.val;
+  return option.is_some;
+}
+
+bool terminal_stdout_get_terminal_stdout(terminal_stdout_own_terminal_output_t *ret) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[8];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_terminal_stdout_get_terminal_stdout(ptr);
+  terminal_stdout_option_own_terminal_output_t option;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      option.is_some = false;
+      break;
+    }
+    case 1: {
+      option.is_some = true;
+      option.val = (terminal_stdout_own_terminal_output_t) { *((int32_t*) (ptr + 4)) };
+      break;
+    }
+  }
+  *ret = option.val;
+  return option.is_some;
+}
+
+bool terminal_stderr_get_terminal_stderr(terminal_stderr_own_terminal_output_t *ret) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[8];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_terminal_stderr_get_terminal_stderr(ptr);
+  terminal_stderr_option_own_terminal_output_t option;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      option.is_some = false;
+      break;
+    }
+    case 1: {
+      option.is_some = true;
+      option.val = (terminal_stderr_own_terminal_output_t) { *((int32_t*) (ptr + 4)) };
+      break;
+    }
+  }
+  *ret = option.val;
+  return option.is_some;
+}
+
+monotonic_clock_instant_t monotonic_clock_now(void) {
+  int64_t ret = __wasm_import_monotonic_clock_now();
+  return (uint64_t) (ret);
+}
+
+monotonic_clock_duration_t monotonic_clock_resolution(void) {
+  int64_t ret = __wasm_import_monotonic_clock_resolution();
+  return (uint64_t) (ret);
+}
+
+monotonic_clock_own_pollable_t monotonic_clock_subscribe_instant(monotonic_clock_instant_t when) {
+  int32_t ret = __wasm_import_monotonic_clock_subscribe_instant((int64_t) (when));
+  return (monotonic_clock_own_pollable_t) { ret };
+}
+
+monotonic_clock_own_pollable_t monotonic_clock_subscribe_duration(monotonic_clock_duration_t when) {
+  int32_t ret = __wasm_import_monotonic_clock_subscribe_duration((int64_t) (when));
+  return (monotonic_clock_own_pollable_t) { ret };
+}
+
+void wall_clock_now(wall_clock_datetime_t *ret) {
+  __attribute__((__aligned__(8)))
+  uint8_t ret_area[16];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_wall_clock_now(ptr);
+  *ret = (wall_clock_datetime_t) {
+    (uint64_t) (*((int64_t*) (ptr + 0))),
+    (uint32_t) (*((int32_t*) (ptr + 8))),
+  };
+}
+
+void wall_clock_resolution(wall_clock_datetime_t *ret) {
+  __attribute__((__aligned__(8)))
+  uint8_t ret_area[16];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_wall_clock_resolution(ptr);
+  *ret = (wall_clock_datetime_t) {
+    (uint64_t) (*((int64_t*) (ptr + 0))),
+    (uint32_t) (*((int32_t*) (ptr + 8))),
+  };
+}
+
+bool filesystem_method_descriptor_read_via_stream(filesystem_borrow_descriptor_t self, filesystem_filesize_t offset, filesystem_own_input_stream_t *ret, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[8];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_read_via_stream((self).__handle, (int64_t) (offset), ptr);
+  filesystem_result_own_input_stream_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (filesystem_own_input_stream_t) { *((int32_t*) (ptr + 4)) };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_write_via_stream(filesystem_borrow_descriptor_t self, filesystem_filesize_t offset, filesystem_own_output_stream_t *ret, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[8];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_write_via_stream((self).__handle, (int64_t) (offset), ptr);
+  filesystem_result_own_output_stream_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (filesystem_own_output_stream_t) { *((int32_t*) (ptr + 4)) };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_append_via_stream(filesystem_borrow_descriptor_t self, filesystem_own_output_stream_t *ret, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[8];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_append_via_stream((self).__handle, ptr);
+  filesystem_result_own_output_stream_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (filesystem_own_output_stream_t) { *((int32_t*) (ptr + 4)) };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_advise(filesystem_borrow_descriptor_t self, filesystem_filesize_t offset, filesystem_filesize_t length, filesystem_advice_t advice, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_advise((self).__handle, (int64_t) (offset), (int64_t) (length), (int32_t) advice, ptr);
+  filesystem_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_sync_data(filesystem_borrow_descriptor_t self, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_sync_data((self).__handle, ptr);
+  filesystem_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_get_flags(filesystem_borrow_descriptor_t self, filesystem_descriptor_flags_t *ret, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_get_flags((self).__handle, ptr);
+  filesystem_result_descriptor_flags_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_get_type(filesystem_borrow_descriptor_t self, filesystem_descriptor_type_t *ret, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_get_type((self).__handle, ptr);
+  filesystem_result_descriptor_type_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_set_size(filesystem_borrow_descriptor_t self, filesystem_filesize_t size, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_set_size((self).__handle, (int64_t) (size), ptr);
+  filesystem_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_set_times(filesystem_borrow_descriptor_t self, filesystem_new_timestamp_t *data_access_timestamp, filesystem_new_timestamp_t *data_modification_timestamp, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t variant;
+  int64_t variant2;
+  int32_t variant3;
+  switch ((int32_t) (*data_access_timestamp).tag) {
+    case 0: {
+      variant = 0;
+      variant2 = 0;
+      variant3 = 0;
+      break;
+    }
+    case 1: {
+      variant = 1;
+      variant2 = 0;
+      variant3 = 0;
+      break;
+    }
+    case 2: {
+      const filesystem_datetime_t *payload1 = &(*data_access_timestamp).val.timestamp;
+      variant = 2;
+      variant2 = (int64_t) ((*payload1).seconds);
+      variant3 = (int32_t) ((*payload1).nanoseconds);
+      break;
+    }
+  }
+  int32_t variant7;
+  int64_t variant8;
+  int32_t variant9;
+  switch ((int32_t) (*data_modification_timestamp).tag) {
+    case 0: {
+      variant7 = 0;
+      variant8 = 0;
+      variant9 = 0;
+      break;
+    }
+    case 1: {
+      variant7 = 1;
+      variant8 = 0;
+      variant9 = 0;
+      break;
+    }
+    case 2: {
+      const filesystem_datetime_t *payload6 = &(*data_modification_timestamp).val.timestamp;
+      variant7 = 2;
+      variant8 = (int64_t) ((*payload6).seconds);
+      variant9 = (int32_t) ((*payload6).nanoseconds);
+      break;
+    }
+  }
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_set_times((self).__handle, variant, variant2, variant3, variant7, variant8, variant9, ptr);
+  filesystem_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_read(filesystem_borrow_descriptor_t self, filesystem_filesize_t length, filesystem_filesize_t offset, wasip2_tuple2_list_u8_bool_t *ret, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[16];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_read((self).__handle, (int64_t) (length), (int64_t) (offset), ptr);
+  filesystem_result_tuple2_list_u8_bool_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (wasip2_tuple2_list_u8_bool_t) {
+        (wasip2_list_u8_t) { (uint8_t*)(*((int32_t*) (ptr + 4))), (size_t)(*((int32_t*) (ptr + 8))) },
+        (int32_t) (*((uint8_t*) (ptr + 12))),
+      };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_write(filesystem_borrow_descriptor_t self, wasip2_list_u8_t *buffer, filesystem_filesize_t offset, filesystem_filesize_t *ret, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(8)))
+  uint8_t ret_area[16];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_write((self).__handle, (int32_t) (*buffer).ptr, (int32_t) (*buffer).len, (int64_t) (offset), ptr);
+  filesystem_result_filesize_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8)));
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 8)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_read_directory(filesystem_borrow_descriptor_t self, filesystem_own_directory_entry_stream_t *ret, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[8];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_read_directory((self).__handle, ptr);
+  filesystem_result_own_directory_entry_stream_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (filesystem_own_directory_entry_stream_t) { *((int32_t*) (ptr + 4)) };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_sync(filesystem_borrow_descriptor_t self, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_sync((self).__handle, ptr);
+  filesystem_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_create_directory_at(filesystem_borrow_descriptor_t self, wasip2_string_t *path, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_create_directory_at((self).__handle, (int32_t) (*path).ptr, (int32_t) (*path).len, ptr);
+  filesystem_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_stat(filesystem_borrow_descriptor_t self, filesystem_descriptor_stat_t *ret, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(8)))
+  uint8_t ret_area[104];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_stat((self).__handle, ptr);
+  filesystem_result_descriptor_stat_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      filesystem_option_datetime_t option;
+      switch ((int32_t) (*((uint8_t*) (ptr + 32)))) {
+        case 0: {
+          option.is_some = false;
+          break;
+        }
+        case 1: {
+          option.is_some = true;
+          option.val = (wall_clock_datetime_t) {
+            (uint64_t) (*((int64_t*) (ptr + 40))),
+            (uint32_t) (*((int32_t*) (ptr + 48))),
+          };
+          break;
+        }
+      }
+      filesystem_option_datetime_t option0;
+      switch ((int32_t) (*((uint8_t*) (ptr + 56)))) {
+        case 0: {
+          option0.is_some = false;
+          break;
+        }
+        case 1: {
+          option0.is_some = true;
+          option0.val = (wall_clock_datetime_t) {
+            (uint64_t) (*((int64_t*) (ptr + 64))),
+            (uint32_t) (*((int32_t*) (ptr + 72))),
+          };
+          break;
+        }
+      }
+      filesystem_option_datetime_t option1;
+      switch ((int32_t) (*((uint8_t*) (ptr + 80)))) {
+        case 0: {
+          option1.is_some = false;
+          break;
+        }
+        case 1: {
+          option1.is_some = true;
+          option1.val = (wall_clock_datetime_t) {
+            (uint64_t) (*((int64_t*) (ptr + 88))),
+            (uint32_t) (*((int32_t*) (ptr + 96))),
+          };
+          break;
+        }
+      }
+      
+      result.val.ok = (filesystem_descriptor_stat_t) {
+        (int32_t) (*((uint8_t*) (ptr + 8))),
+        (uint64_t) (*((int64_t*) (ptr + 16))),
+        (uint64_t) (*((int64_t*) (ptr + 24))),
+        option,
+        option0,
+        option1,
+      };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 8)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_stat_at(filesystem_borrow_descriptor_t self, filesystem_path_flags_t path_flags, wasip2_string_t *path, filesystem_descriptor_stat_t *ret, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(8)))
+  uint8_t ret_area[104];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_stat_at((self).__handle, path_flags, (int32_t) (*path).ptr, (int32_t) (*path).len, ptr);
+  filesystem_result_descriptor_stat_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      filesystem_option_datetime_t option;
+      switch ((int32_t) (*((uint8_t*) (ptr + 32)))) {
+        case 0: {
+          option.is_some = false;
+          break;
+        }
+        case 1: {
+          option.is_some = true;
+          option.val = (wall_clock_datetime_t) {
+            (uint64_t) (*((int64_t*) (ptr + 40))),
+            (uint32_t) (*((int32_t*) (ptr + 48))),
+          };
+          break;
+        }
+      }
+      filesystem_option_datetime_t option0;
+      switch ((int32_t) (*((uint8_t*) (ptr + 56)))) {
+        case 0: {
+          option0.is_some = false;
+          break;
+        }
+        case 1: {
+          option0.is_some = true;
+          option0.val = (wall_clock_datetime_t) {
+            (uint64_t) (*((int64_t*) (ptr + 64))),
+            (uint32_t) (*((int32_t*) (ptr + 72))),
+          };
+          break;
+        }
+      }
+      filesystem_option_datetime_t option1;
+      switch ((int32_t) (*((uint8_t*) (ptr + 80)))) {
+        case 0: {
+          option1.is_some = false;
+          break;
+        }
+        case 1: {
+          option1.is_some = true;
+          option1.val = (wall_clock_datetime_t) {
+            (uint64_t) (*((int64_t*) (ptr + 88))),
+            (uint32_t) (*((int32_t*) (ptr + 96))),
+          };
+          break;
+        }
+      }
+      
+      result.val.ok = (filesystem_descriptor_stat_t) {
+        (int32_t) (*((uint8_t*) (ptr + 8))),
+        (uint64_t) (*((int64_t*) (ptr + 16))),
+        (uint64_t) (*((int64_t*) (ptr + 24))),
+        option,
+        option0,
+        option1,
+      };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 8)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_set_times_at(filesystem_borrow_descriptor_t self, filesystem_path_flags_t path_flags, wasip2_string_t *path, filesystem_new_timestamp_t *data_access_timestamp, filesystem_new_timestamp_t *data_modification_timestamp, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t variant;
+  int64_t variant2;
+  int32_t variant3;
+  switch ((int32_t) (*data_access_timestamp).tag) {
+    case 0: {
+      variant = 0;
+      variant2 = 0;
+      variant3 = 0;
+      break;
+    }
+    case 1: {
+      variant = 1;
+      variant2 = 0;
+      variant3 = 0;
+      break;
+    }
+    case 2: {
+      const filesystem_datetime_t *payload1 = &(*data_access_timestamp).val.timestamp;
+      variant = 2;
+      variant2 = (int64_t) ((*payload1).seconds);
+      variant3 = (int32_t) ((*payload1).nanoseconds);
+      break;
+    }
+  }
+  int32_t variant7;
+  int64_t variant8;
+  int32_t variant9;
+  switch ((int32_t) (*data_modification_timestamp).tag) {
+    case 0: {
+      variant7 = 0;
+      variant8 = 0;
+      variant9 = 0;
+      break;
+    }
+    case 1: {
+      variant7 = 1;
+      variant8 = 0;
+      variant9 = 0;
+      break;
+    }
+    case 2: {
+      const filesystem_datetime_t *payload6 = &(*data_modification_timestamp).val.timestamp;
+      variant7 = 2;
+      variant8 = (int64_t) ((*payload6).seconds);
+      variant9 = (int32_t) ((*payload6).nanoseconds);
+      break;
+    }
+  }
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_set_times_at((self).__handle, path_flags, (int32_t) (*path).ptr, (int32_t) (*path).len, variant, variant2, variant3, variant7, variant8, variant9, ptr);
+  filesystem_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_link_at(filesystem_borrow_descriptor_t self, filesystem_path_flags_t old_path_flags, wasip2_string_t *old_path, filesystem_borrow_descriptor_t new_descriptor, wasip2_string_t *new_path, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_link_at((self).__handle, old_path_flags, (int32_t) (*old_path).ptr, (int32_t) (*old_path).len, (new_descriptor).__handle, (int32_t) (*new_path).ptr, (int32_t) (*new_path).len, ptr);
+  filesystem_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_open_at(filesystem_borrow_descriptor_t self, filesystem_path_flags_t path_flags, wasip2_string_t *path, filesystem_open_flags_t open_flags, filesystem_descriptor_flags_t flags, filesystem_own_descriptor_t *ret, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[8];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_open_at((self).__handle, path_flags, (int32_t) (*path).ptr, (int32_t) (*path).len, open_flags, flags, ptr);
+  filesystem_result_own_descriptor_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (filesystem_own_descriptor_t) { *((int32_t*) (ptr + 4)) };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_readlink_at(filesystem_borrow_descriptor_t self, wasip2_string_t *path, wasip2_string_t *ret, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[12];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_readlink_at((self).__handle, (int32_t) (*path).ptr, (int32_t) (*path).len, ptr);
+  filesystem_result_string_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (wasip2_string_t) { (uint8_t*)(*((int32_t*) (ptr + 4))), (size_t)(*((int32_t*) (ptr + 8))) };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_remove_directory_at(filesystem_borrow_descriptor_t self, wasip2_string_t *path, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_remove_directory_at((self).__handle, (int32_t) (*path).ptr, (int32_t) (*path).len, ptr);
+  filesystem_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_rename_at(filesystem_borrow_descriptor_t self, wasip2_string_t *old_path, filesystem_borrow_descriptor_t new_descriptor, wasip2_string_t *new_path, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_rename_at((self).__handle, (int32_t) (*old_path).ptr, (int32_t) (*old_path).len, (new_descriptor).__handle, (int32_t) (*new_path).ptr, (int32_t) (*new_path).len, ptr);
+  filesystem_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_symlink_at(filesystem_borrow_descriptor_t self, wasip2_string_t *old_path, wasip2_string_t *new_path, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_symlink_at((self).__handle, (int32_t) (*old_path).ptr, (int32_t) (*old_path).len, (int32_t) (*new_path).ptr, (int32_t) (*new_path).len, ptr);
+  filesystem_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_unlink_file_at(filesystem_borrow_descriptor_t self, wasip2_string_t *path, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_unlink_file_at((self).__handle, (int32_t) (*path).ptr, (int32_t) (*path).len, ptr);
+  filesystem_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_is_same_object(filesystem_borrow_descriptor_t self, filesystem_borrow_descriptor_t other) {
+  int32_t ret = __wasm_import_filesystem_method_descriptor_is_same_object((self).__handle, (other).__handle);
+  return ret;
+}
+
+bool filesystem_method_descriptor_metadata_hash(filesystem_borrow_descriptor_t self, filesystem_metadata_hash_value_t *ret, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(8)))
+  uint8_t ret_area[24];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_metadata_hash((self).__handle, ptr);
+  filesystem_result_metadata_hash_value_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (filesystem_metadata_hash_value_t) {
+        (uint64_t) (*((int64_t*) (ptr + 8))),
+        (uint64_t) (*((int64_t*) (ptr + 16))),
+      };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 8)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_descriptor_metadata_hash_at(filesystem_borrow_descriptor_t self, filesystem_path_flags_t path_flags, wasip2_string_t *path, filesystem_metadata_hash_value_t *ret, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(8)))
+  uint8_t ret_area[24];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_descriptor_metadata_hash_at((self).__handle, path_flags, (int32_t) (*path).ptr, (int32_t) (*path).len, ptr);
+  filesystem_result_metadata_hash_value_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (filesystem_metadata_hash_value_t) {
+        (uint64_t) (*((int64_t*) (ptr + 8))),
+        (uint64_t) (*((int64_t*) (ptr + 16))),
+      };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 8)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_method_directory_entry_stream_read_directory_entry(filesystem_borrow_directory_entry_stream_t self, filesystem_option_directory_entry_t *ret, filesystem_error_code_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[20];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_method_directory_entry_stream_read_directory_entry((self).__handle, ptr);
+  filesystem_result_option_directory_entry_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      filesystem_option_directory_entry_t option;
+      switch ((int32_t) (*((uint8_t*) (ptr + 4)))) {
+        case 0: {
+          option.is_some = false;
+          break;
+        }
+        case 1: {
+          option.is_some = true;
+          option.val = (filesystem_directory_entry_t) {
+            (int32_t) (*((uint8_t*) (ptr + 8))),
+            (wasip2_string_t) { (uint8_t*)(*((int32_t*) (ptr + 12))), (size_t)(*((int32_t*) (ptr + 16))) },
+          };
+          break;
+        }
+      }
+      
+      result.val.ok = option;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool filesystem_filesystem_error_code(filesystem_borrow_error_t err_, filesystem_error_code_t *ret) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_filesystem_error_code((err_).__handle, ptr);
+  filesystem_option_error_code_t option;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      option.is_some = false;
+      break;
+    }
+    case 1: {
+      option.is_some = true;
+      option.val = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  *ret = option.val;
+  return option.is_some;
+}
+
+void filesystem_preopens_get_directories(filesystem_preopens_list_tuple2_own_descriptor_string_t *ret) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[8];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_filesystem_preopens_get_directories(ptr);
+  *ret = (filesystem_preopens_list_tuple2_own_descriptor_string_t) { (filesystem_preopens_tuple2_own_descriptor_string_t*)(*((int32_t*) (ptr + 0))), (size_t)(*((int32_t*) (ptr + 4))) };
+}
+
+instance_network_own_network_t instance_network_instance_network(void) {
+  int32_t ret = __wasm_import_instance_network_instance_network();
+  return (instance_network_own_network_t) { ret };
+}
+
+bool udp_method_udp_socket_start_bind(udp_borrow_udp_socket_t self, udp_borrow_network_t network, udp_ip_socket_address_t *local_address, udp_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t variant;
+  int32_t variant1;
+  int32_t variant2;
+  int32_t variant3;
+  int32_t variant4;
+  int32_t variant5;
+  int32_t variant6;
+  int32_t variant7;
+  int32_t variant8;
+  int32_t variant9;
+  int32_t variant10;
+  int32_t variant11;
+  switch ((int32_t) (*local_address).tag) {
+    case 0: {
+      const network_ipv4_socket_address_t *payload = &(*local_address).val.ipv4;
+      variant = 0;
+      variant1 = (int32_t) ((*payload).port);
+      variant2 = (int32_t) (((*payload).address).f0);
+      variant3 = (int32_t) (((*payload).address).f1);
+      variant4 = (int32_t) (((*payload).address).f2);
+      variant5 = (int32_t) (((*payload).address).f3);
+      variant6 = 0;
+      variant7 = 0;
+      variant8 = 0;
+      variant9 = 0;
+      variant10 = 0;
+      variant11 = 0;
+      break;
+    }
+    case 1: {
+      const network_ipv6_socket_address_t *payload0 = &(*local_address).val.ipv6;
+      variant = 1;
+      variant1 = (int32_t) ((*payload0).port);
+      variant2 = (int32_t) ((*payload0).flow_info);
+      variant3 = (int32_t) (((*payload0).address).f0);
+      variant4 = (int32_t) (((*payload0).address).f1);
+      variant5 = (int32_t) (((*payload0).address).f2);
+      variant6 = (int32_t) (((*payload0).address).f3);
+      variant7 = (int32_t) (((*payload0).address).f4);
+      variant8 = (int32_t) (((*payload0).address).f5);
+      variant9 = (int32_t) (((*payload0).address).f6);
+      variant10 = (int32_t) (((*payload0).address).f7);
+      variant11 = (int32_t) ((*payload0).scope_id);
+      break;
+    }
+  }
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_udp_method_udp_socket_start_bind((self).__handle, (network).__handle, variant, variant1, variant2, variant3, variant4, variant5, variant6, variant7, variant8, variant9, variant10, variant11, ptr);
+  udp_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool udp_method_udp_socket_finish_bind(udp_borrow_udp_socket_t self, udp_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_udp_method_udp_socket_finish_bind((self).__handle, ptr);
+  udp_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool udp_method_udp_socket_stream(udp_borrow_udp_socket_t self, udp_ip_socket_address_t *maybe_remote_address, udp_tuple2_own_incoming_datagram_stream_own_outgoing_datagram_stream_t *ret, udp_error_code_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[12];
+  udp_option_ip_socket_address_t remote_address;
+  remote_address.is_some = maybe_remote_address != NULL;if (maybe_remote_address) {
+    remote_address.val = *maybe_remote_address;
+  }
+  int32_t option;
+  int32_t option14;
+  int32_t option15;
+  int32_t option16;
+  int32_t option17;
+  int32_t option18;
+  int32_t option19;
+  int32_t option20;
+  int32_t option21;
+  int32_t option22;
+  int32_t option23;
+  int32_t option24;
+  int32_t option25;
+  if ((remote_address).is_some) {
+    const udp_ip_socket_address_t *payload0 = &(remote_address).val;
+    int32_t variant;
+    int32_t variant3;
+    int32_t variant4;
+    int32_t variant5;
+    int32_t variant6;
+    int32_t variant7;
+    int32_t variant8;
+    int32_t variant9;
+    int32_t variant10;
+    int32_t variant11;
+    int32_t variant12;
+    int32_t variant13;
+    switch ((int32_t) (*payload0).tag) {
+      case 0: {
+        const network_ipv4_socket_address_t *payload1 = &(*payload0).val.ipv4;
+        variant = 0;
+        variant3 = (int32_t) ((*payload1).port);
+        variant4 = (int32_t) (((*payload1).address).f0);
+        variant5 = (int32_t) (((*payload1).address).f1);
+        variant6 = (int32_t) (((*payload1).address).f2);
+        variant7 = (int32_t) (((*payload1).address).f3);
+        variant8 = 0;
+        variant9 = 0;
+        variant10 = 0;
+        variant11 = 0;
+        variant12 = 0;
+        variant13 = 0;
+        break;
+      }
+      case 1: {
+        const network_ipv6_socket_address_t *payload2 = &(*payload0).val.ipv6;
+        variant = 1;
+        variant3 = (int32_t) ((*payload2).port);
+        variant4 = (int32_t) ((*payload2).flow_info);
+        variant5 = (int32_t) (((*payload2).address).f0);
+        variant6 = (int32_t) (((*payload2).address).f1);
+        variant7 = (int32_t) (((*payload2).address).f2);
+        variant8 = (int32_t) (((*payload2).address).f3);
+        variant9 = (int32_t) (((*payload2).address).f4);
+        variant10 = (int32_t) (((*payload2).address).f5);
+        variant11 = (int32_t) (((*payload2).address).f6);
+        variant12 = (int32_t) (((*payload2).address).f7);
+        variant13 = (int32_t) ((*payload2).scope_id);
+        break;
+      }
+    }
+    option = 1;
+    option14 = variant;
+    option15 = variant3;
+    option16 = variant4;
+    option17 = variant5;
+    option18 = variant6;
+    option19 = variant7;
+    option20 = variant8;
+    option21 = variant9;
+    option22 = variant10;
+    option23 = variant11;
+    option24 = variant12;
+    option25 = variant13;
+  } else {
+    option = 0;
+    option14 = 0;
+    option15 = 0;
+    option16 = 0;
+    option17 = 0;
+    option18 = 0;
+    option19 = 0;
+    option20 = 0;
+    option21 = 0;
+    option22 = 0;
+    option23 = 0;
+    option24 = 0;
+    option25 = 0;
+  }
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_udp_method_udp_socket_stream((self).__handle, option, option14, option15, option16, option17, option18, option19, option20, option21, option22, option23, option24, option25, ptr);
+  udp_result_tuple2_own_incoming_datagram_stream_own_outgoing_datagram_stream_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (udp_tuple2_own_incoming_datagram_stream_own_outgoing_datagram_stream_t) {
+        (udp_own_incoming_datagram_stream_t) { *((int32_t*) (ptr + 4)) },
+        (udp_own_outgoing_datagram_stream_t) { *((int32_t*) (ptr + 8)) },
+      };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool udp_method_udp_socket_local_address(udp_borrow_udp_socket_t self, udp_ip_socket_address_t *ret, udp_error_code_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[36];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_udp_method_udp_socket_local_address((self).__handle, ptr);
+  udp_result_ip_socket_address_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      network_ip_socket_address_t variant;
+      variant.tag = (int32_t) (*((uint8_t*) (ptr + 4)));
+      switch ((int32_t) variant.tag) {
+        case 0: {
+          variant.val.ipv4 = (network_ipv4_socket_address_t) {
+            (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 8)))),
+            (network_ipv4_address_t) {
+              (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 10)))),
+              (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 11)))),
+              (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 12)))),
+              (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 13)))),
+            },
+          };
+          break;
+        }
+        case 1: {
+          variant.val.ipv6 = (network_ipv6_socket_address_t) {
+            (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 8)))),
+            (uint32_t) (*((int32_t*) (ptr + 12))),
+            (network_ipv6_address_t) {
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 16)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 18)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 20)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 22)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 24)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 26)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 28)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 30)))),
+            },
+            (uint32_t) (*((int32_t*) (ptr + 32))),
+          };
+          break;
+        }
+      }
+      
+      result.val.ok = variant;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool udp_method_udp_socket_remote_address(udp_borrow_udp_socket_t self, udp_ip_socket_address_t *ret, udp_error_code_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[36];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_udp_method_udp_socket_remote_address((self).__handle, ptr);
+  udp_result_ip_socket_address_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      network_ip_socket_address_t variant;
+      variant.tag = (int32_t) (*((uint8_t*) (ptr + 4)));
+      switch ((int32_t) variant.tag) {
+        case 0: {
+          variant.val.ipv4 = (network_ipv4_socket_address_t) {
+            (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 8)))),
+            (network_ipv4_address_t) {
+              (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 10)))),
+              (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 11)))),
+              (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 12)))),
+              (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 13)))),
+            },
+          };
+          break;
+        }
+        case 1: {
+          variant.val.ipv6 = (network_ipv6_socket_address_t) {
+            (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 8)))),
+            (uint32_t) (*((int32_t*) (ptr + 12))),
+            (network_ipv6_address_t) {
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 16)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 18)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 20)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 22)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 24)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 26)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 28)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 30)))),
+            },
+            (uint32_t) (*((int32_t*) (ptr + 32))),
+          };
+          break;
+        }
+      }
+      
+      result.val.ok = variant;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+udp_ip_address_family_t udp_method_udp_socket_address_family(udp_borrow_udp_socket_t self) {
+  int32_t ret = __wasm_import_udp_method_udp_socket_address_family((self).__handle);
+  return ret;
+}
+
+bool udp_method_udp_socket_unicast_hop_limit(udp_borrow_udp_socket_t self, uint8_t *ret, udp_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_udp_method_udp_socket_unicast_hop_limit((self).__handle, ptr);
+  udp_result_u8_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 1))));
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool udp_method_udp_socket_set_unicast_hop_limit(udp_borrow_udp_socket_t self, uint8_t value, udp_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_udp_method_udp_socket_set_unicast_hop_limit((self).__handle, (int32_t) (value), ptr);
+  udp_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool udp_method_udp_socket_receive_buffer_size(udp_borrow_udp_socket_t self, uint64_t *ret, udp_error_code_t *err) {
+  __attribute__((__aligned__(8)))
+  uint8_t ret_area[16];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_udp_method_udp_socket_receive_buffer_size((self).__handle, ptr);
+  udp_result_u64_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8)));
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 8)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool udp_method_udp_socket_set_receive_buffer_size(udp_borrow_udp_socket_t self, uint64_t value, udp_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_udp_method_udp_socket_set_receive_buffer_size((self).__handle, (int64_t) (value), ptr);
+  udp_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool udp_method_udp_socket_send_buffer_size(udp_borrow_udp_socket_t self, uint64_t *ret, udp_error_code_t *err) {
+  __attribute__((__aligned__(8)))
+  uint8_t ret_area[16];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_udp_method_udp_socket_send_buffer_size((self).__handle, ptr);
+  udp_result_u64_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8)));
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 8)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool udp_method_udp_socket_set_send_buffer_size(udp_borrow_udp_socket_t self, uint64_t value, udp_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_udp_method_udp_socket_set_send_buffer_size((self).__handle, (int64_t) (value), ptr);
+  udp_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+udp_own_pollable_t udp_method_udp_socket_subscribe(udp_borrow_udp_socket_t self) {
+  int32_t ret = __wasm_import_udp_method_udp_socket_subscribe((self).__handle);
+  return (udp_own_pollable_t) { ret };
+}
+
+bool udp_method_incoming_datagram_stream_receive(udp_borrow_incoming_datagram_stream_t self, uint64_t max_results, udp_list_incoming_datagram_t *ret, udp_error_code_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[12];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_udp_method_incoming_datagram_stream_receive((self).__handle, (int64_t) (max_results), ptr);
+  udp_result_list_incoming_datagram_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (udp_list_incoming_datagram_t) { (udp_incoming_datagram_t*)(*((int32_t*) (ptr + 4))), (size_t)(*((int32_t*) (ptr + 8))) };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+udp_own_pollable_t udp_method_incoming_datagram_stream_subscribe(udp_borrow_incoming_datagram_stream_t self) {
+  int32_t ret = __wasm_import_udp_method_incoming_datagram_stream_subscribe((self).__handle);
+  return (udp_own_pollable_t) { ret };
+}
+
+bool udp_method_outgoing_datagram_stream_check_send(udp_borrow_outgoing_datagram_stream_t self, uint64_t *ret, udp_error_code_t *err) {
+  __attribute__((__aligned__(8)))
+  uint8_t ret_area[16];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_udp_method_outgoing_datagram_stream_check_send((self).__handle, ptr);
+  udp_result_u64_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8)));
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 8)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool udp_method_outgoing_datagram_stream_send(udp_borrow_outgoing_datagram_stream_t self, udp_list_outgoing_datagram_t *datagrams, uint64_t *ret, udp_error_code_t *err) {
+  __attribute__((__aligned__(8)))
+  uint8_t ret_area[16];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_udp_method_outgoing_datagram_stream_send((self).__handle, (int32_t) (*datagrams).ptr, (int32_t) (*datagrams).len, ptr);
+  udp_result_u64_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8)));
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 8)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+udp_own_pollable_t udp_method_outgoing_datagram_stream_subscribe(udp_borrow_outgoing_datagram_stream_t self) {
+  int32_t ret = __wasm_import_udp_method_outgoing_datagram_stream_subscribe((self).__handle);
+  return (udp_own_pollable_t) { ret };
+}
+
+bool udp_create_socket_create_udp_socket(udp_create_socket_ip_address_family_t address_family, udp_create_socket_own_udp_socket_t *ret, udp_create_socket_error_code_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[8];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_udp_create_socket_create_udp_socket((int32_t) address_family, ptr);
+  udp_create_socket_result_own_udp_socket_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (udp_create_socket_own_udp_socket_t) { *((int32_t*) (ptr + 4)) };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_start_bind(tcp_borrow_tcp_socket_t self, tcp_borrow_network_t network, tcp_ip_socket_address_t *local_address, tcp_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t variant;
+  int32_t variant1;
+  int32_t variant2;
+  int32_t variant3;
+  int32_t variant4;
+  int32_t variant5;
+  int32_t variant6;
+  int32_t variant7;
+  int32_t variant8;
+  int32_t variant9;
+  int32_t variant10;
+  int32_t variant11;
+  switch ((int32_t) (*local_address).tag) {
+    case 0: {
+      const network_ipv4_socket_address_t *payload = &(*local_address).val.ipv4;
+      variant = 0;
+      variant1 = (int32_t) ((*payload).port);
+      variant2 = (int32_t) (((*payload).address).f0);
+      variant3 = (int32_t) (((*payload).address).f1);
+      variant4 = (int32_t) (((*payload).address).f2);
+      variant5 = (int32_t) (((*payload).address).f3);
+      variant6 = 0;
+      variant7 = 0;
+      variant8 = 0;
+      variant9 = 0;
+      variant10 = 0;
+      variant11 = 0;
+      break;
+    }
+    case 1: {
+      const network_ipv6_socket_address_t *payload0 = &(*local_address).val.ipv6;
+      variant = 1;
+      variant1 = (int32_t) ((*payload0).port);
+      variant2 = (int32_t) ((*payload0).flow_info);
+      variant3 = (int32_t) (((*payload0).address).f0);
+      variant4 = (int32_t) (((*payload0).address).f1);
+      variant5 = (int32_t) (((*payload0).address).f2);
+      variant6 = (int32_t) (((*payload0).address).f3);
+      variant7 = (int32_t) (((*payload0).address).f4);
+      variant8 = (int32_t) (((*payload0).address).f5);
+      variant9 = (int32_t) (((*payload0).address).f6);
+      variant10 = (int32_t) (((*payload0).address).f7);
+      variant11 = (int32_t) ((*payload0).scope_id);
+      break;
+    }
+  }
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_start_bind((self).__handle, (network).__handle, variant, variant1, variant2, variant3, variant4, variant5, variant6, variant7, variant8, variant9, variant10, variant11, ptr);
+  tcp_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_finish_bind(tcp_borrow_tcp_socket_t self, tcp_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_finish_bind((self).__handle, ptr);
+  tcp_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_start_connect(tcp_borrow_tcp_socket_t self, tcp_borrow_network_t network, tcp_ip_socket_address_t *remote_address, tcp_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t variant;
+  int32_t variant1;
+  int32_t variant2;
+  int32_t variant3;
+  int32_t variant4;
+  int32_t variant5;
+  int32_t variant6;
+  int32_t variant7;
+  int32_t variant8;
+  int32_t variant9;
+  int32_t variant10;
+  int32_t variant11;
+  switch ((int32_t) (*remote_address).tag) {
+    case 0: {
+      const network_ipv4_socket_address_t *payload = &(*remote_address).val.ipv4;
+      variant = 0;
+      variant1 = (int32_t) ((*payload).port);
+      variant2 = (int32_t) (((*payload).address).f0);
+      variant3 = (int32_t) (((*payload).address).f1);
+      variant4 = (int32_t) (((*payload).address).f2);
+      variant5 = (int32_t) (((*payload).address).f3);
+      variant6 = 0;
+      variant7 = 0;
+      variant8 = 0;
+      variant9 = 0;
+      variant10 = 0;
+      variant11 = 0;
+      break;
+    }
+    case 1: {
+      const network_ipv6_socket_address_t *payload0 = &(*remote_address).val.ipv6;
+      variant = 1;
+      variant1 = (int32_t) ((*payload0).port);
+      variant2 = (int32_t) ((*payload0).flow_info);
+      variant3 = (int32_t) (((*payload0).address).f0);
+      variant4 = (int32_t) (((*payload0).address).f1);
+      variant5 = (int32_t) (((*payload0).address).f2);
+      variant6 = (int32_t) (((*payload0).address).f3);
+      variant7 = (int32_t) (((*payload0).address).f4);
+      variant8 = (int32_t) (((*payload0).address).f5);
+      variant9 = (int32_t) (((*payload0).address).f6);
+      variant10 = (int32_t) (((*payload0).address).f7);
+      variant11 = (int32_t) ((*payload0).scope_id);
+      break;
+    }
+  }
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_start_connect((self).__handle, (network).__handle, variant, variant1, variant2, variant3, variant4, variant5, variant6, variant7, variant8, variant9, variant10, variant11, ptr);
+  tcp_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_finish_connect(tcp_borrow_tcp_socket_t self, tcp_tuple2_own_input_stream_own_output_stream_t *ret, tcp_error_code_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[12];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_finish_connect((self).__handle, ptr);
+  tcp_result_tuple2_own_input_stream_own_output_stream_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (tcp_tuple2_own_input_stream_own_output_stream_t) {
+        (tcp_own_input_stream_t) { *((int32_t*) (ptr + 4)) },
+        (tcp_own_output_stream_t) { *((int32_t*) (ptr + 8)) },
+      };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_start_listen(tcp_borrow_tcp_socket_t self, tcp_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_start_listen((self).__handle, ptr);
+  tcp_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_finish_listen(tcp_borrow_tcp_socket_t self, tcp_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_finish_listen((self).__handle, ptr);
+  tcp_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_accept(tcp_borrow_tcp_socket_t self, tcp_tuple3_own_tcp_socket_own_input_stream_own_output_stream_t *ret, tcp_error_code_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[16];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_accept((self).__handle, ptr);
+  tcp_result_tuple3_own_tcp_socket_own_input_stream_own_output_stream_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (tcp_tuple3_own_tcp_socket_own_input_stream_own_output_stream_t) {
+        (tcp_own_tcp_socket_t) { *((int32_t*) (ptr + 4)) },
+        (tcp_own_input_stream_t) { *((int32_t*) (ptr + 8)) },
+        (tcp_own_output_stream_t) { *((int32_t*) (ptr + 12)) },
+      };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_local_address(tcp_borrow_tcp_socket_t self, tcp_ip_socket_address_t *ret, tcp_error_code_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[36];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_local_address((self).__handle, ptr);
+  tcp_result_ip_socket_address_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      network_ip_socket_address_t variant;
+      variant.tag = (int32_t) (*((uint8_t*) (ptr + 4)));
+      switch ((int32_t) variant.tag) {
+        case 0: {
+          variant.val.ipv4 = (network_ipv4_socket_address_t) {
+            (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 8)))),
+            (network_ipv4_address_t) {
+              (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 10)))),
+              (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 11)))),
+              (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 12)))),
+              (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 13)))),
+            },
+          };
+          break;
+        }
+        case 1: {
+          variant.val.ipv6 = (network_ipv6_socket_address_t) {
+            (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 8)))),
+            (uint32_t) (*((int32_t*) (ptr + 12))),
+            (network_ipv6_address_t) {
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 16)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 18)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 20)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 22)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 24)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 26)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 28)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 30)))),
+            },
+            (uint32_t) (*((int32_t*) (ptr + 32))),
+          };
+          break;
+        }
+      }
+      
+      result.val.ok = variant;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_remote_address(tcp_borrow_tcp_socket_t self, tcp_ip_socket_address_t *ret, tcp_error_code_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[36];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_remote_address((self).__handle, ptr);
+  tcp_result_ip_socket_address_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      network_ip_socket_address_t variant;
+      variant.tag = (int32_t) (*((uint8_t*) (ptr + 4)));
+      switch ((int32_t) variant.tag) {
+        case 0: {
+          variant.val.ipv4 = (network_ipv4_socket_address_t) {
+            (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 8)))),
+            (network_ipv4_address_t) {
+              (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 10)))),
+              (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 11)))),
+              (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 12)))),
+              (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 13)))),
+            },
+          };
+          break;
+        }
+        case 1: {
+          variant.val.ipv6 = (network_ipv6_socket_address_t) {
+            (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 8)))),
+            (uint32_t) (*((int32_t*) (ptr + 12))),
+            (network_ipv6_address_t) {
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 16)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 18)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 20)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 22)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 24)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 26)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 28)))),
+              (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 30)))),
+            },
+            (uint32_t) (*((int32_t*) (ptr + 32))),
+          };
+          break;
+        }
+      }
+      
+      result.val.ok = variant;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_is_listening(tcp_borrow_tcp_socket_t self) {
+  int32_t ret = __wasm_import_tcp_method_tcp_socket_is_listening((self).__handle);
+  return ret;
+}
+
+tcp_ip_address_family_t tcp_method_tcp_socket_address_family(tcp_borrow_tcp_socket_t self) {
+  int32_t ret = __wasm_import_tcp_method_tcp_socket_address_family((self).__handle);
+  return ret;
+}
+
+bool tcp_method_tcp_socket_set_listen_backlog_size(tcp_borrow_tcp_socket_t self, uint64_t value, tcp_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_set_listen_backlog_size((self).__handle, (int64_t) (value), ptr);
+  tcp_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_keep_alive_enabled(tcp_borrow_tcp_socket_t self, bool *ret, tcp_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_keep_alive_enabled((self).__handle, ptr);
+  tcp_result_bool_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_set_keep_alive_enabled(tcp_borrow_tcp_socket_t self, bool value, tcp_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_set_keep_alive_enabled((self).__handle, value, ptr);
+  tcp_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_keep_alive_idle_time(tcp_borrow_tcp_socket_t self, tcp_duration_t *ret, tcp_error_code_t *err) {
+  __attribute__((__aligned__(8)))
+  uint8_t ret_area[16];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_keep_alive_idle_time((self).__handle, ptr);
+  tcp_result_duration_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8)));
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 8)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_set_keep_alive_idle_time(tcp_borrow_tcp_socket_t self, tcp_duration_t value, tcp_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_set_keep_alive_idle_time((self).__handle, (int64_t) (value), ptr);
+  tcp_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_keep_alive_interval(tcp_borrow_tcp_socket_t self, tcp_duration_t *ret, tcp_error_code_t *err) {
+  __attribute__((__aligned__(8)))
+  uint8_t ret_area[16];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_keep_alive_interval((self).__handle, ptr);
+  tcp_result_duration_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8)));
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 8)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_set_keep_alive_interval(tcp_borrow_tcp_socket_t self, tcp_duration_t value, tcp_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_set_keep_alive_interval((self).__handle, (int64_t) (value), ptr);
+  tcp_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_keep_alive_count(tcp_borrow_tcp_socket_t self, uint32_t *ret, tcp_error_code_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[8];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_keep_alive_count((self).__handle, ptr);
+  tcp_result_u32_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (uint32_t) (*((int32_t*) (ptr + 4)));
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_set_keep_alive_count(tcp_borrow_tcp_socket_t self, uint32_t value, tcp_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_set_keep_alive_count((self).__handle, (int32_t) (value), ptr);
+  tcp_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_hop_limit(tcp_borrow_tcp_socket_t self, uint8_t *ret, tcp_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_hop_limit((self).__handle, ptr);
+  tcp_result_u8_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 1))));
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_set_hop_limit(tcp_borrow_tcp_socket_t self, uint8_t value, tcp_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_set_hop_limit((self).__handle, (int32_t) (value), ptr);
+  tcp_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_receive_buffer_size(tcp_borrow_tcp_socket_t self, uint64_t *ret, tcp_error_code_t *err) {
+  __attribute__((__aligned__(8)))
+  uint8_t ret_area[16];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_receive_buffer_size((self).__handle, ptr);
+  tcp_result_u64_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8)));
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 8)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_set_receive_buffer_size(tcp_borrow_tcp_socket_t self, uint64_t value, tcp_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_set_receive_buffer_size((self).__handle, (int64_t) (value), ptr);
+  tcp_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_send_buffer_size(tcp_borrow_tcp_socket_t self, uint64_t *ret, tcp_error_code_t *err) {
+  __attribute__((__aligned__(8)))
+  uint8_t ret_area[16];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_send_buffer_size((self).__handle, ptr);
+  tcp_result_u64_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8)));
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 8)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_method_tcp_socket_set_send_buffer_size(tcp_borrow_tcp_socket_t self, uint64_t value, tcp_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_set_send_buffer_size((self).__handle, (int64_t) (value), ptr);
+  tcp_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+tcp_own_pollable_t tcp_method_tcp_socket_subscribe(tcp_borrow_tcp_socket_t self) {
+  int32_t ret = __wasm_import_tcp_method_tcp_socket_subscribe((self).__handle);
+  return (tcp_own_pollable_t) { ret };
+}
+
+bool tcp_method_tcp_socket_shutdown(tcp_borrow_tcp_socket_t self, tcp_shutdown_type_t shutdown_type, tcp_error_code_t *err) {
+  __attribute__((__aligned__(1)))
+  uint8_t ret_area[2];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_method_tcp_socket_shutdown((self).__handle, (int32_t) shutdown_type, ptr);
+  tcp_result_void_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 1)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool tcp_create_socket_create_tcp_socket(tcp_create_socket_ip_address_family_t address_family, tcp_create_socket_own_tcp_socket_t *ret, tcp_create_socket_error_code_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[8];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_tcp_create_socket_create_tcp_socket((int32_t) address_family, ptr);
+  tcp_create_socket_result_own_tcp_socket_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (tcp_create_socket_own_tcp_socket_t) { *((int32_t*) (ptr + 4)) };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool ip_name_lookup_resolve_addresses(ip_name_lookup_borrow_network_t network, wasip2_string_t *name, ip_name_lookup_own_resolve_address_stream_t *ret, ip_name_lookup_error_code_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[8];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_ip_name_lookup_resolve_addresses((network).__handle, (int32_t) (*name).ptr, (int32_t) (*name).len, ptr);
+  ip_name_lookup_result_own_resolve_address_stream_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (ip_name_lookup_own_resolve_address_stream_t) { *((int32_t*) (ptr + 4)) };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+bool ip_name_lookup_method_resolve_address_stream_resolve_next_address(ip_name_lookup_borrow_resolve_address_stream_t self, ip_name_lookup_option_ip_address_t *ret, ip_name_lookup_error_code_t *err) {
+  __attribute__((__aligned__(2)))
+  uint8_t ret_area[22];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_ip_name_lookup_method_resolve_address_stream_resolve_next_address((self).__handle, ptr);
+  ip_name_lookup_result_option_ip_address_error_code_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      ip_name_lookup_option_ip_address_t option;
+      switch ((int32_t) (*((uint8_t*) (ptr + 2)))) {
+        case 0: {
+          option.is_some = false;
+          break;
+        }
+        case 1: {
+          option.is_some = true;
+          network_ip_address_t variant;
+          variant.tag = (int32_t) (*((uint8_t*) (ptr + 4)));
+          switch ((int32_t) variant.tag) {
+            case 0: {
+              variant.val.ipv4 = (network_ipv4_address_t) {
+                (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 6)))),
+                (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 7)))),
+                (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 8)))),
+                (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 9)))),
+              };
+              break;
+            }
+            case 1: {
+              variant.val.ipv6 = (network_ipv6_address_t) {
+                (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 6)))),
+                (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 8)))),
+                (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 10)))),
+                (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 12)))),
+                (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 14)))),
+                (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 16)))),
+                (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 18)))),
+                (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 20)))),
+              };
+              break;
+            }
+          }
+          
+          option.val = variant;
+          break;
+        }
+      }
+      
+      result.val.ok = option;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 2)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
+ip_name_lookup_own_pollable_t ip_name_lookup_method_resolve_address_stream_subscribe(ip_name_lookup_borrow_resolve_address_stream_t self) {
+  int32_t ret = __wasm_import_ip_name_lookup_method_resolve_address_stream_subscribe((self).__handle);
+  return (ip_name_lookup_own_pollable_t) { ret };
+}
+
+void random_get_random_bytes(uint64_t len, wasip2_list_u8_t *ret) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[8];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_random_get_random_bytes((int64_t) (len), ptr);
+  *ret = (wasip2_list_u8_t) { (uint8_t*)(*((int32_t*) (ptr + 0))), (size_t)(*((int32_t*) (ptr + 4))) };
+}
+
+uint64_t random_get_random_u64(void) {
+  int64_t ret = __wasm_import_random_get_random_u64();
+  return (uint64_t) (ret);
+}
+
+void random_insecure_get_insecure_random_bytes(uint64_t len, wasip2_list_u8_t *ret) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[8];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_random_insecure_get_insecure_random_bytes((int64_t) (len), ptr);
+  *ret = (wasip2_list_u8_t) { (uint8_t*)(*((int32_t*) (ptr + 0))), (size_t)(*((int32_t*) (ptr + 4))) };
+}
+
+uint64_t random_insecure_get_insecure_random_u64(void) {
+  int64_t ret = __wasm_import_random_insecure_get_insecure_random_u64();
+  return (uint64_t) (ret);
+}
+
+void random_insecure_seed_insecure_seed(wasip2_tuple2_u64_u64_t *ret) {
+  __attribute__((__aligned__(8)))
+  uint8_t ret_area[16];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_random_insecure_seed_insecure_seed(ptr);
+  *ret = (wasip2_tuple2_u64_u64_t) {
+    (uint64_t) (*((int64_t*) (ptr + 0))),
+    (uint64_t) (*((int64_t*) (ptr + 8))),
+  };
+}
+
+extern void __component_type_object_force_link_wasip2(void);
+void __component_type_object_force_link_wasip2_public_use_in_this_compilation_unit(void) {
+  __component_type_object_force_link_wasip2();
+}
diff --git a/libc-bottom-half/sources/wasip2_component_type.o b/libc-bottom-half/sources/wasip2_component_type.o
new file mode 100644
index 0000000..0548e3e
--- /dev/null
+++ b/libc-bottom-half/sources/wasip2_component_type.o