@bytecodealliance/preview3-shim 0.2.1 → 0.2.2

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

@@ -0,0 +1,270 @@
+import { once } from "node:events";
+import { isMainThread, parentPort } from "worker_threads";
+import dgram from "node:dgram";
+//#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 isLoopbackIpAddress = ({ tag, val: { address } }) => tag === "ipv4" && address[0] === 127 || tag === "ipv6" && address.slice(0, 7).every((segment) => segment === 0) && address[7] === 1;
+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/workers/udp-worker.js
+const sockets = /* @__PURE__ */ new Map();
+let NEXT_SOCKET_ID = 0n;
+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);
+	if ([...sockets].some(([id, { localAddress: boundAddress }]) => id !== socketId && boundAddress && ipAddressConflict(boundAddress, localAddress))) {
+		const err = /* @__PURE__ */ 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 }) {
+	sockets.get(socketId).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 }) {
+	sockets.get(socketId).udp.close();
+	sockets.delete(socketId);
+}
+//#endregion
+export { noLookup };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytecodealliance/preview3-shim",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "WASI Preview3 shim for JS environments",
   "homepage": "https://github.com/bytecodealliance/jco/blob/main/packages/preview3-shim/#readme",
   "bugs": {
@@ -45,12 +45,13 @@
   "devDependencies": {
     "@types/node": "^24.12.4",
     "globals": "^17.6.0",
+    "rolldown": "^1.2.0",
     "typescript": "^6.0.3",
     "vite": "^8.0.16",
     "vitest": "^4.0.8"
   },
   "scripts": {
-    "build": "tsc --project tsconfig.build.json",
+    "build": "tsc --project tsconfig.build.json && node scripts/build-workers.mjs",
     "build:watch": "tsc --watch",
     "types:check": "tsc --noEmit",
     "fmt": "oxfmt",