quickjs-wasi-reactor 0.0.1

package/dist/wasi.js

@@ -0,0 +1,638 @@
+// WASI implementation for QuickJS reactor
+import * as wasi from "./wasi-defs.js";
+/**
+ * An exception that is thrown when the process exits.
+ */
+export class WASIProcExit extends Error {
+    code;
+    constructor(code) {
+        super("exit with exit code " + code);
+        this.code = code;
+    }
+}
+export class WASI {
+    #freeFds = [];
+    args = [];
+    env = [];
+    fds = [];
+    inst;
+    debug = false;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    wasiImport;
+    /** Start a WASI command */
+    start(instance) {
+        this.inst = instance;
+        try {
+            instance.exports._start();
+            return 0;
+        }
+        catch (e) {
+            if (e instanceof WASIProcExit) {
+                return e.code;
+            }
+            throw e;
+        }
+    }
+    /** Initialize a WASI reactor */
+    initialize(instance) {
+        this.inst = instance;
+        if (instance.exports._initialize) {
+            instance.exports._initialize();
+        }
+    }
+    log(...args) {
+        if (this.debug) {
+            console.log("[WASI]", ...args);
+        }
+    }
+    constructor(args, env, fds, options = {}) {
+        this.debug = options.debug ?? false;
+        this.args = args;
+        this.env = env;
+        this.fds = fds;
+        this.wasiImport = {
+            args_sizes_get: (argc, argv_buf_size) => {
+                const buffer = new DataView(this.inst.exports.memory.buffer);
+                buffer.setUint32(argc, this.args.length, true);
+                let buf_size = 0;
+                for (const arg of this.args) {
+                    buf_size += arg.length + 1;
+                }
+                buffer.setUint32(argv_buf_size, buf_size, true);
+                this.log("args_sizes_get", this.args.length, buf_size);
+                return 0;
+            },
+            args_get: (argv, argv_buf) => {
+                const buffer = new DataView(this.inst.exports.memory.buffer);
+                const buffer8 = new Uint8Array(this.inst.exports.memory.buffer);
+                for (let i = 0; i < this.args.length; i++) {
+                    buffer.setUint32(argv, argv_buf, true);
+                    argv += 4;
+                    const arg = new TextEncoder().encode(this.args[i]);
+                    buffer8.set(arg, argv_buf);
+                    buffer.setUint8(argv_buf + arg.length, 0);
+                    argv_buf += arg.length + 1;
+                }
+                return 0;
+            },
+            environ_sizes_get: (environ_count, environ_size) => {
+                const buffer = new DataView(this.inst.exports.memory.buffer);
+                buffer.setUint32(environ_count, this.env.length, true);
+                let buf_size = 0;
+                for (const environ of this.env) {
+                    buf_size += new TextEncoder().encode(environ).length + 1;
+                }
+                buffer.setUint32(environ_size, buf_size, true);
+                return 0;
+            },
+            environ_get: (environ, environ_buf) => {
+                const buffer = new DataView(this.inst.exports.memory.buffer);
+                const buffer8 = new Uint8Array(this.inst.exports.memory.buffer);
+                for (let i = 0; i < this.env.length; i++) {
+                    buffer.setUint32(environ, environ_buf, true);
+                    environ += 4;
+                    const e = new TextEncoder().encode(this.env[i]);
+                    buffer8.set(e, environ_buf);
+                    buffer.setUint8(environ_buf + e.length, 0);
+                    environ_buf += e.length + 1;
+                }
+                return 0;
+            },
+            clock_res_get: (id, res_ptr) => {
+                let resolutionValue;
+                switch (id) {
+                    case wasi.CLOCKID_MONOTONIC: {
+                        resolutionValue = 5000n;
+                        break;
+                    }
+                    case wasi.CLOCKID_REALTIME: {
+                        resolutionValue = 1000000n;
+                        break;
+                    }
+                    default:
+                        return wasi.ERRNO_NOSYS;
+                }
+                const view = new DataView(this.inst.exports.memory.buffer);
+                view.setBigUint64(res_ptr, resolutionValue, true);
+                return wasi.ERRNO_SUCCESS;
+            },
+            clock_time_get: (id, _precision, time) => {
+                const buffer = new DataView(this.inst.exports.memory.buffer);
+                if (id === wasi.CLOCKID_REALTIME) {
+                    buffer.setBigUint64(time, BigInt(new Date().getTime()) * 1000000n, true);
+                }
+                else if (id == wasi.CLOCKID_MONOTONIC) {
+                    let monotonic_time;
+                    try {
+                        monotonic_time = BigInt(Math.round(performance.now() * 1000000));
+                    }
+                    catch {
+                        monotonic_time = 0n;
+                    }
+                    buffer.setBigUint64(time, monotonic_time, true);
+                }
+                else {
+                    buffer.setBigUint64(time, 0n, true);
+                }
+                return 0;
+            },
+            fd_advise: (fd, _offset, _len, _advice) => {
+                if (this.fds[fd] != undefined) {
+                    return wasi.ERRNO_SUCCESS;
+                }
+                return wasi.ERRNO_BADF;
+            },
+            fd_allocate: (fd, offset, len) => {
+                if (this.fds[fd] != undefined) {
+                    return this.fds[fd].fd_allocate(offset, len);
+                }
+                return wasi.ERRNO_BADF;
+            },
+            fd_close: (fd) => {
+                if (this.fds[fd] != undefined) {
+                    const ret = this.fds[fd].fd_close();
+                    this.fds[fd] = undefined;
+                    this.#freeFds.push(fd);
+                    return ret;
+                }
+                return wasi.ERRNO_BADF;
+            },
+            fd_datasync: (fd) => {
+                if (this.fds[fd] != undefined) {
+                    return this.fds[fd].fd_sync();
+                }
+                return wasi.ERRNO_BADF;
+            },
+            fd_fdstat_get: (fd, fdstat_ptr) => {
+                if (this.fds[fd] != undefined) {
+                    const { ret, fdstat } = this.fds[fd].fd_fdstat_get();
+                    if (fdstat != null) {
+                        fdstat.write_bytes(new DataView(this.inst.exports.memory.buffer), fdstat_ptr);
+                    }
+                    return ret;
+                }
+                return wasi.ERRNO_BADF;
+            },
+            fd_fdstat_set_flags: (fd, flags) => {
+                if (this.fds[fd] != undefined) {
+                    return this.fds[fd].fd_fdstat_set_flags(flags);
+                }
+                return wasi.ERRNO_BADF;
+            },
+            fd_fdstat_set_rights: (fd, fs_rights_base, fs_rights_inheriting) => {
+                if (this.fds[fd] != undefined) {
+                    return this.fds[fd].fd_fdstat_set_rights(fs_rights_base, fs_rights_inheriting);
+                }
+                return wasi.ERRNO_BADF;
+            },
+            fd_filestat_get: (fd, filestat_ptr) => {
+                if (this.fds[fd] != undefined) {
+                    const { ret, filestat } = this.fds[fd].fd_filestat_get();
+                    if (filestat != null) {
+                        filestat.write_bytes(new DataView(this.inst.exports.memory.buffer), filestat_ptr);
+                    }
+                    return ret;
+                }
+                return wasi.ERRNO_BADF;
+            },
+            fd_filestat_set_size: (fd, size) => {
+                if (this.fds[fd] != undefined) {
+                    return this.fds[fd].fd_filestat_set_size(size);
+                }
+                return wasi.ERRNO_BADF;
+            },
+            fd_filestat_set_times: (fd, atim, mtim, fst_flags) => {
+                if (this.fds[fd] != undefined) {
+                    return this.fds[fd].fd_filestat_set_times(atim, mtim, fst_flags);
+                }
+                return wasi.ERRNO_BADF;
+            },
+            fd_pread: (fd, iovs_ptr, iovs_len, offset, nread_ptr) => {
+                const buffer = new DataView(this.inst.exports.memory.buffer);
+                const buffer8 = new Uint8Array(this.inst.exports.memory.buffer);
+                if (this.fds[fd] != undefined) {
+                    const iovecs = wasi.Iovec.read_bytes_array(buffer, iovs_ptr, iovs_len);
+                    let nread = 0;
+                    for (const iovec of iovecs) {
+                        const { ret, data } = this.fds[fd].fd_pread(iovec.buf_len, offset);
+                        if (ret != wasi.ERRNO_SUCCESS) {
+                            buffer.setUint32(nread_ptr, nread, true);
+                            return ret;
+                        }
+                        buffer8.set(data, iovec.buf);
+                        nread += data.length;
+                        offset += BigInt(data.length);
+                        if (data.length != iovec.buf_len) {
+                            break;
+                        }
+                    }
+                    buffer.setUint32(nread_ptr, nread, true);
+                    return wasi.ERRNO_SUCCESS;
+                }
+                return wasi.ERRNO_BADF;
+            },
+            fd_prestat_get: (fd, buf_ptr) => {
+                const buffer = new DataView(this.inst.exports.memory.buffer);
+                if (this.fds[fd] != undefined) {
+                    const { ret, prestat } = this.fds[fd].fd_prestat_get();
+                    if (prestat != null) {
+                        prestat.write_bytes(buffer, buf_ptr);
+                    }
+                    return ret;
+                }
+                return wasi.ERRNO_BADF;
+            },
+            fd_prestat_dir_name: (fd, path_ptr, path_len) => {
+                if (this.fds[fd] != undefined) {
+                    const { ret, prestat } = this.fds[fd].fd_prestat_get();
+                    if (prestat == null) {
+                        return ret;
+                    }
+                    const prestat_dir_name = prestat.inner.pr_name;
+                    const buffer8 = new Uint8Array(this.inst.exports.memory.buffer);
+                    buffer8.set(prestat_dir_name.slice(0, path_len), path_ptr);
+                    return prestat_dir_name.byteLength > path_len
+                        ? wasi.ERRNO_NAMETOOLONG
+                        : wasi.ERRNO_SUCCESS;
+                }
+                return wasi.ERRNO_BADF;
+            },
+            fd_pwrite: (fd, iovs_ptr, iovs_len, offset, nwritten_ptr) => {
+                const buffer = new DataView(this.inst.exports.memory.buffer);
+                const buffer8 = new Uint8Array(this.inst.exports.memory.buffer);
+                if (this.fds[fd] != undefined) {
+                    const iovecs = wasi.Ciovec.read_bytes_array(buffer, iovs_ptr, iovs_len);
+                    let nwritten = 0;
+                    for (const iovec of iovecs) {
+                        const data = buffer8.slice(iovec.buf, iovec.buf + iovec.buf_len);
+                        const { ret, nwritten: nwritten_part } = this.fds[fd].fd_pwrite(data, offset);
+                        if (ret != wasi.ERRNO_SUCCESS) {
+                            buffer.setUint32(nwritten_ptr, nwritten, true);
+                            return ret;
+                        }
+                        nwritten += nwritten_part;
+                        offset += BigInt(nwritten_part);
+                        if (nwritten_part != data.byteLength) {
+                            break;
+                        }
+                    }
+                    buffer.setUint32(nwritten_ptr, nwritten, true);
+                    return wasi.ERRNO_SUCCESS;
+                }
+                return wasi.ERRNO_BADF;
+            },
+            fd_read: (fd, iovs_ptr, iovs_len, nread_ptr) => {
+                const buffer = new DataView(this.inst.exports.memory.buffer);
+                const buffer8 = new Uint8Array(this.inst.exports.memory.buffer);
+                if (this.fds[fd] != undefined) {
+                    const iovecs = wasi.Iovec.read_bytes_array(buffer, iovs_ptr, iovs_len);
+                    let nread = 0;
+                    for (const iovec of iovecs) {
+                        const { ret, data } = this.fds[fd].fd_read(iovec.buf_len);
+                        if (ret != wasi.ERRNO_SUCCESS) {
+                            buffer.setUint32(nread_ptr, nread, true);
+                            return ret;
+                        }
+                        buffer8.set(data, iovec.buf);
+                        nread += data.length;
+                        if (data.length != iovec.buf_len) {
+                            break;
+                        }
+                    }
+                    buffer.setUint32(nread_ptr, nread, true);
+                    return wasi.ERRNO_SUCCESS;
+                }
+                return wasi.ERRNO_BADF;
+            },
+            fd_readdir: (fd, buf, buf_len, cookie, bufused_ptr) => {
+                const buffer = new DataView(this.inst.exports.memory.buffer);
+                const buffer8 = new Uint8Array(this.inst.exports.memory.buffer);
+                if (this.fds[fd] != undefined) {
+                    let bufused = 0;
+                    for (;;) {
+                        const { ret, dirent } = this.fds[fd].fd_readdir_single(cookie);
+                        if (ret != 0) {
+                            buffer.setUint32(bufused_ptr, bufused, true);
+                            return ret;
+                        }
+                        if (dirent == null) {
+                            break;
+                        }
+                        if (buf_len - bufused < dirent.head_length()) {
+                            bufused = buf_len;
+                            break;
+                        }
+                        const head_bytes = new ArrayBuffer(dirent.head_length());
+                        dirent.write_head_bytes(new DataView(head_bytes), 0);
+                        buffer8.set(new Uint8Array(head_bytes).slice(0, Math.min(head_bytes.byteLength, buf_len - bufused)), buf);
+                        buf += dirent.head_length();
+                        bufused += dirent.head_length();
+                        if (buf_len - bufused < dirent.name_length()) {
+                            bufused = buf_len;
+                            break;
+                        }
+                        dirent.write_name_bytes(buffer8, buf, buf_len - bufused);
+                        buf += dirent.name_length();
+                        bufused += dirent.name_length();
+                        cookie = dirent.d_next;
+                    }
+                    buffer.setUint32(bufused_ptr, bufused, true);
+                    return 0;
+                }
+                return wasi.ERRNO_BADF;
+            },
+            fd_renumber: (fd, to) => {
+                if (this.fds[fd] != undefined && this.fds[to] != undefined) {
+                    const ret = this.fds[to].fd_close();
+                    if (ret != 0) {
+                        return ret;
+                    }
+                    this.fds[to] = this.fds[fd];
+                    this.fds[fd] = undefined;
+                    this.#freeFds.push(fd);
+                    return 0;
+                }
+                return wasi.ERRNO_BADF;
+            },
+            fd_seek: (fd, offset, whence, offset_out_ptr) => {
+                const buffer = new DataView(this.inst.exports.memory.buffer);
+                if (this.fds[fd] != undefined) {
+                    const { ret, offset: offset_out } = this.fds[fd].fd_seek(offset, whence);
+                    buffer.setBigInt64(offset_out_ptr, offset_out, true);
+                    return ret;
+                }
+                return wasi.ERRNO_BADF;
+            },
+            fd_sync: (fd) => {
+                if (this.fds[fd] != undefined) {
+                    return this.fds[fd].fd_sync();
+                }
+                return wasi.ERRNO_BADF;
+            },
+            fd_tell: (fd, offset_ptr) => {
+                const buffer = new DataView(this.inst.exports.memory.buffer);
+                if (this.fds[fd] != undefined) {
+                    const { ret, offset } = this.fds[fd].fd_tell();
+                    buffer.setBigUint64(offset_ptr, offset, true);
+                    return ret;
+                }
+                return wasi.ERRNO_BADF;
+            },
+            fd_write: (fd, iovs_ptr, iovs_len, nwritten_ptr) => {
+                const buffer = new DataView(this.inst.exports.memory.buffer);
+                const buffer8 = new Uint8Array(this.inst.exports.memory.buffer);
+                if (this.fds[fd] != undefined) {
+                    const iovecs = wasi.Ciovec.read_bytes_array(buffer, iovs_ptr, iovs_len);
+                    let nwritten = 0;
+                    for (const iovec of iovecs) {
+                        const data = buffer8.slice(iovec.buf, iovec.buf + iovec.buf_len);
+                        const { ret, nwritten: nwritten_part } = this.fds[fd].fd_write(data);
+                        if (ret != wasi.ERRNO_SUCCESS) {
+                            buffer.setUint32(nwritten_ptr, nwritten, true);
+                            return ret;
+                        }
+                        nwritten += nwritten_part;
+                        if (nwritten_part != data.byteLength) {
+                            break;
+                        }
+                    }
+                    buffer.setUint32(nwritten_ptr, nwritten, true);
+                    return wasi.ERRNO_SUCCESS;
+                }
+                return wasi.ERRNO_BADF;
+            },
+            path_create_directory: (fd, path_ptr, path_len) => {
+                const buffer8 = new Uint8Array(this.inst.exports.memory.buffer);
+                if (this.fds[fd] != undefined) {
+                    const path = new TextDecoder("utf-8").decode(buffer8.slice(path_ptr, path_ptr + path_len));
+                    return this.fds[fd].path_create_directory(path);
+                }
+                return wasi.ERRNO_BADF;
+            },
+            path_filestat_get: (fd, flags, path_ptr, path_len, filestat_ptr) => {
+                const buffer = new DataView(this.inst.exports.memory.buffer);
+                const buffer8 = new Uint8Array(this.inst.exports.memory.buffer);
+                if (this.fds[fd] != undefined) {
+                    const path = new TextDecoder("utf-8").decode(buffer8.slice(path_ptr, path_ptr + path_len));
+                    const { ret, filestat } = this.fds[fd].path_filestat_get(flags, path);
+                    if (filestat != null) {
+                        filestat.write_bytes(buffer, filestat_ptr);
+                    }
+                    return ret;
+                }
+                return wasi.ERRNO_BADF;
+            },
+            path_filestat_set_times: (fd, flags, path_ptr, path_len, atim, mtim, fst_flags) => {
+                const buffer8 = new Uint8Array(this.inst.exports.memory.buffer);
+                if (this.fds[fd] != undefined) {
+                    const path = new TextDecoder("utf-8").decode(buffer8.slice(path_ptr, path_ptr + path_len));
+                    return this.fds[fd].path_filestat_set_times(flags, path, atim, mtim, fst_flags);
+                }
+                return wasi.ERRNO_BADF;
+            },
+            path_link: (old_fd, old_flags, old_path_ptr, old_path_len, new_fd, new_path_ptr, new_path_len) => {
+                const buffer8 = new Uint8Array(this.inst.exports.memory.buffer);
+                if (this.fds[old_fd] != undefined && this.fds[new_fd] != undefined) {
+                    const old_path = new TextDecoder("utf-8").decode(buffer8.slice(old_path_ptr, old_path_ptr + old_path_len));
+                    const new_path = new TextDecoder("utf-8").decode(buffer8.slice(new_path_ptr, new_path_ptr + new_path_len));
+                    const { ret, inode_obj } = this.fds[old_fd].path_lookup(old_path, old_flags);
+                    if (inode_obj == null) {
+                        return ret;
+                    }
+                    return this.fds[new_fd].path_link(new_path, inode_obj, false);
+                }
+                return wasi.ERRNO_BADF;
+            },
+            path_open: (fd, dirflags, path_ptr, path_len, oflags, fs_rights_base, fs_rights_inheriting, fd_flags, opened_fd_ptr) => {
+                const buffer = new DataView(this.inst.exports.memory.buffer);
+                const buffer8 = new Uint8Array(this.inst.exports.memory.buffer);
+                if (this.fds[fd] != undefined) {
+                    const path = new TextDecoder("utf-8").decode(buffer8.slice(path_ptr, path_ptr + path_len));
+                    this.log("path_open", path);
+                    const { ret, fd_obj } = this.fds[fd].path_open(dirflags, path, oflags, fs_rights_base, fs_rights_inheriting, fd_flags);
+                    if (ret != 0) {
+                        return ret;
+                    }
+                    const opened_fd = (() => {
+                        if (this.#freeFds.length > 0) {
+                            const fd = this.#freeFds.pop();
+                            this.fds[fd] = fd_obj;
+                            return fd;
+                        }
+                        this.fds.push(fd_obj);
+                        return this.fds.length - 1;
+                    })();
+                    buffer.setUint32(opened_fd_ptr, opened_fd, true);
+                    return 0;
+                }
+                return wasi.ERRNO_BADF;
+            },
+            path_readlink: (fd, path_ptr, path_len, buf_ptr, buf_len, nread_ptr) => {
+                const buffer = new DataView(this.inst.exports.memory.buffer);
+                const buffer8 = new Uint8Array(this.inst.exports.memory.buffer);
+                if (this.fds[fd] != undefined) {
+                    const path = new TextDecoder("utf-8").decode(buffer8.slice(path_ptr, path_ptr + path_len));
+                    const { ret, data } = this.fds[fd].path_readlink(path);
+                    if (data != null) {
+                        const data_buf = new TextEncoder().encode(data);
+                        if (data_buf.length > buf_len) {
+                            buffer.setUint32(nread_ptr, 0, true);
+                            return wasi.ERRNO_BADF;
+                        }
+                        buffer8.set(data_buf, buf_ptr);
+                        buffer.setUint32(nread_ptr, data_buf.length, true);
+                    }
+                    return ret;
+                }
+                return wasi.ERRNO_BADF;
+            },
+            path_remove_directory: (fd, path_ptr, path_len) => {
+                const buffer8 = new Uint8Array(this.inst.exports.memory.buffer);
+                if (this.fds[fd] != undefined) {
+                    const path = new TextDecoder("utf-8").decode(buffer8.slice(path_ptr, path_ptr + path_len));
+                    return this.fds[fd].path_remove_directory(path);
+                }
+                return wasi.ERRNO_BADF;
+            },
+            path_rename: (fd, old_path_ptr, old_path_len, new_fd, new_path_ptr, new_path_len) => {
+                const buffer8 = new Uint8Array(this.inst.exports.memory.buffer);
+                if (this.fds[fd] != undefined && this.fds[new_fd] != undefined) {
+                    const old_path = new TextDecoder("utf-8").decode(buffer8.slice(old_path_ptr, old_path_ptr + old_path_len));
+                    const new_path = new TextDecoder("utf-8").decode(buffer8.slice(new_path_ptr, new_path_ptr + new_path_len));
+                    const { ret: unlinkRet, inode_obj } = this.fds[fd].path_unlink(old_path);
+                    if (inode_obj == null) {
+                        return unlinkRet;
+                    }
+                    const linkRet = this.fds[new_fd].path_link(new_path, inode_obj, true);
+                    if (linkRet != wasi.ERRNO_SUCCESS) {
+                        if (this.fds[fd].path_link(old_path, inode_obj, true) !=
+                            wasi.ERRNO_SUCCESS) {
+                            throw "path_link should always return success when relinking an inode back to the original place";
+                        }
+                    }
+                    return linkRet;
+                }
+                return wasi.ERRNO_BADF;
+            },
+            path_symlink: (old_path_ptr, old_path_len, fd, _new_path_ptr, _new_path_len) => {
+                const buffer8 = new Uint8Array(this.inst.exports.memory.buffer);
+                if (this.fds[fd] != undefined) {
+                    new TextDecoder("utf-8").decode(buffer8.slice(old_path_ptr, old_path_ptr + old_path_len));
+                    return wasi.ERRNO_NOTSUP;
+                }
+                return wasi.ERRNO_BADF;
+            },
+            path_unlink_file: (fd, path_ptr, path_len) => {
+                const buffer8 = new Uint8Array(this.inst.exports.memory.buffer);
+                if (this.fds[fd] != undefined) {
+                    const path = new TextDecoder("utf-8").decode(buffer8.slice(path_ptr, path_ptr + path_len));
+                    return this.fds[fd].path_unlink_file(path);
+                }
+                return wasi.ERRNO_BADF;
+            },
+            poll_oneoff: (in_ptr, out_ptr, nsubscriptions, nevents_ptr) => {
+                if (nsubscriptions === 0) {
+                    return wasi.ERRNO_INVAL;
+                }
+                const buffer = new DataView(this.inst.exports.memory.buffer);
+                const subscriptions = [];
+                for (let i = 0; i < nsubscriptions; i++) {
+                    subscriptions.push(wasi.Subscription.read_bytes(buffer, in_ptr + i * wasi.Subscription.size()));
+                }
+                this.log("poll_oneoff: subscriptions", subscriptions);
+                const events = [];
+                let clockTimeout = null;
+                let clockUserdata = 0n;
+                for (const s of subscriptions) {
+                    if (s.eventtype === wasi.EVENTTYPE_CLOCK) {
+                        let getNow;
+                        if (s.clockid === wasi.CLOCKID_MONOTONIC) {
+                            getNow = () => BigInt(Math.round(performance.now() * 1_000_000));
+                        }
+                        else if (s.clockid === wasi.CLOCKID_REALTIME) {
+                            getNow = () => BigInt(new Date().getTime()) * 1000000n;
+                        }
+                        else {
+                            events.push(new wasi.Event(s.userdata, wasi.ERRNO_INVAL, s.eventtype));
+                            continue;
+                        }
+                        const endTime = (s.flags & wasi.SUBCLOCKFLAGS_SUBSCRIPTION_CLOCK_ABSTIME) !== 0
+                            ? s.timeout
+                            : getNow() + s.timeout;
+                        if (clockTimeout === null || endTime < clockTimeout) {
+                            clockTimeout = endTime;
+                            clockUserdata = s.userdata;
+                        }
+                    }
+                    else if (s.eventtype === wasi.EVENTTYPE_FD_READ ||
+                        s.eventtype === wasi.EVENTTYPE_FD_WRITE) {
+                        if (this.fds[s.fd] == undefined) {
+                            events.push(new wasi.Event(s.userdata, wasi.ERRNO_BADF, s.eventtype));
+                            continue;
+                        }
+                        const pollResult = this.fds[s.fd].fd_poll(s.eventtype);
+                        this.log("poll_oneoff: fd", s.fd, "poll result", pollResult);
+                        if (pollResult.ready) {
+                            events.push(new wasi.Event(s.userdata, wasi.ERRNO_SUCCESS, s.eventtype, pollResult.nbytes, pollResult.flags));
+                        }
+                    }
+                    else {
+                        events.push(new wasi.Event(s.userdata, wasi.ERRNO_NOTSUP, s.eventtype));
+                    }
+                }
+                // If no events ready and we have a clock, check if it expired
+                if (events.length === 0 && clockTimeout !== null) {
+                    const getNow = subscriptions.find((s) => s.eventtype === wasi.EVENTTYPE_CLOCK)
+                        ?.clockid === wasi.CLOCKID_REALTIME
+                        ? () => BigInt(new Date().getTime()) * 1000000n
+                        : () => BigInt(Math.round(performance.now() * 1_000_000));
+                    if (getNow() >= clockTimeout) {
+                        events.push(new wasi.Event(clockUserdata, wasi.ERRNO_SUCCESS, wasi.EVENTTYPE_CLOCK));
+                    }
+                }
+                // Write events to output buffer
+                for (let i = 0; i < events.length; i++) {
+                    events[i].write_bytes(buffer, out_ptr + i * wasi.Event.size());
+                }
+                buffer.setUint32(nevents_ptr, events.length, true);
+                this.log("poll_oneoff: returning", events.length, "events");
+                return wasi.ERRNO_SUCCESS;
+            },
+            proc_exit: (exit_code) => {
+                throw new WASIProcExit(exit_code);
+            },
+            proc_raise: (sig) => {
+                throw "raised signal " + sig;
+            },
+            sched_yield: () => { },
+            random_get: (buf, buf_len) => {
+                const buffer8 = new Uint8Array(this.inst.exports.memory.buffer).subarray(buf, buf + buf_len);
+                if ("crypto" in globalThis &&
+                    (typeof SharedArrayBuffer === "undefined" ||
+                        !(this.inst.exports.memory.buffer instanceof SharedArrayBuffer))) {
+                    for (let i = 0; i < buf_len; i += 65536) {
+                        crypto.getRandomValues(buffer8.subarray(i, i + 65536));
+                    }
+                }
+                else {
+                    for (let i = 0; i < buf_len; i++) {
+                        buffer8[i] = (Math.random() * 256) | 0;
+                    }
+                }
+            },
+            sock_recv: (_fd, _ri_data, _ri_flags) => {
+                throw "sockets not supported";
+            },
+            sock_send: (_fd, _si_data, _si_flags) => {
+                throw "sockets not supported";
+            },
+            sock_shutdown: (_fd, _how) => {
+                throw "sockets not supported";
+            },
+            sock_accept: (_fd, _flags) => {
+                throw "sockets not supported";
+            },
+        };
+    }
+}
+//# sourceMappingURL=wasi.js.map