@bytecodealliance/preview3-shim 0.2.0 → 0.2.2

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

@@ -0,0 +1,496 @@
+import { Server, Socket } from "node:net";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+import { once } from "node:events";
+import { isMainThread, parentPort } from "worker_threads";
+import process from "node:process";
+//#region dist/nodejs/workers/resource-worker.js
+function Router() {
+	const _hooks = {
+		beforeAll: null,
+		ops: /* @__PURE__ */ new Map()
+	};
+	if (isMainThread || !parentPort) throw new Error("Router can only be used in worker threads");
+	parentPort.on("message", async (msg) => {
+		const { _reply, _condvar, ...rest } = msg;
+		let result, error, transfer = [];
+		try {
+			if (_hooks.beforeAll) _hooks.beforeAll(rest);
+			const handler = _hooks.ops.get(rest.op);
+			if (!handler) throw new Error(`Unknown op ${rest.op}`);
+			const outcome = await handler(rest);
+			if (outcome && Array.isArray(outcome.transferable)) {
+				result = outcome.result;
+				transfer = outcome.transferable;
+			} else result = outcome;
+		} catch (err) {
+			error = serializeError(err);
+		}
+		_reply.postMessage({
+			result,
+			error
+		}, transfer);
+		_reply.close();
+		if (_condvar) notify(_condvar);
+	});
+	return {
+		beforeAll(fn) {
+			_hooks.beforeAll = fn;
+			return this;
+		},
+		op(name, fn) {
+			_hooks.ops.set(name, fn);
+			return this;
+		}
+	};
+}
+function serializeError(err) {
+	if (!(err instanceof Error)) return err;
+	const serialized = {
+		__resourceWorkerError: true,
+		name: err.name,
+		message: err.message,
+		stack: err.stack
+	};
+	for (const key of Reflect.ownKeys(err)) serialized[key] = err[key];
+	if (err.cause !== void 0) serialized.cause = serializeError(err.cause);
+	return serialized;
+}
+function notify(condvar) {
+	const lock = new Int32Array(condvar);
+	Atomics.store(lock, 0, 1);
+	Atomics.notify(lock, 0, 1);
+}
+//#endregion
+//#region dist/nodejs/sockets/address.js
+const tupleToIpv6 = (segments) => {
+	if (segments.length !== 8) return null;
+	return segments.map((segment) => segment.toString(16)).join(":");
+};
+const tupleToIpv4 = (segments) => {
+	if (segments.length !== 4) return null;
+	return segments.map((segment) => segment.toString(10)).join(".");
+};
+const ipv6ToTuple = (ipv6) => {
+	const [lhs, rhs = ""] = ipv6.includes("::") ? ipv6.split("::") : [ipv6];
+	const lhsParts = lhs === "" ? [] : lhs.split(":");
+	const rhsParts = rhs === "" ? [] : rhs.split(":");
+	return [
+		...lhsParts,
+		...Array(8 - lhsParts.length - rhsParts.length).fill(0),
+		...rhsParts
+	].map((segment) => {
+		const val = parseInt(segment, 16);
+		if (val < 0 || val > 65535 || Number.isNaN(val)) throw new Error(`Invalid IPv6 segment: ${segment}`);
+		return val;
+	});
+};
+const ipv4ToTuple = (ipv4) => {
+	return ipv4.split(".").map((segment) => {
+		const val = parseInt(segment, 10);
+		if (val < 0 || val > 255 || Number.isNaN(val)) throw new Error(`Invalid IPv4 segment: ${segment}`);
+		return val;
+	});
+};
+const isWildcardIpAddress = ({ val: { address } }) => address.every((b) => b === 0);
+const ipAddressConflict = (a, b) => a.tag === b.tag && Number(a.val.port) === Number(b.val.port) && Number(a.val.port) !== 0 && (isWildcardIpAddress(a) || isWildcardIpAddress(b) || a.val.address.every((segment, idx) => segment === b.val.address[idx]));
+/**
+* Serialize a socket‐address to text.
+* @param {{tag:string,val:{address:number[]}}} ipAddr
+* @returns {string|null}
+*/
+const serializeIpAddress = ({ tag, val: { address } }) => {
+	switch (tag) {
+		case "ipv4": return tupleToIpv4(address);
+		case "ipv6": return tupleToIpv6(address);
+		default: throw new Error(`Unknown IP tag: ${tag}`);
+	}
+};
+/**
+* Create a socket‐address object.
+* @param {'ipv4'|'ipv6'} family
+* @param {string} host IP text
+* @param {number|bigint} port
+* @returns {{tag:string,val:Object}}
+*/
+const makeIpAddress = (family, host, port) => {
+	let address;
+	switch (family) {
+		case "ipv4":
+			address = ipv4ToTuple(host);
+			break;
+		case "ipv6":
+			address = ipv6ToTuple(host);
+			break;
+		default: throw new Error(`Unknown IP family: ${family}`);
+	}
+	const base = {
+		address,
+		port
+	};
+	return family === "ipv4" ? {
+		tag: "ipv4",
+		val: base
+	} : {
+		tag: "ipv6",
+		val: {
+			...base,
+			flowInfo: 0,
+			scopeId: 0
+		}
+	};
+};
+//#endregion
+//#region dist/nodejs/sockets/error.js
+const ERROR_MAP = {
+	EACCES: "access-denied",
+	EPERM: "access-denied",
+	EOPNOTSUPP: "not-supported",
+	ENOPROTOOPT: "not-supported",
+	EPFNOSUPPORT: "not-supported",
+	EPROTONOSUPPORT: "not-supported",
+	ESOCKTNOSUPPORT: "not-supported",
+	EINVAL: "invalid-argument",
+	EAFNOSUPPORT: "invalid-argument",
+	ENOMEM: "out-of-memory",
+	ENOBUFS: "out-of-memory",
+	ETIMEDOUT: "timeout",
+	EADDRINUSE: "address-in-use",
+	EADDRNOTAVAIL: "address-not-bindable",
+	EHOSTUNREACH: "remote-unreachable",
+	EHOSTDOWN: "remote-unreachable",
+	ENETUNREACH: "remote-unreachable",
+	ENETDOWN: "remote-unreachable",
+	ENONET: "remote-unreachable",
+	ECONNREFUSED: "connection-refused",
+	EPIPE: "connection-broken",
+	ECONNRESET: "connection-reset",
+	ECONNABORTED: "connection-aborted",
+	EMSGSIZE: "datagram-too-large",
+	ENOTCONN: "invalid-state",
+	EISCONN: "invalid-state",
+	EALREADY: "invalid-state",
+	EDESTADDRREQ: "invalid-argument"
+};
+const CODE_MAP = {
+	4053: "invalid-state",
+	4083: "invalid-state",
+	ENOTCONN: "invalid-state",
+	EBADF: "invalid-state",
+	EACCES: "access-denied",
+	EPERM: "access-denied",
+	ENOTSUP: "not-supported",
+	EOPNOTSUPP: "not-supported",
+	ENOPROTOOPT: "not-supported",
+	EPFNOSUPPORT: "not-supported",
+	EPROTONOSUPPORT: "not-supported",
+	ESOCKTNOSUPPORT: "not-supported",
+	EINVAL: "invalid-argument",
+	EAFNOSUPPORT: "invalid-argument",
+	ENOMEM: "out-of-memory",
+	ENOBUFS: "out-of-memory",
+	4090: "address-not-bindable",
+	EADDRNOTAVAIL: "address-not-bindable",
+	4091: "address-in-use",
+	EADDRINUSE: "address-in-use",
+	EHOSTUNREACH: "remote-unreachable",
+	EHOSTDOWN: "remote-unreachable",
+	ENETUNREACH: "remote-unreachable",
+	ENETDOWN: "remote-unreachable",
+	ENONET: "remote-unreachable",
+	ECONNREFUSED: "connection-refused",
+	EPIPE: "connection-broken",
+	ECONNRESET: "connection-reset",
+	ECONNABORTED: "connection-aborted",
+	EMSGSIZE: "datagram-too-large"
+};
+/**
+* Custom error for Socket operations with JCO compatible payload.
+*
+* https://bytecodealliance.github.io/jco/wit-type-representations.html#result-considerations-idiomatic-js-errors-for-host-implementations
+*/
+var SocketError = class SocketError extends Error {
+	payload;
+	/**
+	* @param {string} tag        – machine‐readable error tag
+	* @param {string} [message]  – human‐readable message
+	* @param {any}    [val]      – optional extra data
+	*/
+	constructor(tag, message = void 0, val = void 0, opts = {}) {
+		super(message ?? `Error: ${tag}`, { cause: opts.cause });
+		this.name = "SocketError";
+		this.payload = val !== void 0 ? {
+			tag,
+			val
+		} : { tag };
+	}
+	/**
+	* Create or rewrap an error into SocketError
+	* @param {any} err – number, string, Error, or SocketError
+	*/
+	static from(err) {
+		if (err instanceof SocketError) return err;
+		let tag, message, val;
+		if (typeof err === "number") {
+			tag = CODE_MAP[err] ?? "other";
+			message = `Error code ${err}`;
+			if (tag === "other") val = message;
+		} else if (typeof err === "string") {
+			tag = ERROR_MAP[err] ?? "other";
+			if (tag === "other") val = err;
+		} else if (err && typeof err.code === "string") {
+			tag = ERROR_MAP[err.code] ?? "other";
+			message = err.message;
+			if (tag === "other") val = err.code;
+		} else if (err && typeof err.message === "string" && ERROR_MAP[err.message]) {
+			tag = ERROR_MAP[err.message];
+			message = err.message;
+		} else {
+			tag = "other";
+			message = err?.message;
+			val = message;
+		}
+		return new SocketError(tag, message, val);
+	}
+};
+//#endregion
+//#region dist/nodejs/workers/tcp-worker.js
+const { TCP, constants: TCPConstants } = process.binding("tcp_wrap");
+const sockets = /* @__PURE__ */ new Map();
+let NEXT_SOCKET_ID = 0n;
+Router().beforeAll((msg) => {
+	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);
+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 };
+}
+async function handleTcpBind({ socketId, localAddress }) {
+	const socket = sockets.get(socketId);
+	const address = serializeIpAddress(localAddress);
+	const port = localAddress.val.port;
+	const { handle, family } = socket;
+	if ([...sockets].some(([id, { localAddress: boundAddress }]) => id !== socketId && boundAddress && ipAddressConflict(boundAddress, localAddress))) {
+		const err = /* @__PURE__ */ new Error("EADDRINUSE");
+		err.code = "EADDRINUSE";
+		throw err;
+	}
+	await new Promise((resolve, reject) => {
+		let code;
+		if (family === "ipv6") code = handle.bind6(address, port, TCPConstants.UV_TCP_IPV6ONLY);
+		else code = handle.bind(address, port);
+		if (code !== 0) reject(SocketError.from(-code));
+		else resolve();
+	});
+	const out = {};
+	const code = handle.getsockname(out);
+	if (code !== 0) throw SocketError.from(-code);
+	socket.localAddress = makeIpAddress(out.family.toLowerCase(), out.address, out.port);
+}
+async function handleTcpConnect({ socketId, remoteAddress }) {
+	const socket = sockets.get(socketId);
+	const host = serializeIpAddress(remoteAddress);
+	const port = remoteAddress.val.port;
+	const tcp = socket.tcp = new Socket({
+		handle: socket.handle,
+		pauseOnCreate: true,
+		allowHalfOpen: true
+	});
+	const onConnect = once(tcp, "connect");
+	const onError = once(tcp, "error").then(([err]) => {
+		throw err;
+	});
+	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 {
+						tcp.resume();
+					}
+				}, settle);
+			};
+			const onEnd = () => {
+				pending = pending.then(async () => {
+					try {
+						await writer.close();
+					} catch {}
+					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;
+let _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();
+}
+async function getDefaultSendBufferSize() {
+	if (!_sendBufferSize) await getDefaultBufferSizes();
+	return _sendBufferSize;
+}
+async function getDefaultReceiveBufferSize() {
+	if (!_recvBufferSize) await getDefaultBufferSizes();
+	return _recvBufferSize;
+}
+//#endregion
+export { getDefaultReceiveBufferSize, getDefaultSendBufferSize };