@bytecodealliance/preview3-shim 0.2.1 → 0.3.0

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/http-worker.bundle.js

@@ -0,0 +1,403 @@
+import { PassThrough, Readable, Writable } from "node:stream";
+import { pipeline } from "stream/promises";
+import { MessageChannel } from "node:worker_threads";
+import { Agent, createServer, request } from "node:http";
+import { Agent as Agent$1, request as request$1 } from "node:https";
+import { isMainThread, parentPort } from "worker_threads";
+//#region dist/nodejs/http/error.js
+/**
+* Custom error class for WASI http interface that properly formats payload for Jco compatibility
+*
+* https://bytecodealliance.github.io/jco/wit-type-representations.html#result-considerations-idiomatic-js-errors-for-host-implementations
+*/
+var HttpError = class HttpError extends Error {
+	payload;
+	/**
+	* Create a new WASI http error
+	* @param {string} tag - The error tag/type
+	* @param {string} [message] - Human-readable error message
+	* @param {any} [val] - Optional value/data for the error
+	*/
+	constructor(tag, message = void 0, val = void 0, opts = {}) {
+		super(message || `Error: ${tag}`, { cause: opts.cause });
+		this.name = "HttpError";
+		this.payload = val !== void 0 ? {
+			tag,
+			val
+		} : { tag };
+	}
+	static from(err) {
+		if (err instanceof HttpError) return err;
+		if (err?.tag) return new HttpError(err.tag, void 0, err.val);
+		const e = getFirstError(err);
+		let tag, val;
+		switch (e.code) {
+			case "ECONNRESET":
+				tag = "HTTP-protocol-error";
+				break;
+			case "ENOTFOUND":
+				tag = "DNS-error";
+				val = {
+					rcode: e.code,
+					infoCode: e.errno < 0 ? -e.errno : e.errno
+				};
+				break;
+			case "ECONNREFUSED":
+				tag = "connection-refused";
+				break;
+			default:
+				tag = "internal-error";
+				val = e.toString();
+		}
+		const httpErr = new HttpError(tag, e.message, val, { cause: e });
+		Error.captureStackTrace(httpErr, HttpError.from);
+		return httpErr;
+	}
+};
+function getFirstError(e) {
+	if (typeof e !== "object" || e === null) return e;
+	if (e.cause) return getFirstError(e.cause);
+	if (e instanceof AggregateError) return getFirstError(e.errors[0]);
+	return e;
+}
+//#endregion
+//#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/http-worker.js
+let NEXT_SERVER_ID = 0n;
+let NEXT_REQUEST_ID = 0n;
+Router().op("server-start", handleHttpServerStart).op("server-stop", handleHttpServerStop).op("server-next", handleNext).op("server-response", handleResponse).op("server-close", handleHttpServerClose).op("client-request", handleRequest);
+var Queue = class {
+	_items = [];
+	_resolvers = [];
+	constructor() {
+		this._items = [];
+		this._resolvers = [];
+	}
+	push(item) {
+		if (this._resolvers.length) this._resolvers.shift()(item);
+		else this._items.push(item);
+	}
+	async pop() {
+		if (this._items.length) return this._items.shift();
+		return new Promise((resolve) => {
+			this._resolvers.push(resolve);
+		});
+	}
+};
+const servers = /* @__PURE__ */ new Map();
+async function handleHttpServerStart({ port, host }) {
+	const serverId = NEXT_SERVER_ID++;
+	const pending = new Queue();
+	const inflight = /* @__PURE__ */ new Map();
+	const server = createServer((req, res) => {
+		const requestId = NEXT_REQUEST_ID++;
+		pending.push(requestId);
+		inflight.set(requestId, {
+			req,
+			res
+		});
+	});
+	await new Promise((resolve, reject) => {
+		server.on("error", reject);
+		server.listen(port, host, () => resolve(void 0));
+	});
+	servers.set(serverId, {
+		server,
+		pending,
+		inflight
+	});
+	return serverId;
+}
+async function handleNext({ serverId }) {
+	const srv = servers.get(serverId);
+	if (!srv) throw new Error(`No such server: ${serverId}`);
+	const requestId = await srv.pending.pop();
+	if (requestId == null) return null;
+	const { req } = srv.inflight.get(requestId);
+	const { port1: tx, port2: trailers } = new MessageChannel();
+	const { readable: body, writable } = new TransformStream();
+	pipeline(req, Writable.fromWeb(writable)).then(() => tx.postMessage({ val: toEntries(req.trailersDistinct || req.trailers || {}) })).catch((err) => tx.postMessage({ err })).finally(() => tx.close());
+	const headers = toEntries(req.headersDistinct);
+	const { method, url } = req;
+	return {
+		result: {
+			requestId,
+			headers,
+			body,
+			trailers,
+			method,
+			url
+		},
+		transferable: [body, trailers]
+	};
+}
+async function handleResponse({ serverId, requestId, statusCode, headers, trailers, stream }) {
+	const srv = servers.get(serverId);
+	if (!srv) throw new Error(`No such server: ${serverId}`);
+	const entry = srv.inflight.get(requestId);
+	if (!entry) throw new Error(`No inflight ${requestId}`);
+	const { res } = entry;
+	try {
+		res.writeHead(statusCode, toObject(headers));
+		if (stream) {
+			await pipeline(Readable.fromWeb(stream), res, { end: false });
+			const fields = await recvTrailers(trailers);
+			if (fields) res.addTrailers(toObject(fields));
+			res.end();
+		} else res.end();
+	} catch (err) {
+		res.destroy(err);
+		throw err;
+	} finally {
+		srv.inflight.delete(requestId);
+	}
+	return null;
+}
+async function handleRequest(args) {
+	const transmit = transmitReporter(args.transmit);
+	try {
+		return await doHandleRequest(args, transmit);
+	} catch (err) {
+		transmit.err(err);
+		throw HttpError.from(err).payload;
+	}
+}
+async function doHandleRequest({ url, method, headers, trailers, body, timeouts }, transmit) {
+	const parsed = new URL(url);
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new HttpError("HTTP-protocol-error");
+	const { connectTimeoutNs, firstByteTimeoutNs, betweenBytesTimeoutNs } = timeouts;
+	const isHttps = parsed.protocol === "https:";
+	const agent = new (isHttps ? Agent$1 : Agent)({ keepAlive: true });
+	const req = (isHttps ? request$1 : request)({
+		agent,
+		method,
+		host: parsed.hostname,
+		port: parsed.port,
+		path: parsed.pathname + parsed.search,
+		headers: toObject(headers),
+		timeout: connectTimeoutNs ? msecs(connectTimeoutNs) : void 0
+	});
+	if (firstByteTimeoutNs) req.setTimeout(msecs(firstByteTimeoutNs));
+	let resStarted = false;
+	const response = new Promise((resolve, reject) => {
+		const onResponse = (response) => {
+			resStarted = true;
+			cleanup();
+			resolve(response);
+		};
+		const onConnect = (_response, socket) => {
+			cleanup();
+			socket.destroy();
+			reject(new HttpError("HTTP-protocol-error"));
+		};
+		const onError = (err) => {
+			cleanup();
+			reject(err);
+		};
+		const onTimeout = () => {
+			cleanup();
+			req.on("error", () => {});
+			req.destroy();
+			reject(new HttpError("connection-timeout"));
+		};
+		const onClose = () => {
+			cleanup();
+			reject(new HttpError("connection-terminated"));
+		};
+		const cleanup = () => {
+			req.off("response", onResponse);
+			req.off("connect", onConnect);
+			req.off("error", onError);
+			req.off("timeout", onTimeout);
+			req.off("close", onClose);
+		};
+		req.once("response", onResponse);
+		req.once("connect", onConnect);
+		req.once("error", onError);
+		req.once("timeout", onTimeout);
+		req.once("close", onClose);
+	});
+	const expectedLength = contentLength(headers);
+	(body ? sendRequestBody(req, body, trailers, () => resStarted, expectedLength) : endRequest(req)).then(() => transmit.ok(), (err) => transmit.err(err));
+	let res;
+	try {
+		res = await response;
+	} catch (err) {
+		req.destroy();
+		throw err;
+	}
+	if (betweenBytesTimeoutNs) res.once("readable", () => res.setTimeout(msecs(betweenBytesTimeoutNs), () => {
+		res.destroy(new HttpError("connection-timeout"));
+	}));
+	const pass = new PassThrough();
+	const web = Readable.toWeb(pass);
+	const { port1: tx, port2: rx } = new MessageChannel();
+	pipeline(res, pass).then(() => tx.postMessage({ val: toEntries(res.trailersDistinct || res.trailers || {}) })).catch((err) => tx.postMessage({ err })).finally(() => tx.close());
+	return {
+		result: {
+			statusCode: res.statusCode,
+			headers: toEntries(res.headersDistinct),
+			body: web,
+			trailers: rx
+		},
+		transferable: [web, rx]
+	};
+}
+function handleHttpServerStop({ serverId }) {
+	const srv = servers.get(serverId);
+	if (!srv) throw new Error(`No such server: ${serverId}`);
+	srv.pending.push(null);
+	return serverId;
+}
+async function handleHttpServerClose({ serverId }) {
+	const srv = servers.get(serverId);
+	if (!srv) throw new Error(`No such server: ${serverId}`);
+	await new Promise((resolve) => srv.server.close(resolve));
+	servers.delete(serverId);
+	return serverId;
+}
+async function sendRequestBody(req, body, trailers, resStarted, expectedLength) {
+	try {
+		req.flushHeaders();
+		await pipeline(validateRequestBody(Readable.fromWeb(body), expectedLength), req, { end: false });
+		const fields = await recvTrailers(trailers);
+		if (fields) req.addTrailers(toObject(fields));
+		await endRequest(req);
+	} catch (err) {
+		if (!resStarted()) req.destroy(err);
+		throw err;
+	}
+}
+async function* validateRequestBody(body, expectedLength) {
+	let bytes = 0n;
+	for await (const chunk of body) {
+		bytes += BigInt(chunk.byteLength);
+		if (expectedLength !== null && bytes > expectedLength) throw new HttpError("HTTP-request-body-size", void 0, bytes);
+		yield chunk;
+	}
+	if (expectedLength !== null && bytes < expectedLength) throw new HttpError("HTTP-request-body-size", void 0, bytes);
+}
+function endRequest(req) {
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const settle = (fn, value) => {
+			if (settled) return;
+			settled = true;
+			req.off("error", onError);
+			req.off("close", onClose);
+			fn(value);
+		};
+		const onError = (err) => settle(reject, err);
+		const onClose = () => settle(reject, new HttpError("connection-terminated"));
+		req.once("error", onError);
+		req.once("close", onClose);
+		try {
+			req.end(() => settle(resolve, void 0));
+		} catch (err) {
+			settle(reject, err);
+		}
+	});
+}
+function transmitReporter(port) {
+	let settled = false;
+	const send = (msg) => {
+		if (settled || !port) return;
+		settled = true;
+		port.postMessage(msg);
+		port.close();
+	};
+	return {
+		ok() {
+			send({ val: void 0 });
+		},
+		err(err) {
+			send({ err: HttpError.from(err).payload });
+		}
+	};
+}
+async function recvTrailers(port) {
+	if (!port) return null;
+	return new Promise((resolve, reject) => {
+		port.once("message", ({ val, err }) => {
+			port.close();
+			if (err) reject(err);
+			else resolve(val);
+		});
+	});
+}
+const msecs = (time) => {
+	return typeof time === "bigint" ? Number(time / 1000000n) : time / 1e6;
+};
+const decoder = new TextDecoder();
+const contentLength = (entries) => {
+	const entry = entries.findLast(([name]) => name.toLowerCase() === "content-length");
+	if (!entry) return null;
+	const value = decoder.decode(entry[1]);
+	return /^\d+$/.test(value) ? BigInt(value) : null;
+};
+const toObject = (entries) => {
+	return Object.fromEntries(entries.map(([key, val]) => [key, decoder.decode(val)]));
+};
+const encoder = new TextEncoder();
+const toEntries = (obj) => {
+	return Object.entries(obj).flatMap(([k, v]) => Array.isArray(v) ? v.map((val) => [k, encoder.encode(val)]) : [[k, encoder.encode(v)]]);
+};
+//#endregion
+export {};

package/dist/nodejs/workers/resource-worker.d.ts

@@ -1,6 +1,6 @@
 export declare class ResourceWorker {
     #private;
-    constructor(workerUrl: any);
+    constructor(createWorker: any);
     terminate(): void;
     /** Async IPC */
     run(msg: any, transferable?: any[]): Promise<unknown>;

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

@@ -1,16 +1,16 @@
-import { Worker, parentPort, isMainThread, MessageChannel, receiveMessageOnPort, } from "worker_threads";
+import { parentPort, isMainThread, MessageChannel, receiveMessageOnPort } from "worker_threads";
 export class ResourceWorker {
     #worker = null;
-    #workerUrl = null;
+    #createWorker = null;
     #pending = new Map();
-    constructor(workerUrl) {
-        this.#workerUrl = workerUrl;
+    constructor(createWorker) {
+        this.#createWorker = createWorker;
     }
     #getWorker() {
         if (this.#worker) {
             return this.#worker;
         }
-        this.#worker = new Worker(this.#workerUrl);
+        this.#worker = this.#createWorker();
         this.#worker.unref();
         return this.#worker;
     }