@bytecodealliance/preview3-shim 0.1.2 → 0.2.1

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

@@ -0,0 +1,318 @@
+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
+let NEXT_SOCKET_ID = 0n;
+// Handle worker messages
+Router()
+    .beforeAll((msg) => {
+    if (msg.op !== "tcp-create" && !sockets.has(msg.socketId)) {
+        throw new Error("Invalid socket ID");
+    }
+})
+    .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);
+// 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,
+        backlog: 128,
+        localAddress: null,
+        disposed: false,
+        activeStreams: 0,
+    });
+    return { socketId };
+}
+// Bind a socket to local address
+async function handleTcpBind({ socketId, localAddress }) {
+    const socket = sockets.get(socketId);
+    const address = serializeIpAddress(localAddress);
+    const port = localAddress.val.port;
+    const { handle, 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();
+        }
+    });
+    const out = {};
+    const code = handle.getsockname(out);
+    if (code !== 0) {
+        throw SocketError.from(-code);
+    }
+    socket.localAddress = makeIpAddress(out.family.toLowerCase(), out.address, out.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 tcp = (socket.tcp = new Socket({
+        handle: socket.handle,
+        pauseOnCreate: true,
+        allowHalfOpen: true,
+    }));
+    const onConnect = once(tcp, "connect");
+    const onError = once(tcp, "error").then(([err]) => {
+        throw err;
+    });
+    // TODO(tandr): Add lookup
+    tcp.connect({ port, host });
+    await Promise.race([onConnect, onError]);
+}
+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");
+    const onError = once(server, "error").then(([err]) => {
+        throw err;
+    });
+    server.listen(handle, backlog);
+    await Promise.race([onListening, onError]);
+    const addr = server.address();
+    if (addr && typeof addr === "object") {
+        socket.localAddress = makeIpAddress(family, addr.address, addr.port);
+    }
+    server.on("connection", (conn) => {
+        conn.allowHalfOpen = true;
+        const id = NEXT_SOCKET_ID++;
+        sockets.set(id, {
+            handle: conn._handle,
+            family,
+            backlog,
+            tcp: conn,
+            server: null,
+            localAddress: makeIpAddress(family, conn.localAddress, conn.localPort),
+            disposed: false,
+            activeStreams: 0,
+        });
+        writer.write({ family, socketId: id });
+    });
+    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);
+    try {
+        await pipeline(readable, tcp);
+    }
+    finally {
+        socket.activeStreams--;
+        cleanupDisposedSocket(socketId, socket);
+    }
+}
+async function handleTcpReceive({ socketId, stream }) {
+    const socket = sockets.get(socketId);
+    const writer = stream.getWriter();
+    socket.activeStreams++;
+    const { tcp } = socket;
+    try {
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            let pending = Promise.resolve();
+            const cleanup = () => {
+                tcp.off("data", onData);
+                tcp.off("end", onEnd);
+                tcp.off("error", onError);
+            };
+            const settle = (err = null) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                cleanup();
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            };
+            const onData = (chunk) => {
+                tcp.pause();
+                pending = pending.then(async () => {
+                    try {
+                        await writer.write(chunk);
+                    }
+                    catch {
+                        settle();
+                        return;
+                    }
+                    finally {
+                        // Always undo the pause, even if the guest dropped or cancelled the
+                        // receive stream. Otherwise the send path can remain backpressured
+                        // forever.
+                        tcp.resume();
+                    }
+                }, settle);
+            };
+            const onEnd = () => {
+                pending = pending.then(async () => {
+                    try {
+                        await writer.close();
+                    }
+                    catch {
+                        // The guest can drop the receive stream before remote EOF.
+                    }
+                    settle();
+                }, settle);
+            };
+            const onError = (err) => {
+                pending = pending.finally(() => settle(err));
+            };
+            writer.closed.then(() => settle(), () => settle());
+            tcp.on("data", onData);
+            tcp.once("end", onEnd);
+            tcp.once("error", onError);
+            tcp.resume();
+        });
+    }
+    finally {
+        writer.releaseLock();
+        socket.activeStreams--;
+        cleanupDisposedSocket(socketId, socket);
+    }
+}
+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);
+}
+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);
+}
+function handleTcpSetBacklogSize({ socketId, value }) {
+    const socket = sockets.get(socketId);
+    socket.backlog = Number(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);
+    }
+}
+async function handleRecvBufferSize({ socketId }) {
+    const socket = sockets.get(socketId);
+    if (socket.tcp) {
+        return BigInt(socket.tcp.getRecvBufferSize());
+    }
+    else {
+        return await getDefaultReceiveBufferSize();
+    }
+}
+async function handleSendBufferSize({ socketId }) {
+    const socket = sockets.get(socketId);
+    if (socket.tcp) {
+        return BigInt(socket.tcp.getSendBufferSize());
+    }
+    else {
+        return await getDefaultSendBufferSize();
+    }
+}
+function handleTcpDispose({ socketId }) {
+    const socket = sockets.get(socketId);
+    if (!socket) {
+        return;
+    }
+    socket.disposed = true;
+    cleanupDisposedSocket(socketId, socket);
+}
+let _recvBufferSize, _sendBufferSize;
+async function getDefaultBufferSizes() {
+    var s = new Socket();
+    s.bind(0);
+    await new Promise((resolve, reject) => {
+        s.once("error", reject);
+        s.once("listening", resolve);
+    });
+    _recvBufferSize = BigInt(s.getRecvBufferSize());
+    _sendBufferSize = BigInt(s.getSendBufferSize());
+    s.close();
+}
+export async function getDefaultSendBufferSize() {
+    if (!_sendBufferSize) {
+        await getDefaultBufferSizes();
+    }
+    return _sendBufferSize;
+}
+export async function getDefaultReceiveBufferSize() {
+    if (!_recvBufferSize) {
+        await getDefaultBufferSizes();
+    }
+    return _recvBufferSize;
+}

package/dist/nodejs/workers/udp-worker.d.ts

@@ -0,0 +1 @@
+export declare function noLookup(ip: any, _opts: any, cb: any): void;

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

@@ -0,0 +1,156 @@
+import { once } from "node:events";
+import { Router } from "../workers/resource-worker.js";
+import { serializeIpAddress, makeIpAddress, ipAddressConflict, isLoopbackIpAddress, } from "../sockets/address.js";
+import dgram from "node:dgram";
+const sockets = new Map();
+// Unique IDs for sockets
+let NEXT_SOCKET_ID = 0n;
+export function noLookup(ip, _opts, cb) {
+    cb(null, ip);
+}
+Router()
+    .beforeAll((msg) => {
+    if (msg.op !== "udp-create" && !sockets.has(msg.socketId)) {
+        throw new Error("Invalid socket ID");
+    }
+})
+    .op("udp-create", handleCreate)
+    .op("udp-bind", handleBind)
+    .op("udp-connect", handleConnect)
+    .op("udp-disconnect", handleDisconnect)
+    .op("udp-send", handleSend)
+    .op("udp-receive", handleReceive)
+    .op("udp-get-local-address", handleGetLocal)
+    .op("udp-set-unicast-hop-limit", handleSetHop)
+    .op("udp-recv-buffer-size", handleRecvBuffer)
+    .op("udp-send-buffer-size", handleSendBuffer)
+    .op("udp-dispose", handleDispose);
+function handleCreate({ family }) {
+    const socketId = NEXT_SOCKET_ID++;
+    const socket = {
+        family,
+        connected: null,
+        localAddress: null,
+        receiveQueue: [],
+    };
+    socket.udp = createSocket(socket);
+    sockets.set(socketId, socket);
+    return { socketId };
+}
+function createSocket(socket) {
+    const type = socket.family === "ipv6" ? "udp6" : "udp4";
+    const ipv6Only = socket.family === "ipv6";
+    const udp = dgram.createSocket({
+        type,
+        ipv6Only,
+        reuseAddr: false,
+        lookup: noLookup,
+    });
+    udp.on("message", (msg, rinfo) => socket.receiveQueue.push({ msg, rinfo }));
+    udp.on("error", () => { });
+    return udp;
+}
+async function handleBind({ socketId, localAddress }) {
+    const socket = sockets.get(socketId);
+    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;
+    }
+    const addr = serializeIpAddress(localAddress);
+    const port = localAddress.val.port;
+    const onListening = once(socket.udp, "listening");
+    const onError = once(socket.udp, "error").then(([err]) => {
+        throw err;
+    });
+    socket.udp.bind(port, addr);
+    await Promise.race([onListening, onError]);
+    const boundAddr = socket.udp.address();
+    socket.localAddress = makeIpAddress(socket.family, boundAddr.address, boundAddr.port);
+}
+async function handleConnect({ socketId, remoteAddress }) {
+    const socket = sockets.get(socketId);
+    const preserveLocalAddress = socket.connected &&
+        socket.localAddress &&
+        isLoopbackIpAddress(socket.connected) &&
+        isLoopbackIpAddress(remoteAddress);
+    if (socket.connected) {
+        const localAddress = preserveLocalAddress ? socket.localAddress : null;
+        await new Promise((resolve) => socket.udp.close(resolve));
+        socket.udp = createSocket(socket);
+        if (localAddress) {
+            await handleBind({ socketId, localAddress });
+        }
+        else {
+            socket.localAddress = null;
+        }
+    }
+    const addr = serializeIpAddress(remoteAddress);
+    const port = remoteAddress.val.port;
+    await new Promise((resolve, reject) => {
+        socket.udp.connect(port, addr, (err) => (err ? reject(err) : resolve()));
+    });
+    const boundAddr = socket.udp.address();
+    socket.localAddress = makeIpAddress(socket.family, boundAddr.address, boundAddr.port);
+    socket.connected = remoteAddress;
+}
+function handleDisconnect({ socketId }) {
+    const socket = sockets.get(socketId);
+    socket.udp.disconnect();
+    socket.connected = null;
+}
+async function handleSend({ socketId, data, remoteAddress }) {
+    const socket = sockets.get(socketId);
+    const isConnected = socket.connected != null;
+    await new Promise((resolve, reject) => {
+        if (isConnected) {
+            socket.udp.send(data, (err) => (err ? reject(err) : resolve()));
+        }
+        else {
+            const addr = serializeIpAddress(remoteAddress);
+            const port = remoteAddress.val.port;
+            socket.udp.send(data, port, addr, (err) => (err ? reject(err) : resolve()));
+        }
+    });
+    const boundAddr = socket.udp.address();
+    socket.localAddress = makeIpAddress(socket.family, boundAddr.address, boundAddr.port);
+}
+async function handleReceive({ socketId }) {
+    const socket = sockets.get(socketId);
+    if (socket.receiveQueue.length === 0) {
+        await Promise.race([
+            once(socket.udp, "message"),
+            once(socket.udp, "error").then(([err]) => {
+                throw err;
+            }),
+        ]);
+    }
+    const { msg, rinfo } = socket.receiveQueue.shift();
+    return {
+        data: msg,
+        remoteAddress: makeIpAddress(socket.family, rinfo.address, rinfo.port),
+    };
+}
+function handleGetLocal({ socketId }) {
+    const socket = sockets.get(socketId);
+    const addr = socket.udp.address();
+    return makeIpAddress(socket.family, addr.address, addr.port);
+}
+function handleSetHop({ socketId, value }) {
+    const socket = sockets.get(socketId);
+    socket.udp.setTTL(value);
+}
+function handleRecvBuffer({ socketId }) {
+    const socket = sockets.get(socketId);
+    return BigInt(socket.udp.getRecvBufferSize());
+}
+function handleSendBuffer({ socketId }) {
+    const socket = sockets.get(socketId);
+    return BigInt(socket.udp.getSendBufferSize());
+}
+function handleDispose({ socketId }) {
+    const socket = sockets.get(socketId);
+    socket.udp.close();
+    sockets.delete(socketId);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytecodealliance/preview3-shim",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "WASI Preview3 shim for JS environments",
   "homepage": "https://github.com/bytecodealliance/jco/blob/main/packages/preview3-shim/#readme",
   "bugs": {
@@ -23,35 +23,43 @@
   },
   "files": [
     "types",
-    "lib"
+    "dist"
   ],
   "type": "module",
-  "types": "./types/index.d.ts",
   "exports": {
     ".": {
-      "types": "./types/index.d.ts",
-      "node": "./lib/nodejs/index.js"
+      "types": "./dist/nodejs/index.d.ts",
+      "node": "./dist/nodejs/index.js"
     },
     "./*": {
-      "types": "./types/*.d.ts",
-      "node": "./lib/nodejs/*.js"
+      "types": "./dist/nodejs/*.d.ts",
+      "node": "./dist/nodejs/*.js"
+    },
+    "./interfaces/*": {
+      "types": "./types/interfaces/*.d.ts"
     }
   },
   "dependencies": {
-    "@bytecodealliance/preview2-shim": "^0.17.3"
+    "@bytecodealliance/preview2-shim": "^0.19.0"
   },
   "devDependencies": {
-    "globals": "^16.3.0",
-    "vite": "^7.1.5",
-    "vitest": "^4.1.0"
+    "@types/node": "^24.12.4",
+    "globals": "^17.6.0",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.16",
+    "vitest": "^4.0.8"
   },
   "scripts": {
-    "compile:check": "tsc --noEmit types/index.d.ts",
+    "build": "tsc --project tsconfig.build.json",
+    "build:watch": "tsc --watch",
+    "types:check": "tsc --noEmit",
     "fmt": "oxfmt",
     "fmt:check": "oxfmt --check",
     "lint": "oxlint",
     "lint:fix": "oxlint --fix",
+    "pretest": "pnpm run build",
     "test": "vitest --run",
+    "prebench": "pnpm run build",
     "bench": "vitest bench --run"
   }
 }

package/types/interfaces/wasi-cli-environment.d.ts

@@ -1,10 +1,10 @@
-/** @module Interface wasi:cli/environment@0.3.0-rc-2026-03-15 **/
+/** @module Interface wasi:cli/environment@0.3.0 **/
 /**
  * Get the POSIX-style environment variables.
- *
+ * 
  * Each environment variable is provided as a pair of string variable names
  * and string value.
- *
+ * 
  * Morally, these are a value import, but until value imports are available
  * in the component model, this import function should return the same
  * values each time it is called.

package/types/interfaces/wasi-cli-exit.d.ts

@@ -1,6 +1,17 @@
-/** @module Interface wasi:cli/exit@0.3.0-rc-2026-03-15 **/
+/** @module Interface wasi:cli/exit@0.3.0 **/
 /**
  * Exit the current instance and any linked instances.
  */
 export function exit(status: Result<void, void>): void;
+/**
+ * Exit the current instance and any linked instances, reporting the
+ * specified status code to the host.
+ * 
+ * The meaning of the code depends on the context, with 0 usually meaning
+ * "success", and other values indicating various types of failure.
+ * 
+ * This function does not return; the effect is analogous to a trap, but
+ * without the connotation that something bad has happened.
+ */
+export function exitWithCode(statusCode: number): void;
 export type Result<T, E> = { tag: 'ok', val: T } | { tag: 'err', val: E };

package/types/interfaces/wasi-cli-run.d.ts

@@ -1,4 +1,4 @@
-/** @module Interface wasi:cli/run@0.3.0-rc-2026-03-15 **/
+/** @module Interface wasi:cli/run@0.3.0 **/
 /**
  * Run the program.
  */

package/types/interfaces/wasi-cli-stderr.d.ts

@@ -1,11 +1,11 @@
-/** @module Interface wasi:cli/stderr@0.3.0-rc-2026-03-15 **/
+/** @module Interface wasi:cli/stderr@0.3.0 **/
 /**
  * Write the given stream to stderr.
- *
+ * 
  * If the stream's writable end is dropped this function will either return
  * success once the entire contents of the stream have been written or an
  * error-code representing a failure.
- *
+ * 
  * Otherwise if there is an error the readable end of the stream will be
  * dropped and this function will return an error-code.
  */

package/types/interfaces/wasi-cli-stdin.d.ts

@@ -1,16 +1,16 @@
-/** @module Interface wasi:cli/stdin@0.3.0-rc-2026-03-15 **/
+/** @module Interface wasi:cli/stdin@0.3.0 **/
 /**
  * Return a stream for reading from stdin.
- *
+ * 
  * This function returns a stream which provides data read from stdin,
  * and a future to signal read results.
- *
+ * 
  * If the stream's readable end is dropped the future will resolve to success.
- *
+ * 
  * If the stream's writable end is dropped the future will either resolve to
  * success if stdin was closed by the writer or to an error-code if reading
  * failed for some other reason.
- *
+ * 
  * Multiple streams may be active at the same time. The behavior of concurrent
  * reads is implementation-specific.
  */

package/types/interfaces/wasi-cli-stdout.d.ts

@@ -1,11 +1,11 @@
-/** @module Interface wasi:cli/stdout@0.3.0-rc-2026-03-15 **/
+/** @module Interface wasi:cli/stdout@0.3.0 **/
 /**
  * Write the given stream to stdout.
- *
+ * 
  * If the stream's writable end is dropped this function will either return
  * success once the entire contents of the stream have been written or an
  * error-code representing a failure.
- *
+ * 
  * Otherwise if there is an error the readable end of the stream will be
  * dropped and this function will return an error-code.
  */

package/types/interfaces/wasi-cli-terminal-input.d.ts

@@ -1,4 +1,4 @@
-/** @module Interface wasi:cli/terminal-input@0.3.0-rc-2026-03-15 **/
+/** @module Interface wasi:cli/terminal-input@0.3.0 **/
 
 export class TerminalInput {
   /**

package/types/interfaces/wasi-cli-terminal-output.d.ts

@@ -1,4 +1,4 @@
-/** @module Interface wasi:cli/terminal-output@0.3.0-rc-2026-03-15 **/
+/** @module Interface wasi:cli/terminal-output@0.3.0 **/
 
 export class TerminalOutput {
   /**

package/types/interfaces/wasi-cli-terminal-stderr.d.ts

@@ -1,4 +1,4 @@
-/** @module Interface wasi:cli/terminal-stderr@0.3.0-rc-2026-03-15 **/
+/** @module Interface wasi:cli/terminal-stderr@0.3.0 **/
 /**
  * If stderr is connected to a terminal, return a `terminal-output` handle
  * allowing further interaction with it.

package/types/interfaces/wasi-cli-terminal-stdin.d.ts

@@ -1,4 +1,4 @@
-/** @module Interface wasi:cli/terminal-stdin@0.3.0-rc-2026-03-15 **/
+/** @module Interface wasi:cli/terminal-stdin@0.3.0 **/
 /**
  * If stdin is connected to a terminal, return a `terminal-input` handle
  * allowing further interaction with it.

package/types/interfaces/wasi-cli-terminal-stdout.d.ts

@@ -1,4 +1,4 @@
-/** @module Interface wasi:cli/terminal-stdout@0.3.0-rc-2026-03-15 **/
+/** @module Interface wasi:cli/terminal-stdout@0.3.0 **/
 /**
  * If stdout is connected to a terminal, return a `terminal-output` handle
  * allowing further interaction with it.