@bytecodealliance/preview2-shim 0.14.1 → 0.15.0

package/lib/nodejs/cli.js

@@ -1,21 +1,31 @@
 import { argv, env, cwd } from "node:process";
 import {
+  ioCall,
   streams,
   inputStreamCreate,
   outputStreamCreate,
 } from "../io/worker-io.js";
-import { STDIN, STDOUT, STDERR } from "../io/calls.js";
+import { INPUT_STREAM_CREATE, STDERR, STDIN, STDOUT } from "../io/calls.js";
 const { InputStream, OutputStream } = streams;
 
-export const _setEnv = env => void (_env = Object.entries(env));
-export const _setArgs = args => void (_args = args);
-export const _setCwd = cwd => void (_cwd = cwd);
-export const _setStdin = stdin => void (stdinStream = stdin);
-export const _setStdout = stdout => void (stdoutStream = stdout);
-export const _setStderr = stderr => void (stderrStream = stderr);
-export const _setTerminalStdin = terminalStdin => void (terminalStdinInstance = terminalStdin);
-export const _setTerminalStdout = terminalStdout => void (terminalStdoutInstance = terminalStdout);
-export const _setTerminalStderr = terminalStderr => void (terminalStderrInstance = terminalStderr);
+export const _appendEnv = (env) => {
+  void (_env = [
+    ..._env.filter(([curKey]) => !(curKey in env)),
+    ...Object.entries(env),
+  ]);
+}
+export const _setEnv = (env) => void (_env = Object.entries(env));
+export const _setArgs = (args) => void (_args = args);
+export const _setCwd = (cwd) => void (_cwd = cwd);
+export const _setStdin = (stdin) => void (stdinStream = stdin);
+export const _setStdout = (stdout) => void (stdoutStream = stdout);
+export const _setStderr = (stderr) => void (stderrStream = stderr);
+export const _setTerminalStdin = (terminalStdin) =>
+  void (terminalStdinInstance = terminalStdin);
+export const _setTerminalStdout = (terminalStdout) =>
+  void (terminalStdoutInstance = terminalStdout);
+export const _setTerminalStderr = (terminalStderr) =>
+  void (terminalStderrInstance = terminalStderr);
 
 let _env = Object.entries(env),
   _args = argv.slice(1),
@@ -39,13 +49,19 @@ export const exit = {
   },
 };
 
-let stdinStream = inputStreamCreate(STDIN, 1);
-let stdoutStream = outputStreamCreate(STDOUT, 2);
-let stderrStream = outputStreamCreate(STDERR, 3);
+// Stdin is created as a FILE descriptor
+let stdinStream;
+let stdoutStream = outputStreamCreate(STDOUT, 1);
+let stderrStream = outputStreamCreate(STDERR, 2);
 
 export const stdin = {
   InputStream,
   getStdin() {
+    if (!stdinStream)
+      stdinStream = inputStreamCreate(
+        STDIN,
+        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,29 +56,29 @@ 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;
 
   static _createPreopen(hostPreopen) {
     const descriptor = new Descriptor();
     descriptor.#hostPreopen = hostPreopen.endsWith("/")
-      ? hostPreopen.slice(0, -1) || '/'
+      ? hostPreopen.slice(0, -1) || "/"
       : hostPreopen;
     // Windows requires UNC paths at minimum
     if (isWindows) {
-      descriptor.#hostPreopen = descriptor.#hostPreopen.replace(/\\/g, '/');
-      if (descriptor.#hostPreopen === '/')
-        descriptor.#hostPreopen = '//';
+      descriptor.#hostPreopen = descriptor.#hostPreopen.replace(/\\/g, "/");
+      if (descriptor.#hostPreopen === "/") descriptor.#hostPreopen = "//";
     }
     return descriptor;
   }
@@ -84,15 +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;
-    if (fullPath.endsWith("/")) throw new Error("bad full path");
     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) {
@@ -118,19 +122,21 @@ class Descriptor {
     return this.writeViaStream(this.stat().size);
   }
 
-  advise(_offset, _length, _advice) { }
+  advise(_offset, _length, _advice) {
+    if (this.getType() === "directory") throw "bad-descriptor";
+  }
 
   syncData() {
     if (this.#hostPreopen) throw "invalid";
     try {
       fdatasyncSync(this.#fd);
     } catch (e) {
+      if (e.code === "EPERM") return;
       throw convertFsError(e);
     }
   }
 
   getFlags() {
-    if (this.#hostPreopen) throw "invalid";
     return this.#mode;
   }
 
@@ -164,7 +170,7 @@ class Descriptor {
     const mtime = this.#getNewTimestamp(
       dataModificationTimestamp,
       dataModificationTimestamp.tag === "no-change" &&
-      stats.dataModificationTimestamp
+        stats.dataModificationTimestamp
     );
     try {
       futimesSync(this.#fd, atime, mtime);
@@ -186,8 +192,14 @@ class Descriptor {
 
   read(length, offset) {
     if (!this.#fullPath) throw "bad-descriptor";
-    const buf = new Uint8Array(length);
-    const bytesRead = readSync(this.#fd, buf, Number(offset), length, 0);
+    const buf = new Uint8Array(Number(length));
+    const bytesRead = readSync(
+      this.#fd,
+      buf,
+      0,
+      Number(length),
+      Number(offset)
+    );
     const out = new Uint8Array(buf.buffer, 0, bytesRead);
     return [out, bytesRead === 0 ? "ended" : "open"];
   }
@@ -195,7 +207,7 @@ class Descriptor {
   write(buffer, offset) {
     if (!this.#fullPath) throw "bad-descriptor";
     return BigInt(
-      writeSync(this.#fd, buffer, Number(offset), buffer.byteLength - offset, 0)
+      writeSync(this.#fd, buffer, 0, buffer.byteLength, Number(offset))
     );
   }
 
@@ -214,6 +226,7 @@ class Descriptor {
     try {
       fsyncSync(this.#fd);
     } catch (e) {
+      if (e.code === "EPERM") return;
       throw convertFsError(e);
     }
   }
@@ -250,7 +263,9 @@ class Descriptor {
     const fullPath = this.#getFullPath(path, false);
     let stats;
     try {
-      stats = (pathFlags.symlinkFollow ? statSync : lstatSync)(fullPath, { bigint: true });
+      stats = (pathFlags.symlinkFollow ? statSync : lstatSync)(fullPath, {
+        bigint: true,
+      });
     } catch (e) {
       throw convertFsError(e);
     }
@@ -280,7 +295,7 @@ class Descriptor {
     const mtime = this.#getNewTimestamp(
       dataModificationTimestamp,
       dataModificationTimestamp.tag === "no-change" &&
-      stats.dataModificationTimestamp
+        stats.dataModificationTimestamp
     );
     try {
       (pathFlags.symlinkFollow ? utimesSync : lutimesSync)(
@@ -297,8 +312,7 @@ class Descriptor {
     const oldFullPath = this.#getFullPath(oldPath, oldPathFlags.symlinkFollow);
     const newFullPath = newDescriptor.#getFullPath(newPath, false);
     // Windows doesn't automatically fail on trailing slashes
-    if (isWindows && newFullPath.endsWith('/'))
-      throw 'no-entry';
+    if (isWindows && newFullPath.endsWith("/")) throw "no-entry";
     try {
       linkSync(oldFullPath, newFullPath);
     } catch (e) {
@@ -320,14 +334,51 @@ class Descriptor {
     else if (descriptorFlags.read) fsOpenFlags |= constants.O_RDONLY;
     if (descriptorFlags.fileIntegritySync) fsOpenFlags |= constants.O_SYNC;
     if (descriptorFlags.dataIntegritySync) fsOpenFlags |= constants.O_DSYNC;
-    // Unsupported:
-    // if (descriptorFlags.requestedWriteSync)
-    // if (descriptorFlags.mutateDirectory)
-
+    if (!pathFlags.symlinkFollow) fsOpenFlags |= constants.O_NOFOLLOW;
+    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);
-      return descriptorCreate(fd, descriptorFlags, fullPath, preopenEntries);
+      const descriptor = descriptorCreate(
+        fd,
+        descriptorFlags,
+        fullPath,
+        preopenEntries
+      );
+      if (fullPath.endsWith("/") && isWindows) {
+        // check if its a directory
+        if (descriptor.getType() !== "directory") {
+          descriptor[symbolDispose]();
+          throw "not-directory";
+        }
+      }
+      return descriptor;
     } catch (e) {
+      if (e.code === "ERR_INVALID_ARG_VALUE")
+        throw isWindows ? "no-entry" : "invalid";
       throw convertFsError(e);
     }
   }
@@ -346,8 +397,7 @@ class Descriptor {
     try {
       rmdirSync(fullPath);
     } catch (e) {
-      if (isWindows && e.code === 'ENOENT')
-        throw 'not-directory';
+      if (isWindows && e.code === "ENOENT") throw "not-directory";
       throw convertFsError(e);
     }
   }
@@ -358,19 +408,29 @@ class Descriptor {
     try {
       renameSync(oldFullPath, newFullPath);
     } catch (e) {
-      if (isWindows && e.code === 'EPERM')
-        throw 'access';
+      if (isWindows && e.code === "EPERM") throw "access";
       throw convertFsError(e);
     }
   }
 
   symlinkAt(target, path) {
     const fullPath = this.#getFullPath(path, false);
+    if (target.startsWith("/")) throw "not-permitted";
     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);
     }
   }
@@ -378,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);
     }
   }
@@ -401,7 +471,9 @@ class Descriptor {
   metadataHashAt(pathFlags, path) {
     const fullPath = this.#getFullPath(path, false);
     try {
-      const stats = (pathFlags.symlinkFollow ? statSync : lstatSync)(fullPath, { bigint: true });
+      const stats = (pathFlags.symlinkFollow ? statSync : lstatSync)(fullPath, {
+        bigint: true,
+      });
       return { upper: stats.mtimeNs, lower: stats.ino };
     } catch (e) {
       throw convertFsError(e);
@@ -412,34 +484,59 @@ class Descriptor {
   #getFullPath(subpath, _followSymlinks) {
     let descriptor = this;
     if (subpath.indexOf("\\") !== -1) subpath = subpath.replace(/\\/g, "/");
-    if (subpath[0] === '/') {
-      let bestPreopenMatch = "";
-      for (const preopenEntry of preopenEntries) {
+    if (subpath.indexOf("//") !== -1) subpath = subpath.replace(/\/\/+/g, "/");
+    if (subpath[0] === "/") throw "not-permitted";
+
+    // segment resolution
+    const segments = [];
+    let segmentIndex = -1;
+    for (let i = 0; i < subpath.length; i++) {
+      // busy reading a segment - only terminate on '/'
+      if (segmentIndex !== -1) {
+        if (subpath[i] === "/") {
+          segments.push(subpath.slice(segmentIndex, i + 1));
+          segmentIndex = -1;
+        }
+        continue;
+      }
+      // new segment - check if it is relative
+      else if (subpath[i] === ".") {
+        // ../ segment
         if (
-          subpath.startsWith(preopenEntry[1]) &&
-          (!bestPreopenMatch ||
-            bestPreopenMatch.length < preopenEntry[1].length)
+          subpath[i + 1] === "." &&
+          (subpath[i + 2] === "/" || i + 2 === subpath.length)
         ) {
-          bestPreopenMatch = preopenEntry;
+          if (segments.pop() === undefined) throw "not-permitted";
+          i += 2;
+          continue;
+        }
+        // ./ segment
+        else if (subpath[i + 1] === "/" || i + 1 === subpath.length) {
+          i += 1;
+          continue;
         }
       }
-      if (!bestPreopenMatch) throw "no-entry";
-      descriptor = bestPreopenMatch[0];
-      subpath = subpath.slice(bestPreopenMatch[1]);
-      if (subpath[0] === "/") subpath = subpath.slice(1);
+      // it is the start of a new segment
+      while (subpath[i] === "/") i++;
+      segmentIndex = i;
     }
-    if (subpath.startsWith("."))
-      subpath = subpath.slice(subpath[1] === "/" ? 2 : 1);
+    // finish reading out the last segment
+    if (segmentIndex !== -1) segments.push(subpath.slice(segmentIndex));
+
+    subpath = segments.join("");
+
     if (descriptor.#hostPreopen)
       return (
-        descriptor.#hostPreopen + (descriptor.#hostPreopen.endsWith('/') ? '' : (subpath.length > 0 ? "/" : "")) + subpath
+        descriptor.#hostPreopen +
+        (descriptor.#hostPreopen.endsWith("/")
+          ? ""
+          : subpath.length > 0
+          ? "/"
+          : "") +
+        subpath
       );
     return descriptor.#fullPath + (subpath.length > 0 ? "/" : "") + subpath;
   }
-
-  [symbolDispose]() {
-    if (this.#fd) closeSync(this.#fd);
-  }
 }
 const descriptorCreatePreopen = Descriptor._createPreopen;
 delete Descriptor._createPreopen;
@@ -448,6 +545,7 @@ delete Descriptor._create;
 
 class DirectoryEntryStream {
   #dir;
+  #finalizer;
   readDirectoryEntry() {
     let entry;
     try {
@@ -462,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;
@@ -489,6 +595,9 @@ _addPreopen("/", isWindows ? "//" : "/");
 export const types = {
   Descriptor,
   DirectoryEntryStream,
+  filesystemErrorCode(err) {
+    return convertFsError(err.payload);
+  },
 };
 
 export function _setPreopens(preopens) {
@@ -564,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":