wasm-platform-kit 0.0.0-stage → 0.2.0

package/assets/wasi/clocks.js

@@ -0,0 +1,55 @@
+import { checkedU64 } from "./common.js";
+import { pollableCreate } from "./io.js";
+const MAX_TIMEOUT_MS = 0x7fffffff;
+function timeout(durationNs) {
+    let remainingMs = Number((durationNs + 999999n) / 1000000n);
+    return new Promise((resolve) => {
+        const next = () => {
+            if (remainingMs <= 0) {
+                resolve();
+                return;
+            }
+            const delay = Math.min(remainingMs, MAX_TIMEOUT_MS);
+            remainingMs -= delay;
+            setTimeout(next, delay);
+        };
+        next();
+    });
+}
+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 = checkedU64(instant, "instant");
+        const now = monotonicClock.now();
+        if (instant <= now) {
+            return pollableCreate();
+        }
+        return monotonicClock.subscribeDuration(instant - now);
+    },
+    subscribeDuration(duration) {
+        duration = checkedU64(duration, "duration");
+        if (duration === 0n) {
+            return pollableCreate();
+        }
+        return pollableCreate(timeout(duration));
+    },
+};
+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/assets/wasi/common.d.ts

@@ -0,0 +1,5 @@
+export declare const MAX_U64: bigint;
+/** Validate and return a WebAssembly u64 value. */
+export declare function checkedU64(value: bigint, name: string): bigint;
+/** Convert a WebAssembly u64 value to a lossless JavaScript number. */
+export declare function checkedU64AsNumber(value: bigint, name: string): number;

package/assets/wasi/common.js

@@ -0,0 +1,16 @@
+export const MAX_U64 = (1n << 64n) - 1n;
+/** Validate and return a WebAssembly u64 value. */
+export function checkedU64(value, name) {
+    if (typeof value !== "bigint" || value < 0n || value > MAX_U64) {
+        throw new TypeError(`${name} must be a valid u64`);
+    }
+    return value;
+}
+/** Convert a WebAssembly u64 value to a lossless JavaScript number. */
+export function checkedU64AsNumber(value, name) {
+    checkedU64(value, name);
+    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new RangeError(`${name} exceeds JavaScript's safe integer range`);
+    }
+    return Number(value);
+}

package/assets/wasi/config.d.ts

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

package/assets/wasi/config.js

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

package/assets/wasi/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/assets/wasi/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/assets/wasi/filesystem.d.ts

@@ -0,0 +1,117 @@
+import { types as TypesNamespace, preopens as PreopensNamespace } from "../../types/filesystem.js";
+import type { FileData } from "./in-memory-filesystem.js";
+export { _setCwd } from "./config.js";
+export { InMemoryFilesystemAdapter } from "./in-memory-filesystem.js";
+export type { FileData, FileDataEntry } from "./in-memory-filesystem.js";
+export { OpfsFilesystemAdapter, loadOpfsCapability } from "./opfs-filesystem.js";
+export type { OpfsCapability } from "./opfs-filesystem.js";
+type Filesize = TypesNamespace.Filesize;
+type OpenFlags = TypesNamespace.OpenFlags;
+type PathFlags = TypesNamespace.PathFlags;
+export interface BrowserDirectoryEntryStream {
+    readDirectoryEntry(): TypesNamespace.DirectoryEntry | undefined;
+}
+export interface BrowserFilesystemDescriptor extends Omit<TypesNamespace.Descriptor, "isSameObject" | "linkAt" | "openAt" | "readDirectory" | "renameAt"> {
+    readDirectory(): BrowserDirectoryEntryStream;
+    linkAt(oldPathFlags: PathFlags, oldPath: string, newDescriptor: BrowserFilesystemDescriptor, newPath: string): void;
+    openAt(pathFlags: PathFlags, path: string, openFlags: OpenFlags, flags: TypesNamespace.DescriptorFlags): BrowserFilesystemDescriptor;
+    renameAt(oldPath: string, newDescriptor: BrowserFilesystemDescriptor, newPath: string): void;
+    isSameObject(other: BrowserFilesystemDescriptor): boolean;
+    /**
+     * Advisory locking, for host application code holding a descriptor directly
+     * (not part of the WASI guest-facing surface). Adapters that support it should
+     * implement all five; `tryLock*` return whether the lock was acquired instead
+     * of throwing.
+     */
+    lockShared?(): void;
+    lockExclusive?(): void;
+    tryLockShared?(): boolean;
+    tryLockExclusive?(): boolean;
+    unlock?(): void;
+}
+export interface BrowserFilesystemAdapter<Capability = unknown> {
+    getRoot(capability: Capability): BrowserFilesystemDescriptor;
+    dispose?(): void | Promise<void>;
+}
+export interface BrowserFilesystemConfig<Capability> {
+    adapter: BrowserFilesystemAdapter<Capability>;
+    preopens: Record<string, Capability>;
+}
+declare class DirectoryEntryStream implements TypesNamespace.DirectoryEntryStream {
+    #private;
+    static _create(implementation: BrowserDirectoryEntryStream): DirectoryEntryStream;
+    readDirectoryEntry(): TypesNamespace.DirectoryEntry | undefined;
+}
+declare class Descriptor implements TypesNamespace.Descriptor {
+    #private;
+    _getImplementation(descriptor: Descriptor): BrowserFilesystemDescriptor;
+    static _create(implementation: BrowserFilesystemDescriptor): Descriptor;
+    readViaStream(offset: Filesize): import("../../types/interfaces/wasi-io-streams.js").InputStream;
+    writeViaStream(offset: Filesize): import("../../types/interfaces/wasi-io-streams.js").OutputStream;
+    appendViaStream(): import("../../types/interfaces/wasi-io-streams.js").OutputStream;
+    advise(offset: Filesize, length: Filesize, advice: TypesNamespace.Advice): void;
+    syncData(): void;
+    getFlags(): TypesNamespace.DescriptorFlags;
+    getType(): TypesNamespace.DescriptorType;
+    setSize(size: Filesize): void;
+    setTimes(dataAccessTimestamp: TypesNamespace.NewTimestamp, dataModificationTimestamp: TypesNamespace.NewTimestamp): void;
+    read(length: Filesize, offset: Filesize): [Uint8Array<ArrayBufferLike>, boolean];
+    write(buffer: Uint8Array, offset: Filesize): bigint;
+    readDirectory(): DirectoryEntryStream;
+    sync(): void;
+    createDirectoryAt(path: string): void;
+    stat(): TypesNamespace.DescriptorStat;
+    statAt(pathFlags: PathFlags, path: string): TypesNamespace.DescriptorStat;
+    setTimesAt(pathFlags: PathFlags, path: string, dataAccessTimestamp: TypesNamespace.NewTimestamp, dataModificationTimestamp: TypesNamespace.NewTimestamp): void;
+    linkAt(oldPathFlags: PathFlags, oldPath: string, newDescriptor: TypesNamespace.Descriptor, newPath: string): void;
+    openAt(pathFlags: PathFlags, path: string, openFlags: OpenFlags, flags: TypesNamespace.DescriptorFlags): Descriptor;
+    readlinkAt(path: string): string;
+    removeDirectoryAt(path: string): void;
+    renameAt(oldPath: string, newDescriptor: TypesNamespace.Descriptor, newPath: string): void;
+    symlinkAt(oldPath: string, newPath: string): void;
+    unlinkFileAt(path: string): void;
+    isSameObject(other: TypesNamespace.Descriptor): boolean;
+    metadataHash(): TypesNamespace.MetadataHashValue;
+    metadataHashAt(pathFlags: PathFlags, path: string): TypesNamespace.MetadataHashValue;
+    lockShared(): void | undefined;
+    lockExclusive(): void | undefined;
+    tryLockShared(): boolean;
+    tryLockExclusive(): boolean;
+    unlock(): void | undefined;
+}
+export declare const preopens: typeof PreopensNamespace;
+/** Create isolated filesystem namespaces backed by an application-selected adapter. */
+export declare function createFilesystem<Capability>({ adapter, preopens: configuredPreopens, }: BrowserFilesystemConfig<Capability>): {
+    types: typeof TypesNamespace;
+    preopens: typeof PreopensNamespace;
+    dispose(): void | Promise<void>;
+};
+export declare function _setFileData(fileData: FileData): void;
+export declare function _getFileData(): string;
+/**
+ * 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;
+/**
+ * Add a single preopen backed by a custom adapter (e.g. `OpfsFilesystemAdapter`) instead of the
+ * default in-memory one. Lets a host wire an alternative `BrowserFilesystemAdapter` into the
+ * top-level `wasi:filesystem/preopens` singleton that transpiled components import statically.
+ * @param virtualPath - The virtual path visible to the guest
+ * @param adapter - The adapter that will back this preopen
+ * @param capability - The adapter-specific capability to load as the preopen's root
+ */
+export declare function _addPreopenWithAdapter<Capability>(virtualPath: string, adapter: BrowserFilesystemAdapter<Capability>, capability: Capability): void;
+/** Clear all preopens, giving the guest no filesystem access. */
+export declare function _clearPreopens(): void;
+/** Get current preopens configuration. */
+export declare function _getPreopens(): [Descriptor, string][];
+/** Reject host paths because browser filesystems require explicit capabilities. */
+export declare function _createPreopenDescriptor(hostPreopen: string): void;
+export declare const types: typeof TypesNamespace;

package/assets/wasi/filesystem.js

@@ -0,0 +1,341 @@
+import { environment } from "./environment.js";
+import { InMemoryFilesystemAdapter } from "./in-memory-filesystem.js";
+import { _setCwd } from "./config.js";
+export { _setCwd } from "./config.js";
+export { InMemoryFilesystemAdapter } from "./in-memory-filesystem.js";
+export { OpfsFilesystemAdapter, loadOpfsCapability } from "./opfs-filesystem.js";
+class DirectoryEntryStream {
+    #implementation;
+    static _create(implementation) {
+        const stream = new DirectoryEntryStream();
+        stream.#implementation = implementation;
+        return stream;
+    }
+    readDirectoryEntry() {
+        return this.#implementation.readDirectoryEntry();
+    }
+}
+const directoryEntryStreamCreate = DirectoryEntryStream._create;
+// @ts-expect-error - Deleting static method
+delete DirectoryEntryStream._create;
+class Descriptor {
+    #implementation;
+    _getImplementation(descriptor) {
+        return descriptor.#implementation;
+    }
+    static _create(implementation) {
+        const descriptor = new Descriptor();
+        descriptor.#implementation = implementation;
+        return descriptor;
+    }
+    readViaStream(offset) {
+        return this.#implementation.readViaStream(offset);
+    }
+    writeViaStream(offset) {
+        return this.#implementation.writeViaStream(offset);
+    }
+    appendViaStream() {
+        return this.#implementation.appendViaStream();
+    }
+    advise(offset, length, advice) {
+        return this.#implementation.advise(offset, length, advice);
+    }
+    syncData() {
+        return this.#implementation.syncData();
+    }
+    getFlags() {
+        return this.#implementation.getFlags();
+    }
+    getType() {
+        return this.#implementation.getType();
+    }
+    setSize(size) {
+        return this.#implementation.setSize(size);
+    }
+    setTimes(dataAccessTimestamp, dataModificationTimestamp) {
+        return this.#implementation.setTimes(dataAccessTimestamp, dataModificationTimestamp);
+    }
+    read(length, offset) {
+        return this.#implementation.read(length, offset);
+    }
+    write(buffer, offset) {
+        return this.#implementation.write(buffer, offset);
+    }
+    readDirectory() {
+        return directoryEntryStreamCreate(this.#implementation.readDirectory());
+    }
+    sync() {
+        return this.#implementation.sync();
+    }
+    createDirectoryAt(path) {
+        return this.#implementation.createDirectoryAt(path);
+    }
+    stat() {
+        return this.#implementation.stat();
+    }
+    statAt(pathFlags, path) {
+        return this.#implementation.statAt(pathFlags, path);
+    }
+    setTimesAt(pathFlags, path, dataAccessTimestamp, dataModificationTimestamp) {
+        return this.#implementation.setTimesAt(pathFlags, path, dataAccessTimestamp, dataModificationTimestamp);
+    }
+    linkAt(oldPathFlags, oldPath, newDescriptor, newPath) {
+        return this.#implementation.linkAt(oldPathFlags, oldPath, descriptorGetImplementation(newDescriptor), newPath);
+    }
+    openAt(pathFlags, path, openFlags, flags) {
+        return descriptorCreate(this.#implementation.openAt(pathFlags, path, openFlags, flags));
+    }
+    readlinkAt(path) {
+        return this.#implementation.readlinkAt(path);
+    }
+    removeDirectoryAt(path) {
+        return this.#implementation.removeDirectoryAt(path);
+    }
+    renameAt(oldPath, newDescriptor, newPath) {
+        return this.#implementation.renameAt(oldPath, descriptorGetImplementation(newDescriptor), newPath);
+    }
+    symlinkAt(oldPath, newPath) {
+        return this.#implementation.symlinkAt(oldPath, newPath);
+    }
+    unlinkFileAt(path) {
+        return this.#implementation.unlinkFileAt(path);
+    }
+    isSameObject(other) {
+        return this.#implementation.isSameObject(descriptorGetImplementation(other));
+    }
+    metadataHash() {
+        return this.#implementation.metadataHash();
+    }
+    metadataHashAt(pathFlags, path) {
+        return this.#implementation.metadataHashAt(pathFlags, path);
+    }
+    lockShared() {
+        return this.#implementation.lockShared?.();
+    }
+    lockExclusive() {
+        return this.#implementation.lockExclusive?.();
+    }
+    tryLockShared() {
+        return this.#implementation.tryLockShared?.() ?? false;
+    }
+    tryLockExclusive() {
+        return this.#implementation.tryLockExclusive?.() ?? false;
+    }
+    unlock() {
+        return this.#implementation.unlock?.();
+    }
+}
+const descriptorGetImplementation = Descriptor.prototype._getImplementation;
+// @ts-expect-error - Deleting prototype method
+delete Descriptor.prototype._getImplementation;
+const descriptorCreate = Descriptor._create;
+// @ts-expect-error - Deleting static method
+delete Descriptor._create;
+const defaultAdapter = new InMemoryFilesystemAdapter();
+let _fileData = { dir: {} };
+let _preopens = [];
+let _rootPreopen = null;
+export const preopens = {
+    getDirectories() {
+        return _preopens;
+    },
+};
+/** Create isolated filesystem namespaces backed by an application-selected adapter. */
+export function createFilesystem({ adapter, preopens: configuredPreopens, }) {
+    const entries = Object.entries(configuredPreopens).map(([guestPath, capability]) => [descriptorCreate(adapter.getRoot(capability)), guestPath]);
+    let disposed = false;
+    let disposal;
+    return {
+        types,
+        preopens: {
+            getDirectories() {
+                if (disposed) {
+                    throw new Error("filesystem adapter has been disposed");
+                }
+                return [...entries];
+            },
+        },
+        dispose() {
+            if (disposed) {
+                return disposal;
+            }
+            disposed = true;
+            disposal = adapter.dispose?.();
+            return disposal;
+        },
+    };
+}
+export function _setFileData(fileData) {
+    _fileData = fileData;
+    if (_rootPreopen) {
+        _rootPreopen[0] = descriptorCreate(defaultAdapter.getRoot(fileData));
+    }
+    else {
+        _setPreopens({ "/": fileData });
+    }
+    const cwd = environment.initialCwd();
+    _setCwd(cwd || "/");
+}
+export function _getFileData() {
+    return JSON.stringify(_fileData);
+}
+/**
+ * Replace all preopens with the given set.
+ * @param preopensConfig - Map of virtual paths to file data entries
+ */
+export function _setPreopens(preopensConfig) {
+    _preopens = [];
+    _rootPreopen = null;
+    for (const [virtualPath, fileData] of Object.entries(preopensConfig)) {
+        _addPreopen(virtualPath, fileData);
+    }
+}
+/**
+ * Add a single preopen mapping.
+ * @param virtualPath - The virtual path visible to the guest
+ * @param fileData - The file data object representing the directory
+ */
+export function _addPreopen(virtualPath, fileData) {
+    const descriptor = descriptorCreate(defaultAdapter.getRoot(fileData));
+    const entry = [descriptor, virtualPath];
+    _preopens.push(entry);
+    if (virtualPath === "/") {
+        _rootPreopen = entry;
+    }
+}
+/**
+ * Add a single preopen backed by a custom adapter (e.g. `OpfsFilesystemAdapter`) instead of the
+ * default in-memory one. Lets a host wire an alternative `BrowserFilesystemAdapter` into the
+ * top-level `wasi:filesystem/preopens` singleton that transpiled components import statically.
+ * @param virtualPath - The virtual path visible to the guest
+ * @param adapter - The adapter that will back this preopen
+ * @param capability - The adapter-specific capability to load as the preopen's root
+ */
+export function _addPreopenWithAdapter(virtualPath, adapter, capability) {
+    const descriptor = descriptorCreate(adapter.getRoot(capability));
+    const entry = [descriptor, virtualPath];
+    _preopens.push(entry);
+    if (virtualPath === "/") {
+        _rootPreopen = entry;
+    }
+}
+/** Clear all preopens, giving the guest no filesystem access. */
+export function _clearPreopens() {
+    _preopens = [];
+    _rootPreopen = null;
+}
+/** Get current preopens configuration. */
+export function _getPreopens() {
+    return [..._preopens];
+}
+/** Reject host paths because browser filesystems require explicit capabilities. */
+export function _createPreopenDescriptor(hostPreopen) {
+    throw new TypeError(`browser preopen ${JSON.stringify(hostPreopen)} is a host path; configure browser file data or an adapter instead`);
+}
+export const types = {
+    Descriptor,
+    DirectoryEntryStream,
+    filesystemErrorCode: (err) => {
+        let message;
+        if ("payload" in err) {
+            message = err.payload;
+        }
+        else if ("message" in err) {
+            message = err.message;
+        }
+        return convertFsError(message);
+    },
+};
+function convertFsError(e) {
+    switch (e.code) {
+        case "EACCES":
+            return "access";
+        case "EAGAIN":
+        case "EWOULDBLOCK":
+            return "would-block";
+        case "EALREADY":
+            return "already";
+        case "EBADF":
+            return "bad-descriptor";
+        case "EBUSY":
+            return "busy";
+        case "EDEADLK":
+            return "deadlock";
+        case "EDQUOT":
+            return "quota";
+        case "EEXIST":
+            return "exist";
+        case "EFBIG":
+            return "file-too-large";
+        case "EILSEQ":
+            return "illegal-byte-sequence";
+        case "EINPROGRESS":
+            return "in-progress";
+        case "EINTR":
+            return "interrupted";
+        case "EINVAL":
+            return "invalid";
+        case "EIO":
+            return "io";
+        case "EISDIR":
+            return "is-directory";
+        case "ELOOP":
+            return "loop";
+        case "EMLINK":
+            return "too-many-links";
+        case "EMSGSIZE":
+            return "message-size";
+        case "ENAMETOOLONG":
+            return "name-too-long";
+        case "ENODEV":
+            return "no-device";
+        case "ENOENT":
+            return "no-entry";
+        case "ENOLCK":
+            return "no-lock";
+        case "ENOMEM":
+            return "insufficient-memory";
+        case "ENOSPC":
+            return "insufficient-space";
+        case "ENOTDIR":
+        case "ERR_FS_EISDIR":
+            return "not-directory";
+        case "ENOTEMPTY":
+            return "not-empty";
+        case "ENOTRECOVERABLE":
+            return "not-recoverable";
+        case "ENOTSUP":
+            return "unsupported";
+        case "ENOTTY":
+            return "no-tty";
+        // windows gives this error for badly structured `//` reads
+        // this seems like a slightly better error than unknown given
+        // that it's a common footgun
+        case -4094:
+        case "ENXIO":
+            return "no-such-device";
+        case "EOVERFLOW":
+            return "overflow";
+        case "EPERM":
+            return "not-permitted";
+        case "EPIPE":
+            return "pipe";
+        case "EROFS":
+            return "read-only";
+        case "ESPIPE":
+            return "invalid-seek";
+        case "ETXTBSY":
+            return "text-file-busy";
+        case "EXDEV":
+            return "cross-device";
+        case "UNKNOWN":
+            switch (e.errno) {
+                case -4094:
+                    return "no-such-device";
+                default:
+                    throw e;
+            }
+        default:
+            throw e;
+    }
+}

package/assets/wasi/helpers/cli.d.ts

@@ -0,0 +1,7 @@
+import { type InputStreamHandler } from "../io.js";
+/**
+ * Build an `InputStreamHandler` that serves a fixed buffer, then reports `closed`.
+ *
+ * Pass the result to `createCli({ stdin })` or `_setStdin` to feed a guest a fixed stdin.
+ */
+export declare function bufferedInputStream(input: Uint8Array | string): InputStreamHandler;

package/assets/wasi/helpers/cli.js

@@ -0,0 +1,25 @@
+import { pollableCreate } from "../io.js";
+/**
+ * Build an `InputStreamHandler` that serves a fixed buffer, then reports `closed`.
+ *
+ * Pass the result to `createCli({ stdin })` or `_setStdin` to feed a guest a fixed stdin.
+ */
+export function bufferedInputStream(input) {
+    const bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
+    let offset = 0;
+    return {
+        blockingRead(len) {
+            if (offset >= bytes.length) {
+                throw { tag: "closed" };
+            }
+            const remaining = bytes.length - offset;
+            const toRead = len < BigInt(remaining) ? Number(len) : remaining;
+            const chunk = bytes.slice(offset, offset + toRead);
+            offset += toRead;
+            return chunk;
+        },
+        subscribe() {
+            return pollableCreate();
+        },
+    };
+}

package/assets/wasi/helpers/filesystem.d.ts

@@ -0,0 +1,6 @@
+import { type WriteFileAtOptions } from "../../common/helpers/filesystem.js";
+export type { WriteFileAtOptions };
+/** Write bytes into a preopened directory's tree from host JS, without a guest. */
+export declare function writeFileAt(virtualPath: string, path: string, data: Uint8Array, options?: WriteFileAtOptions): void;
+/** Read the full contents of a file under a preopened directory from host JS, without a guest. */
+export declare function readFileAt(virtualPath: string, path: string): Uint8Array;

package/assets/wasi/helpers/filesystem.js

@@ -0,0 +1,10 @@
+import { _getPreopens } from "../filesystem.js";
+import { writeFileAt as writeFileAtImpl, readFileAt as readFileAtImpl, } from "../../common/helpers/filesystem.js";
+/** Write bytes into a preopened directory's tree from host JS, without a guest. */
+export function writeFileAt(virtualPath, path, data, options = {}) {
+    writeFileAtImpl(_getPreopens(), virtualPath, path, data, options);
+}
+/** Read the full contents of a file under a preopened directory from host JS, without a guest. */
+export function readFileAt(virtualPath, path) {
+    return readFileAtImpl(_getPreopens(), virtualPath, path);
+}

package/assets/wasi/http.d.ts

@@ -0,0 +1,13 @@
+import type { incomingHandler as IncomingHandlerNamespace, outgoingHandler as OutgoingHandlerNamespace, types as TypesNamespace } from "../../types/http.js";
+export { InMemoryHttpClient } from "./in-memory-http.js";
+/** Enable or disable Fetch `ReadableStream` request bodies. Disabled by default. */
+export declare function _setRequestStreaming(enabled: boolean): void;
+export declare const outgoingHandler: typeof OutgoingHandlerNamespace;
+export declare const incomingHandler: typeof IncomingHandlerNamespace;
+export type WasiIncomingHandler = (request: TypesNamespace.IncomingRequest, responseOut: TypesNamespace.ResponseOutparam) => void | Promise<void>;
+export type WebIncomingHandler = (request: Request) => Response | Promise<Response>;
+/** Create a `wasi:http/incoming-handler` namespace backed by a Web Request handler. */
+export declare function createIncomingHandler(handler: WebIncomingHandler): typeof IncomingHandlerNamespace;
+/** Translate a browser Request through a WASI handler with a synchronously readable body. */
+export declare function handleIncomingRequest(request: Request, handler: WasiIncomingHandler): Promise<Response>;
+export declare const types: typeof TypesNamespace;