@bytecodealliance/preview3-shim 0.3.2 → 0.5.0

package/dist/nodejs/filesystem/descriptor.d.ts

@@ -60,7 +60,7 @@ declare class Descriptor {
      * @returns {Promise<void>}
      * @throws {FSError} `payload.tag` contains mapped WASI error code.
      */
-    advise(_offset: any, _length: any, _advice: any): Promise<void>;
+    advise(offset: any, length: any, advice: any): Promise<void>;
     /**
      * Synchronize file data to disk.
      * WIT:

package/dist/nodejs/filesystem/descriptor.js

@@ -158,11 +158,14 @@ class Descriptor {
      * @returns {Promise<void>}
      * @throws {FSError} `payload.tag` contains mapped WASI error code.
      */
-    async advise(_offset, _length, _advice) {
-        // TODO: This not directly suported on Node.js:
-        // https://github.com/bytecodealliance/jco/issues/718
-        if ((await this.getType()).tag === "directory") {
-            throw new FSError("bad-descriptor");
+    async advise(offset, length, advice) {
+        this.#ensureHandle();
+        try {
+            const { fadvise } = await import("@bytecodealliance/jco-node-fs");
+            fadvise(this.#handle.fd, offset, length, advice);
+        }
+        catch (error) {
+            throw FSError.from(error);
         }
     }
     /**

package/dist/nodejs/sockets/tcp.js

@@ -255,7 +255,13 @@ export class TcpSocket {
         }
         let stream;
         try {
-            stream = readableByteStreamFromReader(data, { name: "tcp send data" });
+            // A remote error arrives from the TCP worker through a MessagePort. Yield
+            // after each chunk so a guest producer that completes writes immediately
+            // cannot starve that error (and its stream cancellation) indefinitely.
+            stream = readableByteStreamFromReader(data, {
+                name: "tcp send data",
+                yieldAfterChunk: true,
+            });
         }
         catch (error) {
             if (error instanceof TypeError) {

package/dist/nodejs/stream.d.ts

@@ -1,5 +1,10 @@
 export declare const DEFAULT_BYTE_STREAM_CHUNK_SIZE: number;
 declare const symbolDispose: symbol;
+interface ReadableByteStreamOptions {
+    chunkSize?: number;
+    name?: string;
+    yieldAfterChunk?: boolean;
+}
 /**
  * Creates a transferable ReadableStream from an async iterator.
  *
@@ -22,9 +27,10 @@ export declare function readableStreamFromIterator(iterator: any, name?: string)
  * @param {object} [opts={}] - Optional adapter settings.
  * @param {number} [opts.chunkSize=DEFAULT_BYTE_STREAM_CHUNK_SIZE] - Maximum bytes to request per generated `read()` call.
  * @param {string} [opts.name="stream reader"] - Reader name used in error messages.
+ * @param {boolean} [opts.yieldAfterChunk=false] - Yield one event-loop turn after each chunk.
  * @returns {ReadableStream<Uint8Array>} A transferable stream of byte chunks.
  */
-export declare function readableByteStreamFromReader(reader: any, opts?: {}): ReadableStream<any>;
+export declare function readableByteStreamFromReader(reader: any, opts?: ReadableByteStreamOptions): ReadableStream<any>;
 export declare function _byteChunk(value: any): any;
 /**
  * Creates a bidirectional stream with separate reader and writer interfaces.

package/dist/nodejs/stream.js

@@ -46,6 +46,7 @@ export function readableStreamFromIterator(iterator, name = "iterator") {
  * @param {object} [opts={}] - Optional adapter settings.
  * @param {number} [opts.chunkSize=DEFAULT_BYTE_STREAM_CHUNK_SIZE] - Maximum bytes to request per generated `read()` call.
  * @param {string} [opts.name="stream reader"] - Reader name used in error messages.
+ * @param {boolean} [opts.yieldAfterChunk=false] - Yield one event-loop turn after each chunk.
  * @returns {ReadableStream<Uint8Array>} A transferable stream of byte chunks.
  */
 export function readableByteStreamFromReader(reader, opts = {}) {
@@ -58,6 +59,9 @@ export function readableByteStreamFromReader(reader, opts = {}) {
                 return;
             }
             controller.enqueue(_byteChunk(value));
+            if (opts.yieldAfterChunk) {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            }
         },
         cancel(reason) {
             return source.cancel?.(reason);

package/dist/nodejs/workers/tcp-worker.bundle.js

@@ -1,9 +1,6 @@
 import { Server, Socket } from "node:net";
-import { Readable } from "stream";
-import { pipeline } from "stream/promises";
 import { once } from "node:events";
 import { isMainThread, parentPort } from "worker_threads";
-import process from "node:process";
 //#region dist/nodejs/workers/resource-worker.js
 function Router() {
 	const _hooks = {
@@ -255,7 +252,6 @@ var SocketError = class SocketError extends Error {
 };
 //#endregion
 //#region dist/nodejs/workers/tcp-worker.js
-const { TCP, constants: TCPConstants } = process.binding("tcp_wrap");
 const sockets = /* @__PURE__ */ new Map();
 let NEXT_SOCKET_ID = 0n;
 Router().beforeAll((msg) => {
@@ -263,14 +259,15 @@ Router().beforeAll((msg) => {
 }).op("tcp-create", handleTcpCreate).op("tcp-bind", handleTcpBind).op("tcp-connect", handleTcpConnect).op("tcp-listen", handleTcpListen).op("tcp-send", handleTcpSend).op("tcp-receive", handleTcpReceive).op("tcp-get-local-address", handleGetLocalAddress).op("tcp-get-remote-address", handleGetRemoteAddress).op("tcp-set-listen-backlog-size", handleTcpSetBacklogSize).op("tcp-set-keep-alive", handleTcpSetKeepAlive).op("tcp-recv-buffer-size", handleRecvBufferSize).op("tcp-send-buffer-size", handleSendBufferSize).op("tcp-dispose", handleTcpDispose);
 function handleTcpCreate({ family }) {
 	const socketId = NEXT_SOCKET_ID++;
-	const handle = new TCP(TCPConstants.SOCKET);
 	sockets.set(socketId, {
-		handle,
 		family,
 		tcp: null,
 		server: null,
+		acceptWriter: null,
 		backlog: 128,
 		localAddress: null,
+		keepAliveEnabled: false,
+		keepAliveIdleTime: 0,
 		disposed: false,
 		activeStreams: 0
 	});
@@ -280,83 +277,132 @@ async function handleTcpBind({ socketId, localAddress }) {
 	const socket = sockets.get(socketId);
 	const address = serializeIpAddress(localAddress);
 	const port = localAddress.val.port;
-	const { handle, family } = socket;
+	const { family } = socket;
 	if ([...sockets].some(([id, { localAddress: boundAddress }]) => id !== socketId && boundAddress && ipAddressConflict(boundAddress, localAddress))) {
 		const err = /* @__PURE__ */ new Error("EADDRINUSE");
 		err.code = "EADDRINUSE";
 		throw err;
 	}
-	await new Promise((resolve, reject) => {
-		let code;
-		if (family === "ipv6") code = handle.bind6(address, port, TCPConstants.UV_TCP_IPV6ONLY);
-		else code = handle.bind(address, port);
-		if (code !== 0) reject(SocketError.from(-code));
-		else resolve();
+	const server = socket.server = createTcpServer(socket);
+	const onListening = once(server, "listening");
+	server.listen({
+		host: address,
+		port,
+		backlog: socket.backlog,
+		ipv6Only: family === "ipv6"
 	});
-	const out = {};
-	const code = handle.getsockname(out);
-	if (code !== 0) throw SocketError.from(-code);
-	socket.localAddress = makeIpAddress(out.family.toLowerCase(), out.address, out.port);
+	await onListening;
+	const boundAddress = server.address();
+	if (!boundAddress || typeof boundAddress === "string") throw new SocketError("invalid-state");
+	socket.localAddress = makeIpAddress(boundAddress.family.toLowerCase(), boundAddress.address, boundAddress.port);
 }
 async function handleTcpConnect({ socketId, remoteAddress }) {
 	const socket = sockets.get(socketId);
 	const host = serializeIpAddress(remoteAddress);
 	const port = remoteAddress.val.port;
-	const tcp = socket.tcp = new Socket({
-		handle: socket.handle,
-		pauseOnCreate: true,
-		allowHalfOpen: true
-	});
+	const localAddress = socket.localAddress;
+	await closeTcpServer(socket);
+	const tcp = socket.tcp = new Socket({ allowHalfOpen: true });
+	tcp.setKeepAlive(socket.keepAliveEnabled, socket.keepAliveIdleTime);
 	const onConnect = once(tcp, "connect");
 	tcp.connect({
 		port,
-		host
+		host,
+		localAddress: localAddress ? serializeIpAddress(localAddress) : void 0,
+		localPort: localAddress?.val.port
 	});
 	await onConnect;
 }
 async function handleTcpListen({ socketId, stream }) {
 	const writer = stream.getWriter();
 	const socket = sockets.get(socketId);
-	const { handle, backlog, family } = socket;
+	const { backlog, family } = socket;
+	socket.acceptWriter = writer;
+	let server = socket.server;
+	if (!server) {
+		server = socket.server = createTcpServer(socket);
+		const onListening = once(server, "listening");
+		server.listen({
+			host: family === "ipv6" ? "::" : "0.0.0.0",
+			port: 0,
+			backlog,
+			ipv6Only: family === "ipv6"
+		});
+		await onListening;
+	}
+	const addr = server.address();
+	if (addr && typeof addr === "object") socket.localAddress = makeIpAddress(family, addr.address, addr.port);
+}
+function createTcpServer(socket) {
 	const server = new Server({
 		pauseOnConnect: true,
 		allowHalfOpen: true
 	});
-	const onListening = once(server, "listening");
-	server.listen(handle, backlog);
-	await onListening;
-	const addr = server.address();
-	if (addr && typeof addr === "object") socket.localAddress = makeIpAddress(family, addr.address, addr.port);
 	server.on("connection", (conn) => {
+		const writer = socket.acceptWriter;
+		if (!writer) {
+			conn.destroy();
+			return;
+		}
 		conn.allowHalfOpen = true;
+		conn.setKeepAlive(socket.keepAliveEnabled, socket.keepAliveIdleTime);
 		const id = NEXT_SOCKET_ID++;
 		sockets.set(id, {
-			handle: conn._handle,
-			family,
-			backlog,
+			family: socket.family,
+			backlog: socket.backlog,
 			tcp: conn,
 			server: null,
-			localAddress: makeIpAddress(family, conn.localAddress, conn.localPort),
+			acceptWriter: null,
+			localAddress: makeIpAddress(socket.family, conn.localAddress, conn.localPort),
+			keepAliveEnabled: socket.keepAliveEnabled,
+			keepAliveIdleTime: socket.keepAliveIdleTime,
 			disposed: false,
 			activeStreams: 0
 		});
 		writer.write({
-			family,
+			family: socket.family,
 			socketId: id
 		});
 	});
-	socket.server = server;
-	server.on("error", (err) => stream.abort(err));
-	server.on("close", () => writer.close());
+	server.on("error", (err) => socket.acceptWriter?.abort(err));
+	server.on("close", () => socket.acceptWriter?.close());
+	return server;
+}
+function closeTcpServer(socket) {
+	const server = socket.server;
+	socket.server = null;
+	if (!server) return Promise.resolve();
+	return new Promise((resolve, reject) => {
+		server.close((err) => err ? reject(err) : resolve());
+	});
 }
 async function handleTcpSend({ socketId, stream }) {
 	const socket = sockets.get(socketId);
 	socket.activeStreams++;
 	const { tcp } = socket;
-	const readable = Readable.fromWeb(stream);
+	const reader = stream.getReader();
+	let rejectOnSocketError;
+	const socketError = new Promise((_resolve, reject) => {
+		rejectOnSocketError = reject;
+	});
+	tcp.once("error", rejectOnSocketError);
 	try {
-		await pipeline(readable, tcp);
+		while (true) {
+			const { done, value } = await Promise.race([reader.read(), socketError]);
+			if (done) break;
+			await Promise.race([new Promise((resolve, reject) => {
+				tcp.write(value, (err) => err ? reject(err) : resolve());
+			}), socketError]);
+		}
+		await new Promise((resolve, reject) => {
+			tcp.end((err) => err ? reject(err) : resolve());
+		});
+	} catch (err) {
+		reader.cancel(err).catch(() => {});
+		throw err;
 	} finally {
+		tcp.off("error", rejectOnSocketError);
+		reader.releaseLock();
 		socket.activeStreams--;
 		cleanupDisposedSocket(socketId, socket);
 	}
@@ -422,22 +468,19 @@ function cleanupDisposedSocket(socketId, socket) {
 	if (!socket.disposed || socket.activeStreams > 0) return;
 	if (socket.server) socket.server.close();
 	if (socket.tcp) socket.tcp.destroy();
-	if (socket.handle) socket.handle.close();
 	sockets.delete(socketId);
 }
 async function handleGetLocalAddress({ socketId }) {
 	const socket = sockets.get(socketId);
-	const out = {};
-	const code = socket.handle.getsockname(out);
-	if (code !== 0) throw SocketError.from(-code);
-	return makeIpAddress(out.family.toLowerCase(), out.address, out.port);
+	const address = socket.tcp?.address();
+	if (address && typeof address !== "string" && "family" in address) return makeIpAddress(address.family.toLowerCase(), address.address, address.port);
+	if (socket.localAddress) return socket.localAddress;
+	throw new SocketError("invalid-state");
 }
 async function handleGetRemoteAddress({ socketId }) {
 	const socket = sockets.get(socketId);
-	const out = {};
-	const code = socket.handle.getpeername(out);
-	if (code !== 0) throw SocketError.from(-code);
-	return makeIpAddress(out.family.toLowerCase(), out.address, out.port);
+	if (!socket.tcp?.remoteFamily || !socket.tcp.remoteAddress || !socket.tcp.remotePort) throw new SocketError("invalid-state");
+	return makeIpAddress(socket.tcp.remoteFamily.toLowerCase(), socket.tcp.remoteAddress, socket.tcp.remotePort);
 }
 function handleTcpSetBacklogSize({ socketId, value }) {
 	const socket = sockets.get(socketId);
@@ -445,9 +488,9 @@ function handleTcpSetBacklogSize({ socketId, value }) {
 }
 async function handleTcpSetKeepAlive({ socketId, keepAliveEnabled, keepAliveIdleTime }) {
 	const socket = sockets.get(socketId);
-	const time = Number(keepAliveIdleTime / 1000000000n);
-	const code = socket.handle.setKeepAlive(keepAliveEnabled, time);
-	if (code !== 0) throw SocketError.from(-code);
+	socket.keepAliveEnabled = keepAliveEnabled;
+	socket.keepAliveIdleTime = Number(keepAliveIdleTime / 1000000000n);
+	socket.tcp?.setKeepAlive(socket.keepAliveEnabled, socket.keepAliveIdleTime);
 }
 async function handleRecvBufferSize({ socketId }) {
 	const socket = sockets.get(socketId);

package/dist/nodejs/workers/tcp-worker.js

@@ -1,12 +1,8 @@
 import { Socket, Server } from "node:net";
-import { Readable } from "stream";
-import { pipeline } from "stream/promises";
 import { once } from "node:events";
 import { Router } from "../workers/resource-worker.js";
 import { serializeIpAddress, makeIpAddress, ipAddressConflict } from "../sockets/address.js";
 import { SocketError } from "../sockets/error.js";
-import process from "node:process";
-const { TCP, constants: TCPConstants } = process.binding("tcp_wrap");
 // Socket instances stored by ID
 const sockets = new Map();
 // Unique IDs for sockets
@@ -34,14 +30,15 @@ Router()
 // Create a new TCP socket
 function handleTcpCreate({ family }) {
     const socketId = NEXT_SOCKET_ID++;
-    const handle = new TCP(TCPConstants.SOCKET);
     sockets.set(socketId, {
-        handle,
         family,
         tcp: null,
         server: null,
+        acceptWriter: null,
         backlog: 128,
         localAddress: null,
+        keepAliveEnabled: false,
+        keepAliveIdleTime: 0,
         disposed: false,
         activeStreams: 0,
     });
@@ -52,48 +49,49 @@ async function handleTcpBind({ socketId, localAddress }) {
     const socket = sockets.get(socketId);
     const address = serializeIpAddress(localAddress);
     const port = localAddress.val.port;
-    const { handle, family } = socket;
+    const { family } = socket;
     const hasConflict = [...sockets].some(([id, { localAddress: boundAddress }]) => id !== socketId && boundAddress && ipAddressConflict(boundAddress, localAddress));
     if (hasConflict) {
         const err = new Error("EADDRINUSE");
         err.code = "EADDRINUSE";
         throw err;
     }
-    await new Promise((resolve, reject) => {
-        let code;
-        if (family === "ipv6") {
-            code = handle.bind6(address, port, TCPConstants.UV_TCP_IPV6ONLY);
-        }
-        else {
-            code = handle.bind(address, port);
-        }
-        if (code !== 0) {
-            reject(SocketError.from(-code));
-        }
-        else {
-            resolve();
-        }
+    // node:net has no public standalone TCP bind API. Keep a server open
+    // to reserve the endpoint, then reuse it for listen or close it for connect.
+    const server = (socket.server = createTcpServer(socket));
+    const onListening = once(server, "listening");
+    server.listen({
+        host: address,
+        port,
+        backlog: socket.backlog,
+        ipv6Only: family === "ipv6",
     });
-    const out = {};
-    const code = handle.getsockname(out);
-    if (code !== 0) {
-        throw SocketError.from(-code);
+    await onListening;
+    const boundAddress = server.address();
+    if (!boundAddress || typeof boundAddress === "string") {
+        throw new SocketError("invalid-state");
     }
-    socket.localAddress = makeIpAddress(out.family.toLowerCase(), out.address, out.port);
+    socket.localAddress = makeIpAddress(boundAddress.family.toLowerCase(), boundAddress.address, boundAddress.port);
 }
 // Connect a socket to remote address
 async function handleTcpConnect({ socketId, remoteAddress }) {
     const socket = sockets.get(socketId);
     const host = serializeIpAddress(remoteAddress);
     const port = remoteAddress.val.port;
+    const localAddress = socket.localAddress;
+    await closeTcpServer(socket);
     const tcp = (socket.tcp = new Socket({
-        handle: socket.handle,
-        pauseOnCreate: true,
         allowHalfOpen: true,
     }));
+    tcp.setKeepAlive(socket.keepAliveEnabled, socket.keepAliveIdleTime);
     // TODO(tandr): Add lookup
     const onConnect = once(tcp, "connect");
-    tcp.connect({ port, host });
+    tcp.connect({
+        port,
+        host,
+        localAddress: localAddress ? serializeIpAddress(localAddress) : undefined,
+        localPort: localAddress?.val.port,
+    });
     // events.once rejects when the emitter produces an error while waiting and
     // removes its temporary listeners after settling. A separate error promise
     // would remain attached after a successful connect and could later reject
@@ -103,46 +101,111 @@ async function handleTcpConnect({ socketId, remoteAddress }) {
 async function handleTcpListen({ socketId, stream }) {
     const writer = stream.getWriter();
     const socket = sockets.get(socketId);
-    const { handle, backlog, family } = socket;
-    const server = new Server({
-        pauseOnConnect: true,
-        allowHalfOpen: true,
-    });
-    const onListening = once(server, "listening");
-    server.listen(handle, backlog);
-    await onListening;
+    const { backlog, family } = socket;
+    socket.acceptWriter = writer;
+    let server = socket.server;
+    if (!server) {
+        server = socket.server = createTcpServer(socket);
+        const onListening = once(server, "listening");
+        server.listen({
+            host: family === "ipv6" ? "::" : "0.0.0.0",
+            port: 0,
+            backlog,
+            ipv6Only: family === "ipv6",
+        });
+        await onListening;
+    }
     const addr = server.address();
     if (addr && typeof addr === "object") {
         socket.localAddress = makeIpAddress(family, addr.address, addr.port);
     }
+}
+function createTcpServer(socket) {
+    const server = new Server({
+        pauseOnConnect: true,
+        allowHalfOpen: true,
+    });
     server.on("connection", (conn) => {
+        const writer = socket.acceptWriter;
+        // The reservation is already listening at the OS level, so reject any
+        // connections that arrive before the WASI socket enters its listen state.
+        if (!writer) {
+            conn.destroy();
+            return;
+        }
         conn.allowHalfOpen = true;
+        conn.setKeepAlive(socket.keepAliveEnabled, socket.keepAliveIdleTime);
         const id = NEXT_SOCKET_ID++;
         sockets.set(id, {
-            handle: conn._handle,
-            family,
-            backlog,
+            family: socket.family,
+            backlog: socket.backlog,
             tcp: conn,
             server: null,
-            localAddress: makeIpAddress(family, conn.localAddress, conn.localPort),
+            acceptWriter: null,
+            localAddress: makeIpAddress(socket.family, conn.localAddress, conn.localPort),
+            keepAliveEnabled: socket.keepAliveEnabled,
+            keepAliveIdleTime: socket.keepAliveIdleTime,
             disposed: false,
             activeStreams: 0,
         });
-        writer.write({ family, socketId: id });
+        writer.write({ family: socket.family, socketId: id });
+    });
+    server.on("error", (err) => socket.acceptWriter?.abort(err));
+    server.on("close", () => socket.acceptWriter?.close());
+    return server;
+}
+function closeTcpServer(socket) {
+    const server = socket.server;
+    socket.server = null;
+    if (!server) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        server.close((err) => (err ? reject(err) : resolve()));
     });
-    socket.server = server;
-    server.on("error", (err) => stream.abort(err));
-    server.on("close", () => writer.close());
 }
 async function handleTcpSend({ socketId, stream }) {
     const socket = sockets.get(socketId);
     socket.activeStreams++;
     const { tcp } = socket;
-    const readable = Readable.fromWeb(stream);
+    const reader = stream.getReader();
+    let rejectOnSocketError;
+    const socketError = new Promise((_resolve, reject) => {
+        rejectOnSocketError = reject;
+    });
+    tcp.once("error", rejectOnSocketError);
     try {
-        await pipeline(readable, tcp);
+        // Do not replace this pump with stream.pipeline(). Node 26 changed async
+        // iteration to preserve allowHalfOpen duplex streams. For WASI TCP send,
+        // however, a write failure must promptly cancel the transferred input
+        // stream so the guest's stream writer is dropped. Explicitly awaiting each
+        // write keeps socket backpressure and cancellation coupled across workers.
+        while (true) {
+            const { done, value } = await Promise.race([reader.read(), socketError]);
+            if (done) {
+                break;
+            }
+            await Promise.race([
+                new Promise((resolve, reject) => {
+                    tcp.write(value, (err) => (err ? reject(err) : resolve()));
+                }),
+                socketError,
+            ]);
+        }
+        await new Promise((resolve, reject) => {
+            tcp.end((err) => (err ? reject(err) : resolve()));
+        });
+    }
+    catch (err) {
+        // Cancellation crosses the worker boundary. Do not wait for its completion:
+        // the producer can itself be waiting for this operation's result, which
+        // would turn error propagation into a cycle.
+        void reader.cancel(err).catch(() => { });
+        throw err;
     }
     finally {
+        tcp.off("error", rejectOnSocketError);
+        reader.releaseLock();
         socket.activeStreams--;
         cleanupDisposedSocket(socketId, socket);
     }
@@ -229,28 +292,25 @@ function cleanupDisposedSocket(socketId, socket) {
     if (socket.tcp) {
         socket.tcp.destroy();
     }
-    if (socket.handle) {
-        socket.handle.close();
-    }
     sockets.delete(socketId);
 }
 async function handleGetLocalAddress({ socketId }) {
     const socket = sockets.get(socketId);
-    const out = {};
-    const code = socket.handle.getsockname(out);
-    if (code !== 0) {
-        throw SocketError.from(-code);
+    const address = socket.tcp?.address();
+    if (address && typeof address !== "string" && "family" in address) {
+        return makeIpAddress(address.family.toLowerCase(), address.address, address.port);
     }
-    return makeIpAddress(out.family.toLowerCase(), out.address, out.port);
+    if (socket.localAddress) {
+        return socket.localAddress;
+    }
+    throw new SocketError("invalid-state");
 }
 async function handleGetRemoteAddress({ socketId }) {
     const socket = sockets.get(socketId);
-    const out = {};
-    const code = socket.handle.getpeername(out);
-    if (code !== 0) {
-        throw SocketError.from(-code);
+    if (!socket.tcp?.remoteFamily || !socket.tcp.remoteAddress || !socket.tcp.remotePort) {
+        throw new SocketError("invalid-state");
     }
-    return makeIpAddress(out.family.toLowerCase(), out.address, out.port);
+    return makeIpAddress(socket.tcp.remoteFamily.toLowerCase(), socket.tcp.remoteAddress, socket.tcp.remotePort);
 }
 function handleTcpSetBacklogSize({ socketId, value }) {
     const socket = sockets.get(socketId);
@@ -258,11 +318,9 @@ function handleTcpSetBacklogSize({ socketId, value }) {
 }
 async function handleTcpSetKeepAlive({ socketId, keepAliveEnabled, keepAliveIdleTime }) {
     const socket = sockets.get(socketId);
-    const time = Number(keepAliveIdleTime / 1000000000n);
-    const code = socket.handle.setKeepAlive(keepAliveEnabled, time);
-    if (code !== 0) {
-        throw SocketError.from(-code);
-    }
+    socket.keepAliveEnabled = keepAliveEnabled;
+    socket.keepAliveIdleTime = Number(keepAliveIdleTime / 1000000000n);
+    socket.tcp?.setKeepAlive(socket.keepAliveEnabled, socket.keepAliveIdleTime);
 }
 async function handleRecvBufferSize({ socketId }) {
     const socket = sockets.get(socketId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytecodealliance/preview3-shim",
-  "version": "0.3.2",
+  "version": "0.5.0",
   "description": "WASI Preview3 shim for JS environments",
   "homepage": "https://github.com/bytecodealliance/jco/blob/main/packages/preview3-shim/#readme",
   "bugs": {
@@ -48,7 +48,8 @@
     }
   },
   "dependencies": {
-    "@bytecodealliance/preview2-shim": "^0.19.0"
+    "@bytecodealliance/jco-node-fs": "0.2.0",
+    "@bytecodealliance/preview2-shim": "^0.22.0"
   },
   "devDependencies": {
     "@types/node": "^24.12.4",