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

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/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);
     }
 
@@ -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",

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)));
 }
@@ -61,6 +62,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 +273,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 +286,7 @@ export class TcpSocket {
       }
       throw error;
     }
+    this.#sendStarted = true;
 
     try {
       // Transfer the stream to the worker
@@ -310,6 +318,16 @@ export class TcpSocket {
     if (this.#state !== STATE.CONNECTED) {
       throw new SocketError("invalid-state");
     }
+    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)];
+    }
+    this.#receiveStarted = true;
 
     const transform = new TransformStream();
     const promise = worker()
@@ -325,7 +343,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.0",
   "description": "WASI Preview3 shim for JS environments",
   "homepage": "https://github.com/bytecodealliance/jco/blob/main/packages/preview3-shim/#readme",
   "bugs": {