@bytecodealliance/preview3-shim 0.1.1 → 0.2.0

package/dist/nodejs/cli.d.ts

@@ -0,0 +1,51 @@
+import { StreamReader } from "./stream.js";
+import * as cliV2 from "@bytecodealliance/preview2-shim/cli";
+export declare const _appendEnv: (env: Record<string, string>) => void, _setEnv: typeof cliV2._setEnv, _setArgs: typeof cliV2._setArgs, _setCwd: typeof cliV2._setCwd, _setTerminalStdin: (terminalStdin: unknown) => void, _setTerminalStdout: (terminalStdout: unknown) => void, _setTerminalStderr: (terminalStderr: unknown) => void, exit: typeof import("@bytecodealliance/preview2-shim/interfaces/wasi-cli-exit"), terminalInput: typeof import("@bytecodealliance/preview2-shim/interfaces/wasi-cli-terminal-input"), terminalOutput: typeof import("@bytecodealliance/preview2-shim/interfaces/wasi-cli-terminal-output"), terminalStdin: typeof import("@bytecodealliance/preview2-shim/interfaces/wasi-cli-terminal-stdin"), terminalStdout: typeof import("@bytecodealliance/preview2-shim/interfaces/wasi-cli-terminal-stdout"), terminalStderr: typeof import("@bytecodealliance/preview2-shim/interfaces/wasi-cli-terminal-stderr");
+export declare const environment: {
+    getEnvironment: typeof import("@bytecodealliance/preview2-shim/interfaces/wasi-cli-environment").getEnvironment;
+    getArguments: typeof import("@bytecodealliance/preview2-shim/interfaces/wasi-cli-environment").getArguments;
+    getInitialCwd: typeof import("@bytecodealliance/preview2-shim/interfaces/wasi-cli-environment").initialCwd;
+};
+export declare const stdin: {
+    /**
+     * Return a stream for reading from stdin, and a future to signal read results.
+     *
+     * WIT:
+     * ```
+     * read-via-stream: func() -> tuple<stream<u8>, future<result<_, error-code>>>;
+     * ```
+     *
+     * @returns {[StreamReader, FutureReader]} A tuple of [stream, future].
+     */
+    readViaStream(): (StreamReader | import("./future.js").FutureReader)[];
+};
+export declare const stdout: {
+    /**
+     * Write the given stream to stdout.
+     *
+     * WIT:
+     * ```
+     * write-via-stream: func(data: stream<u8>) -> future<result<_, error-code>>;
+     * ```
+     * @returns {Promise<{tag: string, val?: string}>} Result of the write operation.
+     */
+    writeViaStream(streamReader: any): Promise<{
+        tag: string;
+        val: string;
+    }>;
+};
+export declare const stderr: {
+    /**
+     * Write the given stream to stderr.
+     *
+     * WIT:
+     * ```
+     * write-via-stream: func(data: stream<u8>) -> future<result<_, error-code>>;
+     * ```
+     * @returns {Promise<{tag: string, val?: string}>} Result of the write operation.
+     */
+    writeViaStream(streamReader: any): Promise<{
+        tag: string;
+        val: string;
+    }>;
+};

package/dist/nodejs/cli.js

@@ -0,0 +1,106 @@
+import process from "node:process";
+import { Readable } from "node:stream";
+import { ResourceWorker } from "./workers/resource-worker.js";
+import { StreamReader, readableByteStreamFromReader } from "./stream.js";
+import { future } from "./future.js";
+import * as cliV2 from "@bytecodealliance/preview2-shim/cli";
+const nodeCliV2 = cliV2;
+export const { _appendEnv, _setEnv, _setArgs, _setCwd, _setTerminalStdin, _setTerminalStdout, _setTerminalStderr, exit, terminalInput, terminalOutput, terminalStdin, terminalStdout, terminalStderr, } = nodeCliV2;
+// `wasi:cli/environment` renamed `initial-cwd` to `get-initial-cwd` between
+// p2 and p3. Adapt the p2-shim shape to the p3 WIT member name while
+// re-exporting the unchanged members.
+export const environment = {
+    getEnvironment: cliV2.environment.getEnvironment,
+    getArguments: cliV2.environment.getArguments,
+    getInitialCwd: cliV2.environment.initialCwd,
+};
+let WORKER = null;
+function worker() {
+    return (WORKER ??= new ResourceWorker(new URL("./workers/cli-worker.js", import.meta.url)));
+}
+/**
+ * Map a Node.js error to a WIT error-code enum value.
+ * WIT: enum error-code { io, illegal-byte-sequence, pipe }
+ * @param {Error} err
+ * @returns {string}
+ */
+function errorCode(err) {
+    if (err?.code === "EPIPE" || err?.code === "ERR_STREAM_PREMATURE_CLOSE") {
+        return "pipe";
+    }
+    if (err?.code === "ERR_ENCODING_INVALID_ENCODED_DATA") {
+        return "illegal-byte-sequence";
+    }
+    return "io";
+}
+export const stdin = {
+    /**
+     * Return a stream for reading from stdin, and a future to signal read results.
+     *
+     * WIT:
+     * ```
+     * read-via-stream: func() -> tuple<stream<u8>, future<result<_, error-code>>>;
+     * ```
+     *
+     * @returns {[StreamReader, FutureReader]} A tuple of [stream, future].
+     */
+    readViaStream() {
+        const readable = Readable.toWeb(process.stdin);
+        const { tx: futureTx, rx: futureRx } = future();
+        async function* stdinChunks() {
+            try {
+                for await (const chunk of readable.values({ preventCancel: true })) {
+                    yield chunk;
+                }
+                await futureTx.write({ tag: "ok", val: undefined });
+            }
+            catch (err) {
+                await futureTx.write({ tag: "err", val: errorCode(err) });
+                throw err;
+            }
+        }
+        return [new StreamReader(stdinChunks()), futureRx];
+    },
+};
+export const stdout = {
+    /**
+     * Write the given stream to stdout.
+     *
+     * WIT:
+     * ```
+     * write-via-stream: func(data: stream<u8>) -> future<result<_, error-code>>;
+     * ```
+     * @returns {Promise<{tag: string, val?: string}>} Result of the write operation.
+     */
+    async writeViaStream(streamReader) {
+        const readableStream = readableByteStreamFromReader(streamReader, { name: "stdout stream" });
+        try {
+            await worker().run({ op: "stdout", stream: readableStream }, [readableStream]);
+            return { tag: "ok", val: undefined };
+        }
+        catch (err) {
+            return { tag: "err", val: errorCode(err) };
+        }
+    },
+};
+export const stderr = {
+    /**
+     * Write the given stream to stderr.
+     *
+     * WIT:
+     * ```
+     * write-via-stream: func(data: stream<u8>) -> future<result<_, error-code>>;
+     * ```
+     * @returns {Promise<{tag: string, val?: string}>} Result of the write operation.
+     */
+    async writeViaStream(streamReader) {
+        const readableStream = readableByteStreamFromReader(streamReader, { name: "stderr stream" });
+        try {
+            await worker().run({ op: "stderr", stream: readableStream }, [readableStream]);
+            return { tag: "ok", val: undefined };
+        }
+        catch (err) {
+            return { tag: "err", val: errorCode(err) };
+        }
+    },
+};

package/dist/nodejs/clocks.d.ts

@@ -0,0 +1,55 @@
+export declare const systemClock: {
+    now: typeof import("@bytecodealliance/preview2-shim/interfaces/wasi-clocks-wall-clock").now;
+    /**
+     * Query the resolution of the clock.
+     *
+     * WIT:
+     * ```
+     * get-resolution: func() -> duration;
+     * ```
+     *
+     * @returns {bigint} The smallest distinguishable duration in nanoseconds.
+     */
+    getResolution(): bigint;
+};
+export declare const monotonicClock: {
+    /**
+     * Query the resolution of the clock.
+     *
+     * WIT:
+     * ```
+     * get-resolution: func() -> duration;
+     * ```
+     *
+     * @returns {bigint} Duration of a clock tick in nanoseconds.
+     */
+    getResolution(): bigint;
+    /**
+     * Waits until a specific mark (in nanoseconds) is reached
+     *
+     * WIT:
+     * ```
+     * wait-until: async func(when: mark);
+     * ```
+     * @async
+     * @param {bigint} targetNs - The target mark in nanoseconds to wait until
+     * @returns {Promise<void>} A promise that resolves when the target mark is reached
+     * @throws {TypeError} If targetNs is not a bigint
+     */
+    waitUntil(targetNs: any): Promise<void>;
+    /**
+     * Waits for a specified duration in nanoseconds
+     *
+     * WIT:
+     * ```
+     * wait-for: async func(how-long: duration);
+     * ```
+     * @async
+     * @param {bigint} durationNs - The duration to wait in nanoseconds
+     * @returns {Promise<void>} A promise that resolves after the specified duration
+     * @throws {TypeError} If durationNs is not a bigint
+     */
+    waitFor(durationNs: any): Promise<void>;
+    now(): import("@bytecodealliance/preview2-shim/interfaces/wasi-clocks-monotonic-clock").Instant;
+    resolution(): import("@bytecodealliance/preview2-shim/interfaces/wasi-clocks-monotonic-clock").Duration;
+};

package/dist/nodejs/clocks.js

@@ -0,0 +1,83 @@
+import { wallClock, monotonicClock as monotonicClockV2, } from "@bytecodealliance/preview2-shim/clocks";
+// Re-export wall-clock as system-clock per latest WASI 0.3.0-draft.
+export const systemClock = {
+    now: wallClock.now,
+    /**
+     * Query the resolution of the clock.
+     *
+     * WIT:
+     * ```
+     * get-resolution: func() -> duration;
+     * ```
+     *
+     * @returns {bigint} The smallest distinguishable duration in nanoseconds.
+     */
+    getResolution() {
+        const dt = wallClock.resolution();
+        return BigInt(dt.seconds) * 1000000000n + BigInt(dt.nanoseconds);
+    },
+};
+// eslint-disable-next-line no-unused-vars
+const { subscribeInstant, subscribeDuration, ...baseMonotonicClock } = monotonicClockV2;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const nsToTimeoutMs = (ns) => (ns + 999999n) / 1000000n;
+export const monotonicClock = {
+    ...baseMonotonicClock,
+    /**
+     * Query the resolution of the clock.
+     *
+     * WIT:
+     * ```
+     * get-resolution: func() -> duration;
+     * ```
+     *
+     * @returns {bigint} Duration of a clock tick in nanoseconds.
+     */
+    getResolution() {
+        return baseMonotonicClock.resolution();
+    },
+    /**
+     * Waits until a specific mark (in nanoseconds) is reached
+     *
+     * WIT:
+     * ```
+     * wait-until: async func(when: mark);
+     * ```
+     * @async
+     * @param {bigint} targetNs - The target mark in nanoseconds to wait until
+     * @returns {Promise<void>} A promise that resolves when the target mark is reached
+     * @throws {TypeError} If targetNs is not a bigint
+     */
+    async waitUntil(targetNs) {
+        while (true) {
+            const nowNs = monotonicClock.now();
+            const diffNs = targetNs - nowNs;
+            if (diffNs <= 0n) {
+                return;
+            }
+            const ms = nsToTimeoutMs(diffNs);
+            if (ms > BigInt(Number.MAX_SAFE_INTEGER)) {
+                throw new TypeError(`Cannot wait for ${targetNs} ns, exceeds maximum safe integer`);
+            }
+            await sleep(Number(ms));
+        }
+    },
+    /**
+     * Waits for a specified duration in nanoseconds
+     *
+     * WIT:
+     * ```
+     * wait-for: async func(how-long: duration);
+     * ```
+     * @async
+     * @param {bigint} durationNs - The duration to wait in nanoseconds
+     * @returns {Promise<void>} A promise that resolves after the specified duration
+     * @throws {TypeError} If durationNs is not a bigint
+     */
+    async waitFor(durationNs) {
+        if (durationNs <= 0n) {
+            return;
+        }
+        await monotonicClock.waitUntil(monotonicClock.now() + durationNs);
+    },
+};