@bytecodealliance/preview2-shim 0.0.21 → 0.14.1

package/README.md

@@ -1,20 +1,10 @@
-# WASI Preview2 JavaScript Shim
+# Preview2 Shim
 
-_**Experimental**_ shim modules for the [WASI Preview2](https://github.com/bytecodealliance/preview2-prototyping) component interfaces in JS environments.
+WASI Preview2 implementations for Node.js & browsers.
 
-Currently supports Node.js and browser versions, but alternative implementations for any JS environments can be supported.
+Browser support is considered experimental, and not currently suitable for production applications.
 
-## Implementation Status
-
-| Interface       | Node.js                      | Browser                      |
-| --------------- | ----------------------------:|-----------------------------:|
-| Clocks          | Pending timezone, poll       | Pending timezone, poll       |
-| Filesystem      | Basic read support           | _N/A_                        |
-| HTTP            | Experimental support         | :x:                          |
-| IO              | Experimental support         | Experimental support         |
-| Random          | :heavy_check_mark:           | :heavy_check_mark:           |
-| Sockets         | :x:                          | _N/A_                        |
-| CLI             | :heavy_check_mark:           | :heavy_check_mark:           |
+Node.js support is currently being stabilized, which can be tracked in https://github.com/bytecodealliance/jco/milestone/1.
 
 # License
 

package/lib/browser/cli.js

@@ -123,13 +123,11 @@ const terminalStderrInstance = new TerminalOutput();
 const terminalStdinInstance = new TerminalInput();
 
 export const terminalInput = {
-  TerminalInput,
-  dropTerminalInput () {}
+  TerminalInput
 };
 
 export const terminalOutput = {
-  TerminalOutput,
-  dropTerminalOutput () {}
+  TerminalOutput
 };
 
 export const terminalStderr = {

package/lib/browser/clocks.js

@@ -1,34 +1,23 @@
-function _hrtimeBigint () {
-  // performance.now() is in milliseconds, but we want nanoseconds
-  return BigInt(Math.floor(performance.now() * 1e6));
-}
-
-let _hrStart = _hrtimeBigint();
-
 export const monotonicClock = {
   resolution() {
-    return 1n;
+    // usually we dont get sub-millisecond accuracy in the browser
+    // Note: is there a better way to determine this?
+    return 1e6;
   },
   now () {
-    return _hrtimeBigint() - _hrStart;
+    // performance.now() is in milliseconds, but we want nanoseconds
+    return BigInt(Math.floor(performance.now() * 1e6));
   },
-  subscribe (_when, _absolute) {
-    console.log(`[monotonic-clock] Subscribe`);
-  }
-};
-
-export const timezone = {
-  display (timezone, when) {
-    console.log(`[timezone] DISPLAY ${timezone} ${when}`);
+  subscribeInstant (instant) {
+    instant = BigInt(instant);
+    const now = this.now();
+    if (instant <= now)
+      return this.subscribeDuration(0);
+    return this.subscribeDuration(instant - now);
   },
-
-  utcOffset (timezone, when) {
-    console.log(`[timezone] UTC OFFSET ${timezone} ${when}`);
-    return 0;
-  },
-
-  dropTimezone (timezone) {
-    console.log(`[timezone] DROP ${timezone}`);
+  subscribeDuration (_duration) {
+    _duration = BigInt(_duration);
+    console.log(`[monotonic-clock] subscribe`);
   }
 };
 
@@ -39,8 +28,7 @@ export const wallClock = {
     const nanoseconds = (now % 1e3) * 1e6;
     return { seconds, nanoseconds };
   },
-
   resolution() {
-    console.log(`[wall-clock] Wall clock resolution`);
+    return { seconds: 0n, nanoseconds: 1e6 };
   }
 };

package/lib/browser/filesystem.js

@@ -142,10 +142,6 @@ class Descriptor {
     return 'unknown';
   }
 
-  setFlags(flags) {
-    console.log(`[filesystem] SET FLAGS ${JSON.stringify(flags)}`);
-  }
-
   setSize(size) {
     console.log(`[filesystem] SET SIZE`, size);
   }
@@ -254,32 +250,8 @@ class Descriptor {
     console.log(`[filesystem] UNLINK FILE AT`);
   }
 
-  changeFilePermissionsAt() {
-    console.log(`[filesystem] CHANGE FILE PERMISSIONS AT`);
-  }
-
-  changeDirectoryPermissionsAt() {
-    console.log(`[filesystem] CHANGE DIR PERMISSIONS AT`);
-  }
-
-  lockShared() {
-    console.log(`[filesystem] LOCK SHARED`);
-  }
-
-  lockExclusive() {
-    console.log(`[filesystem] LOCK EXCLUSIVE`);
-  }
-
-  tryLockShared() {
-    console.log(`[filesystem] TRY LOCK SHARED`);
-  }
-
-  tryLockExclusive() {
-    console.log(`[filesystem] TRY LOCK EXCLUSIVE`);
-  }
-
-  unlock() {
-    console.log(`[filesystem] UNLOCK`);
+  isSameObject(other) {
+    return other === this;
   }
 
   metadataHash() {

package/lib/browser/http.js

@@ -1,5 +1,3 @@
-import { UnexpectedError } from "../http/error.js";
-
 /**
  * @param {import("../../types/interfaces/wasi-http-types").Request} req
  * @returns {string}
@@ -30,7 +28,7 @@ export function send(req) {
       body,
     };
   } catch (err) {
-    throw new UnexpectedError(err.message);
+    throw new Error(err.message);
   }
 }
 

package/lib/browser/io.js

@@ -2,7 +2,7 @@ let id = 0;
 
 const symbolDispose = Symbol.dispose || Symbol.for('dispose');
 
-class Error {
+const IoError = class Error {
   constructor (msg) {
     this.msg = msg;
   }
@@ -164,7 +164,9 @@ class OutputStream {
   }
 }
 
-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));
+}