@bytecodealliance/preview2-shim 0.15.1 → 0.16.0

package/lib/io/calls.js

@@ -65,7 +65,6 @@ export const HTTP_SERVER_CLEAR_OUTGOING_RESPONSE = ++call_id << CALL_SHIFT;
 export const HTTP_OUTGOING_BODY_DISPOSE = ++call_id << CALL_SHIFT;
 
 // Clocks
-export const CLOCKS_NOW = ++call_id << CALL_SHIFT;
 export const CLOCKS_DURATION_SUBSCRIBE = ++call_id << CALL_SHIFT;
 export const CLOCKS_INSTANT_SUBSCRIBE = ++call_id << CALL_SHIFT;
 

package/lib/io/worker-io.js

@@ -33,7 +33,9 @@ import {
   STDOUT,
   reverseMap,
 } from "./calls.js";
-import { _rawDebug, exit, stderr, stdout, env } from "node:process";
+import nodeProcess, { exit, stderr, stdout, env } from "node:process";
+
+const _rawDebug = nodeProcess._rawDebug || console.error.bind(console);
 
 const workerPath = fileURLToPath(
   new URL("./worker-thread.js", import.meta.url)
@@ -409,24 +411,19 @@ function pollableDispose(id) {
   ioCall(POLL_POLLABLE_DISPOSE, id);
 }
 
+const rep = Symbol.for("cabiRep");
+
 class Pollable {
-  #id;
   #finalizer;
   ready() {
-    if (this.#id === 0) return true;
-    return ioCall(POLL_POLLABLE_READY, this.#id);
+    return ioCall(POLL_POLLABLE_READY, this[rep]);
   }
   block() {
-    if (this.#id !== 0) {
-      ioCall(POLL_POLLABLE_BLOCK, this.#id);
-    }
-  }
-  static _getId(pollable) {
-    return pollable.#id;
+    ioCall(POLL_POLLABLE_BLOCK, this[rep]);
   }
   static _create(id, parent) {
     const pollable = new Pollable();
-    pollable.#id = id;
+    pollable[rep] = id;
     pollable.#finalizer = registerDispose(
       pollable,
       parent,
@@ -436,26 +433,88 @@ class Pollable {
     return pollable;
   }
   [symbolDispose]() {
-    if (this.#finalizer) {
+    if (this.#finalizer && this[rep]) {
       earlyDispose(this.#finalizer);
       this.#finalizer = null;
     }
   }
 }
 
+const cabiLowerSymbol = Symbol.for("cabiLower");
+const T_FLAG = 1 << 30;
+
+Pollable.prototype.ready[cabiLowerSymbol] = function ({
+  resourceTables: [table],
+}) {
+  return function pollableReady(handle) {
+    const rep = table[(handle << 1) + 1] & ~T_FLAG;
+    const ready = ioCall(POLL_POLLABLE_READY, rep);
+    return ready ? 1 : 0;
+  };
+};
+
+Pollable.prototype.block[cabiLowerSymbol] = function ({
+  resourceTables: [table],
+}) {
+  return function pollableBlock(handle) {
+    const rep = table[(handle << 1) + 1] & ~T_FLAG;
+    ioCall(POLL_POLLABLE_BLOCK, rep);
+  };
+};
+
+Pollable[Symbol.for("cabiDispose")] = function pollableDispose(rep) {
+  ioCall(POLL_POLLABLE_DISPOSE, rep);
+};
+
 export const pollableCreate = Pollable._create;
 delete Pollable._create;
 
-const pollableGetId = Pollable._getId;
-delete Pollable._getId;
-
 export const poll = {
   Pollable,
   poll(list) {
-    return ioCall(POLL_POLL_LIST, null, list.map(pollableGetId));
+    return ioCall(
+      POLL_POLL_LIST,
+      null,
+      list.map((pollable) => pollable[rep])
+    );
   },
 };
 
+poll.poll[cabiLowerSymbol] = function ({ memory, realloc, resourceTables: [table] }) {
+  return function pollPollList (listPtr, len, retptr) {
+    const handleList = new Uint32Array(memory.buffer, listPtr, len);
+    const repList = Array(len);
+    for (let i = 0; i < len; i++) {
+      const handle = handleList[i];
+      repList[i] = table[(handle << 1) + 1] & ~T_FLAG;
+    }
+    const result = ioCall(POLL_POLL_LIST, null, repList);
+    const ptr = realloc(0, 0, 4, result.byteLength);
+    const out = new Uint32Array(memory.buffer, ptr, result.length);
+    out.set(result);
+    const ret = new Uint32Array(memory.buffer, retptr, 2);
+    ret[0] = ptr;
+    ret[1] = result.length;
+    return retptr;
+  };
+};
+
 export function createPoll(call, id, initPayload) {
   return pollableCreate(ioCall(call, id, initPayload));
 }
+
+export function createPollLower(call, id, table) {
+  return function (initPayload) {
+    const rep = ioCall(call, id, initPayload);
+    const free = table[0] & ~T_FLAG;
+    if (free === 0) {
+      table.push(0);
+      table.push(rep | T_FLAG);
+      return (table.length >> 1) - 1;
+    }
+    table[0] = table[free << 1];
+    table[free << 1] = 0;
+    table[(free << 1) + 1] = rep | T_FLAG;
+    return free;
+  };
+}

package/lib/io/worker-socket-tcp.js

@@ -8,6 +8,7 @@ import {
   pollStateReady,
   verifyPollsDroppedForDrop,
 } from "./worker-thread.js";
+import process from "node:process";
 const { TCP, constants: TCPConstants } = process.binding("tcp_wrap");
 import {
   convertSocketError,

package/lib/io/worker-thread.js

@@ -18,7 +18,6 @@ import {
   CALL_TYPE_MASK,
   CLOCKS_DURATION_SUBSCRIBE,
   CLOCKS_INSTANT_SUBSCRIBE,
-  CLOCKS_NOW,
   FILE,
   FUTURE_DISPOSE,
   FUTURE_SUBSCRIBE,
@@ -147,6 +146,7 @@ import {
   socketUdpStream,
   udpSockets,
 } from "./worker-socket-udp.js";
+import process from "node:process";
 
 function log(msg) {
   if (debug) process._rawDebug(msg);
@@ -536,8 +536,6 @@ function handle(call, id, payload) {
     }
 
     // Clocks
-    case CLOCKS_NOW:
-      return hrtime.bigint();
     case CLOCKS_DURATION_SUBSCRIBE:
       payload = hrtime.bigint() + payload;
     // fallthrough
@@ -775,7 +773,9 @@ function handle(call, id, payload) {
         pollStateCheck(pollState);
         if (pollState.ready) doneList.push(idx);
       }
-      if (doneList.length > 0) return new Uint32Array(doneList);
+      if (doneList.length > 0) {
+        return new Uint32Array(doneList);
+      }
       let readyPromiseResolve;
       const readyPromise = new Promise(
         (resolve) => void (readyPromiseResolve = resolve)

package/lib/nodejs/cli.js

@@ -1,4 +1,4 @@
-import { argv, env, cwd } from "node:process";
+import process, { argv, env, cwd } from "node:process";
 import {
   ioCall,
   streams,

package/lib/nodejs/clocks.js

@@ -1,16 +1,20 @@
-import { ioCall, createPoll } from "../io/worker-io.js";
+import { createPoll } from "../io/worker-io.js";
 import {
-  CLOCKS_NOW,
   CLOCKS_INSTANT_SUBSCRIBE,
   CLOCKS_DURATION_SUBSCRIBE,
 } from "../io/calls.js";
+import { hrtime } from "node:process";
+
+const symbolCabiLower = Symbol.for("cabiLower");
+
+function resolution() {
+  return 1n;
+}
 
 export const monotonicClock = {
-  resolution() {
-    return 1n;
-  },
+  resolution,
   now() {
-    return ioCall(CLOCKS_NOW, null, null);
+    return hrtime.bigint();
   },
   subscribeInstant(instant) {
     return createPoll(CLOCKS_INSTANT_SUBSCRIBE, null, instant);
@@ -22,12 +26,39 @@ export const monotonicClock = {
 };
 
 export const wallClock = {
+  resolution() {
+    return { seconds: 0n, nanoseconds: 1e6 };
+  },
   now() {
     const seconds = BigInt(Math.floor(Date.now() / 1e3));
     const nanoseconds = (Date.now() % 1e3) * 1e6;
     return { seconds, nanoseconds };
   },
-  resolution() {
-    return { seconds: 0n, nanoseconds: 1e6 };
-  },
+};
+
+monotonicClock.resolution[symbolCabiLower] = () => resolution;
+monotonicClock.now[symbolCabiLower] = () => hrtime.bigint;
+wallClock.resolution[symbolCabiLower] = (memory) => {
+  let buf32 = new Int32Array(memory.buffer);
+  return function now(retptr) {
+    if (memory.buffer !== buf32.buffer) buf32 = new Int32Array(memory.buffer);
+    if (retptr % 4) throw new Error('wasi-io trap: retptr not aligned');
+    buf32[(retptr >> 2) + 0] = 0;
+    buf32[(retptr >> 2) + 4] = 0;
+    buf32[(retptr >> 2) + 8] = 1_000_000;
+  };
+};
+
+wallClock.now[symbolCabiLower] = (memory) => {
+  let buf32 = new Int32Array(memory.buffer);
+  let buf64 = new BigInt64Array(memory.buffer);
+  return function now(retptr) {
+    if (memory.buffer !== buf32.buffer) {
+      buf32 = new Int32Array(memory.buffer);
+      buf64 = new BigInt64Array(memory.buffer);
+    }
+    if (retptr % 4) throw new Error('wasi-io trap: retptr not aligned');
+    buf64[(retptr >> 2) + 0] = BigInt(Math.floor(Date.now() / 1e3));
+    buf32[(retptr >> 2) + 8] = (Date.now() % 1e3) * 1e6;
+  };
 };

package/lib/nodejs/filesystem.js

@@ -7,7 +7,7 @@ import {
 } from "../io/worker-io.js";
 import { INPUT_STREAM_CREATE, OUTPUT_STREAM_CREATE } from "../io/calls.js";
 import { FILE } from "../io/calls.js";
-import {
+import nodeFs, {
   closeSync,
   constants,
   fdatasyncSync,
@@ -17,7 +17,6 @@ import {
   futimesSync,
   linkSync,
   lstatSync,
-  lutimesSync,
   mkdirSync,
   opendirSync,
   openSync,
@@ -33,6 +32,8 @@ import {
 } from "node:fs";
 import { platform } from "node:process";
 
+const lutimesSync = nodeFs.lutimesSync;
+
 const symbolDispose = Symbol.dispose || Symbol.for("dispose");
 
 const isWindows = platform === "win32";
@@ -151,6 +152,8 @@ class Descriptor {
     try {
       ftruncateSync(this.#fd, Number(size));
     } catch (e) {
+      if (isWindows && e.code === 'EPERM')
+        throw 'access';
       throw convertFsError(e);
     }
   }
@@ -297,6 +300,9 @@ class Descriptor {
       dataModificationTimestamp.tag === "no-change" &&
         stats.dataModificationTimestamp
     );
+    if (!pathFlags.symlinkFollow && !lutimesSync){
+      throw new Error("Changing the timestamps of symlinks isn't supported");
+    }
     try {
       (pathFlags.symlinkFollow ? utimesSync : lutimesSync)(
         fullPath,
@@ -321,13 +327,14 @@ class Descriptor {
   }
 
   openAt(pathFlags, path, openFlags, descriptorFlags) {
+    if (preopenEntries.length === 0)
+      throw "access";
     const fullPath = this.#getFullPath(path, pathFlags.symlinkFollow);
     let fsOpenFlags = 0x0;
     if (openFlags.create) fsOpenFlags |= constants.O_CREAT;
     if (openFlags.directory) fsOpenFlags |= constants.O_DIRECTORY;
     if (openFlags.exclusive) fsOpenFlags |= constants.O_EXCL;
     if (openFlags.truncate) fsOpenFlags |= constants.O_TRUNC;
-
     if (descriptorFlags.read && descriptorFlags.write)
       fsOpenFlags |= constants.O_RDWR;
     else if (descriptorFlags.write) fsOpenFlags |= constants.O_WRONLY;

package/lib/nodejs/http.js

@@ -21,11 +21,13 @@ import {
   registerDispose,
   registerIncomingHttpHandler,
 } from "../io/worker-io.js";
-import { validateHeaderName, validateHeaderValue } from "node:http";
 import { HTTP } from "../io/calls.js";
 
+import * as http from "node:http";
+const { validateHeaderName = () => {}, validateHeaderValue = () => {} } = http;
+
 const symbolDispose = Symbol.dispose || Symbol.for("dispose");
-export const _forbiddenHeaders = new Set(["connection", "keep-alive"]);
+export const _forbiddenHeaders = new Set(["connection", "keep-alive", "host"]);
 
 class IncomingBody {
   #finished = false;
@@ -174,26 +176,38 @@ const responseOutparamCreate = ResponseOutparam._create;
 delete ResponseOutparam._create;
 
 class RequestOptions {
-  #connectTimeoutMs;
-  #firstByteTimeoutMs;
-  #betweenBytesTimeoutMs;
+  #connectTimeout;
+  #firstByteTimeout;
+  #betweenBytesTimeout;
+  //The WASI Duration is nanoseconds, js timers are set with Ms.
+  //We store the data as nanos, but provide TimeoutMs methods for
+  //convenience in setting timers elsewhere
+  connectTimeout() {
+    return this.#connectTimeout;
+  }
   connectTimeoutMs() {
-    return this.#connectTimeoutMs;
+    return this.#connectTimeout / 1_000_000;
   }
-  setConnectTimeoutMs(duration) {
-    this.#connectTimeoutMs = duration;
+  setConnectTimeout(duration) {
+    this.#connectTimeout = duration;
+  }
+  firstByteTimeout() {
+    return this.#firstByteTimeout;
   }
   firstByteTimeoutMs() {
-    return this.#firstByteTimeoutMs;
+    return this.#firstByteTimeout / 1_000_000;
+  }
+  setFirstByteTimeout(duration) {
+    this.#firstByteTimeout = duration;
   }
-  setFirstByteTimeoutMs(duration) {
-    this.#firstByteTimeoutMs = duration;
+  betweenBytesTimeout() {
+    return this.#betweenBytesTimeout;
   }
   betweenBytesTimeoutMs() {
-    return this.#betweenBytesTimeoutMs;
+    return this.#betweenBytesTimeout / 1_000_000;
   }
-  setBetweenBytesTimeoutMs(duration) {
-    this.#betweenBytesTimeoutMs = duration;
+  setBetweenBytesTimeout(duration) {
+    this.#betweenBytesTimeout = duration;
   }
 }
 

package/lib/nodejs/random.js

@@ -1,32 +1,45 @@
-import { randomBytes } from "node:crypto";
+import { randomBytes, randomFillSync } from "node:crypto";
 
 export const insecure = {
-  getInsecureRandomBytes (len) {
-    return randomBytes(Number(len));
-  },
-  getInsecureRandomU64 () {
+  getInsecureRandomBytes: getRandomBytes,
+  getInsecureRandomU64() {
     return new BigUint64Array(randomBytes(8).buffer)[0];
-  }
+  },
 };
 
 let insecureSeedValue1, insecureSeedValue2;
 
 export const insecureSeed = {
-  insecureSeed () {
+  insecureSeed() {
     if (insecureSeedValue1 === undefined) {
       insecureSeedValue1 = random.getRandomU64();
       insecureSeedValue2 = random.getRandomU64();
     }
     return [insecureSeedValue1, insecureSeedValue2];
-  }
+  },
 };
 
 export const random = {
-  getRandomBytes(len) {
-    return randomBytes(Number(len));
-  },
+  getRandomBytes,
 
-  getRandomU64 () {
+  getRandomU64() {
     return new BigUint64Array(randomBytes(8).buffer)[0];
-  }
+  },
+};
+
+function getRandomBytes(len) {
+  return randomBytes(Number(len));
+}
+
+randomBytes[Symbol.for("cabiLower")] = ({ memory, realloc }) => {
+  let buf32 = new Uint32Array(memory.buffer);
+  return function randomBytes(len, retptr) {
+    len = Number(len);
+    const ptr = realloc(0, 0, 1, len);
+    randomFillSync(memory.buffer, ptr, len);
+    if (memory.buffer !== buf32.buffer) buf32 = new Uint32Array(memory.buffer);
+    if (retptr % 4) throw new Error('wasi-io trap: retptr not aligned');
+    buf32[retptr >> 2] = ptr;
+    buf32[(retptr >> 2) + 1] = len;
+  };
 };

package/lib/synckit/index.js

@@ -87,7 +87,7 @@ export function createSyncFn(workerPath, debug, callbackHandler) {
     }
     return result;
   };
-  worker.unref();
+  if (worker.unref) worker.unref();
   return syncFn;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytecodealliance/preview2-shim",
-  "version": "0.15.1",
+  "version": "0.16.0",
   "description": "WASI Preview2 shim for JS environments",
   "author": "Guy Bedford, Eduardo Rodrigues<16357187+eduardomourar@users.noreply.github.com>",
   "type": "module",