@bytecodealliance/preview2-shim 0.14.0 → 0.14.2

package/README.md

@@ -2,9 +2,9 @@
 
 WASI Preview2 implementations for Node.js & browsers.
 
-Browser support is considered experimental, and not currently suitable for production applications.
+Node.js support is fully tested and conformant against the Wasmtime test suite.
 
-Node.js support is currently being stabilized, which can be tracked in https://github.com/bytecodealliance/jco/milestone/1.
+Browser support is considered experimental, and not currently suitable for production applications.
 
 # License
 

package/lib/browser/filesystem.js

@@ -39,12 +39,13 @@ function getChildEntry (parentEntry, subpath, openFlags) {
     if (!entry || !entry.dir) throw 'not-directory';
     segmentIdx = subpath.indexOf('/');
     const segment = segmentIdx === -1 ? subpath : subpath.slice(0, segmentIdx);
-    if (segment === '.' || segment === '') return entry;
     if (segment === '..') throw 'no-entry';
-    if (!entry.dir[segment] && openFlags.create)
+    if (segment === '.' || segment === '');
+    else if (!entry.dir[segment] && openFlags.create)
       entry = entry.dir[segment] = openFlags.directory ? { dir: {} } : { source: new Uint8Array([]) };
     else
       entry = entry.dir[segment];
+    subpath = subpath.slice(segmentIdx + 1);
   } while (segmentIdx !== -1)
   if (!entry) throw 'no-entry';
   return entry;
@@ -179,13 +180,13 @@ class Descriptor {
   stat() {
     let type = 'unknown', size = BigInt(0);
     if (this.#entry.source) {
-      type = 'directory';
-    }
-    else if (this.#entry.dir) {
       type = 'regular-file';
       const source = getSource(this.#entry);
       size = BigInt(source.byteLength);
     }
+    else if (this.#entry.dir) {
+      type = 'directory';
+    }
     return {
       type,
       linkCount: BigInt(0),

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/random.js

@@ -33,7 +33,7 @@ export const random = {
       for (var generated = 0; generated < len; generated += MAX_BYTES) {
         // buffer.slice automatically checks if the end is past the end of
         // the buffer so we don't have to here
-        crypto.getRandomValues(bytes.slice(generated, generated + MAX_BYTES));
+        crypto.getRandomValues(bytes.subarray(generated, generated + MAX_BYTES));
       }
     } else {
       crypto.getRandomValues(bytes);

package/lib/io/calls.js

@@ -43,13 +43,47 @@ 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;
+// Http server
+export const HTTP_SERVER_START = ++call_id << CALL_SHIFT;
+export const HTTP_SERVER_STOP = ++call_id << CALL_SHIFT;
+export const HTTP_SERVER_INCOMING_HANDLER = ++call_id << CALL_SHIFT;
+export const HTTP_SERVER_SET_OUTGOING_RESPONSE = ++call_id << CALL_SHIFT;
+export const HTTP_SERVER_CLEAR_OUTGOING_RESPONSE = ++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
+// Sockets (TCP)
+export const SOCKET_TCP_CREATE_HANDLE = ++call_id << 24;
+export const SOCKET_TCP_BIND = ++call_id << 24;
+export const SOCKET_TCP_CONNECT = ++call_id << 24;
+export const SOCKET_TCP_LISTEN = ++call_id << 24;
+export const SOCKET_TCP_ACCEPT = ++call_id << 24;
+export const SOCKET_TCP_GET_LOCAL_ADDRESS = ++call_id << 24;
+export const SOCKET_TCP_GET_REMOTE_ADDRESS = ++call_id << 24;
+export const SOCKET_TCP_SHUTDOWN = ++call_id << 24;
+export const SOCKET_TCP_SET_KEEP_ALIVE = ++call_id << 24;
+export const SOCKET_TCP_DISPOSE = ++call_id << 24;
+export const SOCKET_TCP_CREATE_INPUT_STREAM = ++call_id << 24;
+export const SOCKET_TCP_CREATE_OUTPUT_STREAM = ++call_id << 24;
+// Sockets (UDP)
+export const SOCKET_UDP_CREATE_HANDLE = ++call_id << 24;
+export const SOCKET_UDP_BIND = ++call_id << 24;
+export const SOCKET_UDP_CONNECT = ++call_id << 24;
+export const SOCKET_UDP_DISCONNECT = ++call_id << 24;
+export const SOCKET_UDP_CHECK_SEND = ++call_id << 24;
+export const SOCKET_UDP_SEND = ++call_id << 24;
+export const SOCKET_UDP_RECEIVE = ++call_id << 24;
+export const SOCKET_UDP_DISPOSE = ++call_id << 24;
+export const SOCKET_UDP_GET_LOCAL_ADDRESS = ++call_id << 24;
+export const SOCKET_UDP_GET_REMOTE_ADDRESS = ++call_id << 24;
+export const SOCKET_UDP_GET_RECEIVE_BUFFER_SIZE = ++call_id << 24;
+export const SOCKET_UDP_SET_RECEIVE_BUFFER_SIZE = ++call_id << 24;
+export const SOCKET_UDP_GET_SEND_BUFFER_SIZE = ++call_id << 24;
+export const SOCKET_UDP_SET_SEND_BUFFER_SIZE = ++call_id << 24;
+export const SOCKET_UDP_SET_UNICAST_HOP_LIMIT = ++call_id << 24;
 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;
@@ -62,3 +96,96 @@ export const STDERR = ++cnt;
 export const FILE = ++cnt;
 export const HTTP = ++cnt;
 export const SOCKET = ++cnt;
+
+export const callTypeMap = {
+  [STDIN]: "STDIN",
+  [STDOUT]: "STDOUT",
+  [STDERR]: "STDERR",
+  [FILE]: "FILE",
+  [HTTP]: "HTTP",
+  [SOCKET]: "SOCKET",
+};
+
+export const callMap = {
+  [INPUT_STREAM_CREATE]: 'INPUT_STREAM_CREATE',
+  [INPUT_STREAM_READ]: "INPUT_STREAM_READ",
+  [INPUT_STREAM_BLOCKING_READ]: "INPUT_STREAM_BLOCKING_READ",
+  [INPUT_STREAM_SKIP]: "INPUT_STREAM_SKIP",
+  [INPUT_STREAM_BLOCKING_SKIP]: "INPUT_STREAM_BLOCKING_SKIP",
+  [INPUT_STREAM_SUBSCRIBE]: "INPUT_STREAM_SUBSCRIBE",
+  [INPUT_STREAM_DISPOSE]: "INPUT_STREAM_DISPOSE",
+
+  // Io Output Stream
+  [OUTPUT_STREAM_CREATE]: "OUTPUT_STREAM_CREATE",
+  [OUTPUT_STREAM_CHECK_WRITE]: "OUTPUT_STREAM_CHECK_WRITE",
+  [OUTPUT_STREAM_WRITE]: "OUTPUT_STREAM_WRITE",
+  [OUTPUT_STREAM_BLOCKING_WRITE_AND_FLUSH]: "OUTPUT_STREAM_BLOCKING_WRITE_AND_FLUSH",
+  [OUTPUT_STREAM_FLUSH]: "OUTPUT_STREAM_FLUSH",
+  [OUTPUT_STREAM_BLOCKING_FLUSH]: "OUTPUT_STREAM_BLOCKING_FLUSH",
+  [OUTPUT_STREAM_WRITE_ZEROES]: "OUTPUT_STREAM_WRITE_ZEROES",
+  [OUTPUT_STREAM_BLOCKING_WRITE_ZEROES_AND_FLUSH]: "OUTPUT_STREAM_BLOCKING_WRITE_ZEROES_AND_FLUSH",
+  [OUTPUT_STREAM_SPLICE]: "OUTPUT_STREAM_SPLICE",
+  [OUTPUT_STREAM_BLOCKING_SPLICE]: "OUTPUT_STREAM_BLOCKING_SPLICE",
+  [OUTPUT_STREAM_SUBSCRIBE]: "OUTPUT_STREAM_SUBSCRIBE",
+  [OUTPUT_STREAM_DISPOSE]: "OUTPUT_STREAM_DISPOSE",
+
+  [OUTPUT_STREAM_GET_TOTAL_BYTES]: "OUTPUT_STREAM_GET_TOTAL_BYTES",
+
+  // Io Poll
+  [POLL_POLLABLE_READY]: "POLL_POLLABLE_READY",
+  [POLL_POLLABLE_BLOCK]: "POLL_POLLABLE_BLOCK",
+  [POLL_POLL_LIST]: "POLL_POLL_LIST",
+
+  // Futures
+  [FUTURE_GET_VALUE_AND_DISPOSE]: "FUTURE_GET_VALUE_AND_DISPOSE",
+  [FUTURE_DISPOSE]: "FUTURE_DISPOSE",
+
+  // Http
+  [HTTP_CREATE_REQUEST]: "HTTP_CREATE_REQUEST",
+  [HTTP_OUTPUT_STREAM_FINISH]: "HTTP_OUTPUT_STREAM_FINISH",
+  // Http server
+  [HTTP_SERVER_START]: "HTTP_SERVER_START",
+  [HTTP_SERVER_STOP]: "HTTP_SERVER_STOP",
+  [HTTP_SERVER_INCOMING_HANDLER]: "HTTP_SERVER_INCOMING_HANDLER",
+  [HTTP_SERVER_SET_OUTGOING_RESPONSE]: "HTTP_SERVER_SET_OUTGOING_RESPONSE",
+  [HTTP_SERVER_CLEAR_OUTGOING_RESPONSE]: "HTTP_SERVER_CLEAR_OUTGOING_RESPONSE",
+
+  // Clocks
+  [CLOCKS_NOW]: "CLOCKS_NOW",
+  [CLOCKS_DURATION_SUBSCRIBE]: "CLOCKS_DURATION_SUBSCRIBE",
+  [CLOCKS_INSTANT_SUBSCRIBE]: "CLOCKS_INSTANT_SUBSCRIBE",
+
+  // Sockets TCP
+  [SOCKET_TCP_CREATE_HANDLE]: "SOCKET_TCP_CREATE_HANDLE",
+  [SOCKET_TCP_BIND]: "SOCKET_TCP_BIND",
+  [SOCKET_TCP_CONNECT]: "SOCKET_TCP_CONNECT",
+  [SOCKET_TCP_LISTEN]: "SOCKET_TCP_LISTEN",
+  [SOCKET_TCP_ACCEPT]: "SOCKET_TCP_ACCEPT",
+  [SOCKET_TCP_GET_LOCAL_ADDRESS]: "SOCKET_TCP_GET_LOCAL_ADDRESS",
+  [SOCKET_TCP_GET_REMOTE_ADDRESS]: "SOCKET_TCP_GET_REMOTE_ADDRESS",
+  [SOCKET_TCP_SHUTDOWN]: "SOCKET_TCP_SHUTDOWN",
+  [SOCKET_TCP_SET_KEEP_ALIVE]: "SOCKET_TCP_SET_KEEP_ALIVE",
+  [SOCKET_TCP_DISPOSE]: "SOCKET_TCP_DISPOSE",
+  [SOCKET_TCP_CREATE_INPUT_STREAM]: "SOCKET_TCP_CREATE_INPUT_STREAM",
+  [SOCKET_TCP_CREATE_OUTPUT_STREAM]: "SOCKET_TCP_CREATE_OUTPUT_STREAM",
+  // Sockets UDP
+  [SOCKET_UDP_CREATE_HANDLE]: "SOCKET_UDP_CREATE_HANDLE",
+  [SOCKET_UDP_BIND]: "SOCKET_UDP_BIND",
+  [SOCKET_UDP_CONNECT]: "SOCKET_UDP_CONNECT",
+  [SOCKET_UDP_DISCONNECT]: "SOCKET_UDP_DISCONNECT",
+  [SOCKET_UDP_CHECK_SEND]: "SOCKET_UDP_CHECK_SEND",
+  [SOCKET_UDP_SEND]: "SOCKET_UDP_SEND",
+  [SOCKET_UDP_RECEIVE]: "SOCKET_UDP_RECEIVE",
+  [SOCKET_UDP_DISPOSE]: "SOCKET_UDP_DISPOSE",
+  [SOCKET_UDP_GET_LOCAL_ADDRESS]: "SOCKET_UDP_GET_LOCAL_ADDRESS",
+  [SOCKET_UDP_GET_REMOTE_ADDRESS]: "SOCKET_UDP_GET_REMOTE_ADDRESS",
+  [SOCKET_UDP_GET_RECEIVE_BUFFER_SIZE]: "SOCKET_UDP_GET_RECEIVE_BUFFER_SIZE",
+  [SOCKET_UDP_SET_RECEIVE_BUFFER_SIZE]: "SOCKET_UDP_SET_RECEIVE_BUFFER_SIZE",
+  [SOCKET_UDP_GET_SEND_BUFFER_SIZE]: "SOCKET_UDP_GET_SEND_BUFFER_SIZE",
+  [SOCKET_UDP_SET_SEND_BUFFER_SIZE]: "SOCKET_UDP_SET_SEND_BUFFER_SIZE",
+  [SOCKET_UDP_SET_UNICAST_HOP_LIMIT]: "SOCKET_UDP_SET_UNICAST_HOP_LIMIT",
+  // Socket DNS
+  [SOCKET_RESOLVE_ADDRESS_CREATE_REQUEST]: "SOCKET_RESOLVE_ADDRESS_CREATE_REQUEST",
+  [SOCKET_RESOLVE_ADDRESS_GET_AND_DISPOSE_REQUEST]: "SOCKET_RESOLVE_ADDRESS_GET_AND_DISPOSE_REQUEST",
+  [SOCKET_RESOLVE_ADDRESS_DISPOSE_REQUEST]: "SOCKET_RESOLVE_ADDRESS_DISPOSE_REQUEST",
+};

package/lib/io/worker-http.js

@@ -1,14 +1,91 @@
-import { Readable } from "node:stream";
 import { createStream, getStreamOrThrow } from "./worker-thread.js";
+import {
+  createServer,
+  request as httpRequest,
+  Agent as HttpAgent,
+} from "node:http";
+import { request as httpsRequest, Agent as HttpsAgent } from "node:https";
+import { parentPort } from "node:worker_threads";
+import { HTTP_SERVER_INCOMING_HANDLER } from "./calls.js";
 
-export async function createHttpRequest(method, url, headers, bodyId) {
-  let body = null;
+const agentOptions = {
+  keepAlive: true,
+};
+const httpAgent = new HttpAgent(agentOptions);
+const httpsAgent = new HttpsAgent(agentOptions);
+
+const servers = new Map();
+
+let responseCnt = 0;
+const responses = new Map();
+
+export async function stopHttpServer(id) {
+  await new Promise((resolve) => servers.get(id).close(resolve));
+}
+
+export function clearOutgoingResponse(id) {
+  responses.delete(id);
+}
+
+export async function setOutgoingResponse(
+  id,
+  { statusCode, headers, streamId }
+) {
+  const response = responses.get(id);
+  const textDecoder = new TextDecoder();
+  response.writeHead(
+    statusCode,
+    Object.fromEntries(
+      headers.map(([key, val]) => [key, textDecoder.decode(val)])
+    )
+  );
+  response.flushHeaders();
+  const { stream } = getStreamOrThrow(streamId);
+  stream.pipe(response);
+  responses.delete(id);
+}
+
+export async function startHttpServer(id, { port, host }) {
+  const server = createServer((req, res) => {
+    // create the streams and their ids
+    const streamId = createStream(req);
+    const responseId = ++responseCnt;
+    parentPort.postMessage({
+      type: HTTP_SERVER_INCOMING_HANDLER,
+      id,
+      payload: {
+        responseId,
+        method: req.method,
+        host: req.headers.host || host || 'localhost',
+        pathWithQuery: req.url,
+        headers: Object.entries(req.headersDistinct).flatMap(([key, val]) => val.map(val => [key, val])),
+        streamId,
+      },
+    });
+    responses.set(responseId, res);
+  });
+  await new Promise((resolve, reject) => {
+    server.listen(port, host, resolve);
+    server.on("error", reject);
+  });
+  servers.set(id, server);
+}
+
+export async function createHttpRequest(
+  method,
+  scheme,
+  authority,
+  pathWithQuery,
+  headers,
+  bodyId,
+  connectTimeout,
+  betweenBytesTimeout,
+  firstByteTimeout
+) {
+  let stream = null;
   if (bodyId) {
     try {
-      const { stream } = getStreamOrThrow(bodyId);
-      body = stream.readableBodyStream;
-      // this indicates we're attached
-      stream.readableBodyStream = null;
+      ({ stream } = getStreamOrThrow(bodyId));
     } catch (e) {
       if (e.tag === "closed")
         throw { tag: "internal-error", val: "Unexpected closed body stream" };
@@ -25,71 +102,88 @@ export async function createHttpRequest(method, url, headers, bodyId) {
     }
   }
   try {
-    const res = await fetch(url, {
-      method,
-      headers: new Headers(headers),
-      body,
-      redirect: "manual",
-      duplex: "half",
+    // Make a request
+    let req;
+    switch (scheme) {
+      case "http:":
+        req = httpRequest({
+          agent: httpAgent,
+          method,
+          host: authority.split(':')[0],
+          port: authority.split(':')[1],
+          path: pathWithQuery,
+          timeout: connectTimeout && Number(connectTimeout),
+        });
+        break;
+      case "https:":
+        req = httpsRequest({
+          agent: httpsAgent,
+          method,
+          host: authority.split(':')[0],
+          port: authority.split(':')[1],
+          path: pathWithQuery,
+          timeout: connectTimeout && Number(connectTimeout),
+        });
+        break;
+      default:
+        throw { tag: "HTTP-protocol-error" };
+    }
+    for (const [key, value] of headers) {
+      req.appendHeader(key, value);
+    }
+    req.flushHeaders();
+    if (stream) {
+      stream.pipe(req);
+    } else {
+      req.end();
+    }
+    const res = await new Promise((resolve, reject) => {
+      req.on("response", resolve);
+      req.on("close", () => reject);
+      req.on("error", reject);
     });
-    const bodyStreamId = createStream(Readable.fromWeb(res.body));
+    if (firstByteTimeout)
+      res.setTimeout(Number(firstByteTimeout));
+    if (betweenBytesTimeout)
+      res.on("readable", () => {
+        res.setTimeout(Number(betweenBytesTimeout));
+      });
+    res.on("end", () => void res.emit("readable"));
+    const bodyStreamId = createStream(res);
     return {
-      status: res.status,
-      headers: Array.from(res.headers),
+      status: res.statusCode,
+      headers: Array.from(Object.entries(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")
+    if (e?.tag) throw e;
+    const err = getFirstError(e);
+    switch (err.code) {
+      case "ECONNRESET":
+        throw { tag: "HTTP-protocol-error" };
+      case "ENOTFOUND":
         throw {
-          tag: "HTTP-protocol-error",
+          tag: "DNS-error",
+          val: {
+            rcode: err.code,
+            infoCode: err.errno,
+          },
+        };
+      case "ECONNREFUSED":
+        throw {
+          tag: "connection-refused",
         };
-      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;
+    throw {
+      tag: "internal-error",
+      val: err.toString(),
+    };
   }
 }
+
+function getFirstError(e) {
+  if (typeof e !== "object" || e === null) return e;
+  if (e.cause) return getFirstError(e.cause);
+  if (e instanceof AggregateError) return getFirstError(e.errors[0]);
+  return e;
+}

package/lib/io/worker-io.js

@@ -2,7 +2,6 @@ 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,
@@ -24,6 +23,9 @@ import {
   POLL_POLL_LIST,
   POLL_POLLABLE_BLOCK,
   POLL_POLLABLE_READY,
+  HTTP_SERVER_INCOMING_HANDLER,
+  callTypeMap,
+  callMap
 } from "./calls.js";
 import { STDERR } from "./calls.js";
 
@@ -33,18 +35,37 @@ const workerPath = fileURLToPath(
   new URL("./worker-thread.js", import.meta.url)
 );
 
+const httpIncomingHandlers = new Map();
+export function registerIncomingHttpHandler (id, handler) {
+  httpIncomingHandlers.set(id, handler);
+}
+
+const instanceId = Math.round(Math.random() * 1000).toString();
+
 /**
  * @type {(call: number, id: number | null, payload: any) -> any}
  */
-export let ioCall = createSyncFn(workerPath);
+export let ioCall = createSyncFn(workerPath, (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');
+  const handler = httpIncomingHandlers.get(id);
+  if (!handler)
+    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');
     let ret;
     try {
-      process._rawDebug(
-        (num & CALL_MASK) >> CALL_SHIFT,
-        num & CALL_TYPE_MASK,
+      console.error(
+        instanceId,
+        callMap[(num & CALL_MASK)],
+        callTypeMap[num & CALL_TYPE_MASK],
         id,
         payload
       );
@@ -54,7 +75,7 @@ if (DEBUG) {
       ret = e;
       throw ret;
     } finally {
-      process._rawDebug("->", ret);
+      console.error(instanceId, "->", ret);
     }
   };
 }
@@ -63,6 +84,10 @@ const symbolDispose = Symbol.dispose || Symbol.for("dispose");
 
 const _Error = Error;
 const IoError = class Error extends _Error {
+  constructor (payload) {
+    super(payload);
+    this.payload = payload;
+  }
   toDebugString() {
     return this.message;
   }
@@ -72,10 +97,9 @@ function streamIoErrorCall(call, id, payload) {
   try {
     return ioCall(call, id, payload);
   } catch (e) {
-    if (e.tag === 'closed')
-      throw e;
+    if (e.tag === "closed") throw e;
     if (e.tag === "last-operation-failed") {
-      e.val = new IoError(e.val);
+      e.val = new IoError(Object.assign(new Error(e.val.message), e.val));
       throw e;
     }
     // any invalid error is a trap
@@ -206,16 +230,14 @@ class OutputStream {
     return streamIoErrorCall(
       OUTPUT_STREAM_SPLICE | this.#streamType,
       this.#id,
-      src.#id,
-      len
+      { src: src.#id, len }
     );
   }
   blockingSplice(src, len) {
     return streamIoErrorCall(
       OUTPUT_STREAM_BLOCKING_SPLICE | this.#streamType,
       this.#id,
-      src.#id,
-      len
+      { src: inputStreamId(src), len }
     );
   }
   subscribe() {
@@ -254,21 +276,16 @@ 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;
+    if (this.#id === 0) return true;
+    return ioCall(POLL_POLLABLE_READY, this.#id);
   }
   block() {
-    if (!this.#ready) {
-      ioCall(POLL_POLLABLE_BLOCK, this.#id);
-      this.#ready = true;
-    }
+    if (this.#id === 0) return;
+    ioCall(POLL_POLLABLE_BLOCK, this.#id);
   }
   static _getId(pollable) {
     return pollable.#id;
@@ -276,40 +293,20 @@ class Pollable {
   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;
-    });
+    return ioCall(POLL_POLL_LIST, null, list.map(pollableGetId));
   },
 };