@bytecodealliance/preview2-shim 0.14.1 → 0.14.2

package/lib/io/worker-thread.js

@@ -1,9 +1,18 @@
 import { resolve } from "node:dns/promises";
 import { createReadStream, createWriteStream } from "node:fs";
-import { hrtime } from "node:process";
+import { _rawDebug, exit, hrtime, stderr, stdout } from "node:process";
+import { PassThrough } from "node:stream";
 import { runAsWorker } from "../synckit/index.js";
-import { createHttpRequest } from "./worker-http.js";
-import { Writable } from "node:stream";
+import {
+  clearOutgoingResponse,
+  createHttpRequest,
+  setOutgoingResponse,
+  startHttpServer,
+  stopHttpServer,
+} from "./worker-http.js";
+
+const noop = () => {};
+
 import {
   CALL_MASK,
   CALL_SHIFT,
@@ -11,10 +20,16 @@ import {
   CLOCKS_DURATION_SUBSCRIBE,
   CLOCKS_INSTANT_SUBSCRIBE,
   CLOCKS_NOW,
+  FILE,
   FUTURE_DISPOSE,
   FUTURE_GET_VALUE_AND_DISPOSE,
+  HTTP,
   HTTP_CREATE_REQUEST,
   HTTP_OUTPUT_STREAM_FINISH,
+  HTTP_SERVER_CLEAR_OUTGOING_RESPONSE,
+  HTTP_SERVER_SET_OUTGOING_RESPONSE,
+  HTTP_SERVER_START,
+  HTTP_SERVER_STOP,
   INPUT_STREAM_BLOCKING_READ,
   INPUT_STREAM_BLOCKING_SKIP,
   INPUT_STREAM_CREATE,
@@ -32,21 +47,66 @@ import {
   OUTPUT_STREAM_FLUSH,
   OUTPUT_STREAM_SPLICE,
   OUTPUT_STREAM_SUBSCRIBE,
-  OUTPUT_STREAM_WRITE_ZEROES,
   OUTPUT_STREAM_WRITE,
-  POLL_POLL_LIST,
+  OUTPUT_STREAM_WRITE_ZEROES,
   POLL_POLLABLE_BLOCK,
   POLL_POLLABLE_READY,
+  POLL_POLL_LIST,
   SOCKET_RESOLVE_ADDRESS_CREATE_REQUEST,
   SOCKET_RESOLVE_ADDRESS_DISPOSE_REQUEST,
   SOCKET_RESOLVE_ADDRESS_GET_AND_DISPOSE_REQUEST,
-  FILE,
-  HTTP,
-  SOCKET,
+  SOCKET_TCP_BIND,
+  SOCKET_TCP_CONNECT,
+  SOCKET_TCP_CREATE_HANDLE,
+  SOCKET_TCP_CREATE_INPUT_STREAM,
+  SOCKET_TCP_CREATE_OUTPUT_STREAM,
+  SOCKET_TCP_DISPOSE,
+  SOCKET_TCP_GET_LOCAL_ADDRESS,
+  SOCKET_TCP_GET_REMOTE_ADDRESS,
+  SOCKET_TCP_LISTEN,
+  SOCKET_TCP_SET_KEEP_ALIVE,
+  SOCKET_TCP_SHUTDOWN,
+  SOCKET_UDP_BIND,
+  SOCKET_UDP_CHECK_SEND,
+  SOCKET_UDP_CONNECT,
+  SOCKET_UDP_CREATE_HANDLE,
+  SOCKET_UDP_DISCONNECT,
+  SOCKET_UDP_DISPOSE,
+  SOCKET_UDP_GET_LOCAL_ADDRESS,
+  SOCKET_UDP_GET_RECEIVE_BUFFER_SIZE,
+  SOCKET_UDP_GET_REMOTE_ADDRESS,
+  SOCKET_UDP_GET_SEND_BUFFER_SIZE,
+  SOCKET_UDP_RECEIVE,
+  SOCKET_UDP_SEND,
+  SOCKET_UDP_SET_RECEIVE_BUFFER_SIZE,
+  SOCKET_UDP_SET_SEND_BUFFER_SIZE,
+  SOCKET_UDP_SET_UNICAST_HOP_LIMIT,
   STDERR,
   STDIN,
   STDOUT,
 } from "./calls.js";
+import {
+  createTcpSocket,
+  socketTcpBind,
+  socketTcpConnect,
+  socketTcpDispose,
+  socketTcpGetLocalAddress,
+  socketTcpGetRemoteAddress,
+  socketTcpListen,
+  socketTcpSetKeepAlive,
+  socketTcpShutdown,
+} from "./worker-socket-tcp.js";
+import {
+  SocketUdpReceive,
+  createUdpSocket,
+  getSocketOrThrow,
+  socketUdpBind,
+  socketUdpCheckSend,
+  socketUdpConnect,
+  socketUdpDisconnect,
+  socketUdpDispose,
+  socketUdpSend,
+} from "./worker-socket-udp.js";
 
 let streamCnt = 0,
   pollCnt = 0;
@@ -63,28 +123,28 @@ export const unfinishedFutures = new Map();
 /**
  * @param {NodeJS.ReadableStream | NodeJS.WritableStream} stream
  */
-export function createStream(nodeStream, flushPromise) {
+export function createStream(nodeStream) {
   unfinishedStreams.set(++streamCnt, {
-    flushPromise,
+    flushPromise: null,
     stream: nodeStream,
   });
   return streamCnt;
 }
 
 // Stdio
-createStream(process.stdin, Promise.resolve());
-createStream(process.stdout, Promise.resolve());
-createStream(process.stderr, Promise.resolve());
+// Stdin created when used
+createStream(stdout);
+createStream(stderr);
 
 /**
  * @param {number} streamId
  * @param {NodeJS.ReadableStream | NodeJS.WritableStream} stream
  */
 function streamError(streamId, stream, err) {
-  if (stream.end) stream.end();
+  if (typeof stream.end === "function") stream.end();
   // we delete the stream from unfinishedStreams as it is now "finished" (closed)
   unfinishedStreams.delete(streamId);
-  return { tag: "last-operation-failed", val: err };
+  return { tag: "last-operation-failed", val: { code: err.code, message: err.message, stack: err.stack } };
 }
 
 /**
@@ -92,6 +152,7 @@ function streamError(streamId, stream, err) {
  * @returns {{ stream: NodeJS.ReadableStream | NodeJS.WritableStream, flushPromise: Promise<void> | null }}
  */
 export function getStreamOrThrow(streamId) {
+  if (!streamId) throw new Error("Internal error: no stream id provided");
   const stream = unfinishedStreams.get(streamId);
   // not in unfinished streams <=> closed
   if (!stream) throw { tag: "closed" };
@@ -126,15 +187,36 @@ function handle(call, id, payload) {
   switch (call) {
     // Http
     case HTTP_CREATE_REQUEST: {
-      const { method, url, headers, body } = payload;
-      return createFuture(createHttpRequest(method, url, headers, body));
+      const {
+        method,
+        scheme,
+        authority,
+        pathWithQuery,
+        headers,
+        body,
+        connectTimeout,
+        betweenBytesTimeout,
+        firstByteTimeout,
+      } = payload;
+      return createFuture(
+        createHttpRequest(
+          method,
+          scheme,
+          authority,
+          pathWithQuery,
+          headers,
+          body,
+          connectTimeout,
+          betweenBytesTimeout,
+          firstByteTimeout
+        )
+      );
     }
     case OUTPUT_STREAM_CREATE | HTTP: {
-      const webTransformStream = new TransformStream();
-      const stream = Writable.fromWeb(webTransformStream.writable);
+      const stream = new PassThrough();
       // content length is passed as payload
+      stream.contentLength = payload;
       stream.bytesRemaining = payload;
-      stream.readableBodyStream = webTransformStream.readable;
       return createStream(stream);
     }
     case OUTPUT_STREAM_SUBSCRIBE | HTTP:
@@ -142,32 +224,35 @@ function handle(call, id, payload) {
     case OUTPUT_STREAM_BLOCKING_WRITE_AND_FLUSH | HTTP: {
       // http flush is a noop
       const { stream } = getStreamOrThrow(id);
-      // this existing indicates it's still unattached
-      // therefore there is no subscribe or backpressure
-      if (stream.readableBodyStream) {
-        switch (call) {
-          case OUTPUT_STREAM_BLOCKING_WRITE_AND_FLUSH | HTTP:
-            return handle(OUTPUT_STREAM_WRITE | HTTP, id, payload);
-          case OUTPUT_STREAM_FLUSH | HTTP:
-            return;
-          case OUTPUT_STREAM_SUBSCRIBE | HTTP:
-            return 0;
+      if (call === (OUTPUT_STREAM_BLOCKING_WRITE_AND_FLUSH | HTTP)) {
+        stream.bytesRemaining -= payload.byteLength;
+        if (stream.bytesRemaining < 0) {
+          throw {
+            tag: "last-operation-failed",
+            val: {
+              tag: "HTTP-request-body-size",
+              val: stream.contentLength - stream.bytesRemaining,
+            },
+          };
         }
       }
-      if (call === (OUTPUT_STREAM_BLOCKING_WRITE_AND_FLUSH | HTTP))
-        stream.bytesRemaining -= payload.byteLength;
       // otherwise fall through to generic implementation
       return handle(call & ~HTTP, id, payload);
     }
     case OUTPUT_STREAM_DISPOSE | HTTP:
-      throw new Error('Internal error: HTTP output stream dispose is bypassed for FINISH');
+      throw new Error(
+        "Internal error: HTTP output stream dispose is bypassed for FINISH"
+      );
     case OUTPUT_STREAM_WRITE | HTTP: {
       const { stream } = getStreamOrThrow(id);
       stream.bytesRemaining -= payload.byteLength;
       if (stream.bytesRemaining < 0) {
         throw {
-          tag: 'last-operation-failed',
-          val: 'too much written to output stream'
+          tag: "last-operation-failed",
+          val: {
+            tag: "HTTP-request-body-size",
+            val: stream.contentLength - stream.bytesRemaining,
+          },
         };
       }
       const output = handle(OUTPUT_STREAM_WRITE, id, payload);
@@ -177,49 +262,178 @@ function handle(call, id, payload) {
       const { stream } = getStreamOrThrow(id);
       if (stream.bytesRemaining > 0) {
         throw {
-          tag: 'internal-error',
-          val: 'not enough written to body stream'
+          tag: "HTTP-request-body-size",
+          val: stream.contentLength - stream.bytesRemaining,
         };
       }
       if (stream.bytesRemaining < 0) {
         throw {
-          tag: 'internal-error',
-          val: 'too much written to body stream'
+          tag: "HTTP-request-body-size",
+          val: stream.contentLength - stream.bytesRemaining,
         };
       }
       stream.end();
       break;
     }
+    case HTTP_SERVER_START:
+      return startHttpServer(id, payload);
+    case HTTP_SERVER_STOP:
+      return stopHttpServer(id);
+    case HTTP_SERVER_SET_OUTGOING_RESPONSE:
+      return setOutgoingResponse(id, payload);
+    case HTTP_SERVER_CLEAR_OUTGOING_RESPONSE:
+      return clearOutgoingResponse(id);
+
+    // Sockets TCP
+    case SOCKET_TCP_CREATE_HANDLE:
+      return createFuture(createTcpSocket());
+
+    case SOCKET_TCP_BIND:
+      return socketTcpBind(id, payload);
+
+    case SOCKET_TCP_CONNECT:
+      return socketTcpConnect(id, payload);
+
+    case SOCKET_TCP_LISTEN:
+      return socketTcpListen(id, payload);
+
+    case SOCKET_TCP_GET_LOCAL_ADDRESS:
+      return socketTcpGetLocalAddress(id);
+
+    case SOCKET_TCP_GET_REMOTE_ADDRESS:
+      return socketTcpGetRemoteAddress(id);
+
+    case SOCKET_TCP_SHUTDOWN:
+      return socketTcpShutdown(id, payload);
+
+    case SOCKET_TCP_SET_KEEP_ALIVE:
+      return socketTcpSetKeepAlive(id, payload);
+
+    case SOCKET_TCP_DISPOSE:
+      return socketTcpDispose(id);
+
+    case SOCKET_TCP_CREATE_INPUT_STREAM:
+    case SOCKET_TCP_CREATE_OUTPUT_STREAM:
+      return createStream(new PassThrough());
+
+    // Sockets UDP
+    case SOCKET_UDP_CREATE_HANDLE: {
+      const { addressFamily, reuseAddr } = payload;
+      return createFuture(createUdpSocket(addressFamily, reuseAddr));
+    }
+
+    case SOCKET_UDP_BIND:
+      return socketUdpBind(id, payload);
+
+    case SOCKET_UDP_CHECK_SEND:
+      return socketUdpCheckSend(id);
+
+    case SOCKET_UDP_SEND:
+      return socketUdpSend(id, payload);
+
+    case SOCKET_UDP_RECEIVE:
+      return SocketUdpReceive(id, payload);
+
+    case SOCKET_UDP_CONNECT:
+      return socketUdpConnect(id, payload);
+
+    case SOCKET_UDP_DISCONNECT:
+      return socketUdpDisconnect(id);
+
+    case SOCKET_UDP_GET_LOCAL_ADDRESS: {
+      const socket = getSocketOrThrow(id);
+      return Promise.resolve(socket.address());
+    }
+
+    case SOCKET_UDP_GET_REMOTE_ADDRESS: {
+      const socket = getSocketOrThrow(id);
+      return Promise.resolve(socket.remoteAddress());
+    }
 
-    // Sockets
     case SOCKET_RESOLVE_ADDRESS_CREATE_REQUEST:
       return createFuture(resolve(payload.hostname));
+
     case SOCKET_RESOLVE_ADDRESS_DISPOSE_REQUEST:
       return void unfinishedFutures.delete(id);
+
     case SOCKET_RESOLVE_ADDRESS_GET_AND_DISPOSE_REQUEST: {
       const future = unfinishedFutures.get(id);
       if (!future) {
         // future not ready yet
         if (unfinishedPolls.get(id)) {
-          throw 'would-block';
+          throw "would-block";
         }
         throw new Error("future already got and dropped");
       }
       unfinishedFutures.delete(id);
       return future;
     }
-    case OUTPUT_STREAM_CREATE | SOCKET: {
-      // TODO: implement
+
+    case SOCKET_UDP_GET_RECEIVE_BUFFER_SIZE: {
+      const socket = getSocketOrThrow(id);
+      try {
+        return socket.getRecvBufferSize();
+      } catch (err) {
+        return err.errno;
+      }
+    }
+
+    case SOCKET_UDP_SET_RECEIVE_BUFFER_SIZE: {
+      const socket = getSocketOrThrow(id);
+      try {
+        return socket.setRecvBufferSize(65537);
+      } catch (err) {
+        return err.errno;
+      }
     }
-    case INPUT_STREAM_CREATE | SOCKET: {
-      // TODO: implement
+
+    case SOCKET_UDP_GET_SEND_BUFFER_SIZE: {
+      const socket = getSocketOrThrow(id);
+      try {
+        return socket.getSendBufferSize();
+      } catch (err) {
+        return err.errno;
+      }
     }
 
+    case SOCKET_UDP_SET_SEND_BUFFER_SIZE: {
+      const socket = getSocketOrThrow(id);
+      try {
+        return socket.setSendBufferSize(payload.value);
+      } catch (err) {
+        return err.errno;
+      }
+    }
+
+    case SOCKET_UDP_SET_UNICAST_HOP_LIMIT: {
+      const socket = getSocketOrThrow(id);
+      try {
+        return socket.setTTL(payload.value);
+      } catch (err) {
+        return err.errno;
+      }
+    }
+
+    case SOCKET_UDP_DISPOSE:
+      return socketUdpDispose(id);
+
     // Stdio
+    case OUTPUT_STREAM_BLOCKING_FLUSH | STDOUT:
+    case OUTPUT_STREAM_BLOCKING_FLUSH | STDERR:
+      // no blocking flush for stdio in Node.js
+      return;
     case OUTPUT_STREAM_DISPOSE | STDOUT:
     case OUTPUT_STREAM_DISPOSE | STDERR:
-    case INPUT_STREAM_DISPOSE | STDIN:
       return;
+    case INPUT_STREAM_CREATE | STDIN: {
+      const stream = createReadStream(null, {
+        fd: 0,
+        highWaterMark: 64 * 1024,
+      });
+      // for some reason fs streams dont emit readable on end
+      stream.on("end", () => void stream.emit("readable"));
+      return createStream(stream);
+    }
 
     // Clocks
     case CLOCKS_NOW:
@@ -258,7 +472,9 @@ function handle(call, id, payload) {
       switch (call & CALL_MASK) {
         case INPUT_STREAM_READ: {
           const { stream } = getStreamOrThrow(id);
-          const res = stream.read(Number(payload));
+          const res = stream.read(
+            Math.min(stream.readableLength, Number(payload))
+          );
           return res ?? new Uint8Array();
         }
         case INPUT_STREAM_BLOCKING_READ:
@@ -283,10 +499,6 @@ function handle(call, id, payload) {
           );
         case INPUT_STREAM_SUBSCRIBE: {
           const stream = unfinishedStreams.get(id)?.stream;
-          if (id === 1) {
-            // TODO: stdin subscribe
-            return 0;
-          }
           // already closed or errored -> immediately return poll
           // (poll 0 is immediately resolved)
           if (
@@ -304,10 +516,8 @@ function handle(call, id, payload) {
                 .once("error", (reject = _reject));
             }).then(
               () => void stream.off("error", reject),
-              (err) => {
-                stream.off("readable", resolve);
-                throw streamError(id, stream.stream, err);
-              }
+              // error is read of stream itself when later accessed
+              (_err) => void stream.off("readable", resolve)
             )
           );
         }
@@ -344,8 +554,10 @@ function handle(call, id, payload) {
             );
           }
           return new Promise((resolve, reject) => {
+            stream.once("error", noop);
             stream.write(payload, (err) => {
               if (err) return void reject(streamError(id, stream, err));
+              stream.off("error", noop);
               resolve(BigInt(payload.byteLength));
             });
           });
@@ -413,15 +625,12 @@ function handle(call, id, payload) {
         }
         case OUTPUT_STREAM_SUBSCRIBE: {
           const { stream, flushPromise } = unfinishedStreams.get(id) ?? {};
-          if (flushPromise) return flushPromise;
+          if (flushPromise)
+            return flushPromise.then(() => handle(call, id, payload));
           // not added to unfinishedPolls => it's an immediately resolved poll
-          if (
-            !stream ||
-            stream.closed ||
-            stream.errored ||
-            !stream.writableNeedDrain
-          )
-            return 0;
+          if (!stream || stream.closed || stream.errored) return 0;
+          if (!stream.writableNeedDrain)
+            return createPoll(new Promise((resolve) => setTimeout(resolve)));
           let resolve, reject;
           return createPoll(
             new Promise((_resolve, _reject) => {
@@ -429,10 +638,8 @@ function handle(call, id, payload) {
                 .once("drain", (resolve = _resolve))
                 .once("error", (reject = _reject));
             }).then(() => void stream.off("error", reject)),
-            (err) => {
-              stream.off("drain", resolve);
-              throw streamError(id, stream, err);
-            }
+            // error is read off stream itself when later accessed
+            (_err) => void stream.off("drain", resolve)
           );
         }
         case OUTPUT_STREAM_BLOCKING_SPLICE: {
@@ -489,18 +696,21 @@ function handle(call, id, payload) {
           payload = [id];
         // [intentional case fall-through]
         case POLL_POLL_LIST: {
-          const resolvedList = payload.filter((id) => !unfinishedPolls.has(id));
-          if (resolvedList.length > 0) return resolvedList;
+          const doneList = [];
+          for (const [idx, id] of payload.entries()) {
+            if (!unfinishedPolls.has(id)) doneList.push(idx);
+          }
+          if (doneList.length > 0) return new Uint32Array(doneList);
           // if all polls are promise type, we just race them
           return Promise.race(
             payload.map((id) => unfinishedPolls.get(id))
           ).then(() => {
-            const resolvedList = payload.filter(
-              (id) => !unfinishedPolls.has(id)
-            );
-            if (resolvedList.length === 0)
+            for (const [idx, id] of payload.entries()) {
+              if (!unfinishedPolls.has(id)) doneList.push(idx);
+            }
+            if (doneList.length === 0)
               throw new Error("poll promise did not unregister poll");
-            return resolvedList;
+            return new Uint32Array(doneList);
           });
         }
 
@@ -508,11 +718,7 @@ function handle(call, id, payload) {
           const future = unfinishedFutures.get(id);
           if (!future) {
             // future not ready yet
-            if (unfinishedPolls.get(id)) {
-              // if ((call & CALL_TYPE_MASK) ===
-              // http futures throw
-              throw undefined;
-            }
+            if (unfinishedPolls.get(id)) throw undefined;
             throw new Error("future already got and dropped");
           }
           unfinishedFutures.delete(id);
@@ -539,9 +745,9 @@ export function createPoll(promise) {
     promise.then(
       () => void unfinishedPolls.delete(pollId),
       (err) => {
-        process._rawDebug("Unexpected poll error");
-        process._rawDebug(err);
-        process.exit(1);
+        _rawDebug("Unexpected poll error");
+        _rawDebug(err);
+        exit(1);
       }
     )
   );

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);
+// Stdin is created as a FILE descriptor
+let stdinStream;
 let stdoutStream = outputStreamCreate(STDOUT, 2);
 let stderrStream = outputStreamCreate(STDERR, 3);
 
 export const stdin = {
   InputStream,
   getStdin() {
+    if (!stdinStream)
+      stdinStream = inputStreamCreate(
+        STDIN,
+        ioCall(INPUT_STREAM_CREATE | STDIN, null, null)
+      );
     return stdinStream;
   },
 };