@bytecodealliance/preview3-shim 0.1.0-rc.0 → 0.1.1

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/future.js

@@ -52,6 +52,9 @@ export class FutureReader {
     if (!promise || typeof promise.then !== "function") {
       throw new Error("Provided future must be a Promise");
     }
+    if (promise instanceof Promise) {
+      promise.catch(() => {});
+    }
     this.#promise = promise;
   }
 

package/lib/nodejs/http/client.js

@@ -136,7 +136,7 @@ const responseFromParts = (parts) => {
     });
   });
 
-  const future = new FutureReader(promise.then(_trailerResultFromEntries));
+  const future = new TrailerFutureReader(promise.then(_trailerResultFromEntries), trailers);
   const contents = new StreamReader(body);
   const fields = _fieldsFromEntriesChecked(headers);
 
@@ -144,3 +144,18 @@ const responseFromParts = (parts) => {
   res.setStatusCode(statusCode);
   return res;
 };
+
+class TrailerFutureReader extends FutureReader {
+  #trailers;
+
+  constructor(promise, trailers) {
+    super(promise);
+    this.#trailers = trailers;
+  }
+
+  close() {
+    this.#trailers?.close();
+    this.#trailers = null;
+    super.close();
+  }
+}

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

@@ -2,7 +2,12 @@ import { HttpError } from "./error.js";
 import { _fieldsLock, Fields } from "./fields.js";
 
 import { FutureReader, future } from "../future.js";
-import { StreamReader, readableByteStreamFromReader } from "../stream.js";
+import {
+  DEFAULT_BYTE_STREAM_CHUNK_SIZE,
+  StreamReader,
+  _byteChunk,
+  readableByteStreamFromReader,
+} from "../stream.js";
 
 const symbolDispose = Symbol.dispose || Symbol.for("dispose");
 
@@ -221,7 +226,7 @@ export class Request {
     if (contents != null && !(contents instanceof StreamReader)) {
       try {
         dispose = contents[symbolDispose]?.bind(contents);
-        const inner = readableByteStreamFromReader(contents, { name: "contents" });
+        const inner = readableContentsStream(contents, headers);
         contents = new StreamReader(inner);
       } catch (err) {
         throw new HttpError("invalid-argument", err.message);
@@ -231,7 +236,6 @@ export class Request {
     // Generated P3 futures are lazy thenables so we want to observe them now so early error paths don't hang.
     if (!(trailers instanceof FutureReader)) {
       const promise = Promise.resolve(trailers);
-      void promise.catch(() => {});
       trailers = new FutureReader(promise);
     }
 
@@ -321,7 +325,7 @@ export class Request {
    */
   setPathWithQuery(pathWithQuery) {
     validateUrlPart(pathWithQuery, UrlPart.PATH_WITH_QUERY);
-    this.#pathWithQuery = pathWithQuery ?? undefined;
+    this.#pathWithQuery = pathWithQuery === "" ? "/" : (pathWithQuery ?? undefined);
   }
 
   /**
@@ -477,6 +481,93 @@ export class Request {
   }
 }
 
+function readableContentsStream(reader, headers) {
+  const expectedLength = contentLength(headers.copyAll());
+  if (expectedLength === null) {
+    return readableByteStreamFromReader(reader, { name: "contents" });
+  }
+
+  const source =
+    typeof reader?.read === "function"
+      ? reader
+      : new StreamReader(readableByteStreamFromReader(reader, { name: "contents" }));
+  return readableByteStreamFromReader(contentLengthReader(source, expectedLength), {
+    name: "contents",
+  });
+}
+
+function contentLengthReader(reader, expectedLength) {
+  let sent = 0n;
+  return {
+    async read() {
+      const result = await reader.read(readOpts(expectedLength - sent));
+      if (isIteratorResult(result) && result.rejectedLength !== undefined) {
+        throw requestBodySizeError(sent + BigInt(result.rejectedLength));
+      }
+      if (isIteratorResult(result) && result.done) {
+        if (sent < expectedLength) {
+          throw requestBodySizeError(sent);
+        }
+        return result;
+      }
+
+      const value = isIteratorResult(result) ? result.value : result;
+      const chunk = _byteChunk(value);
+      sent += BigInt(chunk.byteLength);
+      if (sent > expectedLength) {
+        throw requestBodySizeError(sent);
+      }
+      return { value: chunk, done: false };
+    },
+    cancel(reason) {
+      if (typeof reader.cancel === "function") {
+        return reader.cancel(reason);
+      }
+      if (typeof reader.close === "function") {
+        return reader.close();
+      }
+      return reader[symbolDispose]?.();
+    },
+  };
+}
+
+function readOpts(remaining) {
+  if (remaining <= 0n) {
+    return { count: 0, rejectLength: 0 };
+  }
+
+  const count = Number(
+    remaining <= BigInt(DEFAULT_BYTE_STREAM_CHUNK_SIZE)
+      ? remaining
+      : BigInt(DEFAULT_BYTE_STREAM_CHUNK_SIZE),
+  );
+  const opts = { count };
+  if (remaining <= BigInt(Number.MAX_SAFE_INTEGER)) {
+    opts.rejectLength = Number(remaining);
+  }
+  return opts;
+}
+
+function requestBodySizeError(bytes) {
+  return { tag: "HTTP-request-body-size", val: bytes };
+}
+
+function isIteratorResult(value) {
+  return value != null && typeof value === "object" && typeof value.done === "boolean";
+}
+
+const decoder = new TextDecoder();
+
+const contentLength = (entries) => {
+  const entry = entries.findLast(([name]) => name.toLowerCase() === "content-length");
+  if (!entry) {
+    return null;
+  }
+
+  const value = decoder.decode(entry[1]);
+  return /^\d+$/.test(value) ? BigInt(value) : null;
+};
+
 const UrlPart = {
   PATH_WITH_QUERY: "pathWithQuery",
   SCHEME: "scheme",
@@ -484,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)) {
@@ -506,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");
@@ -523,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") {
@@ -536,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");
@@ -569,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/http/response.js

@@ -71,7 +71,6 @@ export class Response {
     // Generated P3 futures are lazy thenables so we want to observe them now so early error paths don't hang.
     if (!(trailers instanceof FutureReader)) {
       const promise = Promise.resolve(trailers);
-      void promise.catch(() => {});
       trailers = new FutureReader(promise);
     }
 
@@ -90,7 +89,7 @@ export class Response {
   [symbolDispose]() {
     if (this.#contents && !this.#bodyOpen && !this.#bodyEnded) {
       this.#contentsDispose?.();
-      this.#contents.close();
+      this.#closeBody();
     }
     this.#contents = null;
     this.#contentsDispose = null;
@@ -194,9 +193,12 @@ export class Response {
 
     const closedFn = reader.close.bind(reader);
     reader.close = () => {
-      closedFn();
-      response.#bodyEnded = true;
-      response.#bodyOpen = false;
+      response.#closeBody(closedFn);
+    };
+
+    const cancelFn = reader.cancel.bind(reader);
+    reader.cancel = async (...args) => {
+      await response.#closeBody(() => cancelFn(...args));
     };
 
     return [response.#contents, response.#trailersFuture];
@@ -209,4 +211,17 @@ export class Response {
       this.#responseFuture = null;
     }
   }
+
+  #closeBody(close = this.#contents?.close.bind(this.#contents)) {
+    const closeTrailers = !this.#bodyEnded;
+    try {
+      return close?.();
+    } finally {
+      if (closeTrailers) {
+        this.#trailersFuture.close();
+      }
+      this.#bodyEnded = true;
+      this.#bodyOpen = false;
+    }
+  }
 }

package/lib/nodejs/sockets/tcp.js

@@ -13,6 +13,7 @@ import {
 } from "./address.js";
 
 let WORKER = null;
+const symbolDispose = Symbol.dispose || Symbol.for("dispose");
 function worker() {
   return (WORKER ??= new ResourceWorker(new URL("../workers/tcp-worker.js", import.meta.url)));
 }
@@ -22,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",
@@ -61,6 +72,8 @@ export class TcpSocket {
   #socketId = null;
   #family = null;
   #state = "unbound";
+  #sendStarted = false;
+  #receiveStarted = false;
   #options = {
     // defaults per https://nodejs.org/docs/latest/api/net.html#socketsetkeepaliveenable-initialdelay
     keepAliveEnabled: false,
@@ -270,6 +283,10 @@ export class TcpSocket {
     if (this.#state !== STATE.CONNECTED) {
       throw new SocketError("invalid-state");
     }
+    if (this.#sendStarted) {
+      data?.[symbolDispose]?.();
+      throw new SocketError("invalid-state");
+    }
     let stream;
     try {
       stream = readableByteStreamFromReader(data, { name: "tcp send data" });
@@ -279,6 +296,7 @@ export class TcpSocket {
       }
       throw error;
     }
+    this.#sendStarted = true;
 
     try {
       // Transfer the stream to the worker
@@ -308,8 +326,12 @@ export class TcpSocket {
    */
   receive() {
     if (this.#state !== STATE.CONNECTED) {
-      throw new SocketError("invalid-state");
+      return invalidRecv();
+    }
+    if (this.#receiveStarted) {
+      return invalidRecv();
     }
+    this.#receiveStarted = true;
 
     const transform = new TransformStream();
     const promise = worker()
@@ -325,7 +347,10 @@ export class TcpSocket {
         throw SocketError.from(err);
       });
 
-    return [new StreamReader(transform.readable), new FutureReader(promise)];
+    return [
+      new StreamReader(transform.readable, { preventCancel: false }),
+      new FutureReader(promise),
+    ];
   }
 
   /**

package/lib/nodejs/stream.js

@@ -1,4 +1,5 @@
 export const DEFAULT_BYTE_STREAM_CHUNK_SIZE = 64 * 1024;
+const symbolDispose = Symbol.dispose || Symbol.for("dispose");
 
 let BYTE_STREAM_ENCODER = null;
 function encoder() {
@@ -61,7 +62,7 @@ export function readableByteStreamFromReader(reader, opts = {}) {
         controller.close();
         return;
       }
-      controller.enqueue(byteChunk(value));
+      controller.enqueue(_byteChunk(value));
     },
     cancel(reason) {
       return source.cancel?.(reason);
@@ -85,6 +86,15 @@ function byteStreamSource(reader, opts) {
         }
         return { value: result, done: result === null };
       },
+      cancel(reason) {
+        if (typeof reader.cancel === "function") {
+          return reader.cancel(reason);
+        }
+        if (typeof reader.close === "function") {
+          return reader.close();
+        }
+        return reader[symbolDispose]?.();
+      },
     };
   }
 
@@ -107,7 +117,7 @@ function isIteratorResult(value) {
   return value != null && typeof value === "object" && typeof value.done === "boolean";
 }
 
-function byteChunk(value) {
+export function _byteChunk(value) {
   if (value instanceof Uint8Array) {
     return value;
   }
@@ -196,7 +206,7 @@ export class StreamReader {
    * @param {AsyncIterable|Iterable} source - An async or sync iterable to consume e.g. ReadableStream, async generator, array.
    * @throws {Error} If the provided source does not implement `[Symbol.asyncIterator]` or `[Symbol.iterator]`.
    */
-  constructor(source) {
+  constructor(source, opts = {}) {
     if (
       !source ||
       (typeof source[Symbol.asyncIterator] !== "function" &&
@@ -210,7 +220,7 @@ export class StreamReader {
     // For ReadableStream, use values() with preventCancel so the underlying
     // stream is not cancelled when the iterator is released.
     if (source instanceof ReadableStream) {
-      this.#iterator = source.values({ preventCancel: true });
+      this.#iterator = source.values({ preventCancel: opts.preventCancel ?? true });
     } else if (typeof source[Symbol.asyncIterator] === "function") {
       this.#iterator = source[Symbol.asyncIterator]();
     } else {
@@ -298,6 +308,10 @@ export class StreamReader {
     this.#iterator = null;
   }
 
+  [symbolDispose]() {
+    this.close();
+  }
+
   /**
    * Consumes the reader and returns the underlying async iterator.
    *

package/lib/nodejs/workers/http-worker.js

@@ -222,7 +222,10 @@ async function doHandleRequest({ url, method, headers, trailers, body, timeouts
     req.once("close", onClose);
   });
 
-  const upload = body ? sendRequestBody(req, body, trailers, () => resStarted) : endRequest(req);
+  const expectedLength = contentLength(headers);
+  const upload = body
+    ? sendRequestBody(req, body, trailers, () => resStarted, expectedLength)
+    : endRequest(req);
 
   upload.then(
     () => transmit.ok(),
@@ -287,10 +290,12 @@ async function handleHttpServerClose({ serverId }) {
   return serverId;
 }
 
-async function sendRequestBody(req, body, trailers, resStarted) {
+async function sendRequestBody(req, body, trailers, resStarted, expectedLength) {
   try {
     req.flushHeaders();
-    await pipeline(Readable.fromWeb(body), req, { end: false });
+    await pipeline(validateRequestBody(Readable.fromWeb(body), expectedLength), req, {
+      end: false,
+    });
     const fields = await recvTrailers(trailers);
     if (fields) {
       req.addTrailers(toObject(fields));
@@ -304,6 +309,21 @@ async function sendRequestBody(req, body, trailers, resStarted) {
   }
 }
 
+async function* validateRequestBody(body, expectedLength) {
+  let bytes = 0n;
+  for await (const chunk of body) {
+    bytes += BigInt(chunk.byteLength);
+    if (expectedLength !== null && bytes > expectedLength) {
+      throw new HttpError("HTTP-request-body-size", undefined, bytes);
+    }
+    yield chunk;
+  }
+
+  if (expectedLength !== null && bytes < expectedLength) {
+    throw new HttpError("HTTP-request-body-size", undefined, bytes);
+  }
+}
+
 function endRequest(req) {
   return new Promise((resolve, reject) => {
     let settled = false;
@@ -374,6 +394,16 @@ const msecs = (time) => {
 
 const decoder = new TextDecoder();
 
+const contentLength = (entries) => {
+  const entry = entries.findLast(([name]) => name.toLowerCase() === "content-length");
+  if (!entry) {
+    return null;
+  }
+
+  const value = decoder.decode(entry[1]);
+  return /^\d+$/.test(value) ? BigInt(value) : null;
+};
+
 const toObject = (entries) => {
   return Object.fromEntries(entries.map(([key, val]) => [key, decoder.decode(val)]));
 };

package/lib/nodejs/workers/resource-worker.js

@@ -46,7 +46,7 @@ export class ResourceWorker {
         port1.close();
 
         if (error) {
-          reject(error);
+          reject(deserializeError(error));
           return;
         }
         resolve(result);
@@ -77,7 +77,7 @@ export class ResourceWorker {
     const { result, error } = message;
 
     if (error) {
-      throw error;
+      throw deserializeError(error);
     }
     return result;
   }
@@ -118,7 +118,7 @@ export function Router() {
         result = outcome;
       }
     } catch (err) {
-      error = err;
+      error = serializeError(err);
     }
 
     _reply.postMessage({ result, error }, transfer);
@@ -144,6 +144,50 @@ export function Router() {
   };
 }
 
+function serializeError(err) {
+  if (!(err instanceof Error)) {
+    return err;
+  }
+
+  const serialized = {
+    __resourceWorkerError: true,
+    name: err.name,
+    message: err.message,
+    stack: err.stack,
+  };
+
+  for (const key of Reflect.ownKeys(err)) {
+    serialized[key] = err[key];
+  }
+
+  if (err.cause !== undefined) {
+    serialized.cause = serializeError(err.cause);
+  }
+
+  return serialized;
+}
+
+function deserializeError(err) {
+  if (!err || typeof err !== "object" || err.__resourceWorkerError !== true) {
+    return err;
+  }
+
+  const error = new Error(err.message);
+  error.name = err.name;
+  if (err.stack) {
+    error.stack = err.stack;
+  }
+
+  for (const key of Reflect.ownKeys(err)) {
+    if (key === "__resourceWorkerError" || key === "name" || key === "message" || key === "stack") {
+      continue;
+    }
+    error[key] = key === "cause" ? deserializeError(err[key]) : err[key];
+  }
+
+  return error;
+}
+
 function notify(condvar) {
   const lock = new Int32Array(condvar);
   Atomics.store(lock, 0, 1);

package/lib/nodejs/workers/tcp-worker.js

@@ -1,5 +1,5 @@
 import { Socket, Server } from "node:net";
-import { Readable, Writable } from "stream";
+import { Readable } from "stream";
 import { pipeline } from "stream/promises";
 import { once } from "node:events";
 
@@ -48,6 +48,8 @@ function handleTcpCreate({ family }) {
     server: null,
     backlog: 128,
     localAddress: null,
+    disposed: false,
+    activeStreams: 0,
   });
 
   return { socketId };
@@ -143,6 +145,7 @@ async function handleTcpListen({ socketId, stream }) {
   }
 
   server.on("connection", (conn) => {
+    conn.allowHalfOpen = true;
     const id = NEXT_SOCKET_ID++;
     sockets.set(id, {
       handle: conn._handle,
@@ -151,6 +154,8 @@ async function handleTcpListen({ socketId, stream }) {
       tcp: conn,
       server: null,
       localAddress: makeIpAddress(family, conn.localAddress, conn.localPort),
+      disposed: false,
+      activeStreams: 0,
     });
     writer.write({ family, socketId: id });
   });
@@ -162,19 +167,111 @@ async function handleTcpListen({ socketId, stream }) {
 
 async function handleTcpSend({ socketId, stream }) {
   const socket = sockets.get(socketId);
+  socket.activeStreams++;
+
   const { tcp } = socket;
   const readable = Readable.fromWeb(stream);
 
-  // TODO(tandr): Should we handle FIN packet?
-  await pipeline(readable, tcp);
+  try {
+    await pipeline(readable, tcp);
+  } finally {
+    socket.activeStreams--;
+    cleanupDisposedSocket(socketId, socket);
+  }
 }
 
 async function handleTcpReceive({ socketId, stream }) {
   const socket = sockets.get(socketId);
+  const writer = stream.getWriter();
+  socket.activeStreams++;
+
   const { tcp } = socket;
 
-  const writable = Writable.fromWeb(stream);
-  await pipeline(tcp, writable);
+  try {
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      let pending = Promise.resolve();
+
+      const cleanup = () => {
+        tcp.off("data", onData);
+        tcp.off("end", onEnd);
+        tcp.off("error", onError);
+      };
+      const settle = (err) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      };
+      const onData = (chunk) => {
+        tcp.pause();
+        pending = pending.then(async () => {
+          try {
+            await writer.write(chunk);
+          } catch {
+            settle();
+            return;
+          } finally {
+            // Always undo the pause, even if the guest dropped or cancelled the
+            // receive stream. Otherwise the send path can remain backpressured
+            // forever.
+            tcp.resume();
+          }
+        }, settle);
+      };
+      const onEnd = () => {
+        pending = pending.then(async () => {
+          try {
+            await writer.close();
+          } catch {
+            // The guest can drop the receive stream before remote EOF.
+          }
+          settle();
+        }, settle);
+      };
+      const onError = (err) => {
+        pending = pending.finally(() => settle(err));
+      };
+
+      writer.closed.then(
+        () => settle(),
+        () => settle(),
+      );
+      tcp.on("data", onData);
+      tcp.once("end", onEnd);
+      tcp.once("error", onError);
+      tcp.resume();
+    });
+  } finally {
+    writer.releaseLock();
+    socket.activeStreams--;
+    cleanupDisposedSocket(socketId, socket);
+  }
+}
+
+function cleanupDisposedSocket(socketId, socket) {
+  if (!socket.disposed || socket.activeStreams > 0) {
+    return;
+  }
+
+  if (socket.server) {
+    socket.server.close();
+  }
+
+  if (socket.tcp) {
+    socket.tcp.destroy();
+  }
+  if (socket.handle) {
+    socket.handle.close();
+  }
+
+  sockets.delete(socketId);
 }
 
 async function handleGetLocalAddress({ socketId }) {
@@ -241,18 +338,8 @@ function handleTcpDispose({ socketId }) {
     return;
   }
 
-  if (socket.server) {
-    socket.server.close();
-  }
-
-  if (socket.tcp) {
-    socket.tcp.destroy();
-  }
-  if (socket.handle) {
-    socket.handle.close();
-  }
-
-  sockets.delete(socketId);
+  socket.disposed = true;
+  cleanupDisposedSocket(socketId, socket);
 }
 
 let _recvBufferSize, _sendBufferSize;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytecodealliance/preview3-shim",
-  "version": "0.1.0-rc.0",
+  "version": "0.1.1",
   "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",