@bytecodealliance/preview2-shim 0.23.0 → 0.24.1

package/dist/browser/filesystem.js

@@ -1,339 +1,173 @@
-import { inputStreamCreate, outputStreamCreate } from "./io.js";
 import { environment } from "./environment.js";
-import { _setCwd, _getCwd } from "./config.js";
+import { InMemoryFilesystemAdapter } from "./in-memory-filesystem.js";
+import { _setCwd } from "./config.js";
 export { _setCwd } from "./config.js";
-export function _setFileData(fileData) {
-    _fileData = fileData;
-    _rootPreopen[0] = descriptorCreate(fileData);
-    const cwd = environment.initialCwd();
-    _setCwd(cwd || "/");
-}
-export function _getFileData() {
-    return JSON.stringify(_fileData);
-}
-let _fileData = { dir: {} };
-const timeZero = {
-    seconds: 0n,
-    nanoseconds: 0,
-};
-/** Coerce the given object to a safe integer */
-function coerceToSafeIntegerNumber(obj) {
-    let n;
-    if (typeof obj === "number") {
-        n = obj;
-    }
-    else if (typeof obj == "bigint") {
-        n = Number(obj);
-    }
-    else {
-        throw new TypeError(`unexpected non-numeric type: ${obj}`);
-    }
-    if (n > Number.MAX_SAFE_INTEGER) {
-        throw new TypeError(`excessively large number: ${n}`);
-    }
-    return n;
-}
-function getChildEntry(parentEntry, subpath, openFlags) {
-    if (subpath === "." && _rootPreopen && descriptorGetEntry(_rootPreopen[0]) === parentEntry) {
-        subpath = _getCwd();
-        if (subpath.startsWith("/") && subpath !== "/") {
-            subpath = subpath.slice(1);
-        }
-    }
-    let entry = parentEntry;
-    let segmentIdx;
-    do {
-        if (!entry?.dir) {
-            throw "not-directory";
-        }
-        segmentIdx = subpath.indexOf("/");
-        const segment = segmentIdx === -1 ? subpath : subpath.slice(0, segmentIdx);
-        if (segment === "..") {
-            throw "no-entry";
-        }
-        if (segment === "." || segment === "") {
-        }
-        else if (!entry.dir[segment] && openFlags.create) {
-            entry = entry.dir[segment] = openFlags.directory
-                ? { dir: {} }
-                : { source: new Uint8Array([]) };
-        }
-        else {
-            entry = entry.dir[segment];
-        }
-        subpath = subpath.slice(segmentIdx + 1);
-    } while (segmentIdx !== -1);
-    if (!entry) {
-        throw "no-entry";
-    }
-    return entry;
-}
-function getSource(fileEntry) {
-    if (typeof fileEntry.source === "string") {
-        fileEntry.source = new TextEncoder().encode(fileEntry.source);
-    }
-    return fileEntry.source;
-}
-// Keep spare capacity separate so FileDataEntry.source always reflects the logical file size.
-const fileWriteBuffers = new WeakMap();
-function getFileWriteBuffer(entry, source, requiredLength) {
-    let buffer = fileWriteBuffers.get(entry);
-    if (!buffer || buffer.buffer !== source.buffer || buffer.byteOffset !== source.byteOffset) {
-        buffer = source;
-    }
-    if (requiredLength <= buffer.byteLength) {
-        return buffer;
-    }
-    const newBuffer = new Uint8Array(Math.max(requiredLength, source.byteLength * 2));
-    newBuffer.set(source);
-    fileWriteBuffers.set(entry, newBuffer);
-    return newBuffer;
-}
+export { InMemoryFilesystemAdapter } from "./in-memory-filesystem.js";
 class DirectoryEntryStream {
-    idx = 0;
-    entries = [];
-    static _create(entries) {
+    #implementation;
+    static _create(implementation) {
         const stream = new DirectoryEntryStream();
-        stream.entries = entries;
+        stream.#implementation = implementation;
         return stream;
     }
     readDirectoryEntry() {
-        if (this.idx === this.entries.length) {
-            return undefined;
-        }
-        const [name, entry] = this.entries[this.idx];
-        this.idx += 1;
-        return {
-            name,
-            type: entry.dir ? "directory" : "regular-file",
-        };
+        return this.#implementation.readDirectoryEntry();
     }
 }
-const descriptorEntryStreamCreate = DirectoryEntryStream._create;
+const directoryEntryStreamCreate = DirectoryEntryStream._create;
 // @ts-expect-error - Deleting static method
 delete DirectoryEntryStream._create;
 class Descriptor {
-    #stream;
-    #entry;
-    #mtime = 0;
-    _getEntry(descriptor) {
-        return descriptor.#entry;
+    #implementation;
+    _getImplementation(descriptor) {
+        return descriptor.#implementation;
     }
-    static _create(entry, isStream) {
+    static _create(implementation) {
         const descriptor = new Descriptor();
-        if (isStream) {
-            descriptor.#stream = entry;
-        }
-        else {
-            descriptor.#entry = entry;
-        }
+        descriptor.#implementation = implementation;
         return descriptor;
     }
-    readViaStream(_offset) {
-        const source = getSource(this.#entry);
-        let offset = Number(_offset);
-        return inputStreamCreate({
-            blockingRead(len) {
-                if (offset === source.byteLength) {
-                    throw { tag: "closed" };
-                }
-                const bytes = source.slice(offset, offset + Number(len));
-                offset += bytes.byteLength;
-                return bytes;
-            },
-        });
-    }
-    writeViaStream(_offset) {
-        const entry = this.#entry;
-        let offset = coerceToSafeIntegerNumber(_offset);
-        return outputStreamCreate({
-            write(buf) {
-                if (buf.byteLength === 0) {
-                    return;
-                }
-                const source = getSource(entry);
-                const end = offset + buf.byteLength;
-                if (!Number.isSafeInteger(end)) {
-                    throw new TypeError(`excessively large number: ${end}`);
-                }
-                const buffer = getFileWriteBuffer(entry, source, end);
-                if (offset > source.byteLength) {
-                    buffer.fill(0, source.byteLength, offset);
-                }
-                buffer.set(buf, offset);
-                entry.source = buffer.subarray(0, Math.max(source.byteLength, end));
-                offset = end;
-            },
-        });
+    readViaStream(offset) {
+        return this.#implementation.readViaStream(offset);
+    }
+    writeViaStream(offset) {
+        return this.#implementation.writeViaStream(offset);
     }
     appendViaStream() {
-        console.log(`[filesystem] APPEND STREAM`);
-        return {};
+        return this.#implementation.appendViaStream();
     }
     advise(offset, length, advice) {
-        console.log(`[filesystem] ADVISE`, offset, length, advice);
+        return this.#implementation.advise(offset, length, advice);
     }
     syncData() {
-        console.log(`[filesystem] SYNC DATA`);
+        return this.#implementation.syncData();
     }
     getFlags() {
-        console.log(`[filesystem] FLAGS FOR`);
-        return {};
+        return this.#implementation.getFlags();
     }
     getType() {
-        if (this.#stream) {
-            return "fifo";
-        }
-        if (this.#entry.dir) {
-            return "directory";
-        }
-        if (this.#entry.source) {
-            return "regular-file";
-        }
-        return "unknown";
+        return this.#implementation.getType();
     }
     setSize(size) {
-        console.log(`[filesystem] SET SIZE`, size);
+        return this.#implementation.setSize(size);
     }
     setTimes(dataAccessTimestamp, dataModificationTimestamp) {
-        console.log(`[filesystem] SET TIMES`, dataAccessTimestamp, dataModificationTimestamp);
+        return this.#implementation.setTimes(dataAccessTimestamp, dataModificationTimestamp);
     }
     read(length, offset) {
-        const source = getSource(this.#entry);
-        const off = coerceToSafeIntegerNumber(offset);
-        const len = coerceToSafeIntegerNumber(length);
-        const result = [
-            source.slice(off, off + len),
-            off + len >= source.byteLength,
-        ];
-        return result;
+        return this.#implementation.read(length, offset);
     }
     write(buffer, offset) {
-        if (offset !== 0n) {
-            throw "invalid-seek";
-        }
-        this.#entry.source = buffer;
-        return BigInt(buffer.byteLength);
+        return this.#implementation.write(buffer, offset);
     }
     readDirectory() {
-        if (!this.#entry?.dir) {
-            throw "bad-descriptor";
-        }
-        return descriptorEntryStreamCreate(Object.entries(this.#entry.dir).sort(([a], [b]) => (a > b ? 1 : -1)));
+        return directoryEntryStreamCreate(this.#implementation.readDirectory());
     }
     sync() {
-        console.log(`[filesystem] SYNC`);
+        return this.#implementation.sync();
     }
     createDirectoryAt(path) {
-        const entry = getChildEntry(this.#entry, path, {
-            create: true,
-            directory: true,
-        });
-        if (entry.source) {
-            throw "exist";
-        }
+        return this.#implementation.createDirectoryAt(path);
     }
     stat() {
-        let type = "unknown";
-        let size = 0n;
-        if (this.#entry.source) {
-            type = "regular-file";
-            const source = getSource(this.#entry);
-            size = BigInt(source.byteLength);
-        }
-        else if (this.#entry.dir) {
-            type = "directory";
-        }
-        return {
-            type,
-            linkCount: 0n,
-            size,
-            dataAccessTimestamp: timeZero,
-            dataModificationTimestamp: timeZero,
-            statusChangeTimestamp: timeZero,
-        };
-    }
-    statAt(_pathFlags, path) {
-        const entry = getChildEntry(this.#entry, path, {
-            create: false,
-            directory: false,
-        });
-        let type = "unknown";
-        let size = 0n;
-        if (entry.source) {
-            type = "regular-file";
-            const source = getSource(entry);
-            size = BigInt(source.byteLength);
-        }
-        else if (entry.dir) {
-            type = "directory";
-        }
-        return {
-            type,
-            linkCount: 0n,
-            size,
-            dataAccessTimestamp: timeZero,
-            dataModificationTimestamp: timeZero,
-            statusChangeTimestamp: timeZero,
-        };
+        return this.#implementation.stat();
+    }
+    statAt(pathFlags, path) {
+        return this.#implementation.statAt(pathFlags, path);
     }
-    setTimesAt() {
-        console.log(`[filesystem] SET TIMES AT`);
+    setTimesAt(pathFlags, path, dataAccessTimestamp, dataModificationTimestamp) {
+        return this.#implementation.setTimesAt(pathFlags, path, dataAccessTimestamp, dataModificationTimestamp);
     }
-    linkAt() {
-        console.log(`[filesystem] LINK AT`);
+    linkAt(oldPathFlags, oldPath, newDescriptor, newPath) {
+        return this.#implementation.linkAt(oldPathFlags, oldPath, descriptorGetImplementation(newDescriptor), newPath);
     }
-    openAt(_pathFlags, path, openFlags, _flags) {
-        const childEntry = getChildEntry(this.#entry, path, openFlags);
-        return descriptorCreate(childEntry);
+    openAt(pathFlags, path, openFlags, flags) {
+        return descriptorCreate(this.#implementation.openAt(pathFlags, path, openFlags, flags));
     }
-    readlinkAt(_path) {
-        console.log(`[filesystem] READLINK AT`);
-        return "";
+    readlinkAt(path) {
+        return this.#implementation.readlinkAt(path);
     }
-    removeDirectoryAt() {
-        console.log(`[filesystem] REMOVE DIR AT`);
+    removeDirectoryAt(path) {
+        return this.#implementation.removeDirectoryAt(path);
     }
-    renameAt() {
-        console.log(`[filesystem] RENAME AT`);
+    renameAt(oldPath, newDescriptor, newPath) {
+        return this.#implementation.renameAt(oldPath, descriptorGetImplementation(newDescriptor), newPath);
     }
-    symlinkAt() {
-        console.log(`[filesystem] SYMLINK AT`);
+    symlinkAt(oldPath, newPath) {
+        return this.#implementation.symlinkAt(oldPath, newPath);
     }
-    unlinkFileAt() {
-        console.log(`[filesystem] UNLINK FILE AT`);
+    unlinkFileAt(path) {
+        return this.#implementation.unlinkFileAt(path);
     }
     isSameObject(other) {
-        return other === this;
+        return this.#implementation.isSameObject(descriptorGetImplementation(other));
     }
     metadataHash() {
-        let upper = 0n;
-        upper += BigInt(this.#mtime);
-        return { upper, lower: 0n };
+        return this.#implementation.metadataHash();
     }
-    metadataHashAt(_pathFlags, _path) {
-        return this.metadataHash();
+    metadataHashAt(pathFlags, path) {
+        return this.#implementation.metadataHashAt(pathFlags, path);
     }
 }
-const descriptorGetEntry = Descriptor.prototype._getEntry;
+const descriptorGetImplementation = Descriptor.prototype._getImplementation;
 // @ts-expect-error - Deleting prototype method
-delete Descriptor.prototype._getEntry;
+delete Descriptor.prototype._getImplementation;
 const descriptorCreate = Descriptor._create;
 // @ts-expect-error - Deleting static method
 delete Descriptor._create;
-let _preopens = [[descriptorCreate(_fileData), "/"]];
-let _rootPreopen = _preopens[0];
+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;
+    return {
+        types,
+        preopens: {
+            getDirectories() {
+                if (disposed) {
+                    throw new Error("filesystem adapter has been disposed");
+                }
+                return [...entries];
+            },
+        },
+        dispose() {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            adapter.dispose?.();
+        },
+    };
+}
+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);
     }
@@ -344,40 +178,25 @@ export function _setPreopens(preopensConfig) {
  * @param fileData - The file data object representing the directory
  */
 export function _addPreopen(virtualPath, fileData) {
-    const descriptor = descriptorCreate(fileData);
-    _preopens.push([descriptor, virtualPath]);
+    const descriptor = descriptorCreate(defaultAdapter.getRoot(fileData));
+    const entry = [descriptor, virtualPath];
+    _preopens.push(entry);
     if (virtualPath === "/") {
-        _rootPreopen = [descriptor, virtualPath];
+        _rootPreopen = entry;
     }
 }
-/**
- * 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.
- */
+/** Clear all preopens, giving the guest no filesystem access. */
 export function _clearPreopens() {
     _preopens = [];
     _rootPreopen = null;
 }
-/**
- * Get current preopens configuration.
- * @returns Array of [descriptor, virtualPath] pairs
- */
+/** Get current preopens configuration. */
 export function _getPreopens() {
     return [..._preopens];
 }
-/**
- * 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
- */
+/** Reject host paths because browser filesystems require explicit capabilities. */
 export function _createPreopenDescriptor(hostPreopen) {
-    _fileData.dir = {
-        [hostPreopen]: {},
-    };
-    return descriptorCreate(_fileData);
+    throw new TypeError(`browser preopen ${JSON.stringify(hostPreopen)} is a host path; configure browser file data or an adapter instead`);
 }
 export const types = {
     Descriptor,

package/dist/browser/http.d.ts

@@ -1,4 +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;