@bytecodealliance/preview2-shim 0.18.1 → 0.20.0

package/README.md

@@ -15,8 +15,8 @@ An default instantiation object can be used via the `WASIShim` class in `@byteco
 ```typescript
 import { WASIShim } from "@bytecodealliance/preview2-shim/instantiation";
 import type {
-  VersionedWASIImportObject,
-  WASIImportObject,
+    VersionedWASIImportObject,
+    WASIImportObject,
 } from "@bytecodealliance/preview2-shim/instantiation";
 
 const shim = new WASIShim();
@@ -27,7 +27,7 @@ unversioned satisfies WASIImportObject;
 unversioned satisfies VersionedWASIImportObject<"">;
 
 const versioned: VersionedWASIImportObject<"0.2.3"> = shim.getImportObject({
-  asVersion: "0.2.3",
+    asVersion: "0.2.3",
 });
 //console.log('versioned', versioned);
 versioned satisfies VersionedWASIImportObject<"0.2.3">;
@@ -66,23 +66,23 @@ import { WASIShim } from "@bytecodealliance/preview2-shim/instantiation";
 
 // Fully sandboxed - no filesystem, network, or env access
 const sandboxedShim = new WASIShim({
-  sandbox: {
-    preopens: {}, // No filesystem access
-    env: {}, // No environment variables
-    args: ["arg1"], // Custom arguments
-    enableNetwork: false, // Disable network access
-  },
+    sandbox: {
+        preopens: {}, // No filesystem access
+        env: {}, // No environment variables
+        args: ["arg1"], // Custom arguments
+        enableNetwork: false, // Disable network access
+    },
 });
 
 // Limited filesystem access - map virtual paths to host paths
 const limitedShim = new WASIShim({
-  sandbox: {
-    preopens: {
-      "/data": "/tmp/guest-data", // Guest sees /data, maps to /tmp/guest-data
-      "/config": "/etc/app", // Guest sees /config, maps to /etc/app
+    sandbox: {
+        preopens: {
+            "/data": "/tmp/guest-data", // Guest sees /data, maps to /tmp/guest-data
+            "/config": "/etc/app", // Guest sees /config, maps to /etc/app
+        },
+        env: { ENV1: "42" }, // Only expose specific env vars
     },
-    env: { ENV1: "42" }, // Only expose specific env vars
-  },
 });
 
 const component = await instantiate(loader, sandboxedShim.getImportObject());

package/dist/browser/cli.d.ts

@@ -0,0 +1,16 @@
+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";
+import { type InputStreamHandler, type OutputStreamHandler } from "./io.js";
+export { _setEnv, _setArgs, environment } from "./environment.js";
+export { _setCwd } from "./config.js";
+export declare const exit: typeof ExitNamespace;
+export declare function _setStdin(handler: InputStreamHandler): void;
+export declare function _setStderr(handler: OutputStreamHandler): void;
+export declare function _setStdout(handler: OutputStreamHandler): void;
+export declare const stdin: typeof StdinNamespace;
+export declare const stdout: typeof StdoutNamespace;
+export declare const stderr: typeof StderrNamespace;
+export declare const terminalInput: typeof TerminalInputNamespace;
+export declare const terminalOutput: typeof TerminalOutputNamespace;
+export declare const terminalStderr: typeof TerminalStderrNamespace;
+export declare const terminalStdin: typeof TerminalStdinNamespace;
+export declare const terminalStdout: typeof TerminalStdoutNamespace;

package/dist/browser/cli.js

@@ -0,0 +1,109 @@
+import { inputStreamCreate, outputStreamCreate, pollableCreate, } from "./io.js";
+export { _setEnv, _setArgs, environment } from "./environment.js";
+export { _setCwd } from "./config.js";
+const symbolDispose = Symbol.dispose ?? Symbol.for("dispose");
+class ComponentExit extends Error {
+    exitError = true;
+    code;
+    constructor(code) {
+        super(`Component exited ${code === 0 ? "successfully" : "with error"}`);
+        this.code = code;
+    }
+}
+export const exit = {
+    exit(status) {
+        throw new ComponentExit(status.tag === "err" ? 1 : 0);
+    },
+    // @ts-expect-error - Available only wasi-cli v0.2.12
+    exitWithCode(code) {
+        throw new ComponentExit(code);
+    },
+};
+export function _setStdin(handler) {
+    stdinStream.handler = handler;
+}
+export function _setStderr(handler) {
+    stderrStream.handler = handler;
+}
+export function _setStdout(handler) {
+    stdoutStream.handler = handler;
+}
+const stdinStream = inputStreamCreate({
+    blockingRead(_len) {
+        // TODO
+        return new Uint8Array(0);
+    },
+    subscribe() {
+        // TODO
+        return pollableCreate();
+    },
+    [symbolDispose]() {
+        // TODO
+    },
+});
+const textDecoder = new TextDecoder();
+const stdoutStream = outputStreamCreate({
+    write(contents) {
+        if (contents.at(-1) == 10) {
+            // console.log already appends a new line
+            contents = contents.subarray(0, -1);
+        }
+        console.log(textDecoder.decode(contents));
+    },
+    blockingFlush() { },
+    [symbolDispose]() { },
+});
+const stderrStream = outputStreamCreate({
+    write(contents) {
+        if (contents.at(-1) == 10) {
+            // console.error already appends a new line
+            contents = contents.subarray(0, -1);
+        }
+        console.error(textDecoder.decode(contents));
+    },
+    blockingFlush() { },
+    [symbolDispose]() { },
+});
+export const stdin = {
+    getStdin() {
+        return stdinStream;
+    },
+};
+export const stdout = {
+    getStdout() {
+        return stdoutStream;
+    },
+};
+export const stderr = {
+    getStderr() {
+        return stderrStream;
+    },
+};
+class TerminalInput {
+}
+class TerminalOutput {
+}
+const terminalStdoutInstance = new TerminalOutput();
+const terminalStderrInstance = new TerminalOutput();
+const terminalStdinInstance = new TerminalInput();
+export const terminalInput = {
+    TerminalInput,
+};
+export const terminalOutput = {
+    TerminalOutput,
+};
+export const terminalStderr = {
+    getTerminalStderr() {
+        return terminalStderrInstance;
+    },
+};
+export const terminalStdin = {
+    getTerminalStdin() {
+        return terminalStdinInstance;
+    },
+};
+export const terminalStdout = {
+    getTerminalStdout() {
+        return terminalStdoutInstance;
+    },
+};

package/dist/browser/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/browser/clocks.js

@@ -0,0 +1,36 @@
+import { pollableCreate } from "./io.js";
+export const monotonicClock = {
+    resolution() {
+        // usually we dont get sub-millisecond accuracy in the browser
+        // Note: is there a better way to determine this?
+        return BigInt(1e6);
+    },
+    now() {
+        // performance.now() is in milliseconds, but we want nanoseconds
+        return BigInt(Math.floor(performance.now() * 1e6));
+    },
+    subscribeInstant(instant) {
+        instant = BigInt(instant);
+        const now = monotonicClock.now();
+        if (instant <= now) {
+            return pollableCreate(new Promise((resolve) => setTimeout(resolve, 0)));
+        }
+        return monotonicClock.subscribeDuration(instant - now);
+    },
+    subscribeDuration(duration) {
+        duration = BigInt(duration);
+        const ms = duration <= 0n ? 0 : Number(duration / 1000000n);
+        return pollableCreate(new Promise((resolve) => setTimeout(resolve, ms)));
+    },
+};
+export const wallClock = {
+    now() {
+        let now = Date.now(); // in milliseconds
+        const seconds = BigInt(Math.floor(now / 1e3));
+        const nanoseconds = (now % 1e3) * 1e6;
+        return { seconds, nanoseconds };
+    },
+    resolution() {
+        return { seconds: 0n, nanoseconds: 1e6 };
+    },
+};

package/dist/browser/config.d.ts

@@ -0,0 +1,2 @@
+export declare function _setCwd(cwd: string): void;
+export declare function _getCwd(): string;

package/{lib → dist}/browser/config.js

@@ -1,9 +1,7 @@
 let _cwd = "/";
-
 export function _setCwd(cwd) {
-  _cwd = cwd;
+    _cwd = cwd;
 }
-
 export function _getCwd() {
-  return _cwd;
+    return _cwd;
 }

package/dist/browser/environment.d.ts

@@ -0,0 +1,5 @@
+import type { environment as EnvironmentNamespace } from "../../types/cli.js";
+export declare function _setEnv(envObj: Record<string, string>): void;
+export declare function _setArgs(args: string[]): void;
+export declare function _setCwd(cwd: string): void;
+export declare const environment: typeof EnvironmentNamespace;

package/dist/browser/environment.js

@@ -0,0 +1,24 @@
+import { _setCwd as fsSetCwd } from "./config.js";
+let _env = [];
+let _args = [];
+let _cwd = "/";
+export function _setEnv(envObj) {
+    _env = Object.entries(envObj);
+}
+export function _setArgs(args) {
+    _args = args;
+}
+export function _setCwd(cwd) {
+    fsSetCwd((_cwd = cwd));
+}
+export const environment = {
+    getEnvironment() {
+        return _env;
+    },
+    getArguments() {
+        return _args;
+    },
+    initialCwd() {
+        return _cwd;
+    },
+};

package/dist/browser/filesystem.d.ts

@@ -0,0 +1,132 @@
+import { types as TypesNamespace, preopens as PreopensNamespace } from "../../types/filesystem.js";
+import { InputStream as IInputStream, OutputStream as IOutputStream } from "../../types/interfaces/wasi-io-streams.js";
+export { _setCwd } from "./config.js";
+type Filesize = TypesNamespace.Filesize;
+type OpenFlags = TypesNamespace.OpenFlags;
+type PathFlags = TypesNamespace.PathFlags;
+export interface FileDataEntry {
+    dir?: Record<string, FileDataEntry>;
+    source?: Uint8Array | string;
+}
+/**
+ * Root file data structure representing a filesystem tree.
+ * Each entry is either a directory (has `dir` property) or a file (has `source` property).
+ * @example
+ * // A simple filesystem with one directory containing one file:
+ * const fileData = {
+ *   dir: {
+ *     'myfile.txt': { source: new Uint8Array([72, 101, 108, 108, 111]) }
+ *   }
+ * };
+ */
+export type FileData = FileDataEntry;
+export declare function _setFileData(fileData: FileData): void;
+export declare function _getFileData(): string;
+declare class DirectoryEntryStream implements TypesNamespace.DirectoryEntryStream {
+    idx: number;
+    entries: [string, FileDataEntry][];
+    static _create(entries: [string, FileDataEntry][]): DirectoryEntryStream;
+    readDirectoryEntry(): TypesNamespace.DirectoryEntry | undefined;
+}
+declare class Descriptor implements TypesNamespace.Descriptor {
+    #private;
+    _getEntry(descriptor: Descriptor): FileDataEntry;
+    static _create(entry: FileDataEntry | any, isStream?: boolean): Descriptor;
+    readViaStream(_offset: bigint): IInputStream;
+    writeViaStream(_offset: bigint): IOutputStream;
+    appendViaStream(): IOutputStream;
+    advise(offset: Filesize, length: Filesize, advice: TypesNamespace.Advice): void;
+    syncData(): void;
+    getFlags(): TypesNamespace.DescriptorFlags;
+    getType(): "directory" | "regular-file" | "unknown" | "fifo";
+    setSize(size: bigint): void;
+    setTimes(dataAccessTimestamp: any, dataModificationTimestamp: any): void;
+    read(length: bigint, offset: bigint): [Uint8Array<ArrayBufferLike>, boolean];
+    write(buffer: Uint8Array, offset: Filesize): bigint;
+    readDirectory(): DirectoryEntryStream;
+    sync(): void;
+    createDirectoryAt(path: string): void;
+    stat(): {
+        type: "directory" | "regular-file" | "unknown";
+        linkCount: bigint;
+        size: bigint;
+        dataAccessTimestamp: {
+            seconds: bigint;
+            nanoseconds: number;
+        };
+        dataModificationTimestamp: {
+            seconds: bigint;
+            nanoseconds: number;
+        };
+        statusChangeTimestamp: {
+            seconds: bigint;
+            nanoseconds: number;
+        };
+    };
+    statAt(_pathFlags: PathFlags, path: string): {
+        type: "directory" | "regular-file" | "unknown";
+        linkCount: bigint;
+        size: bigint;
+        dataAccessTimestamp: {
+            seconds: bigint;
+            nanoseconds: number;
+        };
+        dataModificationTimestamp: {
+            seconds: bigint;
+            nanoseconds: number;
+        };
+        statusChangeTimestamp: {
+            seconds: bigint;
+            nanoseconds: number;
+        };
+    };
+    setTimesAt(): void;
+    linkAt(): void;
+    openAt(_pathFlags: PathFlags, path: string, openFlags: OpenFlags, _flags: TypesNamespace.DescriptorFlags): Descriptor;
+    readlinkAt(_path: string): string;
+    removeDirectoryAt(): void;
+    renameAt(): void;
+    symlinkAt(): void;
+    unlinkFileAt(): void;
+    isSameObject(other: TypesNamespace.Descriptor): boolean;
+    metadataHash(): {
+        upper: bigint;
+        lower: bigint;
+    };
+    metadataHashAt(_pathFlags: any, _path: string): {
+        upper: bigint;
+        lower: bigint;
+    };
+}
+export declare const preopens: typeof PreopensNamespace;
+/**
+ * Replace all preopens with the given set.
+ * @param preopensConfig - Map of virtual paths to file data entries
+ */
+export declare function _setPreopens(preopensConfig: Record<string, FileData>): void;
+/**
+ * Add a single preopen mapping.
+ * @param virtualPath - The virtual path visible to the guest
+ * @param fileData - The file data object representing the directory
+ */
+export declare function _addPreopen(virtualPath: string, fileData: FileData): void;
+/**
+ * Clear all preopens, giving the guest no filesystem access.
+ *
+ * This functionality exists mostly to maintain backwards compatibility. Prefer setting preopens
+ * via `WASIShim` rather than making top level changes to preopens using these functions.
+ */
+export declare function _clearPreopens(): void;
+/**
+ * Get current preopens configuration.
+ * @returns 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 declare const types: typeof TypesNamespace;