@bytecodealliance/preview3-shim 0.6.1 → 0.7.0

package/README.md

@@ -1,6 +1,13 @@
-# Preview 3 Shim
+# Preview3 Shim
 
-Experimental WASI Preview 3 implementations for Node.js.
+[WebAssembly System Interface (WASI) Preview 3][wasi] implementations for NodeJS & browsers.
+
+Similar to the [Preview 2 Shim][p2-shim], the P3 shim makes available WASI
+interfaces for [WebAssembly Components][cm-book] that make use of them.
+
+[wasi]: https://github.com/webassembly/wasi
+[cm-book]: https://component-model.bytecodealliance.org/
+[p2-shim]: https://www.npmjs.com/package/@bytecodealliance/preview2-shim
 
 ### Contribution
 

package/dist/browser/cli/environment.d.ts

@@ -1,3 +1,4 @@
+export declare function _setCwd(cwd: string): void;
 declare function getEnvironment(): Array<[string, string]>;
 declare function getArguments(): Array<string>;
 declare function getInitialCwd(): string | undefined;

package/dist/browser/cli/environment.js

@@ -1,12 +1,17 @@
-import { Todo } from "../../common/errors.js";
+import { _setCwd as setPreview2Cwd, environment } from "@bytecodealliance/preview2-shim/cli";
+let initialCwd = environment.initialCwd();
+export function _setCwd(cwd) {
+    initialCwd = cwd;
+    setPreview2Cwd(cwd);
+}
 function getEnvironment() {
-    throw new Todo();
+    return environment.getEnvironment();
 }
 function getArguments() {
-    throw new Todo();
+    return environment.getArguments();
 }
 function getInitialCwd() {
-    throw new Todo();
+    return initialCwd;
 }
 export default {
     getEnvironment,

package/dist/browser/cli/exit.js

@@ -1,9 +1,10 @@
-import { Todo } from "../../common/errors.js";
+import { exit as preview2Exit } from "@bytecodealliance/preview2-shim/cli";
+const exitWithCodeV2 = preview2Exit;
 function exit(status) {
-    throw new Todo();
+    preview2Exit.exit(status);
 }
 function exitWithCode(statusCode) {
-    throw new Todo();
+    exitWithCodeV2.exitWithCode(statusCode);
 }
 export default {
     exit,

package/dist/browser/cli/run.d.ts

@@ -1,4 +1,6 @@
+type RunHandler = () => void | Promise<void>;
 declare function run(): Promise<void>;
+export declare function _setRun(next: RunHandler | undefined): RunHandler | undefined;
 declare const _default: {
     run: typeof run;
 };

package/dist/browser/cli/run.js

@@ -1,6 +1,14 @@
-import { Todo } from "../../common/errors.js";
-function run() {
-    throw new Todo();
+let handler;
+async function run() {
+    if (!handler) {
+        throw new Error("wasi:cli/run import is not configured");
+    }
+    await handler();
+}
+export function _setRun(next) {
+    const previous = handler;
+    handler = next;
+    return previous;
 }
 export default {
     run,

package/dist/browser/cli/stderr.js

@@ -1,6 +1,13 @@
-import { Todo } from "../../common/errors.js";
-function writeViaStream(data) {
-    throw new Todo();
+import { stderr } from "@bytecodealliance/preview2-shim/cli";
+import { preview2StreamErrorCode, writeToPreview2Output } from "../streams.js";
+async function writeViaStream(data) {
+    try {
+        await writeToPreview2Output(data, stderr.getStderr());
+        return { tag: "ok", val: undefined };
+    }
+    catch (error) {
+        return { tag: "err", val: preview2StreamErrorCode(error) };
+    }
 }
 export default {
     writeViaStream,

package/dist/browser/cli/stdin.js

@@ -1,6 +1,7 @@
-import { Todo } from "../../common/errors.js";
+import { stdin } from "@bytecodealliance/preview2-shim/cli";
+import { readableFromPreview2Input } from "../streams.js";
 function readViaStream() {
-    throw new Todo();
+    return readableFromPreview2Input(stdin.getStdin(), () => "io");
 }
 export default {
     readViaStream,

package/dist/browser/cli/stdout.js

@@ -1,6 +1,13 @@
-import { Todo } from "../../common/errors.js";
-function writeViaStream(data) {
-    throw new Todo();
+import { stdout } from "@bytecodealliance/preview2-shim/cli";
+import { preview2StreamErrorCode, writeToPreview2Output } from "../streams.js";
+async function writeViaStream(data) {
+    try {
+        await writeToPreview2Output(data, stdout.getStdout());
+        return { tag: "ok", val: undefined };
+    }
+    catch (error) {
+        return { tag: "err", val: preview2StreamErrorCode(error) };
+    }
 }
 export default {
     writeViaStream,

package/dist/browser/cli/terminal-stderr.js

@@ -1,6 +1,6 @@
-import { Todo } from "../../common/errors.js";
+import { terminalStderr } from "@bytecodealliance/preview2-shim/cli";
 function getTerminalStderr() {
-    throw new Todo();
+    return terminalStderr.getTerminalStderr();
 }
 export default {
     getTerminalStderr,

package/dist/browser/cli/terminal-stdin.js

@@ -1,6 +1,6 @@
-import { Todo } from "../../common/errors.js";
+import { terminalStdin } from "@bytecodealliance/preview2-shim/cli";
 function getTerminalStdin() {
-    throw new Todo();
+    return terminalStdin.getTerminalStdin();
 }
 export default {
     getTerminalStdin,

package/dist/browser/cli/terminal-stdout.js

@@ -1,6 +1,6 @@
-import { Todo } from "../../common/errors.js";
+import { terminalStdout } from "@bytecodealliance/preview2-shim/cli";
 function getTerminalStdout() {
-    throw new Todo();
+    return terminalStdout.getTerminalStdout();
 }
 export default {
     getTerminalStdout,

package/dist/browser/cli.d.ts

@@ -1,6 +1,8 @@
 export { default as environment } from "./cli/environment.js";
+export { _setCwd } from "./cli/environment.js";
 export { default as exit } from "./cli/exit.js";
 export { default as run } from "./cli/run.js";
+export { _setRun } from "./cli/run.js";
 export { default as stderr } from "./cli/stderr.js";
 export { default as stdin } from "./cli/stdin.js";
 export { default as stdout } from "./cli/stdout.js";
@@ -9,3 +11,4 @@ export { default as terminalOutput } from "./cli/terminal-output.js";
 export { default as terminalStderr } from "./cli/terminal-stderr.js";
 export { default as terminalStdin } from "./cli/terminal-stdin.js";
 export { default as terminalStdout } from "./cli/terminal-stdout.js";
+export { _setArgs, _setEnv, _setStderr, _setStdin, _setStdout, } from "@bytecodealliance/preview2-shim/cli";

package/dist/browser/cli.js

@@ -1,6 +1,8 @@
 export { default as environment } from "./cli/environment.js";
+export { _setCwd } from "./cli/environment.js";
 export { default as exit } from "./cli/exit.js";
 export { default as run } from "./cli/run.js";
+export { _setRun } from "./cli/run.js";
 export { default as stderr } from "./cli/stderr.js";
 export { default as stdin } from "./cli/stdin.js";
 export { default as stdout } from "./cli/stdout.js";
@@ -9,3 +11,4 @@ export { default as terminalOutput } from "./cli/terminal-output.js";
 export { default as terminalStderr } from "./cli/terminal-stderr.js";
 export { default as terminalStdin } from "./cli/terminal-stdin.js";
 export { default as terminalStdout } from "./cli/terminal-stdout.js";
+export { _setArgs, _setEnv, _setStderr, _setStdin, _setStdout, } from "@bytecodealliance/preview2-shim/cli";

package/dist/browser/clocks/monotonic-clock.js

@@ -1,15 +1,15 @@
-import { Todo } from "../../common/errors.js";
+import { monotonicClock } from "@bytecodealliance/preview2-shim/clocks";
 function now() {
-    throw new Todo();
+    return monotonicClock.now();
 }
 function getResolution() {
-    throw new Todo();
+    return monotonicClock.resolution();
 }
-function waitUntil(when) {
-    throw new Todo();
+async function waitUntil(when) {
+    await monotonicClock.subscribeInstant(when).block();
 }
-function waitFor(howLong) {
-    throw new Todo();
+async function waitFor(howLong) {
+    await monotonicClock.subscribeDuration(howLong).block();
 }
 export default {
     now,

package/dist/browser/clocks/system-clock.js

@@ -1,9 +1,10 @@
-import { Todo } from "../../common/errors.js";
+import { wallClock } from "@bytecodealliance/preview2-shim/clocks";
 function now() {
-    throw new Todo();
+    return wallClock.now();
 }
 function getResolution() {
-    throw new Todo();
+    const resolution = wallClock.resolution();
+    return resolution.seconds * 1000000000n + BigInt(resolution.nanoseconds);
 }
 export default {
     now,

package/dist/browser/filesystem/preopens.js

@@ -1,6 +1,7 @@
-import { Todo } from "../../common/errors.js";
+import { preopens } from "@bytecodealliance/preview2-shim/filesystem";
+import { wrapDescriptor } from "./types.js";
 function getDirectories() {
-    throw new Todo();
+    return preopens.getDirectories().map(([descriptor, path]) => [wrapDescriptor(descriptor), path]);
 }
 export default {
     getDirectories,

package/dist/browser/filesystem/types.d.ts

@@ -1,5 +1,47 @@
 import type { Descriptor as DescriptorT, Advice, DescriptorFlags, DescriptorStat, DescriptorType, DirectoryEntry, ErrorCode, Filesize, MetadataHashValue, NewTimestamp, OpenFlags, PathFlags, Result } from "../../../types/interfaces/wasi-filesystem-types.d.ts";
-declare class Descriptor implements DescriptorT {
+import { readableFromPreview2Input, writeToPreview2Output } from "../streams.js";
+declare const symbolDispose: symbol;
+type Preview2Descriptor = {
+    readViaStream(offset: Filesize): Parameters<typeof readableFromPreview2Input>[0];
+    writeViaStream(offset: Filesize): Parameters<typeof writeToPreview2Output>[1];
+    appendViaStream(): Parameters<typeof writeToPreview2Output>[1];
+    advise(offset: Filesize, length: Filesize, advice: Advice): void;
+    syncData(): void;
+    getFlags(): DescriptorFlags;
+    getType(): string;
+    setSize(size: Filesize): void;
+    setTimes(dataAccessTimestamp: NewTimestamp, dataModificationTimestamp: NewTimestamp): void;
+    readDirectory(): {
+        readDirectoryEntry(): {
+            type: string;
+            name: string;
+        } | undefined;
+    };
+    sync(): void;
+    createDirectoryAt(path: string): void;
+    stat(): Omit<DescriptorStat, "type"> & {
+        type: string;
+    };
+    statAt(pathFlags: PathFlags, path: string): Omit<DescriptorStat, "type"> & {
+        type: string;
+    };
+    setTimesAt(pathFlags: PathFlags, path: string, dataAccessTimestamp: NewTimestamp, dataModificationTimestamp: NewTimestamp): void;
+    linkAt(oldPathFlags: PathFlags, oldPath: string, newDescriptor: Preview2Descriptor, newPath: string): void;
+    openAt(pathFlags: PathFlags, path: string, openFlags: OpenFlags, flags: DescriptorFlags): Preview2Descriptor;
+    readlinkAt(path: string): string;
+    removeDirectoryAt(path: string): void;
+    renameAt(oldPath: string, newDescriptor: Preview2Descriptor, newPath: string): void;
+    symlinkAt(oldPath: string, newPath: string): void;
+    unlinkFileAt(path: string): void;
+    isSameObject(other: Preview2Descriptor): boolean;
+    metadataHash(): MetadataHashValue;
+    metadataHashAt(pathFlags: PathFlags, path: string): MetadataHashValue;
+};
+export declare function filesystemErrorCode(error: unknown): ErrorCode;
+export declare class Descriptor implements DescriptorT {
+    #private;
+    [symbolDispose]: () => void;
+    static _wrap(descriptor: Preview2Descriptor): Descriptor;
     readViaStream(offset: Filesize): [ReadableStream<number>, Promise<Result<void, ErrorCode>>];
     writeViaStream(data: ReadableStream<number>, offset: Filesize): Promise<Result<void, ErrorCode>>;
     appendViaStream(data: ReadableStream<number>): Promise<Result<void, ErrorCode>>;
@@ -26,6 +68,7 @@ declare class Descriptor implements DescriptorT {
     metadataHash(): Promise<MetadataHashValue>;
     metadataHashAt(pathFlags: PathFlags, path: string): Promise<MetadataHashValue>;
 }
+export declare function wrapDescriptor(descriptor: unknown): Descriptor;
 declare const _default: {
     Descriptor: typeof Descriptor;
 };

package/dist/browser/filesystem/types.js

@@ -1,81 +1,170 @@
-import { Todo } from "../../common/errors.js";
-class Descriptor {
+import { readableFromPreview2Input, writeToPreview2Output } from "../streams.js";
+const symbolDispose = Symbol.dispose ?? Symbol.for("dispose");
+const TYPE_TAGS = new Set([
+    "block-device",
+    "character-device",
+    "directory",
+    "fifo",
+    "symbolic-link",
+    "regular-file",
+    "socket",
+]);
+function descriptorType(type) {
+    if (TYPE_TAGS.has(type)) {
+        return { tag: type };
+    }
+    return { tag: "other", val: type === "unknown" ? undefined : type };
+}
+export function filesystemErrorCode(error) {
+    let tag = typeof error === "string" ? error : error?.tag;
+    if (!tag && error instanceof Error) {
+        tag = error.message;
+    }
+    if (tag === "would-block") {
+        return { tag: "other", val: tag };
+    }
+    if (tag) {
+        return { tag };
+    }
+    return { tag: "other", val: String(error) };
+}
+class FilesystemError extends Error {
+    payload;
+    constructor(error) {
+        const payload = filesystemErrorCode(error);
+        super(payload.tag);
+        this.name = "FilesystemError";
+        this.payload = payload;
+    }
+}
+function filesystemCall(operation) {
+    try {
+        return operation();
+    }
+    catch (error) {
+        throw error instanceof FilesystemError ? error : new FilesystemError(error);
+    }
+}
+function stat(value) {
+    return { ...value, type: descriptorType(value.type) };
+}
+export class Descriptor {
+    #descriptor;
+    static _wrap(descriptor) {
+        const wrapped = new Descriptor();
+        wrapped.#descriptor = descriptor;
+        return wrapped;
+    }
     readViaStream(offset) {
-        throw new Todo();
+        return readableFromPreview2Input(this.#descriptor.readViaStream(offset), filesystemErrorCode);
     }
-    writeViaStream(data, offset) {
-        throw new Todo();
+    async writeViaStream(data, offset) {
+        try {
+            await writeToPreview2Output(data, this.#descriptor.writeViaStream(offset));
+            return { tag: "ok", val: undefined };
+        }
+        catch (error) {
+            return { tag: "err", val: filesystemErrorCode(error) };
+        }
     }
-    appendViaStream(data) {
-        throw new Todo();
+    async appendViaStream(data) {
+        try {
+            await writeToPreview2Output(data, this.#descriptor.appendViaStream());
+            return { tag: "ok", val: undefined };
+        }
+        catch (error) {
+            return { tag: "err", val: filesystemErrorCode(error) };
+        }
     }
-    advise(offset, length, advice) {
-        throw new Todo();
+    async advise(offset, length, advice) {
+        filesystemCall(() => this.#descriptor.advise(offset, length, advice));
     }
-    syncData() {
-        throw new Todo();
+    async syncData() {
+        filesystemCall(() => this.#descriptor.syncData());
     }
-    getFlags() {
-        throw new Todo();
+    async getFlags() {
+        return filesystemCall(() => this.#descriptor.getFlags());
     }
-    getType() {
-        throw new Todo();
+    async getType() {
+        return descriptorType(filesystemCall(() => this.#descriptor.getType()));
     }
-    setSize(size) {
-        throw new Todo();
+    async setSize(size) {
+        filesystemCall(() => this.#descriptor.setSize(size));
     }
-    setTimes(dataAccessTimestamp, dataModificationTimestamp) {
-        throw new Todo();
+    async setTimes(dataAccessTimestamp, dataModificationTimestamp) {
+        filesystemCall(() => this.#descriptor.setTimes(dataAccessTimestamp, dataModificationTimestamp));
     }
     readDirectory() {
-        throw new Todo();
+        const directory = this.#descriptor.readDirectory();
+        const stream = new ReadableStream({
+            pull(controller) {
+                try {
+                    const entry = directory.readDirectoryEntry();
+                    if (!entry) {
+                        controller.close();
+                        return;
+                    }
+                    controller.enqueue({ ...entry, type: descriptorType(entry.type) });
+                }
+                catch (error) {
+                    controller.error(error);
+                }
+            },
+        });
+        return [stream, Promise.resolve({ tag: "ok", val: undefined })];
+    }
+    async sync() {
+        filesystemCall(() => this.#descriptor.sync());
     }
-    sync() {
-        throw new Todo();
+    async createDirectoryAt(path) {
+        filesystemCall(() => this.#descriptor.createDirectoryAt(path));
     }
-    createDirectoryAt(path) {
-        throw new Todo();
+    async stat() {
+        return stat(filesystemCall(() => this.#descriptor.stat()));
     }
-    stat() {
-        throw new Todo();
+    async statAt(pathFlags, path) {
+        return stat(filesystemCall(() => this.#descriptor.statAt(pathFlags, path)));
     }
-    statAt(pathFlags, path) {
-        throw new Todo();
+    async setTimesAt(pathFlags, path, dataAccessTimestamp, dataModificationTimestamp) {
+        filesystemCall(() => this.#descriptor.setTimesAt(pathFlags, path, dataAccessTimestamp, dataModificationTimestamp));
     }
-    setTimesAt(pathFlags, path, dataAccessTimestamp, dataModificationTimestamp) {
-        throw new Todo();
+    async linkAt(oldPathFlags, oldPath, newDescriptor, newPath) {
+        filesystemCall(() => this.#descriptor.linkAt(oldPathFlags, oldPath, newDescriptor.#descriptor, newPath));
     }
-    linkAt(oldPathFlags, oldPath, newDescriptor, newPath) {
-        throw new Todo();
+    async openAt(pathFlags, path, openFlags, flags) {
+        return Descriptor._wrap(filesystemCall(() => this.#descriptor.openAt(pathFlags, path, openFlags, flags)));
     }
-    openAt(pathFlags, path, openFlags, flags) {
-        throw new Todo();
+    async readlinkAt(path) {
+        return filesystemCall(() => this.#descriptor.readlinkAt(path));
     }
-    readlinkAt(path) {
-        throw new Todo();
+    async removeDirectoryAt(path) {
+        filesystemCall(() => this.#descriptor.removeDirectoryAt(path));
     }
-    removeDirectoryAt(path) {
-        throw new Todo();
+    async renameAt(oldPath, newDescriptor, newPath) {
+        filesystemCall(() => this.#descriptor.renameAt(oldPath, newDescriptor.#descriptor, newPath));
     }
-    renameAt(oldPath, newDescriptor, newPath) {
-        throw new Todo();
+    async symlinkAt(oldPath, newPath) {
+        filesystemCall(() => this.#descriptor.symlinkAt(oldPath, newPath));
     }
-    symlinkAt(oldPath, newPath) {
-        throw new Todo();
+    async unlinkFileAt(path) {
+        filesystemCall(() => this.#descriptor.unlinkFileAt(path));
     }
-    unlinkFileAt(path) {
-        throw new Todo();
+    async isSameObject(other) {
+        return filesystemCall(() => this.#descriptor.isSameObject(other.#descriptor));
     }
-    isSameObject(other) {
-        throw new Todo();
+    async metadataHash() {
+        return filesystemCall(() => this.#descriptor.metadataHash());
     }
-    metadataHash() {
-        throw new Todo();
+    async metadataHashAt(pathFlags, path) {
+        return filesystemCall(() => this.#descriptor.metadataHashAt(pathFlags, path));
     }
-    metadataHashAt(pathFlags, path) {
-        throw new Todo();
+    [symbolDispose]() {
+        this.#descriptor[symbolDispose]?.();
     }
 }
+export function wrapDescriptor(descriptor) {
+    return Descriptor._wrap(descriptor);
+}
 export default {
     Descriptor,
 };

package/dist/browser/filesystem.d.ts

@@ -1,2 +1,15 @@
+import type { BrowserFilesystemConfig } from "@bytecodealliance/preview2-shim/filesystem";
 export { default as preopens } from "./filesystem/preopens.js";
 export { default as types } from "./filesystem/types.js";
+export { _addPreopen, _addPreopenWithAdapter, _clearPreopens, _getFileData, _setCwd, _setFileData, _setPreopens, InMemoryFilesystemAdapter, loadOpfsCapability, OpfsFilesystemAdapter, } from "@bytecodealliance/preview2-shim/filesystem";
+export type { BrowserFilesystemAdapter, BrowserFilesystemConfig, FileData, FileDataEntry, OpfsCapability, } from "@bytecodealliance/preview2-shim/filesystem";
+export declare function _getPreopens(): (readonly [import("./filesystem/types.js").Descriptor, string])[];
+export declare function createFilesystem<Capability>(config: BrowserFilesystemConfig<Capability>): {
+    types: {
+        Descriptor: typeof import("./filesystem/types.js").Descriptor;
+    };
+    preopens: {
+        getDirectories(): (readonly [import("./filesystem/types.js").Descriptor, string])[];
+    };
+    dispose: () => void;
+};

package/dist/browser/filesystem.js

@@ -1,2 +1,22 @@
+import { _getPreopens as getPreview2Preopens, createFilesystem as createPreview2Filesystem, } from "@bytecodealliance/preview2-shim/filesystem";
+import types, { wrapDescriptor } from "./filesystem/types.js";
 export { default as preopens } from "./filesystem/preopens.js";
 export { default as types } from "./filesystem/types.js";
+export { _addPreopen, _addPreopenWithAdapter, _clearPreopens, _getFileData, _setCwd, _setFileData, _setPreopens, InMemoryFilesystemAdapter, loadOpfsCapability, OpfsFilesystemAdapter, } from "@bytecodealliance/preview2-shim/filesystem";
+export function _getPreopens() {
+    return getPreview2Preopens().map(([descriptor, path]) => [wrapDescriptor(descriptor), path]);
+}
+export function createFilesystem(config) {
+    const filesystem = createPreview2Filesystem(config);
+    return {
+        types,
+        preopens: {
+            getDirectories() {
+                return filesystem.preopens
+                    .getDirectories()
+                    .map(([descriptor, path]) => [wrapDescriptor(descriptor), path]);
+            },
+        },
+        dispose: filesystem.dispose,
+    };
+}

package/dist/browser/http/client.d.ts

@@ -1,5 +1,5 @@
-import type { Request, Response } from "../../../types/interfaces/wasi-http-client.d.ts";
-declare function send(request: Request): Promise<Response>;
+import type { Request as RequestT, Response as ResponseT } from "../../../types/interfaces/wasi-http-types.d.ts";
+declare function send(request: RequestT): Promise<ResponseT>;
 declare const _default: {
     send: typeof send;
 };