@bytecodealliance/preview2-shim 0.14.2 → 0.15.0

package/lib/nodejs/cli.js

@@ -51,8 +51,8 @@ export const exit = {
 
 // Stdin is created as a FILE descriptor
 let stdinStream;
-let stdoutStream = outputStreamCreate(STDOUT, 2);
-let stderrStream = outputStreamCreate(STDERR, 3);
+let stdoutStream = outputStreamCreate(STDOUT, 1);
+let stderrStream = outputStreamCreate(STDERR, 2);
 
 export const stdin = {
   InputStream,
@@ -60,7 +60,7 @@ export const stdin = {
     if (!stdinStream)
       stdinStream = inputStreamCreate(
         STDIN,
-        ioCall(INPUT_STREAM_CREATE | STDIN, null, null)
+        ioCall(INPUT_STREAM_CREATE | STDIN, null, null),
       );
     return stdinStream;
   },

package/lib/nodejs/clocks.js

@@ -1,20 +1,23 @@
-import { ioCall, createPoll, resolvedPoll } from "../io/worker-io.js";
-import * as calls from "../io/calls.js";
+import { ioCall, createPoll } from "../io/worker-io.js";
+import {
+  CLOCKS_NOW,
+  CLOCKS_INSTANT_SUBSCRIBE,
+  CLOCKS_DURATION_SUBSCRIBE,
+} from "../io/calls.js";
 
 export const monotonicClock = {
   resolution() {
     return 1n;
   },
   now() {
-    return ioCall(calls.CLOCKS_NOW);
+    return ioCall(CLOCKS_NOW, null, null);
   },
   subscribeInstant(instant) {
-    return createPoll(calls.CLOCKS_INSTANT_SUBSCRIBE, null, instant);
+    return createPoll(CLOCKS_INSTANT_SUBSCRIBE, null, instant);
   },
   subscribeDuration(duration) {
     duration = BigInt(duration);
-    if (duration === 0n) return resolvedPoll();
-    return createPoll(calls.CLOCKS_DURATION_SUBSCRIBE, null, duration);
+    return createPoll(CLOCKS_DURATION_SUBSCRIBE, null, duration);
   },
 };
 

package/lib/nodejs/filesystem.js

@@ -1,11 +1,12 @@
 import {
-  ioCall,
+  earlyDispose,
   inputStreamCreate,
+  ioCall,
   outputStreamCreate,
+  registerDispose,
 } from "../io/worker-io.js";
 import { INPUT_STREAM_CREATE, OUTPUT_STREAM_CREATE } from "../io/calls.js";
 import { FILE } from "../io/calls.js";
-// import { environment } from "./cli.js";
 import {
   closeSync,
   constants,
@@ -35,6 +36,7 @@ import { platform } from "node:process";
 const symbolDispose = Symbol.dispose || Symbol.for("dispose");
 
 const isWindows = platform === "win32";
+const isMac = platform === "darwin";
 
 const nsMagnitude = 1_000_000_000_000n;
 function nsToDateTime(ns) {
@@ -54,16 +56,17 @@ function lookupType(obj) {
   return "unknown";
 }
 
-// Note: This should implement per-segment semantics of openAt, but we cannot currently
-//       due to the lack of support for openat() in Node.js.
+// Note: This should implement per-segment semantics of openAt, but we cannot
+//       currently due to the lack of support for openat() in Node.js.
 //       Tracking issue: https://github.com/libuv/libuv/issues/4167
+
 /**
  * @implements {DescriptorProps}
  */
-let descriptorCnt = 3;
 class Descriptor {
   #hostPreopen;
   #fd;
+  #finalizer;
   #mode;
   #fullPath;
 
@@ -83,14 +86,17 @@ class Descriptor {
   static _create(fd, mode, fullPath) {
     const descriptor = new Descriptor();
     descriptor.#fd = fd;
+    descriptor.#finalizer = registerDispose(descriptor, null, fd, closeSync);
     descriptor.#mode = mode;
     descriptor.#fullPath = fullPath;
     return descriptor;
   }
 
-  constructor() {
-    // this id is purely for debugging purposes
-    this._id = descriptorCnt++;
+  [symbolDispose]() {
+    if (this.#finalizer) {
+      earlyDispose(this.#finalizer);
+      this.#finalizer = null;
+    }
   }
 
   readViaStream(offset) {
@@ -125,6 +131,7 @@ class Descriptor {
     try {
       fdatasyncSync(this.#fd);
     } catch (e) {
+      if (e.code === "EPERM") return;
       throw convertFsError(e);
     }
   }
@@ -219,6 +226,7 @@ class Descriptor {
     try {
       fsyncSync(this.#fd);
     } catch (e) {
+      if (e.code === "EPERM") return;
       throw convertFsError(e);
     }
   }
@@ -327,10 +335,31 @@ class Descriptor {
     if (descriptorFlags.fileIntegritySync) fsOpenFlags |= constants.O_SYNC;
     if (descriptorFlags.dataIntegritySync) fsOpenFlags |= constants.O_DSYNC;
     if (!pathFlags.symlinkFollow) fsOpenFlags |= constants.O_NOFOLLOW;
-
-    // Unsupported:
-    // if (descriptorFlags.requestedWriteSync)
-    // if (descriptorFlags.mutateDirectory)
+    if (descriptorFlags.requestedWriteSync || descriptorFlags.mutateDirectory)
+      throw "unsupported";
+    // Currently throw to match Wasmtime
+    if (descriptorFlags.fileIntegritySync || descriptorFlags.dataIntegritySync)
+      throw "unsupported";
+    if (isWindows) {
+      if (!pathFlags.symlinkFollow && !openFlags.create) {
+        let isSymlink = false;
+        try {
+          isSymlink = lstatSync(fullPath).isSymbolicLink();
+        } catch (e) {
+          //
+        }
+        if (isSymlink) throw openFlags.directory ? "not-directory" : "loop";
+      }
+      if (pathFlags.symlinkFollow && openFlags.directory) {
+        let isFile = false;
+        try {
+          isFile = !statSync(fullPath).isDirectory();
+        } catch (e) {
+          //
+        }
+        if (isFile) throw "not-directory";
+      }
+    }
     try {
       const fd = openSync(fullPath, fsOpenFlags);
       const descriptor = descriptorCreate(
@@ -339,13 +368,17 @@ class Descriptor {
         fullPath,
         preopenEntries
       );
-      if (fullPath.endsWith("/")) {
+      if (fullPath.endsWith("/") && isWindows) {
         // check if its a directory
-        if (!descriptor.getType() === "directory") throw "not-directory";
+        if (descriptor.getType() !== "directory") {
+          descriptor[symbolDispose]();
+          throw "not-directory";
+        }
       }
       return descriptor;
     } catch (e) {
-      if (e.code === "ERR_INVALID_ARG_VALUE") throw "invalid";
+      if (e.code === "ERR_INVALID_ARG_VALUE")
+        throw isWindows ? "no-entry" : "invalid";
       throw convertFsError(e);
     }
   }
@@ -386,8 +419,18 @@ class Descriptor {
     try {
       symlinkSync(target, fullPath);
     } catch (e) {
-      if (isWindows && (e.code === "EPERM" || e.code === "EEXIST"))
-        throw "no-entry";
+      if (fullPath.endsWith("/") && e.code === "EEXIST") {
+        let isDir = false;
+        try {
+          isDir = statSync(fullPath).isDirectory();
+        } catch (_) {
+          //
+        }
+        if (!isDir) throw isWindows ? "no-entry" : "not-directory";
+      }
+      if (isWindows) {
+        if (e.code === "EPERM" || e.code === "EEXIST") throw "no-entry";
+      }
       throw convertFsError(e);
     }
   }
@@ -395,8 +438,18 @@ class Descriptor {
   unlinkFileAt(path) {
     const fullPath = this.#getFullPath(path, false);
     try {
+      if (fullPath.endsWith("/")) {
+        let isDir = false;
+        try {
+          isDir = statSync(fullPath).isDirectory();
+        } catch (e) {
+          //
+        }
+        throw isDir ? (isWindows ? "access" : (isMac ? "not-permitted" : "is-directory")) : "not-directory";
+      }
       unlinkSync(fullPath);
     } catch (e) {
+      if (isWindows && e.code === "EPERM") throw "access";
       throw convertFsError(e);
     }
   }
@@ -484,10 +537,6 @@ class Descriptor {
       );
     return descriptor.#fullPath + (subpath.length > 0 ? "/" : "") + subpath;
   }
-
-  [symbolDispose]() {
-    if (this.#fd) closeSync(this.#fd);
-  }
 }
 const descriptorCreatePreopen = Descriptor._createPreopen;
 delete Descriptor._createPreopen;
@@ -496,6 +545,7 @@ delete Descriptor._create;
 
 class DirectoryEntryStream {
   #dir;
+  #finalizer;
   readDirectoryEntry() {
     let entry;
     try {
@@ -510,15 +560,23 @@ class DirectoryEntryStream {
     const type = lookupType(entry);
     return { name, type };
   }
-  [symbolDispose]() {
-    this.#dir.closeSync();
-  }
-
   static _create(dir) {
     const dirStream = new DirectoryEntryStream();
+    dirStream.#finalizer = registerDispose(
+      dirStream,
+      null,
+      null,
+      dir.closeSync.bind(dir)
+    );
     dirStream.#dir = dir;
     return dirStream;
   }
+  [symbolDispose]() {
+    if (this.#finalizer) {
+      earlyDispose(this.#finalizer);
+      this.#finalizer = null;
+    }
+  }
 }
 const directoryEntryStreamCreate = DirectoryEntryStream._create;
 delete DirectoryEntryStream._create;
@@ -615,6 +673,10 @@ function convertFsError(e) {
       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":

package/lib/nodejs/http.js

@@ -1,20 +1,24 @@
 import {
-  INPUT_STREAM_DISPOSE,
+  FUTURE_DISPOSE,
+  FUTURE_SUBSCRIBE,
+  FUTURE_TAKE_VALUE,
   HTTP_CREATE_REQUEST,
+  HTTP_OUTGOING_BODY_DISPOSE,
   HTTP_OUTPUT_STREAM_FINISH,
+  HTTP_SERVER_CLEAR_OUTGOING_RESPONSE,
+  HTTP_SERVER_SET_OUTGOING_RESPONSE,
   HTTP_SERVER_START,
   HTTP_SERVER_STOP,
   OUTPUT_STREAM_CREATE,
-  FUTURE_GET_VALUE_AND_DISPOSE,
-  FUTURE_DISPOSE,
-  HTTP_SERVER_SET_OUTGOING_RESPONSE,
-  HTTP_SERVER_CLEAR_OUTGOING_RESPONSE,
+  OUTPUT_STREAM_DISPOSE,
 } from "../io/calls.js";
 import {
-  ioCall,
-  pollableCreate,
+  earlyDispose,
   inputStreamCreate,
+  ioCall,
   outputStreamCreate,
+  pollableCreate,
+  registerDispose,
   registerIncomingHttpHandler,
 } from "../io/worker-io.js";
 import { validateHeaderName, validateHeaderValue } from "node:http";
@@ -23,19 +27,14 @@ import { HTTP } from "../io/calls.js";
 const symbolDispose = Symbol.dispose || Symbol.for("dispose");
 export const _forbiddenHeaders = new Set(["connection", "keep-alive"]);
 
-let requestCnt = 1;
-let responseCnt = 1;
-let fieldsCnt = 1;
-let futureCnt = 1;
-
 class IncomingBody {
   #finished = false;
-  #calledStream = false;
-  #streamId = undefined;
+  #stream = undefined;
   stream() {
-    if (this.#calledStream) throw undefined;
-    this.#calledStream = true;
-    return inputStreamCreate(HTTP, this.#streamId);
+    if (!this.#stream) throw undefined;
+    const stream = this.#stream;
+    this.#stream = null;
+    return stream;
   }
   static finish(incomingBody) {
     if (incomingBody.#finished)
@@ -43,15 +42,10 @@ class IncomingBody {
     incomingBody.#finished = true;
     return futureTrailersCreate();
   }
-  [symbolDispose]() {
-    if (!this.#finished) {
-      ioCall(INPUT_STREAM_DISPOSE | HTTP, this.#streamId);
-      this.#streamId = undefined;
-    }
-  }
+  [symbolDispose]() {}
   static _create(streamId) {
     const incomingBody = new IncomingBody();
-    incomingBody.#streamId = streamId;
+    incomingBody.#stream = inputStreamCreate(HTTP, streamId);
     return incomingBody;
   }
 }
@@ -83,6 +77,7 @@ class IncomingRequest {
   consume() {
     return incomingBodyCreate(this.#streamId);
   }
+  [symbolDispose]() {}
   static _create(method, pathWithQuery, scheme, authority, headers, streamId) {
     const incomingRequest = new IncomingRequest();
     incomingRequest.#method = method;
@@ -98,21 +93,19 @@ const incomingRequestCreate = IncomingRequest._create;
 delete IncomingRequest._create;
 
 class FutureTrailers {
-  _id = futureCnt++;
   #requested = false;
   subscribe() {
-    return pollableCreate(0);
+    return pollableCreate(0, this);
   }
   get() {
-    if (this.#requested)
-      return { tag: "err" };
+    if (this.#requested) return { tag: "err" };
     this.#requested = true;
     return {
       tag: "ok",
       val: {
         tag: "ok",
         val: undefined,
-      }
+      },
     };
   }
   static _create() {
@@ -124,7 +117,6 @@ const futureTrailersCreate = FutureTrailers._create;
 delete FutureTrailers._create;
 
 class OutgoingResponse {
-  _id = responseCnt++;
   #body;
   /** @type {number} */ #statusCode = 200;
   /** @type {Fields} */ #headers;
@@ -155,7 +147,7 @@ class OutgoingResponse {
     let contentLength;
     if (contentLengthValues.length > 0)
       contentLength = Number(new TextDecoder().decode(contentLengthValues[0]));
-    this.#body = outgoingBodyCreate(contentLength, true);
+    this.#body = outgoingBodyCreate(contentLength);
     return this.#body;
   }
 
@@ -206,7 +198,6 @@ class RequestOptions {
 }
 
 class OutgoingRequest {
-  _id = requestCnt++;
   /** @type {Method} */ #method = { tag: "get" };
   /** @type {Scheme | undefined} */ #scheme = undefined;
   /** @type {string | undefined} */ #pathWithQuery = undefined;
@@ -223,7 +214,7 @@ class OutgoingRequest {
     let contentLength;
     if (contentLengthValues.length > 0)
       contentLength = Number(new TextDecoder().decode(contentLengthValues[0]));
-    this.#body = outgoingBodyCreate(contentLength, false);
+    this.#body = outgoingBodyCreate(contentLength);
   }
   body() {
     if (this.#bodyRequested) throw new Error("Body already requested");
@@ -310,25 +301,14 @@ class OutgoingBody {
   #outputStream = null;
   #outputStreamId = null;
   #contentLength = undefined;
+  #finalizer;
   write() {
-    if (!this.#outputStreamId) this.#createOutputStream();
     // can only call write once
     const outputStream = this.#outputStream;
     if (outputStream === null) throw undefined;
     this.#outputStream = null;
     return outputStream;
   }
-  #createOutputStream() {
-    this.#outputStream = outputStreamCreate(
-      HTTP,
-      (this.#outputStreamId = ioCall(
-        OUTPUT_STREAM_CREATE | HTTP,
-        null,
-        this.#contentLength
-      ))
-    );
-    this.#outputStream[symbolDispose] = () => {};
-  }
   /**
    * @param {OutgoingBody} body
    * @param {Fields | undefined} trailers
@@ -337,19 +317,43 @@ class OutgoingBody {
     if (trailers) throw { tag: "internal-error", val: "trailers unsupported" };
     // this will verify content length, and also verify not already finished
     // throwing errors as appropriate
-    if (body.#outputStreamId)
-      ioCall(HTTP_OUTPUT_STREAM_FINISH, body.#outputStreamId, null);
+    ioCall(HTTP_OUTPUT_STREAM_FINISH, body.#outputStreamId, null);
   }
   static _outputStreamId(outgoingBody) {
     return outgoingBody.#outputStreamId;
   }
-  static _create(contentLength, createBodyStream) {
+  static _create(contentLength) {
     const outgoingBody = new OutgoingBody();
     outgoingBody.#contentLength = contentLength;
-    if (createBodyStream) outgoingBody.#createOutputStream();
+    outgoingBody.#outputStreamId = ioCall(
+      OUTPUT_STREAM_CREATE | HTTP,
+      null,
+      outgoingBody.#contentLength
+    );
+    outgoingBody.#outputStream = outputStreamCreate(
+      HTTP,
+      outgoingBody.#outputStreamId
+    );
+    outgoingBody.#finalizer = registerDispose(
+      outgoingBody,
+      null,
+      outgoingBody.#outputStreamId,
+      outgoingBodyDispose
+    );
     return outgoingBody;
   }
+  [symbolDispose]() {
+    if (this.#finalizer) {
+      earlyDispose(this.#finalizer);
+      this.#finalizer = null;
+    }
+  }
 }
+
+function outgoingBodyDispose(id) {
+  ioCall(HTTP_OUTGOING_BODY_DISPOSE, id, null);
+}
+
 const outgoingBodyOutputStreamId = OutgoingBody._outputStreamId;
 delete OutgoingBody._outputStreamId;
 
@@ -357,10 +361,9 @@ const outgoingBodyCreate = OutgoingBody._create;
 delete OutgoingBody._create;
 
 class IncomingResponse {
-  _id = responseCnt++;
   /** @type {Fields} */ #headers = undefined;
   #status = 0;
-  /** @type {number} */ #bodyStreamId;
+  /** @type {number} */ #bodyStream;
   status() {
     return this.#status;
   }
@@ -368,22 +371,19 @@ class IncomingResponse {
     return this.#headers;
   }
   consume() {
-    if (this.#bodyStreamId === undefined) throw undefined;
-    const bodyStreamId = this.#bodyStreamId;
-    this.#bodyStreamId = undefined;
-    return incomingBodyCreate(bodyStreamId);
+    if (this.#bodyStream === undefined) throw undefined;
+    const bodyStream = this.#bodyStream;
+    this.#bodyStream = undefined;
+    return bodyStream;
   }
   [symbolDispose]() {
-    if (this.#bodyStreamId) {
-      ioCall(INPUT_STREAM_DISPOSE | HTTP, this.#bodyStreamId);
-      this.#bodyStreamId = undefined;
-    }
+    if (this.#bodyStream) this.#bodyStream[symbolDispose]();
   }
   static _create(status, headers, bodyStreamId) {
     const res = new IncomingResponse();
     res.#status = status;
     res.#headers = headers;
-    res.#bodyStreamId = bodyStreamId;
+    res.#bodyStream = incomingBodyCreate(bodyStreamId);
     return res;
   }
 }
@@ -392,38 +392,29 @@ const incomingResponseCreate = IncomingResponse._create;
 delete IncomingResponse._create;
 
 class FutureIncomingResponse {
-  _id = futureCnt++;
-  #pollId;
+  #id;
+  #finalizer;
   subscribe() {
-    if (this.#pollId) return pollableCreate(this.#pollId);
-    // 0 poll is immediately resolving
-    return pollableCreate(0);
+    return pollableCreate(
+      ioCall(FUTURE_SUBSCRIBE | HTTP, this.#id, null),
+      this
+    );
   }
   get() {
-    // already taken
-    if (!this.#pollId) return { tag: "err" };
-    const ret = ioCall(FUTURE_GET_VALUE_AND_DISPOSE | HTTP, this.#pollId);
-    if (!ret) return;
-    this.#pollId = undefined;
-    if (ret.error) return { tag: "ok", val: { tag: "err", val: ret.value } };
-    const { status, headers, bodyStreamId } = ret.value;
-    const textEncoder = new TextEncoder();
-    return {
-      tag: "ok",
-      val: {
-        tag: "ok",
-        val: incomingResponseCreate(
-          status,
-          fieldsFromEntriesChecked(
-            headers.map(([key, val]) => [key, textEncoder.encode(val)])
-          ),
-          bodyStreamId
+    const ret = ioCall(FUTURE_TAKE_VALUE | HTTP, this.#id, null);
+    if (ret === undefined) return undefined;
+    if (ret.tag === "ok" && ret.val.tag === "ok") {
+      const textEncoder = new TextEncoder();
+      const { status, headers, bodyStreamId } = ret.val.val;
+      ret.val.val = incomingResponseCreate(
+        status,
+        fieldsFromEntriesChecked(
+          headers.map(([key, val]) => [key, textEncoder.encode(val)])
         ),
-      },
-    };
-  }
-  [symbolDispose]() {
-    if (this.#pollId) ioCall(FUTURE_DISPOSE | HTTP, this.#pollId);
+        bodyStreamId
+      );
+    }
+    return ret;
   }
   static _create(
     method,
@@ -437,7 +428,7 @@ class FutureIncomingResponse {
     firstByteTimeout
   ) {
     const res = new FutureIncomingResponse();
-    res.#pollId = ioCall(HTTP_CREATE_REQUEST, null, {
+    res.#id = ioCall(HTTP_CREATE_REQUEST, null, {
       method,
       scheme,
       authority,
@@ -448,15 +439,30 @@ class FutureIncomingResponse {
       betweenBytesTimeout,
       firstByteTimeout,
     });
+    res.#finalizer = registerDispose(
+      res,
+      null,
+      res.#id,
+      futureIncomingResponseDispose
+    );
     return res;
   }
+  [symbolDispose]() {
+    if (this.#finalizer) {
+      earlyDispose(this.#finalizer);
+      this.#finalizer = null;
+    }
+  }
+}
+
+function futureIncomingResponseDispose(id) {
+  ioCall(FUTURE_DISPOSE | HTTP, id, null);
 }
 
 const futureIncomingResponseCreate = FutureIncomingResponse._create;
 delete FutureIncomingResponse._create;
 
 class Fields {
-  _id = fieldsCnt++;
   #immutable = false;
   /** @type {[string, Uint8Array[]][]} */ #entries = [];
   /** @type {Map<string, [string, Uint8Array[]][]>} */ #table = new Map();
@@ -664,26 +670,29 @@ export class HTTPServer {
           ),
           streamId
         );
+        let outgoingBodyStreamId;
         const responseOutparam = responseOutparamCreate((response) => {
           if (response.tag === "ok") {
             const outgoingResponse = response.val;
             const statusCode = outgoingResponse.statusCode();
             const headers = outgoingResponse.headers().entries();
             const body = outgoingResponseBody(outgoingResponse);
-            const streamId = outgoingBodyOutputStreamId(body);
+            outgoingBodyStreamId = outgoingBodyOutputStreamId(body);
             ioCall(HTTP_SERVER_SET_OUTGOING_RESPONSE, responseId, {
               statusCode,
               headers,
-              streamId,
+              streamId: outgoingBodyStreamId,
             });
           } else {
-            ioCall(HTTP_SERVER_CLEAR_OUTGOING_RESPONSE, responseId);
-            console.error("TODO: handle outparam error");
-            console.error(response);
+            ioCall(HTTP_SERVER_CLEAR_OUTGOING_RESPONSE, responseId, null);
+            console.error(response.val);
             process.exit(1);
           }
         });
         incomingHandler.handle(request, responseOutparam);
+        if (outgoingBodyStreamId) {
+          ioCall(OUTPUT_STREAM_DISPOSE, outgoingBodyStreamId, null);
+        }
       }
     );
   }
@@ -694,6 +703,7 @@ export class HTTPServer {
   }
   stop() {
     clearInterval(this.#liveEventLoopInterval);
-    ioCall(HTTP_SERVER_STOP, this.#id);
+    ioCall(HTTP_SERVER_STOP, this.#id, null);
+    httpServers.delete(this.#id);
   }
 }

package/lib/nodejs/index.js

@@ -15,5 +15,3 @@ export {
   sockets,
   cli
 }
-
-export { WasiSockets } from "./sockets/wasi-sockets.js";