@bytecodealliance/preview2-shim 0.20.0 → 0.20.2

package/README.md

@@ -6,6 +6,10 @@ Node.js support is fully tested and conformant against the Wasmtime test suite.
 
 Browser support is considered experimental, and not currently suitable for production applications.
 
+The Node.js implementation owns its worker artifact. Direct package use and supported downstream
+bundlers should resolve it through the public shim imports; applications do not need to import or
+copy files from `dist/io`.
+
 # Features
 
 ## WASI Shim object for easy instantiation

package/dist/browser/filesystem.d.ts

@@ -38,7 +38,7 @@ declare class Descriptor implements TypesNamespace.Descriptor {
     advise(offset: Filesize, length: Filesize, advice: TypesNamespace.Advice): void;
     syncData(): void;
     getFlags(): TypesNamespace.DescriptorFlags;
-    getType(): "directory" | "regular-file" | "unknown" | "fifo";
+    getType(): "directory" | "fifo" | "regular-file" | "unknown";
     setSize(size: bigint): void;
     setTimes(dataAccessTimestamp: any, dataModificationTimestamp: any): void;
     read(length: bigint, offset: bigint): [Uint8Array<ArrayBufferLike>, boolean];

package/dist/io/calls.d.ts

@@ -29,6 +29,17 @@ export declare const OUTPUT_STREAM_BLOCKING_SPLICE: number;
 export declare const OUTPUT_STREAM_SUBSCRIBE: number;
 export declare const OUTPUT_STREAM_DISPOSE: number;
 export declare const OUTPUT_STREAM_GET_TOTAL_BYTES: number;
+export declare const FILESYSTEM_DESCRIPTOR_OPEN: number;
+export declare const FILESYSTEM_DESCRIPTOR_CLOSE: number;
+export declare const FILESYSTEM_DESCRIPTOR_SYNC_DATA: number;
+export declare const FILESYSTEM_DESCRIPTOR_GET_TYPE: number;
+export declare const FILESYSTEM_DESCRIPTOR_SET_SIZE: number;
+export declare const FILESYSTEM_DESCRIPTOR_SET_TIMES: number;
+export declare const FILESYSTEM_DESCRIPTOR_READ: number;
+export declare const FILESYSTEM_DESCRIPTOR_WRITE: number;
+export declare const FILESYSTEM_DESCRIPTOR_SYNC: number;
+export declare const FILESYSTEM_DESCRIPTOR_STAT: number;
+export declare const FILESYSTEM_DESCRIPTOR_METADATA_HASH: number;
 export declare const POLL_POLLABLE_READY: number;
 export declare const POLL_POLLABLE_BLOCK: number;
 export declare const POLL_POLLABLE_DISPOSE: number;

package/dist/io/calls.js

@@ -35,6 +35,18 @@ export const OUTPUT_STREAM_BLOCKING_SPLICE = ++call_id << CALL_SHIFT;
 export const OUTPUT_STREAM_SUBSCRIBE = ++call_id << CALL_SHIFT;
 export const OUTPUT_STREAM_DISPOSE = ++call_id << CALL_SHIFT;
 export const OUTPUT_STREAM_GET_TOTAL_BYTES = ++call_id << CALL_SHIFT;
+// Filesystem descriptors
+export const FILESYSTEM_DESCRIPTOR_OPEN = ++call_id << CALL_SHIFT;
+export const FILESYSTEM_DESCRIPTOR_CLOSE = ++call_id << CALL_SHIFT;
+export const FILESYSTEM_DESCRIPTOR_SYNC_DATA = ++call_id << CALL_SHIFT;
+export const FILESYSTEM_DESCRIPTOR_GET_TYPE = ++call_id << CALL_SHIFT;
+export const FILESYSTEM_DESCRIPTOR_SET_SIZE = ++call_id << CALL_SHIFT;
+export const FILESYSTEM_DESCRIPTOR_SET_TIMES = ++call_id << CALL_SHIFT;
+export const FILESYSTEM_DESCRIPTOR_READ = ++call_id << CALL_SHIFT;
+export const FILESYSTEM_DESCRIPTOR_WRITE = ++call_id << CALL_SHIFT;
+export const FILESYSTEM_DESCRIPTOR_SYNC = ++call_id << CALL_SHIFT;
+export const FILESYSTEM_DESCRIPTOR_STAT = ++call_id << CALL_SHIFT;
+export const FILESYSTEM_DESCRIPTOR_METADATA_HASH = ++call_id << CALL_SHIFT;
 // Io Poll
 export const POLL_POLLABLE_READY = ++call_id << CALL_SHIFT;
 export const POLL_POLLABLE_BLOCK = ++call_id << CALL_SHIFT;

package/dist/io/worker-filesystem.d.ts

@@ -0,0 +1,29 @@
+export declare function openFileResource(path: string, flags: number): Promise<{
+    id: number;
+    type: any;
+}>;
+export declare function retainFileResource(id: number): number;
+export declare function releaseFileResource(id: number): Promise<void>;
+export declare function fileResourceFd(id: number): number;
+export declare function syncFileResourceData(id: number): Promise<void>;
+export declare function getFileResourceType(id: number): Promise<"block-device" | "character-device" | "directory" | "fifo" | "regular-file" | "socket" | "symbolic-link" | "unknown">;
+export declare function setFileResourceSize(id: number, size: number): Promise<void>;
+export declare function setFileResourceTimes(id: number, atime: number, mtime: number): Promise<void>;
+export declare function readFileResource(id: number, length: number, offset: number): Promise<{
+    bytes: Uint8Array<ArrayBuffer>;
+    eof: boolean;
+}>;
+export declare function writeFileResource(id: number, buffer: Uint8Array, offset: number): Promise<number>;
+export declare function syncFileResource(id: number): Promise<void>;
+export declare function statFileResource(id: number): Promise<{
+    type: string;
+    nlink: bigint;
+    size: bigint;
+    atimeNs: bigint;
+    mtimeNs: bigint;
+    ctimeNs: bigint;
+}>;
+export declare function metadataHashFileResource(id: number): Promise<{
+    upper: bigint;
+    lower: bigint;
+}>;

package/dist/io/worker-filesystem.js

@@ -0,0 +1,116 @@
+import fs from "node:fs";
+import { promisify } from "node:util";
+const closeAsync = promisify(fs.close);
+const fdatasyncAsync = promisify(fs.fdatasync);
+const fstatAsync = promisify(fs.fstat);
+const fsyncAsync = promisify(fs.fsync);
+const ftruncateAsync = promisify(fs.ftruncate);
+const futimesAsync = promisify(fs.futimes);
+const openAsync = promisify(fs.open);
+const readAsync = promisify(fs.read);
+const writeAsync = promisify(fs.write);
+let nextFileResourceId = 0;
+const fileResources = new Map();
+function lookupType(obj) {
+    if (obj.isFile()) {
+        return "regular-file";
+    }
+    if (obj.isSocket()) {
+        return "socket";
+    }
+    if (obj.isSymbolicLink()) {
+        return "symbolic-link";
+    }
+    if (obj.isFIFO()) {
+        return "fifo";
+    }
+    if (obj.isDirectory()) {
+        return "directory";
+    }
+    if (obj.isCharacterDevice()) {
+        return "character-device";
+    }
+    if (obj.isBlockDevice()) {
+        return "block-device";
+    }
+    return "unknown";
+}
+function getFileResource(id) {
+    const resource = fileResources.get(id);
+    if (!resource) {
+        const error = new Error(`Invalid filesystem descriptor resource: ${id}`);
+        error.code = "EBADF";
+        throw error;
+    }
+    return resource;
+}
+export async function openFileResource(path, flags) {
+    const fd = await openAsync(path, flags);
+    let type;
+    try {
+        type = lookupType(await fstatAsync(fd, { bigint: true }));
+    }
+    catch (error) {
+        await closeAsync(fd);
+        throw error;
+    }
+    const id = ++nextFileResourceId;
+    fileResources.set(id, { fd, refs: 1 });
+    return { id, type };
+}
+export function retainFileResource(id) {
+    getFileResource(id).refs++;
+    return id;
+}
+export async function releaseFileResource(id) {
+    const resource = getFileResource(id);
+    if (--resource.refs === 0) {
+        fileResources.delete(id);
+        await closeAsync(resource.fd);
+    }
+}
+export function fileResourceFd(id) {
+    return getFileResource(id).fd;
+}
+export async function syncFileResourceData(id) {
+    await fdatasyncAsync(fileResourceFd(id));
+}
+export async function getFileResourceType(id) {
+    return lookupType(await fstatAsync(fileResourceFd(id), { bigint: true }));
+}
+export async function setFileResourceSize(id, size) {
+    await ftruncateAsync(fileResourceFd(id), size);
+}
+export async function setFileResourceTimes(id, atime, mtime) {
+    await futimesAsync(fileResourceFd(id), atime, mtime);
+}
+export async function readFileResource(id, length, offset) {
+    const buffer = new Uint8Array(length);
+    const result = await readAsync(fileResourceFd(id), buffer, 0, length, offset);
+    // Deno v1 returns the byte count directly, while Node returns an object
+    // containing the byte count and buffer through util.promisify's custom args.
+    const bytesRead = typeof result === "number" ? result : result.bytesRead;
+    return { bytes: buffer.subarray(0, bytesRead), eof: bytesRead === 0 };
+}
+export async function writeFileResource(id, buffer, offset) {
+    const result = await writeAsync(fileResourceFd(id), buffer, 0, buffer.byteLength, offset);
+    return typeof result === "number" ? result : result.bytesWritten;
+}
+export async function syncFileResource(id) {
+    await fsyncAsync(fileResourceFd(id));
+}
+export async function statFileResource(id) {
+    const stats = await fstatAsync(fileResourceFd(id), { bigint: true });
+    return {
+        type: lookupType(stats),
+        nlink: stats.nlink,
+        size: stats.size,
+        atimeNs: stats.atimeNs,
+        mtimeNs: stats.mtimeNs,
+        ctimeNs: stats.ctimeNs,
+    };
+}
+export async function metadataHashFileResource(id) {
+    const stats = await fstatAsync(fileResourceFd(id), { bigint: true });
+    return { upper: stats.mtimeNs, lower: stats.ino };
+}

package/dist/io/worker-http.d.ts

@@ -2,13 +2,13 @@ export declare function stopHttpServer(id: any): Promise<void>;
 export declare function clearOutgoingResponse(id: any): void;
 export declare function getHttpServerAddress(id: any): Promise<any>;
 export declare function setOutgoingResponse(id: any, { statusCode, headers, streamId }: {
-    statusCode: any;
     headers: any;
+    statusCode: any;
     streamId: any;
 }): Promise<void>;
 export declare function startHttpServer(id: number, { port, host }: {
-    port: any;
     host: any;
+    port: any;
 }): Promise<void>;
 export declare function createHttpRequest(method: any, scheme: any, authority: any, pathWithQuery: any, headers: any, bodyId: any, connectTimeout: any, betweenBytesTimeout: any, firstByteTimeout: any): Promise<{
     status: number | undefined;

package/dist/io/worker-io.js

@@ -1,4 +1,4 @@
-import { fileURLToPath } from "node:url";
+import { Worker } from "node:worker_threads";
 import { createSyncFn } from "../synckit/index.js";
 import { CALL_MASK, CALL_TYPE_MASK, FILE, HTTP_SERVER_INCOMING_HANDLER, HTTP, INPUT_STREAM_BLOCKING_READ, INPUT_STREAM_BLOCKING_SKIP, INPUT_STREAM_DISPOSE, INPUT_STREAM_READ, INPUT_STREAM_SKIP, INPUT_STREAM_SUBSCRIBE, OUTPUT_STREAM_BLOCKING_FLUSH, OUTPUT_STREAM_BLOCKING_SPLICE, OUTPUT_STREAM_BLOCKING_WRITE_AND_FLUSH, OUTPUT_STREAM_BLOCKING_WRITE_ZEROES_AND_FLUSH, OUTPUT_STREAM_CHECK_WRITE, OUTPUT_STREAM_DISPOSE, OUTPUT_STREAM_FLUSH, OUTPUT_STREAM_SPLICE, OUTPUT_STREAM_SUBSCRIBE, OUTPUT_STREAM_WRITE_ZEROES, OUTPUT_STREAM_WRITE, POLL_POLL_LIST, POLL_POLLABLE_BLOCK, POLL_POLLABLE_DISPOSE, POLL_POLLABLE_READY, SOCKET_TCP, STDERR, STDIN, STDOUT, reverseMap, } from "./calls.js";
 import nodeProcess, { exit, stderr, stdout, env } from "node:process";
@@ -6,7 +6,6 @@ const symbolDispose = Symbol.dispose || Symbol.for("dispose");
 const _rawDebug = "_rawDebug" in nodeProcess
     ? nodeProcess._rawDebug
     : console.error.bind(console);
-const workerPath = fileURLToPath(new URL("./worker-thread.js", import.meta.url));
 const httpIncomingHandlers = new Map();
 export function registerIncomingHttpHandler(id, handler) {
     httpIncomingHandlers.set(id, handler);
@@ -21,7 +20,7 @@ const DEBUG = env.PREVIEW2_SHIM_DEBUG === "0"
 /**
  * @type {(call: number, id: number | null, payload: any) -> any}
  */
-export let ioCall = createSyncFn(workerPath, DEBUG, (type, id, payload) => {
+export let ioCall = createSyncFn((options) => new Worker(new URL("./worker-thread.bundle.js", import.meta.url), options), DEBUG, (type, id, payload) => {
     // 'callbacks' from the worker
     // ONLY happens for an http server incoming handler, and NOTHING else (not even sockets, since accept is sync!)
     if (type !== HTTP_SERVER_INCOMING_HANDLER) {

package/dist/io/worker-sockets.d.ts

@@ -11,12 +11,12 @@ export declare function noLookup(ip: any, _opts: any, cb: any): void;
 export declare function socketResolveAddress(name: string): Promise<{
     tag: string;
     val: Ipv4Address | Ipv6Address;
-}[]> | Promise<{
+}[][]> | Promise<{
     tag: string;
     val: Ipv4Address | Ipv6Address;
-}[][]>;
-export declare function convertSocketError(err: any): "unknown" | "would-block" | "connection-refused" | "invalid-argument" | "invalid-state" | "access-denied" | "not-supported" | "out-of-memory" | "concurrency-conflict" | "address-not-bindable" | "address-in-use" | "connection-reset" | "connection-aborted";
-export declare function convertSocketErrorCode(code: any): "unknown" | "would-block" | "connection-refused" | "invalid-argument" | "invalid-state" | "access-denied" | "not-supported" | "out-of-memory" | "concurrency-conflict" | "address-not-bindable" | "address-in-use" | "connection-reset" | "connection-aborted";
+}[]>;
+export declare function convertSocketError(err: any): "access-denied" | "address-in-use" | "address-not-bindable" | "concurrency-conflict" | "connection-aborted" | "connection-refused" | "connection-reset" | "invalid-argument" | "invalid-state" | "not-supported" | "out-of-memory" | "unknown" | "would-block";
+export declare function convertSocketErrorCode(code: any): "access-denied" | "address-in-use" | "address-not-bindable" | "concurrency-conflict" | "connection-aborted" | "connection-refused" | "connection-reset" | "invalid-argument" | "invalid-state" | "not-supported" | "out-of-memory" | "unknown" | "would-block";
 export declare function tupleToIPv6(arr: Ipv6Address): string | null;
 export declare function tupleToIpv4(arr: Ipv4Address): string | null;
 export declare function isMulticastIpAddress(ipSocketAddress: IpSocketAddress): boolean;