@bytecodealliance/preview2-shim 0.18.1 → 0.20.0

package/dist/io/worker-io.d.ts

@@ -0,0 +1,84 @@
+import type { streams as StreamsNamespace } from "../../types/io.js";
+declare const symbolDispose: symbol;
+type IInputStream = StreamsNamespace.InputStream;
+type IOutputStream = StreamsNamespace.OutputStream;
+export declare function registerIncomingHttpHandler(id: any, handler: any): void;
+/**
+ * @type {(call: number, id: number | null, payload: any) -> any}
+ */
+export declare let ioCall: (...args: any[]) => any;
+export declare function registerDispose(resource: any, parentResource: any, id: number, disposeFn: (id: number) => void): () => void;
+export declare function earlyDispose(finalizer: any): void;
+declare class InputStream implements IInputStream {
+    #private;
+    [symbolDispose]: () => void;
+    read(len: any): any;
+    blockingRead(len: any): any;
+    skip(len: any): any;
+    blockingSkip(len: any): any;
+    subscribe(): Pollable;
+    static _id(stream: any): any;
+    /**
+     * @param {FILE | SOCKET_TCP | STDIN | HTTP} streamType
+     */
+    static _create(streamType: any, id: any): InputStream;
+}
+export declare const inputStreamCreate: typeof InputStream._create;
+export declare const inputStreamId: typeof InputStream._id;
+declare class OutputStream implements IOutputStream {
+    #private;
+    [symbolDispose]: () => void;
+    checkWrite(): any;
+    write(buf: any): any;
+    blockingWriteAndFlush(buf: any): any;
+    flush(): any;
+    blockingFlush(): any;
+    writeZeroes(len: any): any;
+    blockingWriteZeroesAndFlush(len: any): any;
+    splice(src: any, len: any): any;
+    blockingSplice(src: any, len: any): any;
+    subscribe(): Pollable;
+    static _id(outputStream: any): any;
+    /**
+     * @param {OutputStreamType} streamType
+     * @param {any} createPayload
+     */
+    static _create(streamType: any, id: any): OutputStream;
+}
+export declare const outputStreamCreate: typeof OutputStream._create;
+export declare const outputStreamId: typeof OutputStream._id;
+export declare const error: {
+    Error: {
+        new (payload: any): {
+            payload: any;
+            toDebugString(): string;
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+};
+export declare const streams: {
+    InputStream: typeof InputStream;
+    OutputStream: typeof OutputStream;
+};
+declare class Pollable {
+    #private;
+    [symbolDispose]: () => void;
+    ready(): any;
+    block(): void;
+    static _create(id: any, parent: any): Pollable;
+}
+export declare const pollableCreate: typeof Pollable._create;
+export declare const poll: {
+    Pollable: typeof Pollable;
+    poll(list: any): any;
+};
+export declare function createPoll(call: any, id: any, initPayload: any): Pollable;
+export declare function createPollLower(call: any, id: any, table: any): (initPayload: any) => number;
+export {};

package/dist/io/worker-io.js

@@ -0,0 +1,381 @@
+import { fileURLToPath } from "node:url";
+import { createSyncFn } from "../synckit/index.js";
+import { CALL_MASK, CALL_TYPE_MASK, FILE, HTTP_SERVER_INCOMING_HANDLER, HTTP, INPUT_STREAM_BLOCKING_READ, INPUT_STREAM_BLOCKING_SKIP, INPUT_STREAM_DISPOSE, INPUT_STREAM_READ, INPUT_STREAM_SKIP, INPUT_STREAM_SUBSCRIBE, OUTPUT_STREAM_BLOCKING_FLUSH, OUTPUT_STREAM_BLOCKING_SPLICE, OUTPUT_STREAM_BLOCKING_WRITE_AND_FLUSH, OUTPUT_STREAM_BLOCKING_WRITE_ZEROES_AND_FLUSH, OUTPUT_STREAM_CHECK_WRITE, OUTPUT_STREAM_DISPOSE, OUTPUT_STREAM_FLUSH, OUTPUT_STREAM_SPLICE, OUTPUT_STREAM_SUBSCRIBE, OUTPUT_STREAM_WRITE_ZEROES, OUTPUT_STREAM_WRITE, POLL_POLL_LIST, POLL_POLLABLE_BLOCK, POLL_POLLABLE_DISPOSE, POLL_POLLABLE_READY, SOCKET_TCP, STDERR, STDIN, STDOUT, reverseMap, } from "./calls.js";
+import nodeProcess, { exit, stderr, stdout, env } from "node:process";
+const symbolDispose = Symbol.dispose || Symbol.for("dispose");
+const _rawDebug = "_rawDebug" in nodeProcess
+    ? nodeProcess._rawDebug
+    : console.error.bind(console);
+const workerPath = fileURLToPath(new URL("./worker-thread.js", import.meta.url));
+const httpIncomingHandlers = new Map();
+export function registerIncomingHttpHandler(id, handler) {
+    httpIncomingHandlers.set(id, handler);
+}
+const instanceId = Math.round(Math.random() * 1000).toString();
+const DEBUG_DEFAULT = false;
+const DEBUG = env.PREVIEW2_SHIM_DEBUG === "0"
+    ? false
+    : env.PREVIEW2_SHIM_DEBUG === "1"
+        ? true
+        : DEBUG_DEFAULT;
+/**
+ * @type {(call: number, id: number | null, payload: any) -> any}
+ */
+export let ioCall = createSyncFn(workerPath, DEBUG, (type, id, payload) => {
+    // 'callbacks' from the worker
+    // ONLY happens for an http server incoming handler, and NOTHING else (not even sockets, since accept is sync!)
+    if (type !== HTTP_SERVER_INCOMING_HANDLER) {
+        throw new Error("Internal error: only incoming handler callback is permitted");
+    }
+    const handler = httpIncomingHandlers.get(id);
+    if (!handler) {
+        throw new Error(`Internal error: no incoming handler registered for server ${id}`);
+    }
+    handler(payload);
+});
+if (DEBUG) {
+    const _ioCall = ioCall;
+    ioCall = function ioCall(num, id, payload) {
+        if (typeof id !== "number" && id !== null) {
+            throw new Error("id must be a number or null");
+        }
+        let ret;
+        try {
+            _rawDebug(instanceId, reverseMap[num & CALL_MASK], reverseMap[num & CALL_TYPE_MASK], id, payload);
+            ret = _ioCall(num, id, payload);
+            return ret;
+        }
+        catch (e) {
+            ret = e;
+            throw ret;
+        }
+        finally {
+            _rawDebug(instanceId, "->", ret);
+        }
+    };
+}
+const finalizationRegistry = new FinalizationRegistry((dispose) => void dispose());
+const dummySymbol = Symbol();
+export function registerDispose(resource, parentResource, id, disposeFn) {
+    // While strictly speaking all components should handle their disposal,
+    // this acts as a last-resort to catch all missed drops through the JS GC.
+    // Mainly for two cases - (1) components which are long lived, that get shut
+    // down and (2) users that interface with low-level WASI APIs directly in JS
+    // for various reasons may end up leaning on JS GC inadvertantly.
+    function finalizer() {
+        // This has no functional purpose other than to pin a strong reference
+        // from the child resource's finalizer to the parent resource, to ensure
+        // that we can never finalize a parent resource before a child resource.
+        // This makes the generational JS GC become piecewise over child resource
+        // graphs (generational at each resource hierarchy level at least).
+        if (parentResource?.[dummySymbol]) {
+            return;
+        }
+        disposeFn(id);
+    }
+    finalizationRegistry.register(resource, finalizer, finalizer);
+    return finalizer;
+}
+export function earlyDispose(finalizer) {
+    finalizationRegistry.unregister(finalizer);
+    finalizer();
+}
+const _Error = Error;
+const IoError = class Error extends _Error {
+    payload;
+    constructor(payload) {
+        super(payload);
+        this.payload = payload;
+    }
+    toDebugString() {
+        return this.message;
+    }
+};
+function streamIoErrorCall(call, id, payload) {
+    try {
+        return ioCall(call, id, payload);
+    }
+    catch (e) {
+        if (e.tag === "closed") {
+            throw e;
+        }
+        if (e.tag === "last-operation-failed") {
+            e.val = new IoError(Object.assign(new Error(e.val.message), e.val));
+            throw e;
+        }
+        // any invalid error is a trap
+        console.trace(e);
+        exit(1);
+    }
+}
+class InputStream {
+    #id;
+    #streamType;
+    #finalizer;
+    read(len) {
+        return streamIoErrorCall(INPUT_STREAM_READ | this.#streamType, this.#id, len);
+    }
+    blockingRead(len) {
+        return streamIoErrorCall(INPUT_STREAM_BLOCKING_READ | this.#streamType, this.#id, len);
+    }
+    skip(len) {
+        return streamIoErrorCall(INPUT_STREAM_SKIP | this.#streamType, this.#id, len);
+    }
+    blockingSkip(len) {
+        return streamIoErrorCall(INPUT_STREAM_BLOCKING_SKIP | this.#streamType, this.#id, len);
+    }
+    subscribe() {
+        return pollableCreate(ioCall(INPUT_STREAM_SUBSCRIBE | this.#streamType, this.#id), this);
+    }
+    static _id(stream) {
+        return stream.#id;
+    }
+    /**
+     * @param {FILE | SOCKET_TCP | STDIN | HTTP} streamType
+     */
+    static _create(streamType, id) {
+        const stream = new InputStream();
+        stream.#id = id;
+        stream.#streamType = streamType;
+        let disposeFn;
+        switch (streamType) {
+            case FILE:
+                disposeFn = fileInputStreamDispose;
+                break;
+            case SOCKET_TCP:
+                disposeFn = socketTcpInputStreamDispose;
+                break;
+            case STDIN:
+                disposeFn = stdinInputStreamDispose;
+                break;
+            case HTTP:
+                disposeFn = httpInputStreamDispose;
+                break;
+            default:
+                throw new Error("wasi-io trap: Dispose function not created for stream type " +
+                    reverseMap[streamType]);
+        }
+        stream.#finalizer = registerDispose(stream, null, id, disposeFn);
+        return stream;
+    }
+    [symbolDispose]() {
+        if (this.#finalizer) {
+            earlyDispose(this.#finalizer);
+            this.#finalizer = null;
+        }
+    }
+}
+function fileInputStreamDispose(id) {
+    ioCall(INPUT_STREAM_DISPOSE | FILE, id, null);
+}
+function socketTcpInputStreamDispose(id) {
+    ioCall(INPUT_STREAM_DISPOSE | SOCKET_TCP, id, null);
+}
+function stdinInputStreamDispose(id) {
+    ioCall(INPUT_STREAM_DISPOSE | STDIN, id, null);
+}
+function httpInputStreamDispose(id) {
+    ioCall(INPUT_STREAM_DISPOSE | HTTP, id, null);
+}
+export const inputStreamCreate = InputStream._create;
+// @ts-expect-error - Deleting static method
+delete InputStream._create;
+export const inputStreamId = InputStream._id;
+// @ts-expect-error - Deleting static method
+delete InputStream._id;
+class OutputStream {
+    #id;
+    #streamType;
+    #finalizer;
+    checkWrite() {
+        return streamIoErrorCall(OUTPUT_STREAM_CHECK_WRITE | this.#streamType, this.#id, null);
+    }
+    write(buf) {
+        if (this.#streamType <= STDERR) {
+            return this.blockingWriteAndFlush(buf);
+        }
+        return streamIoErrorCall(OUTPUT_STREAM_WRITE | this.#streamType, this.#id, buf);
+    }
+    blockingWriteAndFlush(buf) {
+        if (this.#streamType <= STDERR) {
+            const stream = this.#streamType === STDERR ? stderr : stdout;
+            return void stream.write(buf);
+        }
+        return streamIoErrorCall(OUTPUT_STREAM_BLOCKING_WRITE_AND_FLUSH | this.#streamType, this.#id, buf);
+    }
+    flush() {
+        return streamIoErrorCall(OUTPUT_STREAM_FLUSH | this.#streamType, this.#id, undefined);
+    }
+    blockingFlush() {
+        return streamIoErrorCall(OUTPUT_STREAM_BLOCKING_FLUSH | this.#streamType, this.#id, undefined);
+    }
+    writeZeroes(len) {
+        return streamIoErrorCall(OUTPUT_STREAM_WRITE_ZEROES | this.#streamType, this.#id, len);
+    }
+    blockingWriteZeroesAndFlush(len) {
+        return streamIoErrorCall(OUTPUT_STREAM_BLOCKING_WRITE_ZEROES_AND_FLUSH | this.#streamType, this.#id, len);
+    }
+    splice(src, len) {
+        return streamIoErrorCall(OUTPUT_STREAM_SPLICE | this.#streamType, this.#id, {
+            src: src.#id,
+            len,
+        });
+    }
+    blockingSplice(src, len) {
+        return streamIoErrorCall(OUTPUT_STREAM_BLOCKING_SPLICE | this.#streamType, this.#id, {
+            src: inputStreamId(src),
+            len,
+        });
+    }
+    subscribe() {
+        return pollableCreate(ioCall(OUTPUT_STREAM_SUBSCRIBE | this.#streamType, this.#id), undefined);
+    }
+    static _id(outputStream) {
+        return outputStream.#id;
+    }
+    /**
+     * @param {OutputStreamType} streamType
+     * @param {any} createPayload
+     */
+    static _create(streamType, id) {
+        const stream = new OutputStream();
+        stream.#id = id;
+        stream.#streamType = streamType;
+        let disposeFn;
+        switch (streamType) {
+            case STDOUT:
+                disposeFn = stdoutOutputStreamDispose;
+                break;
+            case STDERR:
+                disposeFn = stderrOutputStreamDispose;
+                break;
+            case SOCKET_TCP:
+                disposeFn = socketTcpOutputStreamDispose;
+                break;
+            case FILE:
+                disposeFn = fileOutputStreamDispose;
+                break;
+            case HTTP:
+                return stream;
+            default:
+                throw new Error("wasi-io trap: Dispose function not created for stream type " +
+                    reverseMap[streamType]);
+        }
+        stream.#finalizer = registerDispose(stream, null, id, disposeFn);
+        return stream;
+    }
+    [symbolDispose]() {
+        if (this.#finalizer) {
+            earlyDispose(this.#finalizer);
+            this.#finalizer = null;
+        }
+    }
+}
+function stdoutOutputStreamDispose(id) {
+    ioCall(OUTPUT_STREAM_DISPOSE | STDOUT, id);
+}
+function stderrOutputStreamDispose(id) {
+    ioCall(OUTPUT_STREAM_DISPOSE | STDERR, id);
+}
+function socketTcpOutputStreamDispose(id) {
+    ioCall(OUTPUT_STREAM_DISPOSE | SOCKET_TCP, id);
+}
+function fileOutputStreamDispose(id) {
+    ioCall(OUTPUT_STREAM_DISPOSE | FILE, id);
+}
+export const outputStreamCreate = OutputStream._create;
+// @ts-expect-error - Deleting static method
+delete OutputStream._create;
+export const outputStreamId = OutputStream._id;
+// @ts-expect-error - Deleting static method
+delete OutputStream._id;
+export const error = { Error: IoError };
+export const streams = { InputStream, OutputStream };
+function pollableDispose(id) {
+    ioCall(POLL_POLLABLE_DISPOSE, id);
+}
+const rep = Symbol.for("cabiRep");
+class Pollable {
+    #finalizer;
+    ready() {
+        return ioCall(POLL_POLLABLE_READY, this[rep]);
+    }
+    block() {
+        ioCall(POLL_POLLABLE_BLOCK, this[rep]);
+    }
+    static _create(id, parent) {
+        const pollable = new Pollable();
+        pollable[rep] = id;
+        pollable.#finalizer = registerDispose(pollable, parent, id, pollableDispose);
+        return pollable;
+    }
+    [symbolDispose]() {
+        if (this.#finalizer && this[rep]) {
+            earlyDispose(this.#finalizer);
+            this.#finalizer = null;
+        }
+    }
+}
+const cabiLowerSymbol = Symbol.for("cabiLower");
+const T_FLAG = 1 << 30;
+Pollable.prototype.ready[cabiLowerSymbol] = function ({ resourceTables: [table] }) {
+    return function pollableReady(handle) {
+        const rep = table[(handle << 1) + 1] & ~T_FLAG;
+        const ready = ioCall(POLL_POLLABLE_READY, rep);
+        return ready ? 1 : 0;
+    };
+};
+Pollable.prototype.block[cabiLowerSymbol] = function ({ resourceTables: [table] }) {
+    return function pollableBlock(handle) {
+        const rep = table[(handle << 1) + 1] & ~T_FLAG;
+        ioCall(POLL_POLLABLE_BLOCK, rep);
+    };
+};
+Pollable[Symbol.for("cabiDispose")] = function pollableDispose(rep) {
+    ioCall(POLL_POLLABLE_DISPOSE, rep);
+};
+export const pollableCreate = Pollable._create;
+// @ts-expect-error - Deleting static method
+delete Pollable._create;
+export const poll = {
+    Pollable,
+    poll(list) {
+        return ioCall(POLL_POLL_LIST, null, list.map((pollable) => pollable[rep]));
+    },
+};
+poll.poll[cabiLowerSymbol] = function ({ memory, realloc, resourceTables: [table] }) {
+    return function pollPollList(listPtr, len, retptr) {
+        const handleList = new Uint32Array(memory.buffer, listPtr, len);
+        const repList = Array(len);
+        for (let i = 0; i < len; i++) {
+            const handle = handleList[i];
+            repList[i] = table[(handle << 1) + 1] & ~T_FLAG;
+        }
+        const result = ioCall(POLL_POLL_LIST, null, repList);
+        const ptr = realloc(0, 0, 4, result.byteLength);
+        const out = new Uint32Array(memory.buffer, ptr, result.length);
+        out.set(result);
+        const ret = new Uint32Array(memory.buffer, retptr, 2);
+        ret[0] = ptr;
+        ret[1] = result.length;
+        return retptr;
+    };
+};
+export function createPoll(call, id, initPayload) {
+    return pollableCreate(ioCall(call, id, initPayload), undefined);
+}
+export function createPollLower(call, id, table) {
+    return function (initPayload) {
+        const rep = ioCall(call, id, initPayload);
+        const free = table[0] & ~T_FLAG;
+        if (free === 0) {
+            table.push(0);
+            table.push(rep | T_FLAG);
+            return (table.length >> 1) - 1;
+        }
+        table[0] = table[free << 1];
+        table[free << 1] = 0;
+        table[(free << 1) + 1] = rep | T_FLAG;
+        return free;
+    };
+}

package/dist/io/worker-socket-tcp.d.ts

@@ -0,0 +1,34 @@
+import { PollState } from "./worker-thread.js";
+import { Socket as TcpSocket } from "node:net";
+import { IpSocketAddress } from "../../types/interfaces/wasi-sockets-network.js";
+interface PendingAccept {
+    tcpSocket: TcpSocket | null;
+    err: Error | null;
+    pollState: PollState | null;
+}
+interface TcpSocketRecord {
+    state: number;
+    future: number | null;
+    tcpSocket: TcpSocket | null;
+    listenBacklogSize: number;
+    handle: TCP;
+    pendingAccepts: PendingAccept[];
+    pollState: PollState | null;
+}
+export declare const tcpSockets: Map<number, TcpSocketRecord>;
+export declare function createTcpSocket(): number;
+export declare function socketTcpFinish(id: number, fromState: any, toState: any): any;
+export declare function socketTcpBindStart(id: number, localAddress: any, family: any): void;
+export declare function socketTcpConnectStart(id: number, remoteAddress: IpSocketAddress, family: any): void;
+export declare function socketTcpListenStart(id: number): void;
+export declare function socketTcpAccept(id: number): number[];
+export declare function socketTcpSetListenBacklogSize(id: number, backlogSize: any): void;
+export declare function socketTcpGetLocalAddress(id: number): IpSocketAddress;
+export declare function socketTcpGetRemoteAddress(id: number): IpSocketAddress;
+export declare function socketTcpShutdown(id: number, _shutdownType: any): void;
+export declare function socketTcpSetKeepAlive(id: number, { keepAlive, keepAliveIdleTime }: {
+    keepAlive: any;
+    keepAliveIdleTime: any;
+}): void;
+export declare function socketTcpDispose(id: number): void;
+export {};