@bytecodealliance/preview3-shim 0.1.0 → 0.1.2

package/lib/nodejs/clocks.js

@@ -27,6 +27,7 @@ export const systemClock = {
 const { subscribeInstant, subscribeDuration, ...baseMonotonicClock } = monotonicClockV2;
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const nsToTimeoutMs = (ns) => (ns + 999_999n) / 1_000_000n;
 
 export const monotonicClock = {
   ...baseMonotonicClock,
@@ -58,19 +59,21 @@ export const monotonicClock = {
    * @throws {TypeError} If targetNs is not a bigint
    */
   async waitUntil(targetNs) {
-    const nowNs = monotonicClock.now();
-    const diffNs = targetNs - nowNs;
+    while (true) {
+      const nowNs = monotonicClock.now();
+      const diffNs = targetNs - nowNs;
 
-    if (diffNs <= 0n) {
-      return;
-    }
+      if (diffNs <= 0n) {
+        return;
+      }
 
-    const ms = diffNs / 1_000_000n;
-    if (ms > BigInt(Number.MAX_SAFE_INTEGER)) {
-      throw new TypeError(`Cannot wait for ${targetNs} ns, exceeds maximum safe integer`);
-    }
+      const ms = nsToTimeoutMs(diffNs);
+      if (ms > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new TypeError(`Cannot wait for ${targetNs} ns, exceeds maximum safe integer`);
+      }
 
-    await sleep(Number(ms));
+      await sleep(Number(ms));
+    }
   },
 
   /**
@@ -90,11 +93,6 @@ export const monotonicClock = {
       return;
     }
 
-    const ms = durationNs / 1_000_000n;
-    if (ms > BigInt(Number.MAX_SAFE_INTEGER)) {
-      throw new TypeError(`Cannot wait for ${durationNs} ns, exceeds maximum safe integer`);
-    }
-
-    await sleep(Number(ms));
+    await monotonicClock.waitUntil(monotonicClock.now() + durationNs);
   },
 };

package/lib/nodejs/filesystem/descriptor.js

@@ -1,4 +1,5 @@
 import fs from "node:fs/promises";
+import nodePath from "node:path";
 import process from "node:process";
 
 import { StreamReader, readableByteStreamFromReader } from "../stream.js";
@@ -29,8 +30,10 @@ class Descriptor {
   #finalizer;
   /** Host filesystem path for preopened directories */
   #hostPreopen;
+  /** Whether this descriptor refers to a directory. */
+  #isDirectory = false;
 
-  static _create(handle, mode, fullPath) {
+  static _create(handle, mode, fullPath, isDirectory = false) {
     const {
       read = false,
       write = false,
@@ -52,6 +55,7 @@ class Descriptor {
     const desc = new Descriptor();
     desc.#handle = handle;
     desc.#fullPath = fullPath;
+    desc.#isDirectory = isDirectory;
     desc.#mode = merged;
     desc.#finalizer = registerDispose(desc, null, handle, (handle) => handle.close());
 
@@ -60,6 +64,15 @@ class Descriptor {
 
   static _createPreopen(hostPreopen) {
     const desc = new Descriptor();
+    desc.#isDirectory = true;
+    desc.#mode = {
+      read: true,
+      write: false,
+      fileIntegritySync: false,
+      dataIntegritySync: false,
+      requestedWriteSync: false,
+      mutateDirectory: true,
+    };
 
     if (hostPreopen.endsWith("/")) {
       desc.#hostPreopen = hostPreopen.slice(0, -1) || "/";
@@ -363,6 +376,7 @@ class Descriptor {
    * @throws {FSError} `payload.tag` contains mapped WASI error code.
    */
   async createDirectoryAt(path) {
+    await this.#ensureSandboxedPath(path);
     const full = this.#getFullPath(path, false);
     try {
       await fs.mkdir(full);
@@ -426,6 +440,7 @@ class Descriptor {
    * @throws {FSError} `payload.tag` contains mapped WASI error code.
    */
   async statAt(flags, path) {
+    await this.#ensureSandboxedPath(path);
     const full = this.#getFullPath(path, flags.symlinkFollow);
     try {
       const statFn = flags.symlinkFollow ? fs.stat : fs.lstat;
@@ -464,6 +479,7 @@ class Descriptor {
    * @throws {FSError} `payload.tag` contains mapped WASI error code.
    */
   async setTimesAt(flags, path, atimeDesc, mtimeDesc) {
+    await this.#ensureSandboxedPath(path);
     const { atime, mtime } = await this.#computeTimestamps(atimeDesc, mtimeDesc, path);
 
     if (!flags.symlinkFollow && !fs.lutimes) {
@@ -501,6 +517,8 @@ class Descriptor {
    * @throws {FSError} `payload.tag` contains mapped WASI error code.
    */
   async linkAt(oldFlags, oldPath, newDesc, newPath) {
+    await this.#ensureSandboxedPath(oldPath);
+    await newDesc.#ensureSandboxedPath(newPath);
     const src = this.#getFullPath(oldPath, oldFlags.symlinkFollow);
     const dst = newDesc.#getFullPath(newPath, false);
 
@@ -542,9 +560,16 @@ class Descriptor {
       throw new FSError("access");
     }
 
+    await this.#ensureSandboxedPath(path);
     const fullPath = this.#getFullPath(path, pf.symlinkFollow);
     const target = stripTrailingSlash(fullPath);
 
+    const mode = {
+      ...df,
+      read: df.read || !df.write,
+      write: df.write || of.create || of.truncate,
+    };
+
     const makeFsFlags = () => {
       let fsFlags = 0;
       if (of.create) {
@@ -559,11 +584,11 @@ class Descriptor {
       if (of.truncate) {
         fsFlags |= fs.constants.O_TRUNC;
       }
-      if (df.read && df.write) {
+      if (mode.read && mode.write) {
         fsFlags |= fs.constants.O_RDWR;
-      } else if (df.write) {
+      } else if (mode.write) {
         fsFlags |= fs.constants.O_WRONLY;
-      } else if (df.read) {
+      } else if (mode.read) {
         fsFlags |= fs.constants.O_RDONLY;
       }
       if (df.fileIntegritySync) {
@@ -610,8 +635,9 @@ class Descriptor {
 
     try {
       const handle = await fs.open(target, fsFlags);
-      const desc = descriptorCreate(handle, df, fullPath);
-      const isDir = (await desc.getType()).tag === "directory";
+      const stats = await handle.stat();
+      const isDir = stats.isDirectory();
+      const desc = descriptorCreate(handle, mode, fullPath, isDir);
 
       if (fullPath.endsWith("/") && !isDir) {
         desc[symbolDispose]();
@@ -639,6 +665,7 @@ class Descriptor {
    * @throws {FSError} `payload.tag` contains mapped WASI error code.
    */
   async readlinkAt(path) {
+    await this.#ensureSandboxedPath(path);
     const full = this.#getFullPath(path, false);
     try {
       return await fs.readlink(full);
@@ -660,6 +687,10 @@ class Descriptor {
    * @throws {FSError} `payload.tag` contains mapped WASI error code.
    */
   async removeDirectoryAt(path) {
+    if (path === ".") {
+      throw new FSError("invalid");
+    }
+    await this.#ensureSandboxedPath(path);
     const full = this.#getFullPath(path, false);
     try {
       await fs.rmdir(full);
@@ -686,6 +717,8 @@ class Descriptor {
    * @throws {FSError} `payload.tag` contains mapped WASI error code.
    */
   async renameAt(oldPath, newDesc, newPath) {
+    await this.#ensureSandboxedPath(oldPath);
+    await newDesc.#ensureSandboxedPath(newPath);
     const src = this.#getFullPath(oldPath, false);
     const dst = newDesc.#getFullPath(newPath, false);
     try {
@@ -715,6 +748,7 @@ class Descriptor {
     if (target.startsWith("/")) {
       throw new FSError("not-permitted");
     }
+    await this.#ensureSandboxedPath(path);
     const full = this.#getFullPath(path, false);
 
     try {
@@ -750,6 +784,7 @@ class Descriptor {
    * @throws {FSError} `payload.tag` contains mapped WASI error code.
    */
   async unlinkFileAt(path) {
+    await this.#ensureSandboxedPath(path);
     const full = this.#getFullPath(path, false);
     if (full.endsWith("/")) {
       const isDir = (await fs.stat(full)).isDirectory();
@@ -787,7 +822,8 @@ class Descriptor {
    * @returns {Promise<boolean>}
    */
   async isSameObject(other) {
-    return other === this;
+    const [left, right] = await Promise.all([this.#statForIdentity(), other.#statForIdentity()]);
+    return left.dev === right.dev && left.ino === right.ino;
   }
 
   /**
@@ -802,11 +838,8 @@ class Descriptor {
    * @throws {FSError} `payload.tag` contains mapped WASI error code.
    */
   async metadataHash() {
-    if (this.#hostPreopen) {
-      return { upper: 0n, lower: BigInt(this._id) };
-    }
     try {
-      const s = await this.#handle.stat();
+      const s = await this.#statForIdentity();
       return { upper: s.mtimeNs, lower: s.ino };
     } catch (e) {
       throw FSError.from(e);
@@ -827,10 +860,11 @@ class Descriptor {
    * @throws {FSError} `payload.tag` contains mapped WASI error code.
    */
   async metadataHashAt(flags, path) {
+    await this.#ensureSandboxedPath(path);
     const full = this.#getFullPath(path, false);
     try {
       const statFn = flags.symlinkFollow ? fs.stat : fs.lstat;
-      const s = await statFn(full);
+      const s = await statFn(full, { bigint: true });
       return { upper: s.mtimeNs, lower: s.ino };
     } catch (e) {
       throw FSError.from(e);
@@ -896,6 +930,10 @@ class Descriptor {
   #getFullPath(subpath, _followSymlinks) {
     subpath = subpath.replaceAll("\\", "/").replace(/\/\/+/g, "/");
 
+    if (subpath === "") {
+      throw new FSError("no-entry");
+    }
+
     if (subpath.startsWith("/")) {
       throw new FSError("not-permitted");
     }
@@ -924,6 +962,59 @@ class Descriptor {
     return `${baseNormalized}/${segments.join("/")}`;
   }
 
+  async #statForIdentity() {
+    if (this.#hostPreopen) {
+      return fs.stat(this.#hostPreopen, { bigint: true });
+    }
+    this.#ensureHandle();
+    return this.#handle.stat({ bigint: true });
+  }
+
+  // WASI paths are always relative to a directory descriptor. During path
+  // resolution, both `..` and symlinks must not escape that descriptor's base.
+  async #ensureSandboxedPath(subpath) {
+    if (!this.#isDirectory) {
+      throw new FSError("not-directory");
+    }
+
+    const base = this.#hostPreopen ?? this.#fullPath;
+    const baseResolved = nodePath.resolve(base);
+    const segments = subpath.replaceAll("\\", "/").replace(/\/\/+/g, "/").split("/");
+    let current = baseResolved;
+
+    for (const seg of segments) {
+      if (seg === "" || seg === ".") {
+        continue;
+      }
+      if (seg === "..") {
+        current = nodePath.dirname(current);
+        if (!isWithinPath(baseResolved, current)) {
+          throw new FSError("not-permitted");
+        }
+        continue;
+      }
+
+      current = nodePath.join(current, seg);
+      let stat;
+      try {
+        stat = await fs.lstat(current);
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          return;
+        }
+        throw FSError.from(err);
+      }
+
+      if (stat.isSymbolicLink()) {
+        const target = await fs.readlink(current);
+        current = nodePath.resolve(nodePath.dirname(current), target);
+        if (!isWithinPath(baseResolved, current)) {
+          throw new FSError("not-permitted");
+        }
+      }
+    }
+  }
+
   #ensureHandle() {
     if (!this.#handle) {
       throw new FSError("bad-descriptor");
@@ -964,6 +1055,11 @@ function stripTrailingSlash(path) {
   return path.replace(/\/+$/, "");
 }
 
+function isWithinPath(base, candidate) {
+  const relative = nodePath.relative(base, candidate);
+  return relative === "" || (!relative.startsWith("..") && !nodePath.isAbsolute(relative));
+}
+
 const preopenEntries = [];
 export const preopens = {
   Descriptor,

package/lib/nodejs/http/fields.js

@@ -115,16 +115,19 @@ export class Fields {
     let bucket = this.#table.get(lowercased);
     if (bucket) {
       this.#entries = this.#entries.filter((e) => !bucket.includes(e));
-      bucket.splice(0, bucket.length);
-    } else {
-      bucket = [];
-      this.#table.set(lowercased, bucket);
+      this.#table.delete(lowercased);
+    }
+
+    if (values.length === 0) {
+      return;
     }
 
+    bucket = [];
+    this.#table.set(lowercased, bucket);
     for (const value of values) {
       const entry = [name, value];
       this.#entries.push(entry);
-      this.#table.get(lowercased).push(entry);
+      bucket.push(entry);
     }
   }
 
@@ -140,6 +143,7 @@ export class Fields {
    */
   delete(name) {
     this.#ensureMutable();
+    this.#validateName(name);
     const lowercased = name.toLowerCase();
     const tableEntries = this.#table.get(lowercased);
 
@@ -162,6 +166,7 @@ export class Fields {
    */
   getAndDelete(name) {
     this.#ensureMutable();
+    this.#validateName(name);
 
     const values = this.get(name);
     this.delete(name);
@@ -188,10 +193,11 @@ export class Fields {
     this.#validateValue(name, value);
 
     const lowercased = name.toLowerCase();
-    const entry = [name, value];
-    this.#entries.push(entry);
 
     const tableEntries = this.#table.get(lowercased);
+    const entryName = tableEntries?.[0]?.[0] ?? name;
+    const entry = [entryName, value];
+    this.#entries.push(entry);
     if (tableEntries) {
       tableEntries.push(entry);
     } else {
@@ -274,7 +280,7 @@ export class Fields {
 
   #validateValue(name, value) {
     try {
-      validateHeaderValue(name, new TextDecoder().decode(value));
+      validateHeaderValue(name, bytesToHeaderValueString(value));
     } catch {
       throw new HttpError("invalid-syntax", `Invalid header value for ${name}`);
     }
@@ -287,6 +293,14 @@ export class Fields {
   }
 }
 
+function bytesToHeaderValueString(value) {
+  let result = "";
+  for (let i = 0; i < value.length; i += 0x8000) {
+    result += String.fromCharCode(...value.subarray(i, i + 0x8000));
+  }
+  return result;
+}
+
 export function _fieldsLock(fields) {
   return Fields._lock(fields);
 }

package/lib/nodejs/http/request.js

@@ -325,7 +325,7 @@ export class Request {
    */
   setPathWithQuery(pathWithQuery) {
     validateUrlPart(pathWithQuery, UrlPart.PATH_WITH_QUERY);
-    this.#pathWithQuery = pathWithQuery ?? undefined;
+    this.#pathWithQuery = pathWithQuery === "" ? "/" : (pathWithQuery ?? undefined);
   }
 
   /**
@@ -575,7 +575,7 @@ const UrlPart = {
 };
 
 function normalizeMethod(method) {
-  const VALUE_TOKEN_RE = /^[a-zA-Z-]+$/;
+  const VALUE_TOKEN_RE = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
 
   if (typeof method === "string") {
     if (!VALUE_TOKEN_RE.test(method)) {
@@ -597,7 +597,10 @@ function normalizeMethod(method) {
   }
 
   if (method.tag === "other" && typeof method.val === "string" && VALUE_TOKEN_RE.test(method.val)) {
-    return { tag: "other", val: method.val.toLowerCase() };
+    const standard = method.val.toLowerCase();
+    return SUPPORTED_METHODS.includes(standard) && method.val === method.val.toUpperCase()
+      ? { tag: standard }
+      : { tag: "other", val: method.val };
   }
 
   throw new HttpError("invalid-syntax");
@@ -614,7 +617,7 @@ function normalizeScheme(scheme) {
     if (uppercase === "HTTP" || uppercase === "HTTPS") {
       return { tag: uppercase };
     }
-    return { tag: "other", val: scheme.toLowerCase() };
+    return { tag: "other", val: scheme };
   }
 
   if (typeof scheme !== "object" || typeof scheme.tag !== "string") {
@@ -627,7 +630,11 @@ function normalizeScheme(scheme) {
 
   if (scheme.tag === "other" && typeof scheme.val === "string") {
     validateUrlPart(scheme.val, UrlPart.SCHEME);
-    return { tag: "other", val: scheme.val.toLowerCase() };
+    const uppercase = scheme.val.toUpperCase();
+    if (uppercase === "HTTP" || uppercase === "HTTPS") {
+      return { tag: uppercase };
+    }
+    return { tag: "other", val: scheme.val };
   }
 
   throw new HttpError("invalid-syntax");
@@ -660,6 +667,10 @@ function validateUrlPart(value, part) {
     throw new HttpError("invalid-syntax", `Invalid ${part}: ${value}`);
   }
 
+  if (part === UrlPart.PATH_WITH_QUERY && /[ <>`]/.test(value)) {
+    throw new HttpError("invalid-syntax", `Invalid ${part}: ${value}`);
+  }
+
   try {
     switch (part) {
       case UrlPart.PATH_WITH_QUERY:

package/lib/nodejs/sockets/tcp.js

@@ -23,6 +23,16 @@ function token() {
   return (TCP_CREATE_TOKEN ??= Symbol("TcpCreateToken"));
 }
 
+function invalidRecv() {
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.close();
+    },
+  });
+  const promise = Promise.reject(new SocketError("invalid-state"));
+  return [new StreamReader(stream, { preventCancel: false }), new FutureReader(promise)];
+}
+
 const STATE = {
   UNBOUND: "unbound",
   BOUND: "bound",
@@ -316,16 +326,10 @@ export class TcpSocket {
    */
   receive() {
     if (this.#state !== STATE.CONNECTED) {
-      throw new SocketError("invalid-state");
+      return invalidRecv();
     }
     if (this.#receiveStarted) {
-      const stream = new ReadableStream({
-        start(controller) {
-          controller.close();
-        },
-      });
-      const promise = Promise.reject(new SocketError("invalid-state"));
-      return [new StreamReader(stream, { preventCancel: false }), new FutureReader(promise)];
+      return invalidRecv();
     }
     this.#receiveStarted = true;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytecodealliance/preview3-shim",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "WASI Preview3 shim for JS environments",
   "homepage": "https://github.com/bytecodealliance/jco/blob/main/packages/preview3-shim/#readme",
   "bugs": {
@@ -43,7 +43,7 @@
   "devDependencies": {
     "globals": "^16.3.0",
     "vite": "^7.1.5",
-    "vitest": "^3.2.4"
+    "vitest": "^4.1.0"
   },
   "scripts": {
     "compile:check": "tsc --noEmit types/index.d.ts",