@bytecodealliance/preview2-shim 0.18.1 → 0.20.0

package/dist/nodejs/cli.d.ts

@@ -0,0 +1,30 @@
+import type { exit as ExitNamespace, stderr as StderrNamespace, stdin as StdinNamespace, stdout as StdoutNamespace, terminalInput as TerminalInputNamespace, terminalOutput as TerminalOutputNamespace, terminalStderr as TerminalStderrNamespace, terminalStdin as TerminalStdinNamespace, terminalStdout as TerminalStdoutNamespace } from "../../types/cli.js";
+export declare const _appendEnv: (env: Record<string, string>) => void;
+export declare const _setEnv: (env: Record<string, string>) => undefined;
+export declare const _setArgs: (args: string[]) => undefined;
+export declare const _setCwd: (cwd: string) => undefined;
+export declare const _setStdin: (stdin: any) => undefined;
+export declare const _setStdout: (stdout: any) => undefined;
+export declare const _setStderr: (stderr: any) => undefined;
+export declare const _setTerminalStdin: (terminalStdin: TerminalInput) => undefined;
+export declare const _setTerminalStdout: (terminalStdout: TerminalOutput) => undefined;
+export declare const _setTerminalStderr: (terminalStderr: TerminalOutput) => undefined;
+export declare const environment: {
+    getEnvironment(): [string, string | undefined][];
+    getArguments(): string[];
+    initialCwd(): string;
+};
+export declare const exit: typeof ExitNamespace;
+export declare const stdin: typeof StdinNamespace;
+export declare const stdout: typeof StdoutNamespace;
+export declare const stderr: typeof StderrNamespace;
+declare class TerminalInput {
+}
+declare class TerminalOutput {
+}
+export declare const terminalInput: typeof TerminalInputNamespace;
+export declare const terminalOutput: typeof TerminalOutputNamespace;
+export declare const terminalStdin: typeof TerminalStdinNamespace;
+export declare const terminalStdout: typeof TerminalStdoutNamespace;
+export declare const terminalStderr: typeof TerminalStderrNamespace;
+export {};

package/dist/nodejs/cli.js

@@ -0,0 +1,86 @@
+import process, { argv, env, cwd } from "node:process";
+import { ioCall, inputStreamCreate, outputStreamCreate } from "../io/worker-io.js";
+import { INPUT_STREAM_CREATE, STDERR, STDIN, STDOUT } from "../io/calls.js";
+export const _appendEnv = (env) => {
+    void (_env = [..._env.filter(([curKey]) => !(curKey in env)), ...Object.entries(env)]);
+};
+export const _setEnv = (env) => void (_env = Object.entries(env));
+export const _setArgs = (args) => void (_args = args);
+export const _setCwd = (cwd) => void (_cwd = cwd);
+export const _setStdin = (stdin) => void (stdinStream = stdin);
+export const _setStdout = (stdout) => void (stdoutStream = stdout);
+export const _setStderr = (stderr) => void (stderrStream = stderr);
+export const _setTerminalStdin = (terminalStdin) => void (terminalStdinInstance = terminalStdin);
+export const _setTerminalStdout = (terminalStdout) => void (terminalStdoutInstance = terminalStdout);
+export const _setTerminalStderr = (terminalStderr) => void (terminalStderrInstance = terminalStderr);
+let _env = Object.entries(env), _args = argv.slice(1), _cwd = cwd();
+export const environment = {
+    getEnvironment() {
+        return _env;
+    },
+    getArguments() {
+        return _args;
+    },
+    initialCwd() {
+        return _cwd;
+    },
+};
+export const exit = {
+    exit(status) {
+        process.exit(status.tag === "err" ? 1 : 0);
+    },
+    // @ts-expect-error - Available only wasi-cli v0.2.12
+    exitWithCode(code) {
+        process.exit(code);
+    },
+};
+// Stdin is created as a FILE descriptor
+let stdinStream;
+let stdoutStream = outputStreamCreate(STDOUT, 1);
+let stderrStream = outputStreamCreate(STDERR, 2);
+export const stdin = {
+    getStdin() {
+        if (!stdinStream) {
+            stdinStream = inputStreamCreate(STDIN, ioCall(INPUT_STREAM_CREATE | STDIN, null, null));
+        }
+        return stdinStream;
+    },
+};
+export const stdout = {
+    getStdout() {
+        return stdoutStream;
+    },
+};
+export const stderr = {
+    getStderr() {
+        return stderrStream;
+    },
+};
+class TerminalInput {
+}
+class TerminalOutput {
+}
+let terminalStdoutInstance = new TerminalOutput();
+let terminalStderrInstance = new TerminalOutput();
+let terminalStdinInstance = new TerminalInput();
+export const terminalInput = {
+    TerminalInput,
+};
+export const terminalOutput = {
+    TerminalOutput,
+};
+export const terminalStdin = {
+    getTerminalStdin() {
+        return terminalStdinInstance;
+    },
+};
+export const terminalStdout = {
+    getTerminalStdout() {
+        return terminalStdoutInstance;
+    },
+};
+export const terminalStderr = {
+    getTerminalStderr() {
+        return terminalStderrInstance;
+    },
+};

package/dist/nodejs/clocks.d.ts

@@ -0,0 +1,3 @@
+import type { monotonicClock as MonotonicClockNamespace, wallClock as WallClockNamespace } from "../../types/clocks.js";
+export declare const monotonicClock: typeof MonotonicClockNamespace;
+export declare const wallClock: typeof WallClockNamespace;

package/dist/nodejs/clocks.js

@@ -0,0 +1,61 @@
+import { createPoll } from "../io/worker-io.js";
+import { CLOCKS_INSTANT_SUBSCRIBE, CLOCKS_DURATION_SUBSCRIBE } from "../io/calls.js";
+import { hrtime } from "node:process";
+const symbolCabiLower = Symbol.for("cabiLower");
+function resolution() {
+    return 1n;
+}
+export const monotonicClock = {
+    resolution,
+    now() {
+        return hrtime.bigint();
+    },
+    subscribeInstant(instant) {
+        return createPoll(CLOCKS_INSTANT_SUBSCRIBE, null, instant);
+    },
+    subscribeDuration(duration) {
+        duration = BigInt(duration);
+        return createPoll(CLOCKS_DURATION_SUBSCRIBE, null, duration);
+    },
+};
+export const wallClock = {
+    resolution() {
+        return { seconds: 0n, nanoseconds: 1e6 };
+    },
+    now() {
+        const seconds = BigInt(Math.floor(Date.now() / 1e3));
+        const nanoseconds = (Date.now() % 1e3) * 1e6;
+        return { seconds, nanoseconds };
+    },
+};
+monotonicClock.resolution[symbolCabiLower] = () => resolution;
+monotonicClock.now[symbolCabiLower] = () => hrtime.bigint;
+wallClock.resolution[symbolCabiLower] = ({ memory }) => {
+    let buf32 = new Int32Array(memory.buffer);
+    return function now(retptr) {
+        if (memory.buffer !== buf32.buffer) {
+            buf32 = new Int32Array(memory.buffer);
+        }
+        if (retptr % 4) {
+            throw new Error("wasi-io trap: retptr not aligned");
+        }
+        buf32[(retptr >> 2) + 0] = 0;
+        buf32[(retptr >> 2) + 4] = 0;
+        buf32[(retptr >> 2) + 8] = 1_000_000;
+    };
+};
+wallClock.now[symbolCabiLower] = ({ memory }) => {
+    let buf32 = new Int32Array(memory.buffer);
+    let buf64 = new BigInt64Array(memory.buffer);
+    return function now(retptr) {
+        if (memory.buffer !== buf32.buffer) {
+            buf32 = new Int32Array(memory.buffer);
+            buf64 = new BigInt64Array(memory.buffer);
+        }
+        if (retptr % 4) {
+            throw new Error("wasi-io trap: retptr not aligned");
+        }
+        buf64[(retptr >> 2) + 0] = BigInt(Math.floor(Date.now() / 1e3));
+        buf32[(retptr >> 2) + 8] = (Date.now() % 1e3) * 1e6;
+    };
+};

package/dist/nodejs/filesystem.d.ts

@@ -0,0 +1,113 @@
+import { types as TypesNamespace, preopens as PreopensNamespace } from "../../types/filesystem.js";
+import type { Descriptor as IDescriptor, DirectoryEntryStream as IDirectoryEntryStream } from "../../types/interfaces/wasi-filesystem-types.js";
+declare const symbolDispose: symbol;
+/**
+ * @implements {DescriptorProps}
+ */
+declare class Descriptor implements IDescriptor {
+    #private;
+    [symbolDispose]: () => void;
+    private _id;
+    static _createPreopen(hostPreopen: any): Descriptor;
+    static _create(fd: any, mode: any, fullPath: any): Descriptor;
+    readViaStream(offset: any): any;
+    writeViaStream(offset: any): any;
+    appendViaStream(): any;
+    advise(_offset: any, _length: any, _advice: any): void;
+    syncData(): void;
+    getFlags(): any;
+    getType(): TypesNamespace.DescriptorType;
+    setSize(size: any): void;
+    setTimes(dataAccessTimestamp: any, dataModificationTimestamp: any): void;
+    read(length: any, offset: any): [Uint8Array, boolean];
+    write(buffer: any, offset: any): bigint;
+    readDirectory(): IDirectoryEntryStream;
+    sync(): void;
+    createDirectoryAt(path: any): void;
+    stat(): {
+        type: TypesNamespace.DescriptorType;
+        linkCount: any;
+        size: any;
+        dataAccessTimestamp: {
+            seconds: bigint;
+            nanoseconds: number;
+        };
+        dataModificationTimestamp: {
+            seconds: bigint;
+            nanoseconds: number;
+        };
+        statusChangeTimestamp: {
+            seconds: bigint;
+            nanoseconds: number;
+        };
+    };
+    statAt(pathFlags: any, path: any): {
+        type: TypesNamespace.DescriptorType;
+        linkCount: any;
+        size: any;
+        dataAccessTimestamp: {
+            seconds: bigint;
+            nanoseconds: number;
+        };
+        dataModificationTimestamp: {
+            seconds: bigint;
+            nanoseconds: number;
+        };
+        statusChangeTimestamp: {
+            seconds: bigint;
+            nanoseconds: number;
+        };
+    };
+    setTimesAt(pathFlags: any, path: any, dataAccessTimestamp: any, dataModificationTimestamp: any): void;
+    linkAt(oldPathFlags: any, oldPath: any, newDescriptor: any, newPath: any): void;
+    openAt(pathFlags: any, path: any, openFlags: any, descriptorFlags: any): Descriptor;
+    readlinkAt(path: any): string;
+    removeDirectoryAt(path: any): void;
+    renameAt(oldPath: any, newDescriptor: any, newPath: any): void;
+    symlinkAt(target: any, path: any): void;
+    unlinkFileAt(path: any): void;
+    isSameObject(other: any): boolean;
+    metadataHash(): {
+        upper: bigint;
+        lower: bigint;
+    };
+    metadataHashAt(pathFlags: any, path: any): {
+        upper: bigint;
+        lower: bigint;
+    };
+}
+export declare const preopens: typeof PreopensNamespace;
+export declare const types: typeof TypesNamespace;
+/**
+ * Replace all preopens with the given set.
+ * @param {Record<string, string>} preopens - Map of virtual paths to host paths
+ */
+export declare function _setPreopens(preopens: any): void;
+/**
+ * Add a single preopen mapping.
+ * @param {string} virtualPath - The virtual path visible to the guest
+ * @param {string} hostPreopen - The host filesystem path
+ */
+export declare function _addPreopen(virtualPath: any, hostPreopen: any): void;
+/**
+ * Clear all preopens, giving the guest no filesystem access.
+ * Call this immediately after import to disable default full filesystem access.
+ *
+ * @example
+ * import { _clearPreopens } from '@bytecodealliance/preview2-shim/filesystem';
+ * _clearPreopens(); // Now guest has no filesystem access by default
+ */
+export declare function _clearPreopens(): void;
+/**
+ * Get current preopens configuration.
+ * @returns {Array<[Descriptor, string]>} Array of [descriptor, virtualPath] pairs
+ */
+export declare function _getPreopens(): [Descriptor, string][];
+/**
+ * Create a preopen descriptor for a host path.
+ * This is used internally to create isolated preopen instances.
+ * @param  hostPreopen - The host filesystem path
+ * @returns A preopen descriptor
+ */
+export declare function _createPreopenDescriptor(hostPreopen: string): Descriptor;
+export {};