@remix_labs/hub-client 2.2248.0-dev → 2.2249.0

package/miniwasi.js

@@ -0,0 +1,155 @@
+
+// Minimal WASI implementation to run mixrt.wasm and mixcore_mini.wasm
+class MiniWASI {
+    constructor() {
+        this.inst = null; // same field as in bjorn's WASI shim that's used for mixcore
+        this.memory = null;
+        this.stdout = new Array();
+        this.stderr = new Array();
+        this.imp_wasi_snapshot_preview1 = {
+            "fd_write": this.fd_write.bind(this),
+            "fd_close": this.fd_close.bind(this),
+            "fd_seek": this.fd_seek.bind(this),
+            "fd_fdstat_get": this.fd_fdstat_get.bind(this),
+            "environ_sizes_get": this.environ_sizes_get.bind(this),
+            "environ_get": this.environ_get.bind(this),
+            "random_get": this.random_get.bind(this),
+            "proc_exit": this.proc_exit.bind(this),
+            "clock_time_get": this.clock_time_get.bind(this),
+            "poll_oneoff": this.poll_oneoff.bind(this),
+        };
+        this.wasiImport = this.imp_wasi_snapshot_preview1;
+    }
+
+    update() {
+        this.memory = this.inst.exports.memory;
+        this.mem8 = new Uint8Array(this.memory.buffer);
+        this.mem32 = new Uint32Array(this.memory.buffer);
+    }
+
+    fd_seek(fd, offset_low, offset_high, whence, newOffset) {
+        this.update();
+        this.abort("unexpected fd_seek call");
+    }
+
+    clock_time_get(id, precision, time) {
+        const buffer = new DataView(this.memory.buffer);
+        if (id === 0 /* CLOCKID_REALTIME */) {
+            buffer.setBigUint64(
+                time,
+                BigInt(new Date().getTime()) * 1_000_000n,
+                true,
+            );
+        } else if (id == 1 /* CLOCKID_MONOTONIC */) {
+            let monotonic_time;
+            try {
+                monotonic_time = BigInt(Math.round(performance.now() * 1000000));
+            } catch (e) {
+                // performance.now() is only available in browsers.
+                // TODO use the perf_hooks builtin module for NodeJS
+                monotonic_time = 0n;
+            }
+            buffer.setBigUint64(time, monotonic_time, true);
+        } else {
+            // TODO
+            buffer.setBigUint64(time, 0n, true);
+        }
+        return 0;
+    }
+
+    poll_oneoff(in_, out, nsub) {
+        this.update();
+        this.abort("unexpected poll_oneoff call");
+    }
+
+    fd_write(fd, iov, iovcnt, pnum) {
+        this.update();
+        let buffer;
+        let logger;
+        switch (fd) {
+        case 1:
+            buffer = this.stdout;
+            logger = console.debug;
+            break;
+        case 2: // redirect to stdout...
+            buffer = this.stdout;
+            logger = console.debug;
+            break;
+        default:
+            return 0;
+        }
+        let num = 0;
+        for (let i = 0; i < iovcnt; i++) {
+            let ptr = this.mem32[((iov)+(i*8))>>2];
+            let len = this.mem32[((iov)+(i*8 + 4))>>2];
+            for (let j = 0; j < len; j++) {
+                let byte = this.mem8[ptr+j];
+                if (byte >= 32)
+                    buffer.push(byte)
+                else if (byte == 10) {
+                    let uint8 = new Uint8Array(buffer);
+                    console.log("WASM: %s", this.utf8array_to_string(uint8, 0, buffer.length));
+                    buffer.length = 0;
+                }
+            }
+            num += len;
+        }
+        this.mem32[pnum>>2]=num;
+        return 0;
+    }
+
+    utf8array_to_string(bytes, idx, count) {
+        let limit = idx + count;
+        let ptr = idx;
+        while (bytes[ptr] && ptr < limit) ptr++;
+        return new TextDecoder().decode(bytes.subarray(idx, ptr));
+    }
+
+    fd_close(fd) {
+        this.update();
+        return 0;
+    }
+
+    fd_fdstat_get(fd, buf) {
+        this.update();
+        this.abort("unexpected fd_fdstat_get call");
+    }
+
+    environ_sizes_get(ptr_count, ptr_sizes) {
+        this.update();
+        this.mem32[ptr_count >> 2] = 0;
+        return 0;
+    }
+
+    environ_get(ptr_environ, ptr_environ_buf) {
+        this.update();
+        return 0;
+    }
+
+    random_get(ptr_buf, size) {
+        this.update();
+        // node's version of getRandom doesn't like to write directly to
+        // wasm memory, so this indirection is needed:
+        let mem = this.mem8.subarray(ptr_buf, ptr_buf + size);
+        let mem2 = new Uint8Array(size);
+        if (!globalThis.ThisIsNode) {
+            crypto.getRandomValues(mem2);
+        } // else 0 according to fair-dice roll
+        mem.set(mem2);
+        return 0;
+    }
+
+    proc_exit(code) {
+        this.update();
+        console.log("exit(" + code + ")")
+    }
+
+    abort(msg) {
+        let e = new Error();
+        let stack = e.stack || "(no stack trace)";
+        console.error("WASM ABORT: %s at %s", msg, stack);
+        throw new WebAssembly.RuntimeError(msg);
+    }
+}
+
+export { MiniWASI }

package/mixcore-common.js

@@ -0,0 +1,39 @@
+
+const CORE_FFI_NAMES = [
+    "$destroyHook",
+    "$hideHook",
+    "$isSyncEnabled",
+    "$loadHook",
+    "$flush",
+    "$mqtt_available",
+    "$showHook",
+    "$mqtt_enabled",
+    "$log",
+    "get_env",
+    "$outputError",
+    "$outputWithVersion",
+    "$co_sleep",
+    "$decodeError",
+];
+
+function ffiNameMatches(name, pattern) {
+    if (pattern == "CORE") {
+        return CORE_FFI_NAMES.includes(name);
+    }
+    if (pattern.slice(-1) === '*') {
+        return name.startsWith(pattern.slice(0, -1));
+    }
+    return name === pattern;
+}
+
+function filterFFINames(names, enable, disable) {
+    if (enable !== undefined) {
+        names = names.filter(name => enable.some(pat => ffiNameMatches(name, pat)));
+    }
+    if (disable !== undefined) {
+        names = names.filter(name => !disable.some(pat => ffiNameMatches(name, pat)));
+    }
+    return names;
+}
+
+export { filterFFINames }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remix_labs/hub-client",
-  "version": "2.2248.0-dev",
+  "version": "2.2249.0",
   "description": "talk to the Hub web worker",
   "main": "node.js",
   "browser": "index.js",