@bytecodealliance/preview2-shim 0.22.0 → 0.24.0

package/dist/browser/random.js

@@ -1,3 +1,4 @@
+import { checkedU64AsNumber } from "./common.js";
 const MAX_BYTES = 65536;
 let insecureRandomValue1, insecureRandomValue2;
 export const insecure = {
@@ -20,11 +21,12 @@ export const insecureSeed = {
 };
 export const random = {
     getRandomBytes(len) {
-        const bytes = new Uint8Array(Number(len));
-        if (len > MAX_BYTES) {
+        const byteLength = checkedU64AsNumber(len, "random byte length");
+        const bytes = new Uint8Array(byteLength);
+        if (byteLength > MAX_BYTES) {
             // this is the max bytes crypto.getRandomValues
             // can do at once see https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues
-            for (var generated = 0; generated < len; generated += MAX_BYTES) {
+            for (let generated = 0; generated < byteLength; generated += MAX_BYTES) {
                 // buffer.slice automatically checks if the end is past the end of
                 // the buffer so we don't have to here
                 crypto.getRandomValues(bytes.subarray(generated, generated + MAX_BYTES));

package/dist/browser/sockets.d.ts

@@ -1,7 +1,8 @@
 import type { instanceNetwork as InstanceNetworkNamespace, ipNameLookup as IpNameLookupNamespace, network as NetworkNamespace, tcpCreateSocket as TcpCreateSocketNamespace, tcp as TcpNamespace, udpCreateSocket as UdpCreateSocketNamespace, udp as UdpNamespace } from "../../types/sockets.js";
+export { InMemoryTcpClient, InMemoryTcpSockets, InMemoryUdpClient, InMemoryUdpSockets, } from "./in-memory-sockets.js";
 export declare const instanceNetwork: typeof InstanceNetworkNamespace;
-export declare const ipNameLookup: typeof IpNameLookupNamespace;
 export declare const network: typeof NetworkNamespace;
+export declare const ipNameLookup: typeof IpNameLookupNamespace;
 export declare const tcpCreateSocket: typeof TcpCreateSocketNamespace;
 export declare const tcp: typeof TcpNamespace;
 export declare const udpCreateSocket: typeof UdpCreateSocketNamespace;

package/dist/browser/sockets.js

@@ -1,66 +1,85 @@
+export { InMemoryTcpClient, InMemoryTcpSockets, InMemoryUdpClient, InMemoryUdpSockets, } from "./in-memory-sockets.js";
+const unsupported = () => {
+    throw "not-supported";
+};
+class Network {
+}
+const defaultNetwork = new Network();
 export const instanceNetwork = {
-    instanceNetwork() {
-        console.log(`[sockets] instance network`);
-    },
+    instanceNetwork: () => defaultNetwork,
 };
+export const network = { Network };
+class ResolveAddressStream {
+    resolveNextAddress = unsupported;
+    subscribe = unsupported;
+}
 export const ipNameLookup = {
-    dropResolveAddressStream() { },
-    subscribe() { },
-    resolveAddresses() { },
-    resolveNextAddress() { },
-    nonBlocking() { },
-    setNonBlocking() { },
-};
-export const network = {
-    dropNetwork() { },
+    ResolveAddressStream,
+    resolveAddresses: unsupported,
 };
+class TcpSocket {
+    startBind = unsupported;
+    finishBind = unsupported;
+    startConnect = unsupported;
+    finishConnect = unsupported;
+    startListen = unsupported;
+    finishListen = unsupported;
+    accept = unsupported;
+    localAddress = unsupported;
+    remoteAddress = unsupported;
+    isListening = unsupported;
+    addressFamily = unsupported;
+    setListenBacklogSize = unsupported;
+    keepAliveEnabled = unsupported;
+    setKeepAliveEnabled = unsupported;
+    keepAliveIdleTime = unsupported;
+    setKeepAliveIdleTime = unsupported;
+    keepAliveInterval = unsupported;
+    setKeepAliveInterval = unsupported;
+    keepAliveCount = unsupported;
+    setKeepAliveCount = unsupported;
+    hopLimit = unsupported;
+    setHopLimit = unsupported;
+    receiveBufferSize = unsupported;
+    setReceiveBufferSize = unsupported;
+    sendBufferSize = unsupported;
+    setSendBufferSize = unsupported;
+    subscribe = unsupported;
+    shutdown = unsupported;
+}
 export const tcpCreateSocket = {
-    createTcpSocket() { },
-};
-export const tcp = {
-    subscribe() { },
-    dropTcpSocket() { },
-    bind() { },
-    connect() { },
-    listen() { },
-    accept() { },
-    localAddress() { },
-    remoteAddress() { },
-    addressFamily() { },
-    setListenBacklogSize() { },
-    keepAlive() { },
-    setKeepAlive() { },
-    noDelay() { },
-    setNoDelay() { },
-    unicastHopLimit() { },
-    setUnicastHopLimit() { },
-    receiveBufferSize() { },
-    setReceiveBufferSize() { },
-    sendBufferSize() { },
-    setSendBufferSize() { },
-    nonBlocking() { },
-    setNonBlocking() { },
-    shutdown() { },
+    createTcpSocket: unsupported,
 };
+export const tcp = { TcpSocket };
+class IncomingDatagramStream {
+    receive = unsupported;
+    subscribe = unsupported;
+}
+class OutgoingDatagramStream {
+    checkSend = unsupported;
+    send = unsupported;
+    subscribe = unsupported;
+}
+class UdpSocket {
+    startBind = unsupported;
+    finishBind = unsupported;
+    stream = unsupported;
+    localAddress = unsupported;
+    remoteAddress = unsupported;
+    addressFamily = unsupported;
+    unicastHopLimit = unsupported;
+    setUnicastHopLimit = unsupported;
+    receiveBufferSize = unsupported;
+    setReceiveBufferSize = unsupported;
+    sendBufferSize = unsupported;
+    setSendBufferSize = unsupported;
+    subscribe = unsupported;
+}
 export const udpCreateSocket = {
-    createUdpSocket() { },
+    createUdpSocket: unsupported,
 };
 export const udp = {
-    subscribe() { },
-    dropUdpSocket() { },
-    bind() { },
-    connect() { },
-    receive() { },
-    send() { },
-    localAddress() { },
-    remoteAddress() { },
-    addressFamily() { },
-    unicastHopLimit() { },
-    setUnicastHopLimit() { },
-    receiveBufferSize() { },
-    setReceiveBufferSize() { },
-    sendBufferSize() { },
-    setSendBufferSize() { },
-    nonBlocking() { },
-    setNonBlocking() { },
+    IncomingDatagramStream,
+    OutgoingDatagramStream,
+    UdpSocket,
 };

package/dist/common/instantiation.d.ts

@@ -59,7 +59,7 @@ import type { WASIShimConfig, GetImportObjectArgs, WASIImportObject } from "../.
  *   }
  * });
  *
- * // Limited filesystem access
+ * // Node.js only: limited host filesystem access
  * const limitedShim = new WASIShim({
  *   sandbox: {
  *     preopens: {
@@ -70,6 +70,9 @@ import type { WASIShimConfig, GetImportObjectArgs, WASIImportObject } from "../.
  * });
  * ```
  *
+ * Browser applications should inject `filesystem` namespaces or explicitly
+ * configure `browserFilesystem`; browser preopens never interpret host paths.
+ *
  * Note that this object is similar but not identical to the Node `WASI` object --
  * it is solely concerned with shimming of preview2 when dealing with a WebAssembly
  * component transpiled by Jco. While this object *does* work with Node (and the browser)

package/dist/common/instantiation.js

@@ -1,5 +1,4 @@
 import * as wasi from "@bytecodealliance/preview2-shim";
-import { types, _createPreopenDescriptor } from "@bytecodealliance/preview2-shim/filesystem";
 /**
  * (EXPERIMENTAL) A class that holds WASI shims and can be used to configure
  * an instantiation of a WebAssembly component transpiled with jco
@@ -60,7 +59,7 @@ import { types, _createPreopenDescriptor } from "@bytecodealliance/preview2-shim
  *   }
  * });
  *
- * // Limited filesystem access
+ * // Node.js only: limited host filesystem access
  * const limitedShim = new WASIShim({
  *   sandbox: {
  *     preopens: {
@@ -71,6 +70,9 @@ import { types, _createPreopenDescriptor } from "@bytecodealliance/preview2-shim
  * });
  * ```
  *
+ * Browser applications should inject `filesystem` namespaces or explicitly
+ * configure `browserFilesystem`; browser preopens never interpret host paths.
+ *
  * Note that this object is similar but not identical to the Node `WASI` object --
  * it is solely concerned with shimming of preview2 when dealing with a WebAssembly
  * component transpiled by Jco. While this object *does* work with Node (and the browser)
@@ -93,8 +95,6 @@ export class WASIShim {
     #sockets;
     /** Object that confirms to the shim interface for `wasi:http` */
     #http;
-    /** Isolated preopens for this instance */
-    #preopens;
     /** Isolated environment for this instance */
     #environment;
     /**
@@ -105,36 +105,94 @@ export class WASIShim {
     constructor(config) {
         // Support both old 'shims' parameter name and new 'config' style
         const shims = config;
-        this.#cli = shims?.cli ?? wasi.cli;
-        this.#filesystem = shims?.filesystem ?? wasi.filesystem;
+        const sandbox = shims?.sandbox;
+        const defaultCli = wasi.cli;
+        this.#cli =
+            shims?.cli ??
+                (defaultCli.createCli &&
+                    (shims?.environment !== undefined ||
+                        shims?.arguments !== undefined ||
+                        shims?.initialCwd !== undefined ||
+                        shims?.stdin !== undefined ||
+                        shims?.stdout !== undefined ||
+                        shims?.stderr !== undefined)
+                    ? defaultCli.createCli({
+                        environment: shims?.environment,
+                        arguments: shims?.arguments,
+                        initialCwd: shims?.initialCwd,
+                        stdin: shims?.stdin,
+                        stdout: shims?.stdout,
+                        stderr: shims?.stderr,
+                    })
+                    : defaultCli);
+        const defaultFilesystem = wasi.filesystem;
+        if (shims?.browserFilesystem && !defaultFilesystem.createFilesystem) {
+            throw new TypeError("the selected filesystem does not support browser adapters");
+        }
+        this.#filesystem = shims?.filesystem ?? defaultFilesystem;
+        if (shims?.filesystem && sandbox?.preopens !== undefined) {
+            if (!shims.filesystem.createPreopens) {
+                throw new TypeError("an application-provided filesystem must implement createPreopens to use sandbox.preopens");
+            }
+            this.#filesystem = {
+                types: shims.filesystem.types,
+                preopens: shims.filesystem.createPreopens(sandbox.preopens),
+                dispose: shims.filesystem.dispose?.bind(shims.filesystem),
+            };
+        }
+        else if (shims?.browserFilesystem) {
+            this.#filesystem = defaultFilesystem.createFilesystem({
+                adapter: shims.browserFilesystem.adapter,
+                preopens: sandbox?.preopens ?? shims.browserFilesystem.preopens,
+            });
+        }
+        else if (sandbox?.preopens !== undefined) {
+            if (!defaultFilesystem.createFilesystem) {
+                throw new TypeError("the selected filesystem cannot create isolated preopens");
+            }
+            this.#filesystem = defaultFilesystem.createFilesystem({
+                preopens: sandbox.preopens,
+            });
+        }
         this.#io = shims?.io ?? wasi.io;
         this.#random = shims?.random ?? wasi.random;
         this.#clocks = shims?.clocks ?? wasi.clocks;
-        this.#sockets = shims?.sockets ?? wasi.sockets;
+        const defaultSockets = wasi.sockets;
+        this.#sockets =
+            shims?.sockets ??
+                (defaultSockets.createSockets
+                    ? defaultSockets.createSockets({
+                        enableNetwork: shims?.sandbox?.enableNetwork,
+                    })
+                    : defaultSockets);
+        if (shims?.tcpSockets) {
+            this.#sockets = {
+                ...this.#sockets,
+                tcp: shims.tcpSockets.tcp,
+                tcpCreateSocket: shims.tcpSockets.tcpCreateSocket,
+            };
+        }
+        if (shims?.udpSockets) {
+            this.#sockets = {
+                ...this.#sockets,
+                udp: shims.udpSockets.udp,
+                udpCreateSocket: shims.udpSockets.udpCreateSocket,
+            };
+        }
         this.#http = shims?.http ?? wasi.http;
-        // Extract sandbox options
-        const sandbox = shims?.sandbox;
-        // Create isolated preopens if configured
-        if (sandbox?.preopens !== undefined) {
-            this.#preopens = createIsolatedPreopens(sandbox.preopens);
+        if (shims?.incomingHandler) {
+            if (!this.#http.createIncomingHandler) {
+                throw new TypeError("the selected HTTP shim does not support Web incoming handlers");
+            }
+            this.#http = {
+                ...this.#http,
+                incomingHandler: this.#http.createIncomingHandler(shims.incomingHandler),
+            };
         }
         // Create isolated environment if env or args are configured
         if (sandbox?.env !== undefined || sandbox?.args !== undefined) {
             this.#environment = createIsolatedEnvironment(sandbox?.env, sandbox?.args, this.#cli);
         }
-        // Apply network restrictions if disabled
-        if (sandbox?.enableNetwork === false) {
-            // Use the sockets module's built-in deny functions
-            if (this.#sockets._denyTcp) {
-                this.#sockets._denyTcp();
-            }
-            if (this.#sockets._denyUdp) {
-                this.#sockets._denyUdp();
-            }
-            if (this.#sockets._denyDnsLookup) {
-                this.#sockets._denyDnsLookup();
-            }
-        }
     }
     /**
      * Generate an import object for the shim that can be used with
@@ -164,8 +222,7 @@ export class WASIShim {
         obj[`wasi:sockets/tcp-create-socket${versionSuffix}`] = this.#sockets.tcpCreateSocket;
         obj[`wasi:sockets/udp${versionSuffix}`] = this.#sockets.udp;
         obj[`wasi:sockets/udp-create-socket${versionSuffix}`] = this.#sockets.udpCreateSocket;
-        obj[`wasi:filesystem/preopens${versionSuffix}`] =
-            this.#preopens ?? this.#filesystem.preopens;
+        obj[`wasi:filesystem/preopens${versionSuffix}`] = this.#filesystem.preopens;
         obj[`wasi:filesystem/types${versionSuffix}`] = this.#filesystem.types;
         obj[`wasi:io/error${versionSuffix}`] = this.#io.error;
         obj[`wasi:io/poll${versionSuffix}`] = this.#io.poll;
@@ -176,32 +233,11 @@ export class WASIShim {
         obj[`wasi:clocks/monotonic-clock${versionSuffix}`] = this.#clocks.monotonicClock;
         obj[`wasi:clocks/wall-clock${versionSuffix}`] = this.#clocks.wallClock;
         obj[`wasi:http/types${versionSuffix}`] = this.#http.types;
+        obj[`wasi:http/incoming-handler${versionSuffix}`] = this.#http.incomingHandler;
         obj[`wasi:http/outgoing-handler${versionSuffix}`] = this.#http.outgoingHandler;
         return obj;
     }
 }
-/**
- * Create an isolated preopens object with its own preopen entries.
- *
- * @param preopensConfig - Map of virtual paths to host paths
- * @returns A preopens object with Descriptor and getDirectories()
- */
-function createIsolatedPreopens(preopensConfig) {
-    const entries = [];
-    // Populate entries using the filesystem's descriptor creation
-    if (_createPreopenDescriptor) {
-        for (const [virtualPath, hostPath] of Object.entries(preopensConfig)) {
-            const descriptor = _createPreopenDescriptor(hostPath);
-            entries.push([descriptor, virtualPath]);
-        }
-    }
-    return {
-        Descriptor: types.Descriptor,
-        getDirectories() {
-            return entries;
-        },
-    };
-}
 /**
  * Create an isolated CLI environment with its own env and args.
  *

package/dist/io/worker-socket-tcp.js

@@ -1,8 +1,6 @@
 import { createFuture, createReadableStream, createReadableStreamPollState, createWritableStream, futureDispose, futureTakeValue, pollStateReady, verifyPollsDroppedForDrop, } from "./worker-thread.js";
-import process from "node:process";
 import { convertSocketError, ipSocketAddress, isIPv4MappedAddress, isMulticastIpAddress, isUnicastIpAddress, isWildcardAddress, noLookup, serializeIpAddress, SOCKET_STATE_BIND, SOCKET_STATE_BOUND, SOCKET_STATE_CLOSED, SOCKET_STATE_CONNECT, SOCKET_STATE_CONNECTION, SOCKET_STATE_INIT, SOCKET_STATE_LISTEN, SOCKET_STATE_LISTENER, } from "./worker-sockets.js";
 import { Server, Socket as TcpSocket } from "node:net";
-const win = process.platform === "win32";
 export const tcpSockets = new Map();
 let tcpSocketCnt = 0;
 export function createTcpSocket() {
@@ -37,7 +35,16 @@ export function socketTcpFinish(id, fromState, toState) {
     futureDispose(socket.future, false);
     socket.future = null;
     if (tag === "err") {
-        socket.state = SOCKET_STATE_CLOSED;
+        // A failed bind does not consume the socket. In particular, callers may
+        // retry after `address-in-use` with another address or port.
+        if (fromState === SOCKET_STATE_BIND) {
+            socket.server = null;
+            socket.localAddress = null;
+            socket.state = SOCKET_STATE_INIT;
+        }
+        else {
+            socket.state = SOCKET_STATE_CLOSED;
+        }
         throw val;
     }
     else {
@@ -77,7 +84,7 @@ export function socketTcpBindStart(id, localAddress, family) {
                 reject("invalid-state");
                 return;
             }
-            socket.localAddress = ipSocketAddress(boundAddress.family.toLowerCase(), boundAddress.address, boundAddress.port);
+            socket.localAddress = ipSocketAddress(boundAddress.family, boundAddress.address, boundAddress.port);
             resolve();
         }
         server.once("listening", handleListen);
@@ -236,7 +243,7 @@ export function socketTcpGetLocalAddress(id) {
     const socket = tcpSockets.get(id);
     const address = socket.tcpSocket?.address();
     if (address && typeof address !== "string" && "family" in address) {
-        return ipSocketAddress(address.family.toLowerCase(), address.address, address.port);
+        return ipSocketAddress(address.family, address.address, address.port);
     }
     if (socket.localAddress) {
         return socket.localAddress;
@@ -248,19 +255,14 @@ export function socketTcpGetRemoteAddress(id) {
     if (!tcpSocket?.remoteFamily || !tcpSocket.remoteAddress || !tcpSocket.remotePort) {
         throw "invalid-state";
     }
-    return ipSocketAddress(tcpSocket.remoteFamily.toLowerCase(), tcpSocket.remoteAddress, tcpSocket.remotePort);
+    return ipSocketAddress(tcpSocket.remoteFamily, tcpSocket.remoteAddress, tcpSocket.remotePort);
 }
 export function socketTcpShutdown(id, _shutdownType) {
     const socket = tcpSockets.get(id);
     if (socket.state !== SOCKET_STATE_CONNECTION) {
         throw "invalid-state";
     }
-    if (win && socket.tcpSocket?.destroySoon) {
-        socket.tcpSocket.destroySoon();
-    }
-    else {
-        socket.tcpSocket?.destroy();
-    }
+    socket.tcpSocket?.destroy();
 }
 export function socketTcpSetKeepAlive(id, { keepAlive, keepAliveIdleTime }) {
     const socket = tcpSockets.get(id);

package/dist/io/worker-socket-udp.js

@@ -61,10 +61,9 @@ function createIncomingDatagramStream(socket) {
         udpSocket.off("error", onError);
     }
     function onMessage(data, rinfo) {
-        const family = rinfo.family.toLowerCase();
         datagramStream.queue?.push({
             data,
-            remoteAddress: ipSocketAddress(family, rinfo.address, rinfo.port),
+            remoteAddress: ipSocketAddress(rinfo.family, rinfo.address, rinfo.port),
         });
         if (!pollState.ready) {
             pollStateReady(pollState);
@@ -168,7 +167,7 @@ export function socketUdpGetLocalAddress(id) {
     catch (err) {
         throw convertSocketError(err);
     }
-    return ipSocketAddress(family.toLowerCase(), address, port);
+    return ipSocketAddress(family, address, port);
 }
 /**
  * @param {number} id
@@ -183,7 +182,7 @@ export function socketUdpGetRemoteAddress(id) {
     catch (err) {
         throw convertSocketError(err);
     }
-    return ipSocketAddress(family.toLowerCase(), address, port);
+    return ipSocketAddress(family, address, port);
 }
 export function socketUdpStream(id, remoteAddress) {
     const socket = udpSockets.get(id);

package/dist/io/worker-sockets.d.ts

@@ -1,4 +1,4 @@
-import { IpAddressFamily, IpSocketAddress, Ipv4Address, Ipv6Address } from "../../types/interfaces/wasi-sockets-network.js";
+import { IpSocketAddress, Ipv4Address, Ipv6Address } from "../../types/interfaces/wasi-sockets-network.js";
 export declare const SOCKET_STATE_INIT: number;
 export declare const SOCKET_STATE_BIND: number;
 export declare const SOCKET_STATE_BOUND: number;
@@ -15,8 +15,8 @@ export declare function socketResolveAddress(name: string): Promise<{
     tag: string;
     val: Ipv4Address | Ipv6Address;
 }[]>;
-export declare function convertSocketError(err: any): "access-denied" | "address-in-use" | "address-not-bindable" | "concurrency-conflict" | "connection-aborted" | "connection-refused" | "connection-reset" | "invalid-argument" | "invalid-state" | "not-supported" | "out-of-memory" | "unknown" | "would-block";
-export declare function convertSocketErrorCode(code: any): "access-denied" | "address-in-use" | "address-not-bindable" | "concurrency-conflict" | "connection-aborted" | "connection-refused" | "connection-reset" | "invalid-argument" | "invalid-state" | "not-supported" | "out-of-memory" | "unknown" | "would-block";
+export declare function convertSocketError(err: any): "access-denied" | "address-in-use" | "address-not-bindable" | "concurrency-conflict" | "connection-aborted" | "connection-refused" | "connection-reset" | "datagram-too-large" | "invalid-argument" | "invalid-state" | "new-socket-limit" | "not-supported" | "out-of-memory" | "remote-unreachable" | "unknown" | "would-block";
+export declare function convertSocketErrorCode(code: any): "access-denied" | "address-in-use" | "address-not-bindable" | "concurrency-conflict" | "connection-aborted" | "connection-refused" | "connection-reset" | "datagram-too-large" | "invalid-argument" | "invalid-state" | "new-socket-limit" | "not-supported" | "out-of-memory" | "remote-unreachable" | "unknown" | "would-block";
 export declare function tupleToIPv6(arr: Ipv6Address): string | null;
 export declare function tupleToIpv4(arr: Ipv4Address): string | null;
 export declare function isMulticastIpAddress(ipSocketAddress: IpSocketAddress): boolean;
@@ -27,6 +27,6 @@ export declare function isBroadcastIpAddress(ipSocketAddress: IpSocketAddress):
 export declare function serializeIpAddress(addr: IpSocketAddress): string | null;
 export declare function ipv6ToTuple(ipv6: string): Ipv6Address;
 export declare function ipv4ToTuple(ipv4: string): Ipv4Address;
-export declare function ipSocketAddress(family: IpAddressFamily, addr: string, port: number): IpSocketAddress;
+export declare function ipSocketAddress(family: string | number, addr: string, port: number): IpSocketAddress;
 export declare function getDefaultSendBufferSize(): Promise<bigint>;
 export declare function getDefaultReceiveBufferSize(): Promise<bigint>;

package/dist/io/worker-sockets.js

@@ -2,7 +2,7 @@ import { isIP } from "node:net";
 import { lookup } from "node:dns/promises";
 import { createSocket } from "node:dgram";
 import { ALL, BADFAMILY, CANCELLED, CONNREFUSED, NODATA, NOMEM, NONAME, NOTFOUND, REFUSED, SERVFAIL, TIMEOUT, V4MAPPED, } from "node:dns";
-import { EACCES, EADDRINUSE, EADDRNOTAVAIL, EALREADY, EBADF, ECONNABORTED, ECONNREFUSED, ECONNRESET, EINVAL, ENOBUFS, ENOMEM, ENOTCONN, ENOTSUP, EPERM, EWOULDBLOCK, } from "node:constants";
+import { EACCES, EADDRINUSE, EADDRNOTAVAIL, EALREADY, EBADF, ECONNABORTED, ECONNREFUSED, ECONNRESET, EHOSTUNREACH, EINVAL, EMFILE, EMSGSIZE, ENETDOWN, ENETUNREACH, ENFILE, ENOBUFS, ENOMEM, ENOTCONN, ENOTSUP, EPERM, EWOULDBLOCK, } from "node:constants";
 let stateCnt = 0;
 export const SOCKET_STATE_INIT = ++stateCnt;
 export const SOCKET_STATE_BIND = ++stateCnt;
@@ -98,18 +98,26 @@ export function convertSocketError(err) {
             return "concurrency-conflict";
         case "EWOULDBLOCK":
             return "would-block";
-        // TODO: return "new-socket-limit";
+        case "EMFILE":
+        case "ENFILE":
+            return "new-socket-limit";
         case "EADDRNOTAVAIL":
             return "address-not-bindable";
         case "EADDRINUSE":
             return "address-in-use";
-        // TODO: return "remote-unreachable";
+        case "EHOSTUNREACH":
+        case "EHOSTDOWN":
+        case "ENETUNREACH":
+        case "ENETDOWN":
+            return "remote-unreachable";
         case "ECONNREFUSED":
             return "connection-refused";
         case "ECONNRESET":
             return "connection-reset";
         case "ECONNABORTED":
             return "connection-aborted";
+        case "EMSGSIZE":
+            return "datagram-too-large";
         default:
             return "unknown";
     }
@@ -135,23 +143,30 @@ export function convertSocketErrorCode(code) {
             return "concurrency-conflict";
         case EWOULDBLOCK:
             return "would-block";
-        // TODO: return "new-socket-limit";
+        case EMFILE:
+        case ENFILE:
+            return "new-socket-limit";
         case 4090: // windows
         case EADDRNOTAVAIL:
             return "address-not-bindable";
         case 4091: // windows
         case EADDRINUSE:
             return "address-in-use";
-        // TODO: return "remote-unreachable";
+        case EHOSTUNREACH:
+        case ENETUNREACH:
+        case ENETDOWN:
+            return "remote-unreachable";
         case ECONNREFUSED:
             return "connection-refused";
         case ECONNRESET:
             return "connection-reset";
         case ECONNABORTED:
             return "connection-aborted";
-        // TODO: return "datagram-too-large";
-        // TODO: return "name-unresolvable";
-        // TODO: return "temporary-resolver-failure";
+        case EMSGSIZE:
+            return "datagram-too-large";
+        // name-unresolvable/temporary-resolver-failure are DNS lookup errors,
+        // which only surface here as string error codes (see
+        // socketResolveAddress above), never as a raw platform errno.
         default:
             // process._rawDebug('unknown error code', code);
             return "unknown";
@@ -219,7 +234,9 @@ export function ipv4ToTuple(ipv4) {
     return ipv4.split(".").map((segment) => parseInt(segment, 10));
 }
 export function ipSocketAddress(family, addr, port) {
-    if (family === "ipv4") {
+    // Node uses "IPv4"/"IPv6", while Deno's Node compatibility layer can
+    // return 4/6. Accept both, as well as the WASI address-family tags.
+    if (family === "ipv4" || family === "IPv4" || family === 4) {
         return {
             tag: "ipv4",
             val: {
@@ -228,6 +245,9 @@ export function ipSocketAddress(family, addr, port) {
             },
         };
     }
+    if (family !== "ipv6" && family !== "IPv6" && family !== 6) {
+        throw "invalid-argument";
+    }
     return {
         tag: "ipv6",
         val: {