@bytecodealliance/preview2-shim 0.14.2 → 0.15.0

package/lib/io/worker-io.js

@@ -3,6 +3,9 @@ import { createSyncFn } from "../synckit/index.js";
 import {
   CALL_MASK,
   CALL_TYPE_MASK,
+  FILE,
+  HTTP_SERVER_INCOMING_HANDLER,
+  HTTP,
   INPUT_STREAM_BLOCKING_READ,
   INPUT_STREAM_BLOCKING_SKIP,
   INPUT_STREAM_DISPOSE,
@@ -22,50 +25,62 @@ import {
   OUTPUT_STREAM_WRITE,
   POLL_POLL_LIST,
   POLL_POLLABLE_BLOCK,
+  POLL_POLLABLE_DISPOSE,
   POLL_POLLABLE_READY,
-  HTTP_SERVER_INCOMING_HANDLER,
-  callTypeMap,
-  callMap
+  SOCKET_TCP,
+  STDERR,
+  STDIN,
+  STDOUT,
+  reverseMap,
 } from "./calls.js";
-import { STDERR } from "./calls.js";
-
-const DEBUG = false;
+import { _rawDebug, exit, stderr, stdout, env } from "node:process";
 
 const workerPath = fileURLToPath(
   new URL("./worker-thread.js", import.meta.url)
 );
 
 const httpIncomingHandlers = new Map();
-export function registerIncomingHttpHandler (id, handler) {
+export function registerIncomingHttpHandler(id, handler) {
   httpIncomingHandlers.set(id, handler);
 }
 
 const instanceId = Math.round(Math.random() * 1000).toString();
+const DEBUG_DEFAULT = false;
+const DEBUG =
+  env.PREVIEW2_SHIM_DEBUG === "0"
+    ? false
+    : env.PREVIEW2_SHIM_DEBUG === "1"
+    ? true
+    : DEBUG_DEFAULT;
 
 /**
  * @type {(call: number, id: number | null, payload: any) -> any}
  */
-export let ioCall = createSyncFn(workerPath, (type, id, payload) => {
+export let ioCall = createSyncFn(workerPath, DEBUG, (type, id, payload) => {
   // 'callbacks' from the worker
   // ONLY happens for an http server incoming handler, and NOTHING else (not even sockets, since accept is sync!)
   if (type !== HTTP_SERVER_INCOMING_HANDLER)
-    throw new Error('Internal error: only incoming handler callback is permitted');
+    throw new Error(
+      "Internal error: only incoming handler callback is permitted"
+    );
   const handler = httpIncomingHandlers.get(id);
   if (!handler)
-    throw new Error(`Internal error: no incoming handler registered for server ${id}`);
+    throw new Error(
+      `Internal error: no incoming handler registered for server ${id}`
+    );
   handler(payload);
 });
 if (DEBUG) {
   const _ioCall = ioCall;
   ioCall = function ioCall(num, id, payload) {
-    if (typeof id !== 'number' && id !== null)
-      throw new Error('id must be a number or null');
+    if (typeof id !== "number" && id !== null)
+      throw new Error("id must be a number or null");
     let ret;
     try {
-      console.error(
+      _rawDebug(
         instanceId,
-        callMap[(num & CALL_MASK)],
-        callTypeMap[num & CALL_TYPE_MASK],
+        reverseMap[num & CALL_MASK],
+        reverseMap[num & CALL_TYPE_MASK],
         id,
         payload
       );
@@ -75,16 +90,53 @@ if (DEBUG) {
       ret = e;
       throw ret;
     } finally {
-      console.error(instanceId, "->", ret);
+      _rawDebug(instanceId, "->", ret);
     }
   };
 }
 
 const symbolDispose = Symbol.dispose || Symbol.for("dispose");
 
+const finalizationRegistry = new FinalizationRegistry(
+  (dispose) => void dispose()
+);
+
+const dummySymbol = Symbol();
+
+/**
+ *
+ * @param {any} resource
+ * @param {any} parentResource
+ * @param {number} id
+ * @param {(number) => void} disposeFn
+ */
+export function registerDispose(resource, parentResource, id, disposeFn) {
+  // While strictly speaking all components should handle their disposal,
+  // this acts as a last-resort to catch all missed drops through the JS GC.
+  // Mainly for two cases - (1) components which are long lived, that get shut
+  // down and (2) users that interface with low-level WASI APIs directly in JS
+  // for various reasons may end up leaning on JS GC inadvertantly.
+  function finalizer() {
+    // This has no functional purpose other than to pin a strong reference
+    // from the child resource's finalizer to the parent resource, to ensure
+    // that we can never finalize a parent resource before a child resource.
+    // This makes the generational JS GC become piecewise over child resource
+    // graphs (generational at each resource hierarchy level at least).
+    if (parentResource?.[dummySymbol]) return;
+    disposeFn(id);
+  }
+  finalizationRegistry.register(resource, finalizer, finalizer);
+  return finalizer;
+}
+
+export function earlyDispose(finalizer) {
+  finalizationRegistry.unregister(finalizer);
+  finalizer();
+}
+
 const _Error = Error;
 const IoError = class Error extends _Error {
-  constructor (payload) {
+  constructor(payload) {
     super(payload);
     this.payload = payload;
   }
@@ -104,16 +156,14 @@ function streamIoErrorCall(call, id, payload) {
     }
     // any invalid error is a trap
     console.trace(e);
-    process.exit(1);
+    exit(1);
   }
 }
 
 class InputStream {
   #id;
   #streamType;
-  get _id() {
-    return this.#id;
-  }
+  #finalizer;
   read(len) {
     return streamIoErrorCall(
       INPUT_STREAM_READ | this.#streamType,
@@ -144,24 +194,65 @@ class InputStream {
   }
   subscribe() {
     return pollableCreate(
-      ioCall(INPUT_STREAM_SUBSCRIBE | this.#streamType, this.#id)
+      ioCall(INPUT_STREAM_SUBSCRIBE | this.#streamType, this.#id),
+      this
     );
   }
-  [symbolDispose]() {
-    ioCall(INPUT_STREAM_DISPOSE | this.#streamType, this.#id);
-  }
   static _id(stream) {
     return stream.#id;
   }
   /**
-   * @param {InputStreamType} streamType
+   * @param {FILE | SOCKET_TCP | STDIN | HTTP} streamType
    */
   static _create(streamType, id) {
     const stream = new InputStream();
     stream.#id = id;
     stream.#streamType = streamType;
+    let disposeFn;
+    switch (streamType) {
+      case FILE:
+        disposeFn = fileInputStreamDispose;
+        break;
+      case SOCKET_TCP:
+        disposeFn = socketTcpInputStreamDispose;
+        break;
+      case STDIN:
+        disposeFn = stdinInputStreamDispose;
+        break;
+      case HTTP:
+        disposeFn = httpInputStreamDispose;
+        break;
+      default:
+        throw new Error(
+          "wasi-io trap: Dispose function not created for stream type " +
+            reverseMap[streamType]
+        );
+    }
+    stream.#finalizer = registerDispose(stream, null, id, disposeFn);
     return stream;
   }
+  [symbolDispose]() {
+    if (this.#finalizer) {
+      earlyDispose(this.#finalizer);
+      this.#finalizer = null;
+    }
+  }
+}
+
+function fileInputStreamDispose(id) {
+  ioCall(INPUT_STREAM_DISPOSE | FILE, id, null);
+}
+
+function socketTcpInputStreamDispose(id) {
+  ioCall(INPUT_STREAM_DISPOSE | SOCKET_TCP, id, null);
+}
+
+function stdinInputStreamDispose(id) {
+  ioCall(INPUT_STREAM_DISPOSE | STDIN, id, null);
+}
+
+function httpInputStreamDispose(id) {
+  ioCall(INPUT_STREAM_DISPOSE | HTTP, id, null);
 }
 
 export const inputStreamCreate = InputStream._create;
@@ -173,9 +264,7 @@ delete InputStream._id;
 class OutputStream {
   #id;
   #streamType;
-  get _id() {
-    return this.#id;
-  }
+  #finalizer;
   checkWrite(len) {
     return streamIoErrorCall(
       OUTPUT_STREAM_CHECK_WRITE | this.#streamType,
@@ -193,8 +282,7 @@ class OutputStream {
   }
   blockingWriteAndFlush(buf) {
     if (this.#streamType <= STDERR) {
-      const stream =
-        this.#streamType === STDERR ? process.stderr : process.stdout;
+      const stream = this.#streamType === STDERR ? stderr : stdout;
       return void stream.write(buf);
     }
     return streamIoErrorCall(
@@ -245,9 +333,6 @@ class OutputStream {
       ioCall(OUTPUT_STREAM_SUBSCRIBE | this.#streamType, this.#id)
     );
   }
-  [symbolDispose]() {
-    ioCall(OUTPUT_STREAM_DISPOSE | this.#streamType, this.#id);
-  }
 
   static _id(outputStream) {
     return outputStream.#id;
@@ -260,8 +345,54 @@ class OutputStream {
     const stream = new OutputStream();
     stream.#id = id;
     stream.#streamType = streamType;
+    let disposeFn;
+    switch (streamType) {
+      case STDOUT:
+        disposeFn = stdoutOutputStreamDispose;
+        break;
+      case STDERR:
+        disposeFn = stderrOutputStreamDispose;
+        break;
+      case SOCKET_TCP:
+        disposeFn = socketTcpOutputStreamDispose;
+        break;
+      case FILE:
+        disposeFn = fileOutputStreamDispose;
+        break;
+      case HTTP:
+        return stream;
+      default:
+        throw new Error(
+          "wasi-io trap: Dispose function not created for stream type " +
+            reverseMap[streamType]
+        );
+    }
+    stream.#finalizer = registerDispose(stream, null, id, disposeFn);
     return stream;
   }
+
+  [symbolDispose]() {
+    if (this.#finalizer) {
+      earlyDispose(this.#finalizer);
+      this.#finalizer = null;
+    }
+  }
+}
+
+function stdoutOutputStreamDispose(id) {
+  ioCall(OUTPUT_STREAM_DISPOSE | STDOUT, id);
+}
+
+function stderrOutputStreamDispose(id) {
+  ioCall(OUTPUT_STREAM_DISPOSE | STDERR, id);
+}
+
+function socketTcpOutputStreamDispose(id) {
+  ioCall(OUTPUT_STREAM_DISPOSE | SOCKET_TCP, id);
+}
+
+function fileOutputStreamDispose(id) {
+  ioCall(OUTPUT_STREAM_DISPOSE | FILE, id);
 }
 
 export const outputStreamCreate = OutputStream._create;
@@ -274,27 +405,42 @@ export const error = { Error: IoError };
 
 export const streams = { InputStream, OutputStream };
 
+function pollableDispose(id) {
+  ioCall(POLL_POLLABLE_DISPOSE, id);
+}
+
 class Pollable {
   #id;
-  get _id() {
-    return this.#id;
-  }
+  #finalizer;
   ready() {
     if (this.#id === 0) return true;
     return ioCall(POLL_POLLABLE_READY, this.#id);
   }
   block() {
-    if (this.#id === 0) return;
-    ioCall(POLL_POLLABLE_BLOCK, this.#id);
+    if (this.#id !== 0) {
+      ioCall(POLL_POLLABLE_BLOCK, this.#id);
+    }
   }
   static _getId(pollable) {
     return pollable.#id;
   }
-  static _create(id) {
+  static _create(id, parent) {
     const pollable = new Pollable();
     pollable.#id = id;
+    pollable.#finalizer = registerDispose(
+      pollable,
+      parent,
+      id,
+      pollableDispose
+    );
     return pollable;
   }
+  [symbolDispose]() {
+    if (this.#finalizer) {
+      earlyDispose(this.#finalizer);
+      this.#finalizer = null;
+    }
+  }
 }
 
 export const pollableCreate = Pollable._create;
@@ -310,10 +456,6 @@ export const poll = {
   },
 };
 
-export function resolvedPoll() {
-  return pollableCreate(0);
-}
-
 export function createPoll(call, id, initPayload) {
   return pollableCreate(ioCall(call, id, initPayload));
 }