@bytecodealliance/preview2-shim 0.20.1 → 0.21.0

package/dist/browser/filesystem.d.ts

@@ -38,7 +38,7 @@ declare class Descriptor implements TypesNamespace.Descriptor {
     advise(offset: Filesize, length: Filesize, advice: TypesNamespace.Advice): void;
     syncData(): void;
     getFlags(): TypesNamespace.DescriptorFlags;
-    getType(): "directory" | "regular-file" | "unknown" | "fifo";
+    getType(): "directory" | "fifo" | "regular-file" | "unknown";
     setSize(size: bigint): void;
     setTimes(dataAccessTimestamp: any, dataModificationTimestamp: any): void;
     read(length: bigint, offset: bigint): [Uint8Array<ArrayBufferLike>, boolean];

package/dist/io/calls.d.ts

@@ -29,6 +29,17 @@ export declare const OUTPUT_STREAM_BLOCKING_SPLICE: number;
 export declare const OUTPUT_STREAM_SUBSCRIBE: number;
 export declare const OUTPUT_STREAM_DISPOSE: number;
 export declare const OUTPUT_STREAM_GET_TOTAL_BYTES: number;
+export declare const FILESYSTEM_DESCRIPTOR_OPEN: number;
+export declare const FILESYSTEM_DESCRIPTOR_CLOSE: number;
+export declare const FILESYSTEM_DESCRIPTOR_SYNC_DATA: number;
+export declare const FILESYSTEM_DESCRIPTOR_GET_TYPE: number;
+export declare const FILESYSTEM_DESCRIPTOR_SET_SIZE: number;
+export declare const FILESYSTEM_DESCRIPTOR_SET_TIMES: number;
+export declare const FILESYSTEM_DESCRIPTOR_READ: number;
+export declare const FILESYSTEM_DESCRIPTOR_WRITE: number;
+export declare const FILESYSTEM_DESCRIPTOR_SYNC: number;
+export declare const FILESYSTEM_DESCRIPTOR_STAT: number;
+export declare const FILESYSTEM_DESCRIPTOR_METADATA_HASH: number;
 export declare const POLL_POLLABLE_READY: number;
 export declare const POLL_POLLABLE_BLOCK: number;
 export declare const POLL_POLLABLE_DISPOSE: number;

package/dist/io/calls.js

@@ -35,6 +35,18 @@ export const OUTPUT_STREAM_BLOCKING_SPLICE = ++call_id << CALL_SHIFT;
 export const OUTPUT_STREAM_SUBSCRIBE = ++call_id << CALL_SHIFT;
 export const OUTPUT_STREAM_DISPOSE = ++call_id << CALL_SHIFT;
 export const OUTPUT_STREAM_GET_TOTAL_BYTES = ++call_id << CALL_SHIFT;
+// Filesystem descriptors
+export const FILESYSTEM_DESCRIPTOR_OPEN = ++call_id << CALL_SHIFT;
+export const FILESYSTEM_DESCRIPTOR_CLOSE = ++call_id << CALL_SHIFT;
+export const FILESYSTEM_DESCRIPTOR_SYNC_DATA = ++call_id << CALL_SHIFT;
+export const FILESYSTEM_DESCRIPTOR_GET_TYPE = ++call_id << CALL_SHIFT;
+export const FILESYSTEM_DESCRIPTOR_SET_SIZE = ++call_id << CALL_SHIFT;
+export const FILESYSTEM_DESCRIPTOR_SET_TIMES = ++call_id << CALL_SHIFT;
+export const FILESYSTEM_DESCRIPTOR_READ = ++call_id << CALL_SHIFT;
+export const FILESYSTEM_DESCRIPTOR_WRITE = ++call_id << CALL_SHIFT;
+export const FILESYSTEM_DESCRIPTOR_SYNC = ++call_id << CALL_SHIFT;
+export const FILESYSTEM_DESCRIPTOR_STAT = ++call_id << CALL_SHIFT;
+export const FILESYSTEM_DESCRIPTOR_METADATA_HASH = ++call_id << CALL_SHIFT;
 // Io Poll
 export const POLL_POLLABLE_READY = ++call_id << CALL_SHIFT;
 export const POLL_POLLABLE_BLOCK = ++call_id << CALL_SHIFT;

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

@@ -0,0 +1,29 @@
+export declare function openFileResource(path: string, flags: number): Promise<{
+    id: number;
+    type: any;
+}>;
+export declare function retainFileResource(id: number): number;
+export declare function releaseFileResource(id: number): Promise<void>;
+export declare function fileResourceFd(id: number): number;
+export declare function syncFileResourceData(id: number): Promise<void>;
+export declare function getFileResourceType(id: number): Promise<"block-device" | "character-device" | "directory" | "fifo" | "regular-file" | "socket" | "symbolic-link" | "unknown">;
+export declare function setFileResourceSize(id: number, size: number): Promise<void>;
+export declare function setFileResourceTimes(id: number, atime: number, mtime: number): Promise<void>;
+export declare function readFileResource(id: number, length: number, offset: number): Promise<{
+    bytes: Uint8Array<ArrayBuffer>;
+    eof: boolean;
+}>;
+export declare function writeFileResource(id: number, buffer: Uint8Array, offset: number): Promise<number>;
+export declare function syncFileResource(id: number): Promise<void>;
+export declare function statFileResource(id: number): Promise<{
+    type: string;
+    nlink: bigint;
+    size: bigint;
+    atimeNs: bigint;
+    mtimeNs: bigint;
+    ctimeNs: bigint;
+}>;
+export declare function metadataHashFileResource(id: number): Promise<{
+    upper: bigint;
+    lower: bigint;
+}>;

package/dist/io/worker-filesystem.js

@@ -0,0 +1,116 @@
+import fs from "node:fs";
+import { promisify } from "node:util";
+const closeAsync = promisify(fs.close);
+const fdatasyncAsync = promisify(fs.fdatasync);
+const fstatAsync = promisify(fs.fstat);
+const fsyncAsync = promisify(fs.fsync);
+const ftruncateAsync = promisify(fs.ftruncate);
+const futimesAsync = promisify(fs.futimes);
+const openAsync = promisify(fs.open);
+const readAsync = promisify(fs.read);
+const writeAsync = promisify(fs.write);
+let nextFileResourceId = 0;
+const fileResources = new Map();
+function lookupType(obj) {
+    if (obj.isFile()) {
+        return "regular-file";
+    }
+    if (obj.isSocket()) {
+        return "socket";
+    }
+    if (obj.isSymbolicLink()) {
+        return "symbolic-link";
+    }
+    if (obj.isFIFO()) {
+        return "fifo";
+    }
+    if (obj.isDirectory()) {
+        return "directory";
+    }
+    if (obj.isCharacterDevice()) {
+        return "character-device";
+    }
+    if (obj.isBlockDevice()) {
+        return "block-device";
+    }
+    return "unknown";
+}
+function getFileResource(id) {
+    const resource = fileResources.get(id);
+    if (!resource) {
+        const error = new Error(`Invalid filesystem descriptor resource: ${id}`);
+        error.code = "EBADF";
+        throw error;
+    }
+    return resource;
+}
+export async function openFileResource(path, flags) {
+    const fd = await openAsync(path, flags);
+    let type;
+    try {
+        type = lookupType(await fstatAsync(fd, { bigint: true }));
+    }
+    catch (error) {
+        await closeAsync(fd);
+        throw error;
+    }
+    const id = ++nextFileResourceId;
+    fileResources.set(id, { fd, refs: 1 });
+    return { id, type };
+}
+export function retainFileResource(id) {
+    getFileResource(id).refs++;
+    return id;
+}
+export async function releaseFileResource(id) {
+    const resource = getFileResource(id);
+    if (--resource.refs === 0) {
+        fileResources.delete(id);
+        await closeAsync(resource.fd);
+    }
+}
+export function fileResourceFd(id) {
+    return getFileResource(id).fd;
+}
+export async function syncFileResourceData(id) {
+    await fdatasyncAsync(fileResourceFd(id));
+}
+export async function getFileResourceType(id) {
+    return lookupType(await fstatAsync(fileResourceFd(id), { bigint: true }));
+}
+export async function setFileResourceSize(id, size) {
+    await ftruncateAsync(fileResourceFd(id), size);
+}
+export async function setFileResourceTimes(id, atime, mtime) {
+    await futimesAsync(fileResourceFd(id), atime, mtime);
+}
+export async function readFileResource(id, length, offset) {
+    const buffer = new Uint8Array(length);
+    const result = await readAsync(fileResourceFd(id), buffer, 0, length, offset);
+    // Deno v1 returns the byte count directly, while Node returns an object
+    // containing the byte count and buffer through util.promisify's custom args.
+    const bytesRead = typeof result === "number" ? result : result.bytesRead;
+    return { bytes: buffer.subarray(0, bytesRead), eof: bytesRead === 0 };
+}
+export async function writeFileResource(id, buffer, offset) {
+    const result = await writeAsync(fileResourceFd(id), buffer, 0, buffer.byteLength, offset);
+    return typeof result === "number" ? result : result.bytesWritten;
+}
+export async function syncFileResource(id) {
+    await fsyncAsync(fileResourceFd(id));
+}
+export async function statFileResource(id) {
+    const stats = await fstatAsync(fileResourceFd(id), { bigint: true });
+    return {
+        type: lookupType(stats),
+        nlink: stats.nlink,
+        size: stats.size,
+        atimeNs: stats.atimeNs,
+        mtimeNs: stats.mtimeNs,
+        ctimeNs: stats.ctimeNs,
+    };
+}
+export async function metadataHashFileResource(id) {
+    const stats = await fstatAsync(fileResourceFd(id), { bigint: true });
+    return { upper: stats.mtimeNs, lower: stats.ino };
+}

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

@@ -2,13 +2,13 @@ export declare function stopHttpServer(id: any): Promise<void>;
 export declare function clearOutgoingResponse(id: any): void;
 export declare function getHttpServerAddress(id: any): Promise<any>;
 export declare function setOutgoingResponse(id: any, { statusCode, headers, streamId }: {
-    statusCode: any;
     headers: any;
+    statusCode: any;
     streamId: any;
 }): Promise<void>;
 export declare function startHttpServer(id: number, { port, host }: {
-    port: any;
     host: any;
+    port: any;
 }): Promise<void>;
 export declare function createHttpRequest(method: any, scheme: any, authority: any, pathWithQuery: any, headers: any, bodyId: any, connectTimeout: any, betweenBytesTimeout: any, firstByteTimeout: any): Promise<{
     status: number | undefined;

package/dist/io/worker-socket-tcp.d.ts

@@ -1,5 +1,5 @@
 import { PollState } from "./worker-thread.js";
-import { Socket as TcpSocket } from "node:net";
+import { Server, Socket as TcpSocket } from "node:net";
 import { IpSocketAddress } from "../../types/interfaces/wasi-sockets-network.js";
 interface PendingAccept {
     tcpSocket: TcpSocket | null;
@@ -10,8 +10,11 @@ interface TcpSocketRecord {
     state: number;
     future: number | null;
     tcpSocket: TcpSocket | null;
+    server: Server | null;
+    localAddress: IpSocketAddress | null;
     listenBacklogSize: number;
-    handle: TCP;
+    keepAlive: boolean;
+    keepAliveIdleTime: number;
     pendingAccepts: PendingAccept[];
     pollState: PollState | null;
 }

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

@@ -1,20 +1,20 @@
 import { createFuture, createReadableStream, createReadableStreamPollState, createWritableStream, futureDispose, futureTakeValue, pollStateReady, verifyPollsDroppedForDrop, } from "./worker-thread.js";
 import process from "node:process";
-// TODO: tcp_wrap is no longer exposed in newer versions of Node.js
-const { TCP, constants: TCPConstants } = process.binding("tcp_wrap");
-import { convertSocketError, convertSocketErrorCode, 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 { 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() {
-    const handle = new TCP(TCPConstants.SOCKET);
     tcpSockets.set(++tcpSocketCnt, {
         state: SOCKET_STATE_INIT,
         future: null,
         tcpSocket: null,
+        server: null,
+        localAddress: null,
         listenBacklogSize: 128,
-        handle,
+        keepAlive: false,
+        keepAliveIdleTime: 0,
         pendingAccepts: [],
         pollState: {
             ready: true,
@@ -44,7 +44,7 @@ export function socketTcpFinish(id, fromState, toState) {
         socket.state = toState;
         // for the listener, we must immediately transition back to unresolved
         if (toState === SOCKET_STATE_LISTENER) {
-            socket.pollState.ready = false;
+            socket.pollState.ready = socket.pendingAccepts.length > 0;
         }
         return val;
     }
@@ -60,26 +60,77 @@ export function socketTcpBindStart(id, localAddress, family) {
         throw "invalid-argument";
     }
     socket.state = SOCKET_STATE_BIND;
-    const { handle } = socket;
-    socket.future = createFuture((async () => {
+    socket.future = createFuture(new Promise((resolve, reject) => {
         const address = serializeIpAddress(localAddress);
         const port = localAddress.val.port;
-        const code = localAddress.tag === "ipv6"
-            ? handle.bind6(address, port, TCPConstants.UV_TCP_IPV6ONLY)
-            : handle.bind(address, port);
-        if (code !== 0) {
-            throw convertSocketErrorCode(-code);
+        // 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));
+        function handleErr(err) {
+            server.off("listening", handleListen);
+            reject(convertSocketError(err));
         }
-        // This is a Node.js / libuv quirk to force the bind error to be thrown
-        // (specifically address-in-use).
-        {
-            const out = {};
-            const code = handle.getsockname(out);
-            if (code !== 0) {
-                throw convertSocketErrorCode(-code);
+        function handleListen() {
+            server.off("error", handleErr);
+            const boundAddress = server.address();
+            if (!boundAddress || typeof boundAddress === "string") {
+                reject("invalid-state");
+                return;
             }
+            socket.localAddress = ipSocketAddress(boundAddress.family.toLowerCase(), boundAddress.address, boundAddress.port);
+            resolve();
         }
-    })(), socket.pollState);
+        server.once("listening", handleListen);
+        server.once("error", handleErr);
+        server.listen({
+            host: address ?? undefined,
+            port,
+            backlog: socket.listenBacklogSize,
+            ipv6Only: family === "ipv6",
+        });
+    }), socket.pollState);
+}
+function createTcpServer(socket) {
+    const server = new Server({
+        pauseOnConnect: true,
+        allowHalfOpen: true,
+    });
+    server.on("connection", (tcpSocket) => {
+        // The reservation is already listening at the OS level, so reject any
+        // connections that arrive before the WASI socket enters its listen state.
+        if (socket.state !== SOCKET_STATE_LISTEN && socket.state !== SOCKET_STATE_LISTENER) {
+            tcpSocket.destroy();
+            return;
+        }
+        pollStateReady(socket.pollState);
+        const pollState = createReadableStreamPollState(tcpSocket);
+        socket.pendingAccepts.push({
+            tcpSocket,
+            err: null,
+            pollState,
+        });
+    });
+    server.on("error", (err) => {
+        if (socket.state === SOCKET_STATE_LISTEN || socket.state === SOCKET_STATE_LISTENER) {
+            pollStateReady(socket.pollState);
+            socket.pendingAccepts.push({
+                tcpSocket: null,
+                err,
+                pollState: null,
+            });
+        }
+    });
+    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()));
+    });
 }
 export function socketTcpConnectStart(id, remoteAddress, family) {
     const socket = tcpSockets.get(id);
@@ -95,71 +146,44 @@ export function socketTcpConnectStart(id, remoteAddress, family) {
         throw "invalid-argument";
     }
     socket.state = SOCKET_STATE_CONNECT;
-    socket.future = createFuture(new Promise((resolve, reject) => {
+    socket.future = createFuture((async () => {
+        const localAddress = socket.localAddress;
+        await closeTcpServer(socket);
         const tcpSocket = (socket.tcpSocket = new TcpSocket({
-            // @ts-expect-error Not present in type definition
-            handle: socket.handle,
-            pauseOnCreate: true,
             allowHalfOpen: true,
         }));
-        function handleErr(err) {
-            tcpSocket.off("connect", handleConnect);
-            reject(convertSocketError(err));
-        }
-        function handleConnect() {
-            tcpSocket.off("error", handleErr);
-            resolve([createReadableStream(tcpSocket), createWritableStream(tcpSocket)]);
-        }
-        tcpSocket.once("connect", handleConnect);
-        tcpSocket.once("error", handleErr);
-        tcpSocket.connect({
-            port: remoteAddress.val.port,
-            host: serializeIpAddress(remoteAddress) ?? undefined,
-            lookup: noLookup,
+        tcpSocket.setKeepAlive(socket.keepAlive, socket.keepAliveIdleTime);
+        await new Promise((resolve, reject) => {
+            function handleErr(err) {
+                tcpSocket.off("connect", handleConnect);
+                reject(convertSocketError(err));
+            }
+            function handleConnect() {
+                tcpSocket.off("error", handleErr);
+                resolve();
+            }
+            tcpSocket.once("connect", handleConnect);
+            tcpSocket.once("error", handleErr);
+            tcpSocket.connect({
+                port: remoteAddress.val.port,
+                host: serializeIpAddress(remoteAddress) ?? undefined,
+                lookup: noLookup,
+                localAddress: localAddress
+                    ? (serializeIpAddress(localAddress) ?? undefined)
+                    : undefined,
+                localPort: localAddress?.val.port,
+            });
         });
-    }), socket.pollState);
+        return [createReadableStream(tcpSocket), createWritableStream(tcpSocket)];
+    })(), socket.pollState);
 }
 export function socketTcpListenStart(id) {
     const socket = tcpSockets.get(id);
     if (socket.state !== SOCKET_STATE_BOUND) {
         throw "invalid-state";
     }
-    const { handle } = socket;
     socket.state = SOCKET_STATE_LISTEN;
-    socket.future = createFuture(new Promise((resolve, reject) => {
-        const server = new Server({
-            pauseOnConnect: true,
-            allowHalfOpen: true,
-        });
-        function handleErr(err) {
-            server.off("listening", handleListen);
-            reject(convertSocketError(err));
-        }
-        function handleListen() {
-            server.off("error", handleErr);
-            server.on("connection", (tcpSocket) => {
-                pollStateReady(socket.pollState);
-                const pollState = createReadableStreamPollState(tcpSocket);
-                socket.pendingAccepts.push({
-                    tcpSocket,
-                    err: null,
-                    pollState,
-                });
-            });
-            server.on("error", (err) => {
-                pollStateReady(socket.pollState);
-                socket.pendingAccepts.push({
-                    tcpSocket: null,
-                    err,
-                    pollState: null,
-                });
-            });
-            resolve();
-        }
-        server.once("listening", handleListen);
-        server.once("error", handleErr);
-        server.listen(handle, socket.listenBacklogSize);
-    }), socket.pollState);
+    socket.future = createFuture(Promise.resolve(), socket.pollState);
 }
 export function socketTcpAccept(id) {
     const socket = tcpSockets.get(id);
@@ -181,9 +205,11 @@ export function socketTcpAccept(id) {
         state: SOCKET_STATE_CONNECTION,
         future: null,
         tcpSocket: accept.tcpSocket,
+        server: null,
+        localAddress: null,
         listenBacklogSize: 128,
-        // @ts-expect-error
-        handle: accept.tcpSocket?._handle,
+        keepAlive: false,
+        keepAliveIdleTime: 0,
         pendingAccepts: [],
         pollState: accept.pollState,
     });
@@ -207,22 +233,22 @@ export function socketTcpSetListenBacklogSize(id, backlogSize) {
     socket.listenBacklogSize = Number(backlogSize);
 }
 export function socketTcpGetLocalAddress(id) {
-    const { handle } = tcpSockets.get(id);
-    const out = {};
-    const code = handle.getsockname(out);
-    if (code !== 0) {
-        throw convertSocketErrorCode(-code);
+    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);
+    }
+    if (socket.localAddress) {
+        return socket.localAddress;
     }
-    return ipSocketAddress(out.family.toLowerCase(), out.address, out.port);
+    throw "invalid-state";
 }
 export function socketTcpGetRemoteAddress(id) {
-    const { handle } = tcpSockets.get(id);
-    const out = {};
-    const code = handle.getpeername(out);
-    if (code !== 0) {
-        throw convertSocketErrorCode(-code);
+    const { tcpSocket } = tcpSockets.get(id);
+    if (!tcpSocket?.remoteFamily || !tcpSocket.remoteAddress || !tcpSocket.remotePort) {
+        throw "invalid-state";
     }
-    return ipSocketAddress(out.family.toLowerCase(), out.address, out.port);
+    return ipSocketAddress(tcpSocket.remoteFamily.toLowerCase(), tcpSocket.remoteAddress, tcpSocket.remotePort);
 }
 export function socketTcpShutdown(id, _shutdownType) {
     const socket = tcpSockets.get(id);
@@ -237,15 +263,15 @@ export function socketTcpShutdown(id, _shutdownType) {
     }
 }
 export function socketTcpSetKeepAlive(id, { keepAlive, keepAliveIdleTime }) {
-    const { handle } = tcpSockets.get(id);
-    const code = handle.setKeepAlive(keepAlive, Number(keepAliveIdleTime / 1000000000n));
-    if (code !== 0) {
-        throw convertSocketErrorCode(-code);
-    }
+    const socket = tcpSockets.get(id);
+    socket.keepAlive = keepAlive;
+    socket.keepAliveIdleTime = Number(keepAliveIdleTime / 1000000000n);
+    socket.tcpSocket?.setKeepAlive(socket.keepAlive, socket.keepAliveIdleTime);
 }
 export function socketTcpDispose(id) {
     const socket = tcpSockets.get(id);
     verifyPollsDroppedForDrop(socket.pollState, "tcp socket");
-    socket.handle.close();
+    socket.server?.close();
+    socket.tcpSocket?.destroy();
     tcpSockets.delete(id);
 }

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

@@ -11,12 +11,12 @@ export declare function noLookup(ip: any, _opts: any, cb: any): void;
 export declare function socketResolveAddress(name: string): Promise<{
     tag: string;
     val: Ipv4Address | Ipv6Address;
-}[]> | Promise<{
+}[][]> | Promise<{
     tag: string;
     val: Ipv4Address | Ipv6Address;
-}[][]>;
-export declare function convertSocketError(err: any): "unknown" | "would-block" | "connection-refused" | "invalid-argument" | "invalid-state" | "access-denied" | "not-supported" | "out-of-memory" | "concurrency-conflict" | "address-not-bindable" | "address-in-use" | "connection-reset" | "connection-aborted";
-export declare function convertSocketErrorCode(code: any): "unknown" | "would-block" | "connection-refused" | "invalid-argument" | "invalid-state" | "access-denied" | "not-supported" | "out-of-memory" | "concurrency-conflict" | "address-not-bindable" | "address-in-use" | "connection-reset" | "connection-aborted";
+}[]>;
+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 tupleToIPv6(arr: Ipv6Address): string | null;
 export declare function tupleToIpv4(arr: Ipv4Address): string | null;
 export declare function isMulticastIpAddress(ipSocketAddress: IpSocketAddress): boolean;