@bytecodealliance/preview2-shim 0.0.20 → 0.14.0

package/lib/{common → browser}/io.js

@@ -1,6 +1,8 @@
 let id = 0;
 
-class Error {
+const symbolDispose = Symbol.dispose || Symbol.for('dispose');
+
+const IoError = class Error {
   constructor (msg) {
     this.msg = msg;
   }
@@ -73,7 +75,7 @@ class InputStream {
   subscribe() {
     console.log(`[streams] Subscribe to input stream ${this.id}`);
   }
-  drop () {
+  [symbolDispose] () {
     if (this.handler.drop)
       this.handler.drop.call(this);
   }
@@ -158,11 +160,13 @@ class OutputStream {
   subscribe() {
     console.log(`[streams] Subscribe to output stream ${this.id}`);
   }
-  drop() {
+  [symbolDispose]() {
   }
 }
 
-export const streams = { Error, InputStream, OutputStream };
+export const error = { Error: IoError };
+
+export const streams = { InputStream, OutputStream };
 
 class Pollable {}
 

package/lib/common/assert.js

@@ -0,0 +1,7 @@
+export function assert(condition, tag, _val) {
+  if (condition) {
+    // TODO: throw meaningful errors
+    // NOTE: wasmtime conformance tests are expecting a string here (a tag)
+    throw tag;
+  }
+}

package/lib/io/calls.js

@@ -0,0 +1,64 @@
+let call_id = 0;
+
+// Call is a 32 bit integer, leading 16 bits are call number, trailing 16 bits allow custom call types
+export const CALL_MASK = 0xff000000;
+export const CALL_TYPE_MASK = 0x00ffffff;
+export const CALL_SHIFT = 24;
+
+// Io Input Stream
+export const INPUT_STREAM_CREATE = ++call_id << CALL_SHIFT;
+export const INPUT_STREAM_READ = ++call_id << CALL_SHIFT;
+export const INPUT_STREAM_BLOCKING_READ = ++call_id << CALL_SHIFT;
+export const INPUT_STREAM_SKIP = ++call_id << CALL_SHIFT;
+export const INPUT_STREAM_BLOCKING_SKIP = ++call_id << CALL_SHIFT;
+export const INPUT_STREAM_SUBSCRIBE = ++call_id << CALL_SHIFT;
+export const INPUT_STREAM_DISPOSE = ++call_id << CALL_SHIFT;
+
+// Io Output Stream
+export const OUTPUT_STREAM_CREATE = ++call_id << CALL_SHIFT;
+export const OUTPUT_STREAM_CHECK_WRITE = ++call_id << CALL_SHIFT;
+export const OUTPUT_STREAM_WRITE = ++call_id << CALL_SHIFT;
+export const OUTPUT_STREAM_BLOCKING_WRITE_AND_FLUSH = ++call_id << CALL_SHIFT;
+export const OUTPUT_STREAM_FLUSH = ++call_id << CALL_SHIFT;
+export const OUTPUT_STREAM_BLOCKING_FLUSH = ++call_id << CALL_SHIFT;
+export const OUTPUT_STREAM_WRITE_ZEROES = ++call_id << CALL_SHIFT;
+export const OUTPUT_STREAM_BLOCKING_WRITE_ZEROES_AND_FLUSH =
+  ++call_id << CALL_SHIFT;
+export const OUTPUT_STREAM_SPLICE = ++call_id << CALL_SHIFT;
+export const OUTPUT_STREAM_BLOCKING_SPLICE = ++call_id << CALL_SHIFT;
+export const OUTPUT_STREAM_SUBSCRIBE = ++call_id << CALL_SHIFT;
+export const OUTPUT_STREAM_DISPOSE = ++call_id << CALL_SHIFT;
+
+export const OUTPUT_STREAM_GET_TOTAL_BYTES = ++call_id << CALL_SHIFT;
+
+// Io Poll
+export const POLL_POLLABLE_READY = ++call_id << CALL_SHIFT;
+export const POLL_POLLABLE_BLOCK = ++call_id << CALL_SHIFT;
+export const POLL_POLL_LIST = ++call_id << CALL_SHIFT;
+
+// Futures
+export const FUTURE_GET_VALUE_AND_DISPOSE = ++call_id << CALL_SHIFT;
+export const FUTURE_DISPOSE = ++call_id << CALL_SHIFT;
+
+// Http
+export const HTTP_CREATE_REQUEST = ++call_id << 24;
+export const HTTP_OUTPUT_STREAM_FINISH = ++call_id << CALL_SHIFT;
+
+// Clocks
+export const CLOCKS_NOW = ++call_id << 24;
+export const CLOCKS_DURATION_SUBSCRIBE = ++call_id << 24;
+export const CLOCKS_INSTANT_SUBSCRIBE = ++call_id << 24;
+
+// Sockets
+export const SOCKET_RESOLVE_ADDRESS_CREATE_REQUEST = ++call_id << 24;
+export const SOCKET_RESOLVE_ADDRESS_GET_AND_DISPOSE_REQUEST = ++call_id << 24;
+export const SOCKET_RESOLVE_ADDRESS_DISPOSE_REQUEST = ++call_id << 24;
+
+// Type indiciator for generic Stream, Future, and Poll calls
+let cnt = 0;
+export const STDIN = ++cnt;
+export const STDOUT = ++cnt;
+export const STDERR = ++cnt;
+export const FILE = ++cnt;
+export const HTTP = ++cnt;
+export const SOCKET = ++cnt;

package/lib/io/worker-http.js

@@ -0,0 +1,95 @@
+import { Readable } from "node:stream";
+import { createStream, getStreamOrThrow } from "./worker-thread.js";
+
+export async function createHttpRequest(method, url, headers, bodyId) {
+  let body = null;
+  if (bodyId) {
+    try {
+      const { stream } = getStreamOrThrow(bodyId);
+      body = stream.readableBodyStream;
+      // this indicates we're attached
+      stream.readableBodyStream = null;
+    } catch (e) {
+      if (e.tag === "closed")
+        throw { tag: "internal-error", val: "Unexpected closed body stream" };
+      // it should never be possible for the body stream to already
+      // be closed, or for there to be a write error
+      // we therefore just throw internal error here
+      if (e.tag === "last-operation-failed")
+        throw {
+          tag: "internal-error",
+          val: e.val,
+        };
+      // entirely unknown error -> trap
+      throw e;
+    }
+  }
+  try {
+    const res = await fetch(url, {
+      method,
+      headers: new Headers(headers),
+      body,
+      redirect: "manual",
+      duplex: "half",
+    });
+    const bodyStreamId = createStream(Readable.fromWeb(res.body));
+    return {
+      status: res.status,
+      headers: Array.from(res.headers),
+      bodyStreamId: bodyStreamId,
+    };
+  } catch (e) {
+    if (e?.cause) {
+      let err = e.cause;
+      if (e.cause instanceof AggregateError) err = e.cause.errors[0];
+      if (err.message === "unknown scheme")
+        throw {
+          tag: "HTTP-protocol-error",
+        };
+      switch (err.syscall) {
+        case "connect": {
+          if (err.code === "ECONNREFUSED")
+            throw {
+              tag: "connection-refused",
+            };
+          break;
+        }
+        case "getaddrinfo": {
+          const { errno, code } = err;
+          throw {
+            tag: "DNS-error",
+            val: {
+              rcode: code,
+              infoCode: errno,
+            },
+          };
+        }
+      }
+    }
+    if (e?.message?.includes("Failed to parse URL")) {
+      throw {
+        tag: "HTTP-request-URI-invalid",
+        val: undefined,
+      };
+    }
+    if (e?.message?.includes("HTTP")) {
+      switch (e?.message.replace(/'[^']+'/, "'{}'")) {
+        case "'{}' HTTP method is unsupported.":
+          throw {
+            tag: "HTTP-protocol-error",
+            val: undefined,
+          };
+        case "'{}' is not a valid HTTP method.":
+          throw {
+            tag: "HTTP-request-method-invalid",
+            val: undefined,
+          };
+      }
+      throw {
+        tag: "internal-error",
+        val: e.toString(),
+      };
+    }
+    throw e;
+  }
+}

package/lib/io/worker-io.js

@@ -0,0 +1,322 @@
+import { fileURLToPath } from "node:url";
+import { createSyncFn } from "../synckit/index.js";
+import {
+  CALL_MASK,
+  CALL_SHIFT,
+  CALL_TYPE_MASK,
+  INPUT_STREAM_BLOCKING_READ,
+  INPUT_STREAM_BLOCKING_SKIP,
+  INPUT_STREAM_DISPOSE,
+  INPUT_STREAM_READ,
+  INPUT_STREAM_SKIP,
+  INPUT_STREAM_SUBSCRIBE,
+  OUTPUT_STREAM_BLOCKING_FLUSH,
+  OUTPUT_STREAM_BLOCKING_SPLICE,
+  OUTPUT_STREAM_BLOCKING_WRITE_AND_FLUSH,
+  OUTPUT_STREAM_BLOCKING_WRITE_ZEROES_AND_FLUSH,
+  OUTPUT_STREAM_CHECK_WRITE,
+  OUTPUT_STREAM_DISPOSE,
+  OUTPUT_STREAM_FLUSH,
+  OUTPUT_STREAM_SPLICE,
+  OUTPUT_STREAM_SUBSCRIBE,
+  OUTPUT_STREAM_WRITE_ZEROES,
+  OUTPUT_STREAM_WRITE,
+  POLL_POLL_LIST,
+  POLL_POLLABLE_BLOCK,
+  POLL_POLLABLE_READY,
+} from "./calls.js";
+import { STDERR } from "./calls.js";
+
+const DEBUG = false;
+
+const workerPath = fileURLToPath(
+  new URL("./worker-thread.js", import.meta.url)
+);
+
+/**
+ * @type {(call: number, id: number | null, payload: any) -> any}
+ */
+export let ioCall = createSyncFn(workerPath);
+if (DEBUG) {
+  const _ioCall = ioCall;
+  ioCall = function ioCall(num, id, payload) {
+    let ret;
+    try {
+      process._rawDebug(
+        (num & CALL_MASK) >> CALL_SHIFT,
+        num & CALL_TYPE_MASK,
+        id,
+        payload
+      );
+      ret = _ioCall(num, id, payload);
+      return ret;
+    } catch (e) {
+      ret = e;
+      throw ret;
+    } finally {
+      process._rawDebug("->", ret);
+    }
+  };
+}
+
+const symbolDispose = Symbol.dispose || Symbol.for("dispose");
+
+const _Error = Error;
+const IoError = class Error extends _Error {
+  toDebugString() {
+    return this.message;
+  }
+};
+
+function streamIoErrorCall(call, id, payload) {
+  try {
+    return ioCall(call, id, payload);
+  } catch (e) {
+    if (e.tag === 'closed')
+      throw e;
+    if (e.tag === "last-operation-failed") {
+      e.val = new IoError(e.val);
+      throw e;
+    }
+    // any invalid error is a trap
+    console.trace(e);
+    process.exit(1);
+  }
+}
+
+class InputStream {
+  #id;
+  #streamType;
+  get _id() {
+    return this.#id;
+  }
+  read(len) {
+    return streamIoErrorCall(
+      INPUT_STREAM_READ | this.#streamType,
+      this.#id,
+      len
+    );
+  }
+  blockingRead(len) {
+    return streamIoErrorCall(
+      INPUT_STREAM_BLOCKING_READ | this.#streamType,
+      this.#id,
+      len
+    );
+  }
+  skip(len) {
+    return streamIoErrorCall(
+      INPUT_STREAM_SKIP | this.#streamType,
+      this.#id,
+      len
+    );
+  }
+  blockingSkip(len) {
+    return streamIoErrorCall(
+      INPUT_STREAM_BLOCKING_SKIP | this.#streamType,
+      this.#id,
+      len
+    );
+  }
+  subscribe() {
+    return pollableCreate(
+      ioCall(INPUT_STREAM_SUBSCRIBE | this.#streamType, this.#id)
+    );
+  }
+  [symbolDispose]() {
+    ioCall(INPUT_STREAM_DISPOSE | this.#streamType, this.#id);
+  }
+  static _id(stream) {
+    return stream.#id;
+  }
+  /**
+   * @param {InputStreamType} streamType
+   */
+  static _create(streamType, id) {
+    const stream = new InputStream();
+    stream.#id = id;
+    stream.#streamType = streamType;
+    return stream;
+  }
+}
+
+export const inputStreamCreate = InputStream._create;
+delete InputStream._create;
+
+export const inputStreamId = InputStream._id;
+delete InputStream._id;
+
+class OutputStream {
+  #id;
+  #streamType;
+  get _id() {
+    return this.#id;
+  }
+  checkWrite(len) {
+    return streamIoErrorCall(
+      OUTPUT_STREAM_CHECK_WRITE | this.#streamType,
+      this.#id,
+      len
+    );
+  }
+  write(buf) {
+    if (this.#streamType <= STDERR) return this.blockingWriteAndFlush(buf);
+    return streamIoErrorCall(
+      OUTPUT_STREAM_WRITE | this.#streamType,
+      this.#id,
+      buf
+    );
+  }
+  blockingWriteAndFlush(buf) {
+    if (this.#streamType <= STDERR) {
+      const stream =
+        this.#streamType === STDERR ? process.stderr : process.stdout;
+      return void stream.write(buf);
+    }
+    return streamIoErrorCall(
+      OUTPUT_STREAM_BLOCKING_WRITE_AND_FLUSH | this.#streamType,
+      this.#id,
+      buf
+    );
+  }
+  flush() {
+    return streamIoErrorCall(OUTPUT_STREAM_FLUSH | this.#streamType, this.#id);
+  }
+  blockingFlush() {
+    return streamIoErrorCall(
+      OUTPUT_STREAM_BLOCKING_FLUSH | this.#streamType,
+      this.#id
+    );
+  }
+  writeZeroes(len) {
+    return streamIoErrorCall(
+      OUTPUT_STREAM_WRITE_ZEROES | this.#streamType,
+      this.#id,
+      len
+    );
+  }
+  blockingWriteZeroesAndFlush(len) {
+    return streamIoErrorCall(
+      OUTPUT_STREAM_BLOCKING_WRITE_ZEROES_AND_FLUSH | this.#streamType,
+      this.#id,
+      len
+    );
+  }
+  splice(src, len) {
+    return streamIoErrorCall(
+      OUTPUT_STREAM_SPLICE | this.#streamType,
+      this.#id,
+      src.#id,
+      len
+    );
+  }
+  blockingSplice(src, len) {
+    return streamIoErrorCall(
+      OUTPUT_STREAM_BLOCKING_SPLICE | this.#streamType,
+      this.#id,
+      src.#id,
+      len
+    );
+  }
+  subscribe() {
+    return pollableCreate(
+      ioCall(OUTPUT_STREAM_SUBSCRIBE | this.#streamType, this.#id)
+    );
+  }
+  [symbolDispose]() {
+    ioCall(OUTPUT_STREAM_DISPOSE | this.#streamType, this.#id);
+  }
+
+  static _id(outputStream) {
+    return outputStream.#id;
+  }
+  /**
+   * @param {OutputStreamType} streamType
+   * @param {any} createPayload
+   */
+  static _create(streamType, id) {
+    const stream = new OutputStream();
+    stream.#id = id;
+    stream.#streamType = streamType;
+    return stream;
+  }
+}
+
+export const outputStreamCreate = OutputStream._create;
+delete OutputStream._create;
+
+export const outputStreamId = OutputStream._id;
+delete OutputStream._id;
+
+export const error = { Error: IoError };
+
+export const streams = { InputStream, OutputStream };
+
+class Pollable {
+  #id;
+  #ready = false;
+  get _id() {
+    return this.#id;
+  }
+  ready() {
+    if (this.#ready) return true;
+    const ready = ioCall(POLL_POLLABLE_READY, this.#id);
+    if (ready) this.#ready = true;
+    return ready;
+  }
+  block() {
+    if (!this.#ready) {
+      ioCall(POLL_POLLABLE_BLOCK, this.#id);
+      this.#ready = true;
+    }
+  }
+  static _getId(pollable) {
+    return pollable.#id;
+  }
+  static _create(id) {
+    const pollable = new Pollable();
+    pollable.#id = id;
+    if (id === 0) pollable.#ready = true;
+    return pollable;
+  }
+  static _listToIds(list) {
+    return list.map((pollable) => pollable.#id);
+  }
+  static _markReady(pollable) {
+    pollable.#ready = true;
+  }
+}
+
+export const pollableCreate = Pollable._create;
+delete Pollable._create;
+
+const pollableListToIds = Pollable._listToIds;
+delete Pollable._listToIds;
+
+const pollableMarkReady = Pollable._markReady;
+delete Pollable._markReady;
+
+const pollableGetId = Pollable._getId;
+delete Pollable._getId;
+
+export const poll = {
+  Pollable,
+  poll(list) {
+    const includeList = ioCall(POLL_POLL_LIST, null, pollableListToIds(list));
+    return list.filter((pollable) => {
+      if (includeList.includes(pollableGetId(pollable))) {
+        pollableMarkReady(pollable);
+        return true;
+      }
+      return false;
+    });
+  },
+};
+
+export function resolvedPoll() {
+  return pollableCreate(0);
+}
+
+export function createPoll(call, id, initPayload) {
+  return pollableCreate(ioCall(call, id, initPayload));
+}