@bytecodealliance/preview3-shim 0.2.0 → 0.2.2

package/dist/nodejs/cli.js

@@ -1,5 +1,6 @@
 import process from "node:process";
 import { Readable } from "node:stream";
+import { Worker } from "node:worker_threads";
 import { ResourceWorker } from "./workers/resource-worker.js";
 import { StreamReader, readableByteStreamFromReader } from "./stream.js";
 import { future } from "./future.js";
@@ -16,7 +17,7 @@ export const environment = {
 };
 let WORKER = null;
 function worker() {
-    return (WORKER ??= new ResourceWorker(new URL("./workers/cli-worker.js", import.meta.url)));
+    return (WORKER ??= new ResourceWorker(() => new Worker(new URL("./workers/cli-worker.bundle.js", import.meta.url))));
 }
 /**
  * Map a Node.js error to a WIT error-code enum value.

package/dist/nodejs/filesystem/descriptor.js

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import nodePath from "node:path";
 import process from "node:process";
+import { Worker } from "node:worker_threads";
 import { StreamReader, readableByteStreamFromReader } from "../stream.js";
 import { FutureReader } from "../future.js";
 import { ResourceWorker } from "../workers/resource-worker.js";
@@ -10,7 +11,7 @@ import { wasiTypeFromDirent } from "./utils.js";
 const symbolDispose = Symbol.dispose || Symbol.for("dispose");
 let WORKER = null;
 function worker() {
-    return (WORKER ??= new ResourceWorker(new URL("../workers/filesystem-worker.js", import.meta.url)));
+    return (WORKER ??= new ResourceWorker(() => new Worker(new URL("../workers/filesystem-worker.bundle.js", import.meta.url))));
 }
 class Descriptor {
     /** Node.js file handle for file operations (FileHandle from fs.promises.open) */

package/dist/nodejs/http/client.js

@@ -8,7 +8,7 @@ import { Response } from "./response.js";
 import { _fieldsFromEntriesChecked, _readTrailersForTransport, _trailerResultFromEntries, } from "./fields.js";
 let WORKER = null;
 function worker() {
-    return (WORKER ??= new ResourceWorker(new URL("../workers/http-worker.js", import.meta.url)));
+    return (WORKER ??= new ResourceWorker(() => new Worker(new URL("../workers/http-worker.bundle.js", import.meta.url))));
 }
 /**
  * HTTP client interface.
@@ -136,3 +136,4 @@ class TrailerFutureReader extends FutureReader {
         super.close();
     }
 }
+import { Worker } from "node:worker_threads";

package/dist/nodejs/http/fields.js

@@ -6,9 +6,14 @@ export const _forbiddenHeaders = {
     get value() {
         return (FORBIDDEN_HEADERS ??= new Set([
             "connection",
-            "keep-alive",
+            "http2-settings",
             "host",
-            "custom-forbidden-header",
+            "keep-alive",
+            "proxy-authenticate",
+            "proxy-authorization",
+            "proxy-connection",
+            "transfer-encoding",
+            "upgrade",
         ]));
     },
 };

package/dist/nodejs/http/server.js

@@ -9,7 +9,7 @@ import { HttpError } from "./error.js";
 import { _fieldsFromEntriesChecked, _readTrailersForTransport, _trailerResultFromEntries, } from "./fields.js";
 let WORKER = null;
 function worker() {
-    return (WORKER ??= new ResourceWorker(new URL("../workers/http-worker.js", import.meta.url)));
+    return (WORKER ??= new ResourceWorker(() => new Worker(new URL("../workers/http-worker.bundle.js", import.meta.url))));
 }
 /**
  * HttpServer uses a background worker thread to handle raw HTTP connections,
@@ -125,3 +125,4 @@ const requestFromParts = (parts) => {
     req.setPathWithQuery(url);
     return req;
 };
+import { Worker } from "node:worker_threads";

package/dist/nodejs/sockets/tcp.js

@@ -6,7 +6,7 @@ import { isWildcardIpAddress, isUnicastIpAddress, isMulticastIpAddress, isIpv4Ma
 let WORKER = null;
 const symbolDispose = Symbol.dispose || Symbol.for("dispose");
 function worker() {
-    return (WORKER ??= new ResourceWorker(new URL("../workers/tcp-worker.js", import.meta.url)));
+    return (WORKER ??= new ResourceWorker(() => new Worker(new URL("../workers/tcp-worker.bundle.js", import.meta.url))));
 }
 let TCP_CREATE_TOKEN = null;
 function token() {
@@ -721,3 +721,4 @@ export class TcpSocket {
             !isIpv4MappedAddress(remoteAddress));
     }
 }
+import { Worker } from "node:worker_threads";

package/dist/nodejs/sockets/udp.js

@@ -3,7 +3,7 @@ import { SocketError } from "./error.js";
 import { isWildcardIpAddress, isUnicastIpAddress, isIpv4MappedAddress, isBindableIpAddress, IP_ADDRESS_FAMILY, } from "./address.js";
 let WORKER = null;
 function worker() {
-    return (WORKER ??= new ResourceWorker(new URL("../workers/udp-worker.js", import.meta.url)));
+    return (WORKER ??= new ResourceWorker(() => new Worker(new URL("../workers/udp-worker.bundle.js", import.meta.url))));
 }
 let UDP_CREATE_TOKEN = null;
 function token() {
@@ -473,3 +473,4 @@ export class UdpSocket {
     }
 }
 export const udpCreateSocket = {};
+import { Worker } from "node:worker_threads";

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

@@ -0,0 +1,88 @@
+import process from "node:process";
+import { Readable } from "node:stream";
+import { pipeline } from "stream/promises";
+import { isMainThread, parentPort } from "worker_threads";
+//#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/workers/cli-worker.js
+Router().op("stdout", handleOp).op("stderr", handleOp);
+async function handleOp(msg) {
+	const { op, stream } = msg;
+	await pipeline(Readable.from(byteChunks(stream), { objectMode: false }), op === "stdout" ? process.stdout : process.stderr, { end: false });
+	return { ok: true };
+}
+async function* byteChunks(stream) {
+	for await (const value of stream) yield nodeByteChunk(value);
+}
+function assertByte(value) {
+	if (!Number.isInteger(value) || value < 0 || value > 255) throw new RangeError(`Invalid byte stream value: ${value}`);
+	return value;
+}
+function nodeByteChunk(value) {
+	if (value instanceof Uint8Array) return value;
+	if (value instanceof ArrayBuffer) return new Uint8Array(value);
+	if (Array.isArray(value)) {
+		for (const byte of value) assertByte(byte);
+		return Uint8Array.from(value);
+	}
+	if (typeof value === "number") return Uint8Array.of(assertByte(value));
+	return value;
+}
+//#endregion
+export {};

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

@@ -0,0 +1,236 @@
+import { promisify } from "util";
+import { isMainThread, parentPort } from "worker_threads";
+import fs from "fs";
+//#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/filesystem/error.js
+const ERROR_MAP = {
+	EACCES: "access",
+	EALREADY: "already",
+	EBADF: "bad-descriptor",
+	EBUSY: "busy",
+	EDEADLK: "deadlock",
+	EDQUOT: "quota",
+	EEXIST: "exist",
+	EFBIG: "file-too-large",
+	EILSEQ: "illegal-byte-sequence",
+	EINPROGRESS: "in-progress",
+	EINTR: "interrupted",
+	EINVAL: "invalid",
+	EIO: "io",
+	EISDIR: "is-directory",
+	ELOOP: "loop",
+	EMLINK: "too-many-links",
+	EMSGSIZE: "message-size",
+	ENAMETOOLONG: "name-too-long",
+	ENODEV: "no-device",
+	ENOENT: "no-entry",
+	ENOLCK: "no-lock",
+	ENOMEM: "insufficient-memory",
+	ENOSPC: "insufficient-space",
+	ENOTDIR: "not-directory",
+	ERR_FS_EISDIR: "not-directory",
+	ENOTEMPTY: "not-empty",
+	ENOTRECOVERABLE: "not-recoverable",
+	ENOTSUP: "unsupported",
+	ENOTTY: "no-tty",
+	ENXIO: "no-such-device",
+	EOVERFLOW: "overflow",
+	EPERM: "not-permitted",
+	EPIPE: "pipe",
+	EROFS: "read-only",
+	ESPIPE: "invalid-seek",
+	ETXTBSY: "text-file-busy",
+	EXDEV: "cross-device"
+};
+function getErrorTag(e) {
+	if (e.code in ERROR_MAP) return ERROR_MAP[e.code];
+	if (e.code === -4094 || e.code === "UNKNOWN" && e.errno === -4094) return "no-such-device";
+	throw e;
+}
+/**
+* Custom error for File operations with JCO compatible payload.
+*/
+var FSError = class FSError extends Error {
+	payload;
+	/**
+	* @param {string} tag        – machine‐readable error tag
+	* @param {string} [message]  – human‐readable message
+	* @param {any}    [val]      – optional extra data
+	* @param {object} [opts]
+	* @param {Error} [opts.cause]
+	*/
+	constructor(tag, message = void 0, val = void 0, opts = {}) {
+		super(message ?? `Error: ${tag}`, { cause: opts.cause });
+		this.name = "FSError";
+		this.payload = val !== void 0 ? {
+			tag,
+			val
+		} : { tag };
+	}
+	/**
+	* Create or rewrap an error into FSError
+	* @param {any} err – number, string, Error, or FSError
+	*/
+	static from(err) {
+		if (err instanceof FSError) return err;
+		const tag = getErrorTag(err);
+		const message = err?.message;
+		return new FSError(tag, message, void 0, { cause: err });
+	}
+};
+//#endregion
+//#region dist/nodejs/filesystem/utils.js
+/** Map fs.Dirent -> WASI type */
+function wasiTypeFromDirent(obj) {
+	if (obj.isFile()) return { tag: "regular-file" };
+	else if (obj.isSocket()) return { tag: "socket" };
+	else if (obj.isSymbolicLink()) return { tag: "symbolic-link" };
+	else if (obj.isFIFO()) return { tag: "fifo" };
+	else if (obj.isDirectory()) return { tag: "directory" };
+	else if (obj.isCharacterDevice()) return { tag: "character-device" };
+	else if (obj.isBlockDevice()) return { tag: "block-device" };
+	return {
+		tag: "other",
+		val: void 0
+	};
+}
+//#endregion
+//#region dist/nodejs/workers/filesystem-worker.js
+const readAsync = promisify(fs.read);
+const writeAsync = promisify(fs.write);
+const { opendir } = fs.promises;
+const CHUNK_BYTES = 64 * 1024;
+const BUFFER = Buffer.alloc(CHUNK_BYTES);
+const MAX_SAFE_FILE_POSITION = BigInt(Number.MAX_SAFE_INTEGER);
+/** Auto‐dispatch all ops */
+Router().op("read", handleRead).op("write", handleWrite).op("readDir", handleReadDir);
+async function handleRead({ fd, offset, stream }) {
+	if (typeof fd !== "number" || fd < 0) throw new TypeError(`Invalid file descriptor: ${fd}`);
+	if (!stream || typeof stream.getWriter !== "function") throw new TypeError("stream must have a getWriter() method");
+	const writer = stream.getWriter();
+	let pos = BigInt(offset);
+	try {
+		filePosition(pos);
+	} catch (err) {
+		await writer.close();
+		throw err;
+	}
+	try {
+		const start = pos;
+		while (true) {
+			const { bytesRead } = await readAsync(fd, BUFFER, 0, CHUNK_BYTES, filePosition(pos));
+			if (bytesRead === 0) break;
+			await writer.write(BUFFER.subarray(0, bytesRead));
+			pos += BigInt(bytesRead);
+		}
+		await writer.close();
+		return { bytesRead: pos - start };
+	} catch (err) {
+		await writer.abort(err);
+		throw err;
+	}
+}
+async function handleWrite({ fd, offset, stream }) {
+	if (typeof fd !== "number" || fd < 0) throw new TypeError(`Invalid file descriptor: ${fd}`);
+	if (!stream || typeof stream.getReader !== "function") throw new TypeError("stream must have a getReader() method");
+	const reader = stream.getReader();
+	try {
+		let pos = BigInt(offset);
+		const start = pos;
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			const buf = Buffer.from(value);
+			const { bytesWritten } = await writeAsync(fd, buf, 0, buf.length, filePosition(pos));
+			pos += BigInt(bytesWritten);
+		}
+		return { bytesWritten: pos - start };
+	} catch (err) {
+		await reader.cancel(err);
+		throw err;
+	}
+}
+function filePosition(position) {
+	if (position < 0n || position > MAX_SAFE_FILE_POSITION) throw new FSError("invalid");
+	return Number(position);
+}
+async function handleReadDir({ fullPath, stream, preopens }) {
+	if (!stream || typeof stream.getWriter !== "function") throw new TypeError("stream must have a getWriter() method");
+	const writer = stream.getWriter();
+	if (!preopens.some((p) => fullPath === p || fullPath.startsWith(p + "/"))) {
+		const err = new FSError("not-permitted");
+		await writer.abort(err);
+		throw err;
+	}
+	try {
+		const walker = await opendir(fullPath);
+		for await (const dirent of walker) await writer.write({
+			name: dirent.name,
+			type: wasiTypeFromDirent(dirent)
+		});
+		await writer.close();
+		return { ok: true };
+	} catch (err) {
+		await writer.abort(err);
+		throw err;
+	}
+}
+//#endregion
+export {};

package/dist/nodejs/workers/filesystem-worker.js

@@ -21,8 +21,15 @@ async function handleRead({ fd, offset, stream }) {
         throw new TypeError("stream must have a getWriter() method");
     }
     const writer = stream.getWriter();
+    let pos = BigInt(offset);
+    try {
+        filePosition(pos);
+    }
+    catch (err) {
+        await writer.close();
+        throw err;
+    }
     try {
-        let pos = BigInt(offset);
         const start = pos;
         while (true) {
             const { bytesRead } = await readAsync(fd, BUFFER, 0, CHUNK_BYTES, filePosition(pos));