@bytecodealliance/preview2-shim 0.18.1 → 0.20.0

package/dist/nodejs/http.js

@@ -0,0 +1,674 @@
+import { FUTURE_DISPOSE, FUTURE_SUBSCRIBE, FUTURE_TAKE_VALUE, HTTP_CREATE_REQUEST, HTTP_OUTGOING_BODY_DISPOSE, HTTP_OUTPUT_STREAM_FINISH, HTTP_SERVER_CLEAR_OUTGOING_RESPONSE, HTTP_SERVER_SET_OUTGOING_RESPONSE, HTTP_SERVER_START, HTTP_SERVER_STOP, HTTP_SERVER_GET_ADDRESS, OUTPUT_STREAM_CREATE, OUTPUT_STREAM_DISPOSE, } from "../io/calls.js";
+import { earlyDispose, inputStreamCreate, ioCall, outputStreamCreate, pollableCreate, createPoll, registerDispose, registerIncomingHttpHandler, } from "../io/worker-io.js";
+import { CLOCKS_DURATION_SUBSCRIBE, HTTP } from "../io/calls.js";
+import * as http from "node:http";
+const { validateHeaderName = () => { }, validateHeaderValue = () => { } } = http;
+const symbolDispose = Symbol.dispose || Symbol.for("dispose");
+export const _forbiddenHeaders = new Set(["connection", "keep-alive", "host"]);
+class IncomingBody {
+    #finished = false;
+    #stream = null;
+    stream() {
+        if (!this.#stream) {
+            throw undefined;
+        }
+        const stream = this.#stream;
+        this.#stream = null;
+        return stream;
+    }
+    static finish(incomingBody) {
+        if (incomingBody.#finished) {
+            throw new Error("incoming body already finished");
+        }
+        incomingBody.#finished = true;
+        return futureTrailersCreate();
+    }
+    [symbolDispose]() { }
+    static _create(streamId) {
+        const incomingBody = new IncomingBody();
+        incomingBody.#stream = inputStreamCreate(HTTP, streamId);
+        return incomingBody;
+    }
+}
+const incomingBodyCreate = IncomingBody._create;
+// @ts-expect-error - Deleting static method
+delete IncomingBody._create;
+class IncomingRequest {
+    #method;
+    #pathWithQuery;
+    #scheme;
+    #authority;
+    #headers;
+    #streamId;
+    method() {
+        return this.#method;
+    }
+    pathWithQuery() {
+        return this.#pathWithQuery;
+    }
+    scheme() {
+        return this.#scheme;
+    }
+    authority() {
+        return this.#authority;
+    }
+    headers() {
+        return this.#headers;
+    }
+    consume() {
+        return incomingBodyCreate(this.#streamId);
+    }
+    [symbolDispose]() { }
+    static _create(method, pathWithQuery, scheme, authority, headers, streamId) {
+        const incomingRequest = new IncomingRequest();
+        incomingRequest.#method = method;
+        incomingRequest.#pathWithQuery = pathWithQuery;
+        incomingRequest.#scheme = scheme;
+        incomingRequest.#authority = authority;
+        incomingRequest.#headers = headers;
+        incomingRequest.#streamId = streamId;
+        return incomingRequest;
+    }
+}
+const incomingRequestCreate = IncomingRequest._create;
+// @ts-expect-error - Deleting static method
+delete IncomingRequest._create;
+class FutureTrailers {
+    #requested = false;
+    subscribe() {
+        return createPoll(CLOCKS_DURATION_SUBSCRIBE, null, 0n);
+    }
+    get() {
+        if (this.#requested) {
+            return { tag: "err", val: undefined };
+        }
+        this.#requested = true;
+        return {
+            tag: "ok",
+            val: {
+                tag: "ok",
+                val: fieldsLock(fieldsFromEntriesChecked([])),
+            },
+        };
+    }
+    static _create() {
+        const res = new FutureTrailers();
+        return res;
+    }
+}
+const futureTrailersCreate = FutureTrailers._create;
+// @ts-expect-error - Deleting static method
+delete FutureTrailers._create;
+class OutgoingResponse {
+    #body;
+    /** @type {number} */ #statusCode = 200;
+    /** @type {Fields} */ #headers;
+    /**
+     * @param {number} statusCode
+     * @param {Fields} headers
+     */
+    constructor(headers) {
+        fieldsLock(headers);
+        this.#headers = headers;
+    }
+    statusCode() {
+        return this.#statusCode;
+    }
+    setStatusCode(statusCode) {
+        this.#statusCode = statusCode;
+    }
+    headers() {
+        return this.#headers;
+    }
+    body() {
+        let contentLengthValues = this.#headers.get("content-length");
+        let contentLength;
+        if (contentLengthValues.length > 0) {
+            contentLength = Number(new TextDecoder().decode(contentLengthValues[0]));
+        }
+        this.#body = outgoingBodyCreate(contentLength);
+        return this.#body;
+    }
+    static _body(outgoingResponse) {
+        return outgoingResponse.#body;
+    }
+}
+const outgoingResponseBody = OutgoingResponse._body;
+// @ts-expect-error - Deleting static method
+delete OutgoingResponse._body;
+class ResponseOutparam {
+    #setListener;
+    static set(param, response) {
+        param.#setListener(response);
+    }
+    static _create(setListener) {
+        const responseOutparam = new ResponseOutparam();
+        responseOutparam.#setListener = setListener;
+        return responseOutparam;
+    }
+}
+const responseOutparamCreate = ResponseOutparam._create;
+// @ts-expect-error - Deleting static method
+delete ResponseOutparam._create;
+const defaultHttpTimeout = 600000000000n;
+class RequestOptions {
+    #connectTimeout = defaultHttpTimeout;
+    #firstByteTimeout = defaultHttpTimeout;
+    #betweenBytesTimeout = defaultHttpTimeout;
+    connectTimeout() {
+        return this.#connectTimeout;
+    }
+    setConnectTimeout(duration) {
+        this.#connectTimeout = duration;
+    }
+    firstByteTimeout() {
+        return this.#firstByteTimeout;
+    }
+    setFirstByteTimeout(duration) {
+        this.#firstByteTimeout = duration;
+    }
+    betweenBytesTimeout() {
+        return this.#betweenBytesTimeout;
+    }
+    setBetweenBytesTimeout(duration) {
+        this.#betweenBytesTimeout = duration;
+    }
+}
+class OutgoingRequest {
+    #method = { tag: "get" };
+    #scheme = undefined;
+    #pathWithQuery = undefined;
+    #authority = undefined;
+    #headers;
+    #body;
+    #bodyRequested = false;
+    constructor(headers) {
+        fieldsLock(headers);
+        this.#headers = headers;
+        let contentLengthValues = this.#headers.get("content-length");
+        if (contentLengthValues.length === 0) {
+            contentLengthValues = this.#headers.get("Content-Length");
+        }
+        let contentLength;
+        if (contentLengthValues.length > 0) {
+            contentLength = Number(new TextDecoder().decode(contentLengthValues[0]));
+        }
+        this.#body = outgoingBodyCreate(contentLength);
+    }
+    body() {
+        if (this.#bodyRequested) {
+            throw new Error("Body already requested");
+        }
+        this.#bodyRequested = true;
+        return this.#body;
+    }
+    method() {
+        return this.#method;
+    }
+    setMethod(method) {
+        if (method.tag === "other" && !method.val.match(/^[a-zA-Z-]+$/)) {
+            throw undefined;
+        }
+        this.#method = method;
+    }
+    pathWithQuery() {
+        return this.#pathWithQuery;
+    }
+    setPathWithQuery(pathWithQuery) {
+        if (pathWithQuery && !pathWithQuery.match(/^[a-zA-Z0-9.\-_~!$&'()*+,;=:@%?/]+$/)) {
+            throw undefined;
+        }
+        this.#pathWithQuery = pathWithQuery;
+    }
+    scheme() {
+        return this.#scheme;
+    }
+    setScheme(scheme) {
+        if (scheme?.tag === "other" && !scheme.val.match(/^[a-zA-Z]+$/)) {
+            throw undefined;
+        }
+        this.#scheme = scheme;
+    }
+    authority() {
+        return this.#authority;
+    }
+    setAuthority(authority) {
+        if (authority) {
+            const [host, port, ...extra] = authority.split(":");
+            const portNum = Number(port);
+            if (extra.length ||
+                (port !== undefined && (portNum.toString() !== port || portNum > 65535)) ||
+                !host.match(/^[a-zA-Z0-9-.]+$/)) {
+                throw undefined;
+            }
+        }
+        this.#authority = authority;
+    }
+    headers() {
+        return this.#headers;
+    }
+    [symbolDispose]() { }
+    static _handle(request, options) {
+        const connectTimeout = options?.connectTimeout();
+        const betweenBytesTimeout = options?.betweenBytesTimeout();
+        const firstByteTimeout = options?.firstByteTimeout();
+        const scheme = schemeString(request.#scheme);
+        // note: host header is automatically added by Node.js
+        const headers = [];
+        const decoder = new TextDecoder();
+        for (const [key, value] of request.#headers.entries()) {
+            headers.push([key, decoder.decode(value)]);
+        }
+        if (!request.#pathWithQuery) {
+            throw { tag: "HTTP-request-URI-invalid" };
+        }
+        return futureIncomingResponseCreate(request.#method.val || request.#method.tag, scheme, request.#authority, request.#pathWithQuery, headers, outgoingBodyOutputStreamId(request.#body), connectTimeout, betweenBytesTimeout, firstByteTimeout);
+    }
+}
+const outgoingRequestHandle = OutgoingRequest._handle;
+// @ts-expect-error - Deleting static method
+delete OutgoingRequest._handle;
+class OutgoingBody {
+    #outputStream = null;
+    #outputStreamId = null;
+    #contentLength = undefined;
+    #finalizer;
+    write() {
+        // can only call write once
+        const outputStream = this.#outputStream;
+        if (outputStream === null) {
+            throw undefined;
+        }
+        this.#outputStream = null;
+        return outputStream;
+    }
+    static finish(body, trailers) {
+        if (trailers) {
+            throw { tag: "internal-error", val: "trailers unsupported" };
+        }
+        // this will verify content length, and also verify not already finished
+        // throwing errors as appropriate
+        ioCall(HTTP_OUTPUT_STREAM_FINISH, body.#outputStreamId, null);
+    }
+    static _outputStreamId(outgoingBody) {
+        return outgoingBody.#outputStreamId;
+    }
+    static _create(contentLength) {
+        const outgoingBody = new OutgoingBody();
+        outgoingBody.#contentLength = contentLength;
+        outgoingBody.#outputStreamId = ioCall(OUTPUT_STREAM_CREATE | HTTP, null, outgoingBody.#contentLength);
+        outgoingBody.#outputStream = outputStreamCreate(HTTP, outgoingBody.#outputStreamId);
+        outgoingBody.#finalizer = registerDispose(outgoingBody, null, outgoingBody.#outputStreamId, outgoingBodyDispose);
+        return outgoingBody;
+    }
+    [symbolDispose]() {
+        if (this.#finalizer) {
+            earlyDispose(this.#finalizer);
+            this.#finalizer = null;
+        }
+    }
+}
+function outgoingBodyDispose(id) {
+    ioCall(HTTP_OUTGOING_BODY_DISPOSE, id, null);
+}
+const outgoingBodyOutputStreamId = OutgoingBody._outputStreamId;
+// @ts-expect-error - Deleting static method
+delete OutgoingBody._outputStreamId;
+const outgoingBodyCreate = OutgoingBody._create;
+// @ts-expect-error - Deleting static method
+delete OutgoingBody._create;
+class IncomingResponse {
+    #headers;
+    #status = 0;
+    #bodyStream;
+    status() {
+        return this.#status;
+    }
+    headers() {
+        return this.#headers;
+    }
+    consume() {
+        if (this.#bodyStream === undefined) {
+            throw undefined;
+        }
+        const bodyStream = this.#bodyStream;
+        this.#bodyStream = undefined;
+        return bodyStream;
+    }
+    [symbolDispose]() {
+        if (this.#bodyStream) {
+            this.#bodyStream[symbolDispose]();
+        }
+    }
+    static _create(status, headers, bodyStreamId) {
+        const res = new IncomingResponse();
+        res.#status = status;
+        res.#headers = headers;
+        res.#bodyStream = incomingBodyCreate(bodyStreamId);
+        return res;
+    }
+}
+const incomingResponseCreate = IncomingResponse._create;
+// @ts-expect-error - Deleting static method
+delete IncomingResponse._create;
+class FutureIncomingResponse {
+    #id;
+    #finalizer;
+    subscribe() {
+        return pollableCreate(ioCall(FUTURE_SUBSCRIBE | HTTP, this.#id, null), this);
+    }
+    get() {
+        const ret = ioCall(FUTURE_TAKE_VALUE | HTTP, this.#id, null);
+        if (ret === undefined) {
+            return undefined;
+        }
+        if (ret.tag === "ok" && ret.val.tag === "ok") {
+            const textEncoder = new TextEncoder();
+            const { status, headers, bodyStreamId } = ret.val.val;
+            ret.val.val = incomingResponseCreate(status, fieldsFromEntriesChecked(headers.map(([key, val]) => [key, textEncoder.encode(val)])), bodyStreamId);
+        }
+        return ret;
+    }
+    static _create(method, scheme, authority, pathWithQuery, headers, body, connectTimeout, betweenBytesTimeout, firstByteTimeout) {
+        const res = new FutureIncomingResponse();
+        res.#id = ioCall(HTTP_CREATE_REQUEST, null, {
+            method,
+            scheme,
+            authority,
+            pathWithQuery,
+            headers,
+            body,
+            connectTimeout,
+            betweenBytesTimeout,
+            firstByteTimeout,
+        });
+        res.#finalizer = registerDispose(res, null, res.#id, futureIncomingResponseDispose);
+        return res;
+    }
+    [symbolDispose]() {
+        if (this.#finalizer) {
+            earlyDispose(this.#finalizer);
+            this.#finalizer = null;
+        }
+    }
+}
+function futureIncomingResponseDispose(id) {
+    ioCall(FUTURE_DISPOSE | HTTP, id, null);
+}
+const futureIncomingResponseCreate = FutureIncomingResponse._create;
+// @ts-expect-error - Deleting static method
+delete FutureIncomingResponse._create;
+class Fields {
+    #immutable = false;
+    #entries = [];
+    #table = new Map();
+    /**
+     * @param {[string, Uint8Array[][]][]} entries
+     */
+    static fromList(entries) {
+        const fields = new Fields();
+        for (const [key, value] of entries) {
+            fields.append(key, value);
+        }
+        return fields;
+    }
+    get(name) {
+        const tableEntries = this.#table.get(name.toLowerCase());
+        if (!tableEntries) {
+            return [];
+        }
+        return tableEntries.map(([, v]) => v);
+    }
+    /**
+     * WIT spec (https://github.com/WebAssembly/WASI/blob/91bb44c3c3a9b1e09187db23c85fa844d1fd6b15/proposals/http/wit/types.wit#L215-L223):
+     *
+     * > Set all of the values for a name. Clears any existing values for that
+     * > name, if they have been set.
+     * >
+     * > Fails with `header-error.immutable` if the `fields` are immutable.
+     * >
+     * > Fails with `header-error.invalid-syntax` if the `field-name` or any of
+     * > the `field-value`s are syntactically invalid.
+     *
+     * The existing-branch splice/reuse is an allocation optimization — values are cleared, not retained.
+     */
+    set(name, values) {
+        if (this.#immutable) {
+            throw { tag: "immutable" };
+        }
+        try {
+            validateHeaderName(name);
+        }
+        catch {
+            throw { tag: "invalid-syntax" };
+        }
+        for (const value of values) {
+            try {
+                validateHeaderValue(name, new TextDecoder().decode(value));
+            }
+            catch {
+                throw { tag: "invalid-syntax" };
+            }
+        }
+        const lowercased = name.toLowerCase();
+        if (_forbiddenHeaders.has(lowercased)) {
+            throw { tag: "forbidden" };
+        }
+        let tableEntries = this.#table.get(lowercased);
+        if (tableEntries) {
+            this.#entries = this.#entries.filter((entry) => !tableEntries?.includes(entry));
+            tableEntries.splice(0, tableEntries.length);
+        }
+        else {
+            this.#table.set(lowercased, []);
+            tableEntries = this.#table.get(lowercased);
+        }
+        for (const value of values) {
+            const entry = [name, value];
+            this.#entries.push(entry);
+            tableEntries?.push(entry);
+        }
+    }
+    has(name) {
+        return this.#table.has(name.toLowerCase());
+    }
+    delete(name) {
+        if (this.#immutable) {
+            throw { tag: "immutable" };
+        }
+        const lowercased = name.toLowerCase();
+        const tableEntries = this.#table.get(lowercased);
+        if (tableEntries) {
+            this.#entries = this.#entries.filter((entry) => !tableEntries.includes(entry));
+            this.#table.delete(lowercased);
+        }
+    }
+    append(name, value) {
+        if (this.#immutable) {
+            throw { tag: "immutable" };
+        }
+        try {
+            validateHeaderName(name);
+        }
+        catch {
+            throw { tag: "invalid-syntax" };
+        }
+        try {
+            validateHeaderValue(name, new TextDecoder().decode(value));
+        }
+        catch {
+            throw { tag: "invalid-syntax" };
+        }
+        const lowercased = name.toLowerCase();
+        if (_forbiddenHeaders.has(lowercased)) {
+            throw { tag: "forbidden" };
+        }
+        const entry = [name, value];
+        this.#entries.push(entry);
+        const tableEntries = this.#table.get(lowercased);
+        if (tableEntries) {
+            tableEntries.push(entry);
+        }
+        else {
+            this.#table.set(lowercased, [entry]);
+        }
+    }
+    entries() {
+        return this.#entries;
+    }
+    clone() {
+        return fieldsFromEntriesChecked(this.#entries);
+    }
+    static _lock(fields) {
+        fields.#immutable = true;
+        return fields;
+    }
+    // assumes entries are already validated
+    static _fromEntriesChecked(entries) {
+        const fields = new Fields();
+        fields.#entries = entries;
+        for (const entry of entries) {
+            const lowercase = entry[0].toLowerCase();
+            const existing = fields.#table.get(lowercase);
+            if (existing) {
+                existing.push(entry);
+            }
+            else {
+                fields.#table.set(lowercase, [entry]);
+            }
+        }
+        return fields;
+    }
+}
+const fieldsLock = Fields._lock;
+// @ts-expect-error - Deleting static method
+delete Fields._lock;
+const fieldsFromEntriesChecked = Fields._fromEntriesChecked;
+// @ts-expect-error - Deleting static method
+delete Fields._fromEntriesChecked;
+export const outgoingHandler = {
+    /**
+     * @param {OutgoingRequest} request
+     * @param {RequestOptions | undefined} options
+     * @returns {FutureIncomingResponse}
+     */
+    handle: outgoingRequestHandle,
+};
+function httpErrorCode(err) {
+    if (err.payload) {
+        return err.payload;
+    }
+    return {
+        tag: "internal-error",
+        val: err.message,
+    };
+}
+export const types = {
+    Fields,
+    FutureIncomingResponse,
+    FutureTrailers,
+    IncomingBody,
+    IncomingRequest,
+    IncomingResponse,
+    OutgoingBody,
+    OutgoingRequest,
+    OutgoingResponse,
+    ResponseOutparam,
+    RequestOptions,
+    httpErrorCode,
+};
+function schemeString(scheme) {
+    if (!scheme) {
+        return "https:";
+    }
+    switch (scheme.tag) {
+        case "HTTP":
+            return "http:";
+        case "HTTPS":
+            return "https:";
+        case "other":
+            return scheme.val.toLowerCase() + ":";
+    }
+}
+const supportedMethods = [
+    "get",
+    "head",
+    "post",
+    "put",
+    "delete",
+    "connect",
+    "options",
+    "trace",
+    "patch",
+];
+function parseMethod(method) {
+    const lowercase = method.toLowerCase();
+    if (supportedMethods.includes(method.toLowerCase())) {
+        return { tag: lowercase };
+    }
+    return { tag: "other", val: lowercase };
+}
+const httpServers = new Map();
+let httpServerCnt = 0;
+export class HTTPServer {
+    #id = ++httpServerCnt;
+    #stopped = false;
+    #liveEventLoopInterval;
+    constructor(incomingHandler) {
+        httpServers.set(this.#id, this);
+        if (typeof incomingHandler?.handle !== "function") {
+            console.error("Not a valid HTTP server component to execute.");
+            process.exit(1);
+        }
+        registerIncomingHttpHandler(this.#id, ({ method, pathWithQuery, host, headers, responseId, streamId }) => {
+            const textEncoder = new TextEncoder();
+            const request = incomingRequestCreate(parseMethod(method), pathWithQuery, { tag: "HTTP" }, host, fieldsLock(fieldsFromEntriesChecked(headers
+                .filter(([key]) => !_forbiddenHeaders.has(key))
+                .map(([key, val]) => [key, textEncoder.encode(val)]))), streamId);
+            let outgoingBodyStreamId;
+            const responseOutparam = responseOutparamCreate((response) => {
+                if (response.tag === "ok") {
+                    const outgoingResponse = response.val;
+                    const statusCode = outgoingResponse.statusCode();
+                    const headers = outgoingResponse.headers().entries();
+                    const body = outgoingResponseBody(outgoingResponse);
+                    outgoingBodyStreamId = outgoingBodyOutputStreamId(body);
+                    ioCall(HTTP_SERVER_SET_OUTGOING_RESPONSE, responseId, {
+                        statusCode,
+                        headers,
+                        streamId: outgoingBodyStreamId,
+                    });
+                }
+                else {
+                    ioCall(HTTP_SERVER_CLEAR_OUTGOING_RESPONSE, responseId, null);
+                    console.error(response.val);
+                    process.exit(1);
+                }
+            });
+            incomingHandler.handle(request, responseOutparam);
+            if (outgoingBodyStreamId) {
+                ioCall(OUTPUT_STREAM_DISPOSE, outgoingBodyStreamId, null);
+            }
+        });
+    }
+    listen(port, host) {
+        // set a dummy interval, to keep the process alive since the server is off-thread
+        this.#liveEventLoopInterval = setInterval(() => { }, 10_000);
+        ioCall(HTTP_SERVER_START, this.#id, { port, host });
+    }
+    address() {
+        return ioCall(HTTP_SERVER_GET_ADDRESS, this.#id);
+    }
+    stop() {
+        if (this.#stopped) {
+            return;
+        }
+        clearInterval(this.#liveEventLoopInterval);
+        ioCall(HTTP_SERVER_STOP, this.#id, null);
+        httpServers.delete(this.#id);
+        this.#stopped = true;
+    }
+    close() {
+        this.stop();
+    }
+}

package/dist/nodejs/index.d.ts

@@ -0,0 +1,7 @@
+export * as cli from "./cli.js";
+export * as clocks from "./clocks.js";
+export * as filesystem from "./filesystem.js";
+export * as http from "./http.js";
+export * as io from "./io.js";
+export * as random from "./random.js";
+export * as sockets from "./sockets.js";

package/dist/nodejs/index.js

@@ -0,0 +1,7 @@
+export * as cli from "./cli.js";
+export * as clocks from "./clocks.js";
+export * as filesystem from "./filesystem.js";
+export * as http from "./http.js";
+export * as io from "./io.js";
+export * as random from "./random.js";
+export * as sockets from "./sockets.js";

package/dist/nodejs/io.d.ts

@@ -0,0 +1 @@
+export { error, streams, poll, inputStreamCreate, outputStreamCreate } from "../io/worker-io.js";

package/dist/nodejs/io.js

@@ -0,0 +1 @@
+export { error, streams, poll, inputStreamCreate, outputStreamCreate } from "../io/worker-io.js";

package/dist/nodejs/random.d.ts

@@ -0,0 +1,4 @@
+import type { insecure as InsecureNamespace, insecureSeed as InsecureSeedNamespace, random as RandomNamespace } from "../../types/random.js";
+export declare const insecure: typeof InsecureNamespace;
+export declare const insecureSeed: typeof InsecureSeedNamespace;
+export declare const random: typeof RandomNamespace;