@bytecodealliance/preview3-shim 0.1.1 → 0.2.0

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

@@ -0,0 +1,102 @@
+import { promisify } from "util";
+import { Router } from "./resource-worker.js";
+import { FSError } from "../filesystem/error.js";
+import { wasiTypeFromDirent } from "../filesystem/utils.js";
+// Use fs callback API for BigInt offset support
+import fs from "fs";
+const readAsync = promisify(fs.read);
+const writeAsync = promisify(fs.write);
+const { opendir } = fs.promises;
+const CHUNK_BYTES = 64 * 1024;
+// Reuse a single buffer for all read/write ops
+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();
+    try {
+        let pos = BigInt(offset);
+        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();
+    const canAccess = preopens.some((p) => fullPath === p || fullPath.startsWith(p + "/"));
+    if (!canAccess) {
+        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;
+    }
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,355 @@
+import { Readable, Writable, PassThrough } from "node:stream";
+import { pipeline } from "stream/promises";
+import { MessageChannel } from "node:worker_threads";
+import { createServer } from "node:http";
+import { request as httpRequest, Agent as HttpAgent } from "node:http";
+import { request as httpsRequest, Agent as HttpsAgent } from "node:https";
+import { HttpError } from "../http/error.js";
+import { Router } from "../workers/resource-worker.js";
+// Unique IDs for servers and requests
+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);
+class Queue {
+    _items = [];
+    _resolvers = [];
+    constructor() {
+        this._items = [];
+        this._resolvers = [];
+    }
+    push(item) {
+        if (this._resolvers.length) {
+            const resolve = this._resolvers.shift();
+            resolve(item);
+        }
+        else {
+            this._items.push(item);
+        }
+    }
+    async pop() {
+        if (this._items.length) {
+            return this._items.shift();
+        }
+        return new Promise((resolve) => {
+            this._resolvers.push(resolve);
+        });
+    }
+}
+// Map<serverId, { server, pending: Queue, inflight: Map }>
+const servers = new Map();
+async function handleHttpServerStart({ port, host }) {
+    const serverId = NEXT_SERVER_ID++;
+    const pending = new Queue();
+    const inflight = 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(undefined));
+    });
+    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();
+    const stream = Writable.fromWeb(writable);
+    pipeline(req, stream)
+        .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;
+    const result = {
+        requestId,
+        headers,
+        body,
+        trailers,
+        method,
+        url,
+    };
+    return { result, 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 AgentClass = isHttps ? HttpsAgent : HttpAgent;
+    const agent = new AgentClass({ keepAlive: true });
+    const request = isHttps ? httpsRequest : httpRequest;
+    const reqOpts = {
+        agent,
+        method,
+        host: parsed.hostname,
+        port: parsed.port,
+        path: parsed.pathname + parsed.search,
+        headers: toObject(headers),
+        timeout: connectTimeoutNs ? msecs(connectTimeoutNs) : undefined,
+    };
+    const req = request(reqOpts);
+    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);
+    const upload = body
+        ? sendRequestBody(req, body, trailers, () => resStarted, expectedLength)
+        : endRequest(req);
+    upload.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());
+    const result = {
+        statusCode: res.statusCode,
+        headers: toEntries(res.headersDistinct),
+        body: web,
+        trailers: rx,
+    };
+    return { result, 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", undefined, bytes);
+        }
+        yield chunk;
+    }
+    if (expectedLength !== null && bytes < expectedLength) {
+        throw new HttpError("HTTP-request-body-size", undefined, 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, undefined));
+        }
+        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: undefined });
+        },
+        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)]]);
+};

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

@@ -0,0 +1,13 @@
+export declare class ResourceWorker {
+    #private;
+    constructor(workerUrl: any);
+    terminate(): void;
+    /** Async IPC */
+    run(msg: any, transferable?: any[]): Promise<unknown>;
+    /** Synchronous IPC */
+    runSync(msg: any, transferable?: any[]): any;
+}
+export declare function Router(): {
+    beforeAll(fn: any): /*elided*/ any;
+    op(name: any, fn: any): /*elided*/ any;
+};

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

@@ -0,0 +1,152 @@
+import { Worker, parentPort, isMainThread, MessageChannel, receiveMessageOnPort, } from "worker_threads";
+export class ResourceWorker {
+    #worker = null;
+    #workerUrl = null;
+    #pending = new Map();
+    constructor(workerUrl) {
+        this.#workerUrl = workerUrl;
+    }
+    #getWorker() {
+        if (this.#worker) {
+            return this.#worker;
+        }
+        this.#worker = new Worker(this.#workerUrl);
+        this.#worker.unref();
+        return this.#worker;
+    }
+    terminate() {
+        if (!this.#worker) {
+            return;
+        }
+        this.#pending.clear();
+        this.#worker.removeAllListeners();
+        this.#worker.terminate();
+        this.#worker = null;
+    }
+    /** Async IPC */
+    run(msg, transferable = []) {
+        const worker = this.#getWorker();
+        const { port1, port2 } = new MessageChannel();
+        return new Promise((resolve, reject) => {
+            port1.once("message", ({ result, error }) => {
+                port1.close();
+                if (error) {
+                    reject(deserializeError(error));
+                    return;
+                }
+                resolve(result);
+            });
+            worker.postMessage({ ...msg, _reply: port2 }, [port2, ...transferable]);
+        });
+    }
+    /** Synchronous IPC */
+    runSync(msg, transferable = []) {
+        const worker = this.#getWorker();
+        const { port1: rx, port2: tx } = new MessageChannel();
+        const _condvar = new SharedArrayBuffer(4);
+        const lock = new Int32Array(_condvar);
+        worker.postMessage({ ...msg, _condvar, _reply: tx }, [tx, ...transferable]);
+        Atomics.wait(lock, 0, 0);
+        const { message } = receiveMessageOnPort(rx) || {};
+        rx.close();
+        if (!message) {
+            throw new Error("No response from worker");
+        }
+        const { result, error } = message;
+        if (error) {
+            throw deserializeError(error);
+        }
+        return result;
+    }
+}
+export function Router() {
+    const _hooks = {
+        beforeAll: null,
+        ops: 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 this is a synchronous operation, notify the main thread.
+        // This will wake up the waiting thread and read the message we
+        // posted on reply channel.
+        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 !== undefined) {
+        serialized.cause = serializeError(err.cause);
+    }
+    return serialized;
+}
+function deserializeError(err) {
+    if (!err || typeof err !== "object" || err.__resourceWorkerError !== true) {
+        return err;
+    }
+    const error = new Error(err.message);
+    error.name = err.name;
+    if (err.stack) {
+        error.stack = err.stack;
+    }
+    for (const key of Reflect.ownKeys(err)) {
+        if (key === "__resourceWorkerError" || key === "name" || key === "message" || key === "stack") {
+            continue;
+        }
+        error[key] = key === "cause" ? deserializeError(err[key]) : err[key];
+    }
+    return error;
+}
+function notify(condvar) {
+    const lock = new Int32Array(condvar);
+    Atomics.store(lock, 0, 1);
+    Atomics.notify(lock, 0, 1);
+}

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

@@ -0,0 +1,2 @@
+export declare function getDefaultSendBufferSize(): Promise<any>;
+export declare function getDefaultReceiveBufferSize(): Promise<any>;