@bytecodealliance/preview2-shim 0.19.0 → 0.20.1

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
@@ -15,8 +19,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 +31,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 +70,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/filesystem.js

@@ -74,6 +74,21 @@ function getSource(fileEntry) {
     }
     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;
+}
 class DirectoryEntryStream {
     idx = 0;
     entries = [];
@@ -130,15 +145,24 @@ class Descriptor {
     }
     writeViaStream(_offset) {
         const entry = this.#entry;
-        let offset = Number(_offset);
+        let offset = coerceToSafeIntegerNumber(_offset);
         return outputStreamCreate({
             write(buf) {
-                const src = entry.source;
-                const newSource = new Uint8Array(buf.byteLength + src.byteLength);
-                newSource.set(src, 0);
-                newSource.set(buf, offset);
-                offset += buf.byteLength;
-                entry.source = newSource;
+                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;
             },
         });
     }

package/dist/browser/http.js

@@ -509,7 +509,7 @@ class FutureTrailers {
             tag: "ok",
             val: {
                 tag: "ok",
-                val: undefined,
+                val: fieldsLock(fieldsFromEntriesChecked([])),
             },
         };
     }

package/dist/common/instantiation.js

@@ -164,7 +164,8 @@ export class WASIShim {
         obj[`wasi:sockets/tcp-create-socket${versionSuffix}`] = this.#sockets.tcpCreateSocket;
         obj[`wasi:sockets/udp${versionSuffix}`] = this.#sockets.udp;
         obj[`wasi:sockets/udp-create-socket${versionSuffix}`] = this.#sockets.udpCreateSocket;
-        obj[`wasi:filesystem/preopens${versionSuffix}`] = this.#preopens ?? this.#filesystem.preopens;
+        obj[`wasi:filesystem/preopens${versionSuffix}`] =
+            this.#preopens ?? this.#filesystem.preopens;
         obj[`wasi:filesystem/types${versionSuffix}`] = this.#filesystem.types;
         obj[`wasi:io/error${versionSuffix}`] = this.#io.error;
         obj[`wasi:io/poll${versionSuffix}`] = this.#io.poll;

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,18 +6,21 @@ 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);
 }
 const instanceId = Math.round(Math.random() * 1000).toString();
 const DEBUG_DEFAULT = false;
-const DEBUG = env.PREVIEW2_SHIM_DEBUG === "0" ? false : env.PREVIEW2_SHIM_DEBUG === "1" ? true : DEBUG_DEFAULT;
+const DEBUG = env.PREVIEW2_SHIM_DEBUG === "0"
+    ? false
+    : env.PREVIEW2_SHIM_DEBUG === "1"
+        ? true
+        : DEBUG_DEFAULT;
 /**
  * @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) {
@@ -148,7 +151,8 @@ class InputStream {
                 disposeFn = httpInputStreamDispose;
                 break;
             default:
-                throw new Error("wasi-io trap: Dispose function not created for stream type " + reverseMap[streamType]);
+                throw new Error("wasi-io trap: Dispose function not created for stream type " +
+                    reverseMap[streamType]);
         }
         stream.#finalizer = registerDispose(stream, null, id, disposeFn);
         return stream;
@@ -253,7 +257,8 @@ class OutputStream {
             case HTTP:
                 return stream;
             default:
-                throw new Error("wasi-io trap: Dispose function not created for stream type " + reverseMap[streamType]);
+                throw new Error("wasi-io trap: Dispose function not created for stream type " +
+                    reverseMap[streamType]);
         }
         stream.#finalizer = registerDispose(stream, null, id, disposeFn);
         return stream;

package/dist/io/worker-socket-udp.js

@@ -406,7 +406,8 @@ export async function socketOutgoingDatagramStreamSend(id, datagrams) {
     function doSendBatch() {
         return new Promise((resolve, reject) => {
             if (socket.remoteAddress) {
-                if (sendQueueAddress !== socket.remoteAddress || sendQueuePort !== socket.remotePort) {
+                if (sendQueueAddress !== socket.remoteAddress ||
+                    sendQueuePort !== socket.remotePort) {
                     return void reject("invalid-argument");
                 }
                 udpSocket.send(sendQueue, handler);