@bytecodealliance/preview3-shim 0.6.0 → 0.7.0

package/dist/browser/sockets/types.js

@@ -1,126 +1,318 @@
-import { Todo } from "../../common/errors.js";
+import * as preview2Sockets from "@bytecodealliance/preview2-shim/sockets";
+import { readableFromPreview2Input, writeToPreview2Output } from "../streams.js";
+let tcpProvider = preview2Sockets;
+let udpProvider = preview2Sockets;
+class SocketError extends Error {
+    payload;
+    constructor(payload) {
+        super(payload.tag);
+        this.name = "SocketError";
+        this.payload = payload;
+    }
+}
+export function socketErrorCode(error) {
+    let tag = typeof error === "string" ? error : error?.tag;
+    if (!tag && error instanceof Error) {
+        tag = error.message;
+    }
+    if (tag === "would-block" || tag === "not-in-progress") {
+        return { tag: "invalid-state" };
+    }
+    if (tag) {
+        return { tag };
+    }
+    return { tag: "other", val: String(error) };
+}
+function socketError(error) {
+    throw error instanceof SocketError ? error : new SocketError(socketErrorCode(error));
+}
+function socketCall(operation) {
+    try {
+        return operation();
+    }
+    catch (error) {
+        socketError(error);
+    }
+}
+export function _setTcpProvider(provider) {
+    const previous = tcpProvider;
+    tcpProvider = provider;
+    return previous;
+}
+export function _setUdpProvider(provider) {
+    const previous = udpProvider;
+    udpProvider = provider;
+    return previous;
+}
 export class TcpSocket {
+    #socket;
+    #input;
+    #output;
     static create(addressFamily) {
-        throw new Todo();
+        try {
+            return TcpSocket._wrap(tcpProvider.tcpCreateSocket.createTcpSocket(addressFamily));
+        }
+        catch (error) {
+            socketError(error);
+        }
+    }
+    static _wrap(socket, input, output) {
+        const wrapped = new TcpSocket();
+        wrapped.#socket = socket;
+        wrapped.#input = input;
+        wrapped.#output = output;
+        return wrapped;
     }
     bind(localAddress) {
-        throw new Todo();
-    }
-    connect(remoteAddress) {
-        throw new Todo();
+        try {
+            this.#socket.startBind({}, localAddress);
+            this.#socket.finishBind();
+        }
+        catch (error) {
+            socketError(error);
+        }
+    }
+    async connect(remoteAddress) {
+        try {
+            this.#socket.startConnect({}, remoteAddress);
+            const connected = this.#socket.finishConnect();
+            if (Array.isArray(connected)) {
+                [this.#input, this.#output] = connected;
+            }
+        }
+        catch (error) {
+            socketError(error);
+        }
     }
     listen() {
-        throw new Todo();
-    }
-    send(data) {
-        throw new Todo();
+        try {
+            this.#socket.startListen();
+            this.#socket.finishListen();
+        }
+        catch (error) {
+            socketError(error);
+        }
+        return new ReadableStream({
+            pull: async (controller) => {
+                while (true) {
+                    try {
+                        const [socket, input, output] = this.#socket.accept();
+                        controller.enqueue(TcpSocket._wrap(socket, input, output));
+                        return;
+                    }
+                    catch (error) {
+                        if (error === "would-block") {
+                            await new Promise((resolve) => setTimeout(resolve, 0));
+                            continue;
+                        }
+                        controller.error(new SocketError(socketErrorCode(error)));
+                        return;
+                    }
+                }
+            },
+        });
+    }
+    async send(data) {
+        if (!this.#output) {
+            return { tag: "err", val: { tag: "invalid-state" } };
+        }
+        try {
+            await writeToPreview2Output(data, this.#output);
+            return { tag: "ok", val: undefined };
+        }
+        catch (error) {
+            return { tag: "err", val: socketErrorCode(error) };
+        }
     }
     receive() {
-        throw new Todo();
+        if (!this.#input) {
+            const error = { tag: "invalid-state" };
+            const stream = new ReadableStream({
+                start(controller) {
+                    controller.error(new SocketError(error));
+                },
+            });
+            return [stream, Promise.resolve({ tag: "err", val: error })];
+        }
+        return readableFromPreview2Input(this.#input, socketErrorCode);
     }
     getLocalAddress() {
-        throw new Todo();
+        try {
+            return this.#socket.localAddress();
+        }
+        catch (error) {
+            socketError(error);
+        }
     }
     getRemoteAddress() {
-        throw new Todo();
+        try {
+            return this.#socket.remoteAddress();
+        }
+        catch (error) {
+            socketError(error);
+        }
     }
     getIsListening() {
-        throw new Todo();
+        return socketCall(() => this.#socket.isListening());
     }
     getAddressFamily() {
-        throw new Todo();
+        return socketCall(() => this.#socket.addressFamily());
     }
     setListenBacklogSize(value) {
-        throw new Todo();
+        socketCall(() => this.#socket.setListenBacklogSize(value));
     }
     getKeepAliveEnabled() {
-        throw new Todo();
+        return socketCall(() => this.#socket.keepAliveEnabled());
     }
     setKeepAliveEnabled(value) {
-        throw new Todo();
+        socketCall(() => this.#socket.setKeepAliveEnabled(value));
     }
     getKeepAliveIdleTime() {
-        throw new Todo();
+        return socketCall(() => this.#socket.keepAliveIdleTime());
     }
     setKeepAliveIdleTime(value) {
-        throw new Todo();
+        socketCall(() => this.#socket.setKeepAliveIdleTime(value));
     }
     getKeepAliveInterval() {
-        throw new Todo();
+        return socketCall(() => this.#socket.keepAliveInterval());
     }
     setKeepAliveInterval(value) {
-        throw new Todo();
+        socketCall(() => this.#socket.setKeepAliveInterval(value));
     }
     getKeepAliveCount() {
-        throw new Todo();
+        return socketCall(() => this.#socket.keepAliveCount());
     }
     setKeepAliveCount(value) {
-        throw new Todo();
+        socketCall(() => this.#socket.setKeepAliveCount(value));
     }
     getHopLimit() {
-        throw new Todo();
+        return socketCall(() => this.#socket.hopLimit());
     }
     setHopLimit(value) {
-        throw new Todo();
+        socketCall(() => this.#socket.setHopLimit(value));
     }
     getReceiveBufferSize() {
-        throw new Todo();
+        return socketCall(() => this.#socket.receiveBufferSize());
     }
     setReceiveBufferSize(value) {
-        throw new Todo();
+        socketCall(() => this.#socket.setReceiveBufferSize(value));
     }
     getSendBufferSize() {
-        throw new Todo();
+        return socketCall(() => this.#socket.sendBufferSize());
     }
     setSendBufferSize(value) {
-        throw new Todo();
+        socketCall(() => this.#socket.setSendBufferSize(value));
     }
 }
 export class UdpSocket {
+    #socket;
+    #incoming;
+    #outgoing;
     static create(addressFamily) {
-        throw new Todo();
+        try {
+            const wrapped = new UdpSocket();
+            wrapped.#socket = udpProvider.udpCreateSocket.createUdpSocket(addressFamily);
+            return wrapped;
+        }
+        catch (error) {
+            socketError(error);
+        }
     }
     bind(localAddress) {
-        throw new Todo();
+        try {
+            this.#socket.startBind({}, localAddress);
+            this.#socket.finishBind();
+        }
+        catch (error) {
+            socketError(error);
+        }
     }
     connect(remoteAddress) {
-        throw new Todo();
+        try {
+            [this.#incoming, this.#outgoing] = this.#socket.stream(remoteAddress);
+        }
+        catch (error) {
+            socketError(error);
+        }
     }
     disconnect() {
-        throw new Todo();
-    }
-    send(data, remoteAddress) {
-        throw new Todo();
-    }
-    receive() {
-        throw new Todo();
+        try {
+            [this.#incoming, this.#outgoing] = this.#socket.stream(undefined);
+        }
+        catch (error) {
+            socketError(error);
+        }
+    }
+    async send(data, remoteAddress) {
+        try {
+            if (!this.#outgoing) {
+                [this.#incoming, this.#outgoing] = this.#socket.stream(remoteAddress);
+            }
+            this.#outgoing.checkSend();
+            this.#outgoing.send([{ data, remoteAddress }]);
+        }
+        catch (error) {
+            socketError(error);
+        }
+    }
+    async receive() {
+        if (!this.#incoming) {
+            try {
+                [this.#incoming, this.#outgoing] = this.#socket.stream(undefined);
+            }
+            catch (error) {
+                socketError(error);
+            }
+        }
+        while (true) {
+            try {
+                const [datagram] = this.#incoming.receive(1n);
+                if (datagram) {
+                    return [datagram.data, datagram.remoteAddress];
+                }
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            }
+            catch (error) {
+                socketError(error);
+            }
+        }
     }
     getLocalAddress() {
-        throw new Todo();
+        try {
+            return this.#socket.localAddress();
+        }
+        catch (error) {
+            socketError(error);
+        }
     }
     getRemoteAddress() {
-        throw new Todo();
+        try {
+            return this.#socket.remoteAddress();
+        }
+        catch (error) {
+            socketError(error);
+        }
     }
     getAddressFamily() {
-        throw new Todo();
+        return socketCall(() => this.#socket.addressFamily());
     }
     getUnicastHopLimit() {
-        throw new Todo();
+        return socketCall(() => this.#socket.unicastHopLimit());
     }
     setUnicastHopLimit(value) {
-        throw new Todo();
+        socketCall(() => this.#socket.setUnicastHopLimit(value));
     }
     getReceiveBufferSize() {
-        throw new Todo();
+        return socketCall(() => this.#socket.receiveBufferSize());
     }
     setReceiveBufferSize(value) {
-        throw new Todo();
+        socketCall(() => this.#socket.setReceiveBufferSize(value));
     }
     getSendBufferSize() {
-        throw new Todo();
+        return socketCall(() => this.#socket.sendBufferSize());
     }
     setSendBufferSize(value) {
-        throw new Todo();
+        socketCall(() => this.#socket.setSendBufferSize(value));
     }
 }
 export default {

package/dist/browser/sockets.d.ts

@@ -1,2 +1,4 @@
 export { default as ipNameLookup } from "./sockets/ip-name-lookup.js";
 export { default as types } from "./sockets/types.js";
+export { _setTcpProvider, _setUdpProvider } from "./sockets/types.js";
+export { InMemoryTcpClient, InMemoryTcpSockets, InMemoryUdpClient, InMemoryUdpSockets, } from "@bytecodealliance/preview2-shim/sockets";

package/dist/browser/sockets.js

@@ -1,2 +1,4 @@
 export { default as ipNameLookup } from "./sockets/ip-name-lookup.js";
 export { default as types } from "./sockets/types.js";
+export { _setTcpProvider, _setUdpProvider } from "./sockets/types.js";
+export { InMemoryTcpClient, InMemoryTcpSockets, InMemoryUdpClient, InMemoryUdpSockets, } from "@bytecodealliance/preview2-shim/sockets";

package/dist/browser/streams.d.ts

@@ -0,0 +1,20 @@
+interface Preview2InputStream {
+    blockingRead(length: bigint): Uint8Array | Promise<Uint8Array>;
+    subscribe(): {
+        block(): void | Promise<void>;
+    };
+}
+interface Preview2OutputStream {
+    blockingWriteAndFlush(contents: Uint8Array): void;
+    blockingFlush(): void;
+}
+export declare function writeToPreview2Output(data: ReadableStream<number>, output: Preview2OutputStream): Promise<void>;
+export declare function readableFromPreview2Input<E>(input: Preview2InputStream, errorCode: (error: unknown) => E): [ReadableStream<number>, Promise<{
+    tag: "ok";
+    val: void;
+} | {
+    tag: "err";
+    val: E;
+}>];
+export declare function preview2StreamErrorCode(error: unknown): "io" | "illegal-byte-sequence" | "pipe";
+export {};

package/dist/browser/streams.js

@@ -0,0 +1,106 @@
+const symbolDispose = Symbol.dispose ?? Symbol.for("dispose");
+const BYTE_CHUNK_SIZE = 64 * 1024;
+const P2_WRITE_CHUNK_SIZE = 4096;
+function byteChunk(value) {
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    if (value instanceof ArrayBuffer) {
+        return new Uint8Array(value);
+    }
+    if (Array.isArray(value)) {
+        return Uint8Array.from(value);
+    }
+    if (typeof value === "number") {
+        if (!Number.isInteger(value) || value < 0 || value > 255) {
+            throw new RangeError(`invalid byte stream value: ${value}`);
+        }
+        return Uint8Array.of(value);
+    }
+    if (typeof value === "string") {
+        return new TextEncoder().encode(value);
+    }
+    throw new TypeError("byte stream values must be bytes or byte arrays");
+}
+function isIteratorResult(value) {
+    return value !== null && typeof value === "object" && "done" in value;
+}
+async function* byteChunks(data) {
+    const stream = data;
+    if (typeof stream.read === "function") {
+        while (true) {
+            const value = await stream.read({ count: BYTE_CHUNK_SIZE });
+            if (isIteratorResult(value)) {
+                if (value.done) {
+                    return;
+                }
+                yield byteChunk(value.value);
+            }
+            else if (value === null) {
+                return;
+            }
+            else {
+                yield byteChunk(value);
+            }
+        }
+    }
+    if (typeof stream[Symbol.asyncIterator] === "function") {
+        for await (const value of stream) {
+            yield byteChunk(value);
+        }
+        return;
+    }
+    throw new TypeError("byte stream must provide read() or [Symbol.asyncIterator]()");
+}
+export async function writeToPreview2Output(data, output) {
+    for await (const bytes of byteChunks(data)) {
+        for (let offset = 0; offset < bytes.byteLength; offset += P2_WRITE_CHUNK_SIZE) {
+            output.blockingWriteAndFlush(bytes.subarray(offset, offset + P2_WRITE_CHUNK_SIZE));
+        }
+    }
+    output.blockingFlush();
+}
+export function readableFromPreview2Input(input, errorCode) {
+    let resolveResult = () => { };
+    const result = new Promise((resolve) => (resolveResult = resolve));
+    let settled = false;
+    const settle = (value) => {
+        if (!settled) {
+            settled = true;
+            resolveResult(value);
+        }
+    };
+    const readable = new ReadableStream({
+        async pull(controller) {
+            try {
+                const bytes = await input.blockingRead(BigInt(BYTE_CHUNK_SIZE));
+                for (const byte of bytes) {
+                    controller.enqueue(byte);
+                }
+            }
+            catch (error) {
+                if (error?.tag === "closed") {
+                    controller.close();
+                    settle({ tag: "ok", val: undefined });
+                    return;
+                }
+                settle({ tag: "err", val: errorCode(error) });
+                controller.error(error);
+            }
+        },
+        cancel() {
+            settle({ tag: "ok", val: undefined });
+        },
+    });
+    return [readable, result];
+}
+export function preview2StreamErrorCode(error) {
+    const code = error?.code;
+    if (code === "EPIPE" || code === "ERR_STREAM_PREMATURE_CLOSE") {
+        return "pipe";
+    }
+    if (code === "ERR_ENCODING_INVALID_ENCODED_DATA") {
+        return "illegal-byte-sequence";
+    }
+    return "io";
+}

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

@@ -1,4 +1,4 @@
-import { Server, Socket } from "node:net";
+import net, { Server, Socket } from "node:net";
 import { once } from "node:events";
 import { isMainThread, parentPort } from "worker_threads";
 //#region dist/nodejs/workers/resource-worker.js
@@ -252,6 +252,7 @@ var SocketError = class SocketError extends Error {
 };
 //#endregion
 //#region dist/nodejs/workers/tcp-worker.js
+const BoundSocket = net.BoundSocket;
 const sockets = /* @__PURE__ */ new Map();
 let NEXT_SOCKET_ID = 0n;
 Router().beforeAll((msg) => {
@@ -263,6 +264,7 @@ function handleTcpCreate({ family }) {
 		family,
 		tcp: null,
 		server: null,
+		bound: null,
 		acceptWriter: null,
 		backlog: 128,
 		localAddress: null,
@@ -283,6 +285,17 @@ async function handleTcpBind({ socketId, localAddress }) {
 		err.code = "EADDRINUSE";
 		throw err;
 	}
+	if (BoundSocket) {
+		const bound = new BoundSocket({
+			host: address,
+			port,
+			ipv6Only: family === "ipv6"
+		});
+		const boundAddress = bound.address();
+		socket.bound = bound;
+		socket.localAddress = makeIpAddress(boundAddress.family.toLowerCase(), boundAddress.address, boundAddress.port);
+		return;
+	}
 	const server = socket.server = createTcpServer(socket);
 	const onListening = once(server, "listening");
 	server.listen({
@@ -300,16 +313,20 @@ async function handleTcpConnect({ socketId, remoteAddress }) {
 	const socket = sockets.get(socketId);
 	const host = serializeIpAddress(remoteAddress);
 	const port = remoteAddress.val.port;
-	const localAddress = socket.localAddress;
+	const { bound, localAddress } = socket;
+	socket.bound = null;
 	await closeTcpServer(socket);
-	const tcp = socket.tcp = new Socket({ allowHalfOpen: true });
+	const tcp = socket.tcp = new Socket({
+		handle: bound ?? void 0,
+		allowHalfOpen: true
+	});
 	tcp.setKeepAlive(socket.keepAliveEnabled, socket.keepAliveIdleTime);
 	const onConnect = once(tcp, "connect");
 	tcp.connect({
 		port,
 		host,
-		localAddress: localAddress ? serializeIpAddress(localAddress) : void 0,
-		localPort: localAddress?.val.port
+		localAddress: !bound && localAddress ? serializeIpAddress(localAddress) : void 0,
+		localPort: !bound ? localAddress?.val.port : void 0
 	});
 	await onConnect;
 }
@@ -322,7 +339,13 @@ async function handleTcpListen({ socketId, stream }) {
 	if (!server) {
 		server = socket.server = createTcpServer(socket);
 		const onListening = once(server, "listening");
-		server.listen({
+		const bound = socket.bound;
+		socket.bound = null;
+		if (bound) server.listen({
+			handle: bound,
+			backlog
+		});
+		else server.listen({
 			host: family === "ipv6" ? "::" : "0.0.0.0",
 			port: 0,
 			backlog,
@@ -352,6 +375,7 @@ function createTcpServer(socket) {
 			backlog: socket.backlog,
 			tcp: conn,
 			server: null,
+			bound: null,
 			acceptWriter: null,
 			localAddress: makeIpAddress(socket.family, conn.localAddress, conn.localPort),
 			keepAliveEnabled: socket.keepAliveEnabled,
@@ -466,6 +490,10 @@ async function handleTcpReceive({ socketId, stream }) {
 }
 function cleanupDisposedSocket(socketId, socket) {
 	if (!socket.disposed || socket.activeStreams > 0) return;
+	if (socket.bound) {
+		socket.bound.close();
+		socket.bound = null;
+	}
 	if (socket.server) socket.server.close();
 	if (socket.tcp) socket.tcp.destroy();
 	sockets.delete(socketId);