@tybys/wasm-util 0.4.0 → 0.5.0

package/dist/wasm-util.js

@@ -141,18 +141,20 @@
             }
         }
         wrapImportFunction(f) {
-            return ((...args) => {
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const _this = this;
+            return (function () {
                 // eslint-disable-next-line no-unreachable-loop
-                while (this.exports.asyncify_get_state() === 2 /* AsyncifyState.REWINDING */) {
-                    this.exports.asyncify_stop_rewind();
-                    return this.value;
+                while (_this.exports.asyncify_get_state() === 2 /* AsyncifyState.REWINDING */) {
+                    _this.exports.asyncify_stop_rewind();
+                    return _this.value;
                 }
-                this.assertState();
-                const v = f(...args);
+                _this.assertState();
+                const v = f.apply(this, arguments);
                 if (!isPromiseLike(v))
                     return v;
-                this.exports.asyncify_start_unwind(this.dataPtr);
-                this.value = v;
+                _this.exports.asyncify_start_unwind(_this.dataPtr);
+                _this.value = v;
             });
         }
         wrapImports(imports) {
@@ -174,17 +176,19 @@
             return importObject;
         }
         wrapExportFunction(f) {
-            return (async (...args) => {
-                this.assertState();
-                let ret = f(...args);
-                while (this.exports.asyncify_get_state() === 1 /* AsyncifyState.UNWINDING */) {
-                    this.exports.asyncify_stop_unwind();
-                    this.value = await this.value;
-                    this.assertState();
-                    this.exports.asyncify_start_rewind(this.dataPtr);
-                    ret = f();
-                }
-                this.assertState();
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const _this = this;
+            return (async function () {
+                _this.assertState();
+                let ret = f.apply(this, arguments);
+                while (_this.exports.asyncify_get_state() === 1 /* AsyncifyState.UNWINDING */) {
+                    _this.exports.asyncify_stop_unwind();
+                    _this.value = await _this.value;
+                    _this.assertState();
+                    _this.exports.asyncify_start_rewind(_this.dataPtr);
+                    ret = f.call(this);
+                }
+                _this.assertState();
                 return ret;
             });
         }
@@ -212,6 +216,11 @@
     // }
     // Object.defineProperty(Instance.prototype, 'exports', { enumerable: true })
 
+    function validateImports(imports) {
+        if (imports && typeof imports !== 'object') {
+            throw new TypeError('imports must be an object or undefined');
+        }
+    }
     async function fetchWasm(urlOrBuffer, imports) {
         if (typeof wx !== 'undefined' && typeof __wxConfig !== 'undefined') {
             return await _WebAssembly.instantiate(urlOrBuffer, imports);
@@ -222,24 +231,12 @@
         return source;
     }
     /** @public */
-    async function load(urlOrBuffer, imports, asyncify) {
-        var _a, _b;
-        if (imports && typeof imports !== 'object') {
-            throw new TypeError('imports must be an object or undefined');
-        }
+    async function load(urlOrBuffer, imports) {
+        validateImports(imports);
         imports = imports !== null && imports !== void 0 ? imports : {};
-        let asyncifyHelper;
         let source;
-        if (asyncify) {
-            asyncifyHelper = new Asyncify();
-            imports = asyncifyHelper.wrapImports(imports);
-        }
         if (urlOrBuffer instanceof ArrayBuffer || ArrayBuffer.isView(urlOrBuffer)) {
             source = await _WebAssembly.instantiate(urlOrBuffer, imports);
-            if (asyncify) {
-                const memory = source.instance.exports.memory || ((_a = imports.env) === null || _a === void 0 ? void 0 : _a.memory);
-                return { module: source.module, instance: asyncifyHelper.init(memory, source.instance, asyncify) };
-            }
             return source;
         }
         if (typeof urlOrBuffer !== 'string' && !(urlOrBuffer instanceof URL)) {
@@ -256,35 +253,41 @@
         else {
             source = await fetchWasm(urlOrBuffer, imports);
         }
-        if (asyncify) {
-            const memory = source.instance.exports.memory || ((_b = imports.env) === null || _b === void 0 ? void 0 : _b.memory);
-            return { module: source.module, instance: asyncifyHelper.init(memory, source.instance, asyncify) };
-        }
         return source;
     }
     /** @public */
-    function loadSync(buffer, imports, asyncify) {
+    async function asyncifyLoad(asyncify, urlOrBuffer, imports) {
         var _a;
+        validateImports(imports);
+        imports = imports !== null && imports !== void 0 ? imports : {};
+        const asyncifyHelper = new Asyncify();
+        imports = asyncifyHelper.wrapImports(imports);
+        const source = await load(urlOrBuffer, imports);
+        const memory = source.instance.exports.memory || ((_a = imports.env) === null || _a === void 0 ? void 0 : _a.memory);
+        return { module: source.module, instance: asyncifyHelper.init(memory, source.instance, asyncify) };
+    }
+    /** @public */
+    function loadSync(buffer, imports) {
         if ((buffer instanceof ArrayBuffer) && !ArrayBuffer.isView(buffer)) {
             throw new TypeError('Invalid source');
         }
-        if (imports && typeof imports !== 'object') {
-            throw new TypeError('imports must be an object or undefined');
-        }
+        validateImports(imports);
         imports = imports !== null && imports !== void 0 ? imports : {};
-        let asyncifyHelper;
-        if (asyncify) {
-            asyncifyHelper = new Asyncify();
-            imports = asyncifyHelper.wrapImports(imports);
-        }
         const module = new _WebAssembly.Module(buffer);
         const instance = new _WebAssembly.Instance(module, imports);
         const source = { instance, module };
-        if (asyncify) {
-            const memory = source.instance.exports.memory || ((_a = imports.env) === null || _a === void 0 ? void 0 : _a.memory);
-            return { module: source.module, instance: asyncifyHelper.init(memory, instance, asyncify) };
-        }
         return source;
+    }
+    /** @public */
+    function asyncifyLoadSync(asyncify, buffer, imports) {
+        var _a;
+        validateImports(imports);
+        imports = imports !== null && imports !== void 0 ? imports : {};
+        const asyncifyHelper = new Asyncify();
+        imports = asyncifyHelper.wrapImports(imports);
+        const source = loadSync(buffer, imports);
+        const memory = source.instance.exports.memory || ((_a = imports.env) === null || _a === void 0 ? void 0 : _a.memory);
+        return { module: source.module, instance: asyncifyHelper.init(memory, source.instance, asyncify) };
     }
 
     const CHAR_DOT = 46; /* . */
@@ -760,7 +763,6 @@
             this.size = options.size;
             this.fds = Array(options.size);
             this.stdio = [options.in, options.out, options.err];
-            this.fs = options.fs;
             this.print = options.print;
             this.printErr = options.printErr;
             this.insertStdio(options.in, 0, '<stdin>');
@@ -807,18 +809,6 @@
             this.used++;
             return entry;
         }
-        getFileTypeByFd(fd) {
-            const stat = this.fs.fstatSync(fd);
-            return toFileType(stat);
-        }
-        insertPreopen(fd, mappedPath, realPath) {
-            const type = this.getFileTypeByFd(fd);
-            if (type !== 3 /* WasiFileType.DIRECTORY */) {
-                throw new WasiError(`Preopen not dir: ["${mappedPath}", "${realPath}"]`, 54 /* WasiErrno.ENOTDIR */);
-            }
-            const result = getRights(this.stdio, fd, 0, type);
-            return this.insert(fd, mappedPath, realPath, type, result.base, result.inheriting, 1);
-        }
         get(id, base, inheriting) {
             if (id >= this.size) {
                 throw new WasiError('Invalid fd', 8 /* WasiErrno.EBADF */);
@@ -844,6 +834,24 @@
             this.fds[id] = undefined;
             this.used--;
         }
+    }
+    class SyncTable extends FileDescriptorTable {
+        constructor(options) {
+            super(options);
+            this.fs = options.fs;
+        }
+        getFileTypeByFd(fd) {
+            const stats = this.fs.fstatSync(fd, { bigint: true });
+            return toFileType(stats);
+        }
+        insertPreopen(fd, mappedPath, realPath) {
+            const type = this.getFileTypeByFd(fd);
+            if (type !== 3 /* WasiFileType.DIRECTORY */) {
+                throw new WasiError(`Preopen not dir: ["${mappedPath}", "${realPath}"]`, 54 /* WasiErrno.ENOTDIR */);
+            }
+            const result = getRights(this.stdio, fd, 0, type);
+            return this.insert(fd, mappedPath, realPath, type, result.base, result.inheriting, 1);
+        }
         renumber(dst, src) {
             if (dst === src)
                 return;
@@ -861,6 +869,41 @@
             this.fds[src] = undefined;
             this.used--;
         }
+    }
+    class AsyncTable extends FileDescriptorTable {
+        // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+        constructor(options) {
+            super(options);
+        }
+        async getFileTypeByFd(fd) {
+            const stats = await fd.stat({ bigint: true });
+            return toFileType(stats);
+        }
+        async insertPreopen(fd, mappedPath, realPath) {
+            const type = await this.getFileTypeByFd(fd);
+            if (type !== 3 /* WasiFileType.DIRECTORY */) {
+                throw new WasiError(`Preopen not dir: ["${mappedPath}", "${realPath}"]`, 54 /* WasiErrno.ENOTDIR */);
+            }
+            const result = getRights(this.stdio, fd.fd, 0, type);
+            return this.insert(fd, mappedPath, realPath, type, result.base, result.inheriting, 1);
+        }
+        async renumber(dst, src) {
+            if (dst === src)
+                return;
+            if (dst >= this.size || src >= this.size) {
+                throw new WasiError('Invalid fd', 8 /* WasiErrno.EBADF */);
+            }
+            const dstEntry = this.fds[dst];
+            const srcEntry = this.fds[src];
+            if (!dstEntry || !srcEntry || dstEntry.id !== dst || srcEntry.id !== src) {
+                throw new WasiError('Invalid fd', 8 /* WasiErrno.EBADF */);
+            }
+            await dstEntry.fd.close();
+            this.fds[dst] = this.fds[src];
+            this.fds[dst].id = dst;
+            this.fds[src] = undefined;
+            this.used--;
+        }
     }
 
     /** @public */
@@ -891,6 +934,44 @@
         return memory;
     }
 
+    function checkWebAssemblyFunction() {
+        const WebAssemblyFunction = _WebAssembly.Function;
+        if (typeof WebAssemblyFunction !== 'function') {
+            throw new Error('WebAssembly.Function is not supported in this environment.' +
+                ' If you are using V8 based browser like Chrome, try to specify' +
+                ' --js-flag="--wasm-staging --experimental-wasm-stack-switching"');
+        }
+        return WebAssemblyFunction;
+    }
+    /** @public */
+    function wrapAsyncImport(f, parameterType, returnType) {
+        const WebAssemblyFunction = checkWebAssemblyFunction();
+        if (typeof f !== 'function') {
+            throw new TypeError('Function required');
+        }
+        const parameters = parameterType.slice(0);
+        parameters.unshift('externref');
+        return new WebAssemblyFunction({ parameters, results: returnType }, f, { suspending: 'first' });
+    }
+    /** @public */
+    function wrapAsyncExport(f) {
+        const WebAssemblyFunction = checkWebAssemblyFunction();
+        if (typeof f !== 'function') {
+            throw new TypeError('Function required');
+        }
+        return new WebAssemblyFunction({ parameters: [...WebAssemblyFunction.type(f).parameters.slice(1)], results: ['externref'] }, f, { promising: 'first' });
+    }
+    /** @public */
+    function wrapExports(exports, needWrap) {
+        return wrapInstanceExports(exports, (exportValue, name) => {
+            let ignore = typeof exportValue !== 'function';
+            if (Array.isArray(needWrap)) {
+                ignore = ignore || (needWrap.indexOf(name) === -1);
+            }
+            return ignore ? exportValue : wrapAsyncExport(exportValue);
+        });
+    }
+
     function copyMemory(targets, src) {
         if (targets.length === 0 || src.length === 0)
             return 0;
@@ -949,7 +1030,7 @@
         Object.defineProperty(f, 'name', { value: name });
         return f;
     }
-    function syscallWrap(name, f) {
+    function syscallWrap(self, name, f) {
         return defineName(name, function () {
             {
                 const args = Array.prototype.slice.call(arguments);
@@ -959,7 +1040,7 @@
             }
             let r;
             try {
-                r = f.apply(this, arguments);
+                r = f.apply(self, arguments);
             }
             catch (err) {
                 return handleError(err);
@@ -970,7 +1051,7 @@
             return r;
         });
     }
-    function resolvePath(fs, fileDescriptor, path, flags) {
+    function resolvePathSync(fs, fileDescriptor, path, flags) {
         let resolvedPath = resolve(fileDescriptor.realPath, path);
         if ((flags & 1) === 1) {
             try {
@@ -984,6 +1065,20 @@
         }
         return resolvedPath;
     }
+    async function resolvePathAsync(fs, fileDescriptor, path, flags) {
+        let resolvedPath = resolve(fileDescriptor.realPath, path);
+        if ((flags & 1) === 1) {
+            try {
+                resolvedPath = await fs.promises.readlink(resolvedPath);
+            }
+            catch (err) {
+                if (err.code !== 'EINVAL' && err.code !== 'ENOENT') {
+                    throw err;
+                }
+            }
+        }
+        return resolvedPath;
+    }
     const encoder = new TextEncoder();
     const decoder = new TextDecoder();
     function readStdin() {
@@ -994,14 +1089,8 @@
         return buffer;
     }
     class WASI$1 {
-        constructor(args, env, preopens, stdio, filesystem, print, printErr) {
-            this._setMemory = function _setMemory(m) {
-                if (!(m instanceof _WebAssembly.Memory)) {
-                    throw new TypeError('"instance.exports.memory" property must be a WebAssembly.Memory');
-                }
-                _memory.set(this, extendMemory(m));
-            };
-            this.args_get = syscallWrap('args_get', function (argv, argv_buf) {
+        constructor(args, env, fds, asyncFs, fs, asyncify) {
+            this.args_get = syscallWrap(this, 'args_get', function (argv, argv_buf) {
                 argv = Number(argv);
                 argv_buf = Number(argv_buf);
                 if (argv === 0 || argv_buf === 0) {
@@ -1020,7 +1109,7 @@
                 }
                 return 0 /* WasiErrno.ESUCCESS */;
             });
-            this.args_sizes_get = syscallWrap('args_sizes_get', function (argc, argv_buf_size) {
+            this.args_sizes_get = syscallWrap(this, 'args_sizes_get', function (argc, argv_buf_size) {
                 argc = Number(argc);
                 argv_buf_size = Number(argv_buf_size);
                 if (argc === 0 || argv_buf_size === 0) {
@@ -1033,7 +1122,7 @@
                 view.setUint32(argv_buf_size, encoder.encode(args.join('\0') + '\0').length, true);
                 return 0 /* WasiErrno.ESUCCESS */;
             });
-            this.environ_get = syscallWrap('environ_get', function (environ, environ_buf) {
+            this.environ_get = syscallWrap(this, 'environ_get', function (environ, environ_buf) {
                 environ = Number(environ);
                 environ_buf = Number(environ_buf);
                 if (environ === 0 || environ_buf === 0) {
@@ -1052,7 +1141,7 @@
                 }
                 return 0 /* WasiErrno.ESUCCESS */;
             });
-            this.environ_sizes_get = syscallWrap('environ_sizes_get', function (len, buflen) {
+            this.environ_sizes_get = syscallWrap(this, 'environ_sizes_get', function (len, buflen) {
                 len = Number(len);
                 buflen = Number(buflen);
                 if (len === 0 || buflen === 0) {
@@ -1064,7 +1153,7 @@
                 view.setUint32(buflen, encoder.encode(wasi.env.join('\0') + '\0').length, true);
                 return 0 /* WasiErrno.ESUCCESS */;
             });
-            this.clock_res_get = syscallWrap('clock_res_get', function (id, resolution) {
+            this.clock_res_get = syscallWrap(this, 'clock_res_get', function (id, resolution) {
                 resolution = Number(resolution);
                 if (resolution === 0) {
                     return 28 /* WasiErrno.EINVAL */;
@@ -1082,7 +1171,7 @@
                     default: return 28 /* WasiErrno.EINVAL */;
                 }
             });
-            this.clock_time_get = syscallWrap('clock_time_get', function (id, _percision, time) {
+            this.clock_time_get = syscallWrap(this, 'clock_time_get', function (id, _percision, time) {
                 time = Number(time);
                 if (time === 0) {
                     return 28 /* WasiErrno.EINVAL */;
@@ -1105,35 +1194,10 @@
                     default: return 28 /* WasiErrno.EINVAL */;
                 }
             });
-            this.fd_advise = syscallWrap('fd_advise', function (_fd, _offset, _len, _advice) {
+            this.fd_advise = syscallWrap(this, 'fd_advise', function (_fd, _offset, _len, _advice) {
                 return 52 /* WasiErrno.ENOSYS */;
             });
-            this.fd_allocate = syscallWrap('fd_allocate', function (fd, offset, len) {
-                const wasi = _wasi.get(this);
-                const fs = getFs(this);
-                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_ALLOCATE, BigInt(0));
-                const stat = fs.fstatSync(fileDescriptor.fd, { bigint: true });
-                if (stat.size < offset + len) {
-                    fs.ftruncateSync(fileDescriptor.fd, Number(offset + len));
-                }
-                return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.fd_close = syscallWrap('fd_close', function (fd) {
-                const wasi = _wasi.get(this);
-                const fileDescriptor = wasi.fds.get(fd, BigInt(0), BigInt(0));
-                const fs = getFs(this);
-                fs.closeSync(fileDescriptor.fd);
-                wasi.fds.remove(fd);
-                return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.fd_datasync = syscallWrap('fd_datasync', function (fd) {
-                const wasi = _wasi.get(this);
-                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_DATASYNC, BigInt(0));
-                const fs = getFs(this);
-                fs.fdatasyncSync(fileDescriptor.fd);
-                return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.fd_fdstat_get = syscallWrap('fd_fdstat_get', function (fd, fdstat) {
+            this.fd_fdstat_get = syscallWrap(this, 'fd_fdstat_get', function (fd, fdstat) {
                 fdstat = Number(fdstat);
                 if (fdstat === 0) {
                     return 28 /* WasiErrno.EINVAL */;
@@ -1147,10 +1211,10 @@
                 view.setBigUint64(fdstat + 16, fileDescriptor.rightsInheriting, true);
                 return 0 /* WasiErrno.ESUCCESS */;
             });
-            this.fd_fdstat_set_flags = syscallWrap('fd_fdstat_set_flags', function (_fd, _flags) {
+            this.fd_fdstat_set_flags = syscallWrap(this, 'fd_fdstat_set_flags', function (_fd, _flags) {
                 return 52 /* WasiErrno.ENOSYS */;
             });
-            this.fd_fdstat_set_rights = syscallWrap('fd_fdstat_set_rights', function (fd, rightsBase, rightsInheriting) {
+            this.fd_fdstat_set_rights = syscallWrap(this, 'fd_fdstat_set_rights', function (fd, rightsBase, rightsInheriting) {
                 const wasi = _wasi.get(this);
                 const fileDescriptor = wasi.fds.get(fd, BigInt(0), BigInt(0));
                 if ((rightsBase | fileDescriptor.rightsBase) > fileDescriptor.rightsBase) {
@@ -1164,65 +1228,7 @@
                 fileDescriptor.rightsInheriting = rightsInheriting;
                 return 0 /* WasiErrno.ESUCCESS */;
             });
-            this.fd_filestat_get = syscallWrap('fd_filestat_get', function (fd, buf) {
-                buf = Number(buf);
-                if (buf === 0)
-                    return 28 /* WasiErrno.EINVAL */;
-                const wasi = _wasi.get(this);
-                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_FILESTAT_GET, BigInt(0));
-                const fs = getFs(this);
-                const stat = fs.fstatSync(fileDescriptor.fd, { bigint: true });
-                const { view } = getMemory(this);
-                toFileStat(view, buf, stat);
-                return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.fd_filestat_set_size = syscallWrap('fd_filestat_set_size', function (fd, size) {
-                const wasi = _wasi.get(this);
-                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_FILESTAT_SET_SIZE, BigInt(0));
-                const fs = getFs(this);
-                fs.ftruncateSync(fileDescriptor.fd, Number(size));
-                return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.fd_filestat_set_times = syscallWrap('fd_filestat_set_times', function (fd, atim, mtim, flags) {
-                const wasi = _wasi.get(this);
-                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_FILESTAT_SET_TIMES, BigInt(0));
-                if ((flags & 2 /* WasiFstFlag.SET_ATIM_NOW */) === 2 /* WasiFstFlag.SET_ATIM_NOW */) {
-                    atim = BigInt(Date.now() * 1000000);
-                }
-                if ((flags & 8 /* WasiFstFlag.SET_MTIM_NOW */) === 8 /* WasiFstFlag.SET_MTIM_NOW */) {
-                    mtim = BigInt(Date.now() * 1000000);
-                }
-                const fs = getFs(this);
-                fs.futimesSync(fileDescriptor.fd, Number(atim), Number(mtim));
-                return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.fd_pread = syscallWrap('fd_pread', function (fd, iovs, iovslen, offset, size) {
-                iovs = Number(iovs);
-                size = Number(size);
-                if (iovs === 0 || size === 0) {
-                    return 28 /* WasiErrno.EINVAL */;
-                }
-                const { HEAPU8, view } = getMemory(this);
-                const wasi = _wasi.get(this);
-                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_READ | WasiRights.FD_SEEK, BigInt(0));
-                let totalSize = 0;
-                const ioVecs = Array.from({ length: Number(iovslen) }, (_, i) => {
-                    const offset = iovs + (i * 8);
-                    const buf = view.getInt32(offset, true);
-                    const bufLen = view.getUint32(offset + 4, true);
-                    totalSize += bufLen;
-                    return HEAPU8.subarray(buf, buf + bufLen);
-                });
-                let nread = 0;
-                const buffer = new Uint8Array(totalSize);
-                buffer._isBuffer = true;
-                const fs = getFs(this);
-                const bytesRead = fs.readSync(fileDescriptor.fd, buffer, 0, buffer.length, Number(offset));
-                nread = buffer ? copyMemory(ioVecs, buffer.subarray(0, bytesRead)) : 0;
-                view.setUint32(size, nread, true);
-                return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.fd_prestat_get = syscallWrap('fd_prestat_get', function (fd, prestat) {
+            this.fd_prestat_get = syscallWrap(this, 'fd_prestat_get', function (fd, prestat) {
                 prestat = Number(prestat);
                 if (prestat === 0) {
                     return 28 /* WasiErrno.EINVAL */;
@@ -1245,7 +1251,7 @@
                 view.setUint32(prestat + 4, encoder.encode(fileDescriptor.path).length + 1, true);
                 return 0 /* WasiErrno.ESUCCESS */;
             });
-            this.fd_prestat_dir_name = syscallWrap('fd_prestat_dir_name', function (fd, path, path_len) {
+            this.fd_prestat_dir_name = syscallWrap(this, 'fd_prestat_dir_name', function (fd, path, path_len) {
                 path = Number(path);
                 path_len = Number(path_len);
                 if (path === 0) {
@@ -1263,64 +1269,7 @@
                 HEAPU8.set(buffer, path);
                 return 0 /* WasiErrno.ESUCCESS */;
             });
-            this.fd_pwrite = syscallWrap('fd_pwrite', function (fd, iovs, iovslen, offset, size) {
-                iovs = Number(iovs);
-                size = Number(size);
-                if (iovs === 0 || size === 0) {
-                    return 28 /* WasiErrno.EINVAL */;
-                }
-                const { HEAPU8, view } = getMemory(this);
-                const wasi = _wasi.get(this);
-                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_WRITE | WasiRights.FD_SEEK, BigInt(0));
-                const buffer = concatBuffer(Array.from({ length: Number(iovslen) }, (_, i) => {
-                    const offset = iovs + (i * 8);
-                    const buf = view.getInt32(offset, true);
-                    const bufLen = view.getUint32(offset + 4, true);
-                    return HEAPU8.subarray(buf, buf + bufLen);
-                }));
-                const fs = getFs(this);
-                const nwritten = fs.writeSync(fileDescriptor.fd, buffer, 0, buffer.length, Number(offset));
-                view.setUint32(size, nwritten, true);
-                return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.fd_read = syscallWrap('fd_read', function (fd, iovs, iovslen, size) {
-                iovs = Number(iovs);
-                size = Number(size);
-                if (iovs === 0 || size === 0) {
-                    return 28 /* WasiErrno.EINVAL */;
-                }
-                const { HEAPU8, view } = getMemory(this);
-                const wasi = _wasi.get(this);
-                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_READ, BigInt(0));
-                let totalSize = 0;
-                const ioVecs = Array.from({ length: Number(iovslen) }, (_, i) => {
-                    const offset = iovs + (i * 8);
-                    const buf = view.getInt32(offset, true);
-                    const bufLen = view.getUint32(offset + 4, true);
-                    totalSize += bufLen;
-                    return HEAPU8.subarray(buf, buf + bufLen);
-                });
-                let buffer;
-                let nread = 0;
-                if (fd === 0) {
-                    if (typeof window === 'undefined' || typeof window.prompt !== 'function') {
-                        return 58 /* WasiErrno.ENOTSUP */;
-                    }
-                    buffer = readStdin();
-                    nread = buffer ? copyMemory(ioVecs, buffer) : 0;
-                }
-                else {
-                    buffer = new Uint8Array(totalSize);
-                    buffer._isBuffer = true;
-                    const fs = getFs(this);
-                    const bytesRead = fs.readSync(fileDescriptor.fd, buffer, 0, buffer.length, Number(fileDescriptor.pos));
-                    nread = buffer ? copyMemory(ioVecs, buffer.subarray(0, bytesRead)) : 0;
-                    fileDescriptor.pos += BigInt(nread);
-                }
-                view.setUint32(size, nread, true);
-                return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.fd_seek = syscallWrap('fd_seek', function (fd, offset, whence, newOffset) {
+            this.fd_seek = syscallWrap(this, 'fd_seek', function (fd, offset, whence, newOffset) {
                 newOffset = Number(newOffset);
                 if (newOffset === 0) {
                     return 28 /* WasiErrno.EINVAL */;
@@ -1334,7 +1283,349 @@
                 view.setBigUint64(newOffset, r, true);
                 return 0 /* WasiErrno.ESUCCESS */;
             });
-            this.fd_readdir = syscallWrap('fd_readdir', function (fd, buf, buf_len, cookie, bufused) {
+            this.fd_tell = syscallWrap(this, 'fd_tell', function (fd, offset) {
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_TELL, BigInt(0));
+                const pos = BigInt(fileDescriptor.pos);
+                const { view } = getMemory(this);
+                view.setBigUint64(Number(offset), pos, true);
+                return 0 /* WasiErrno.ESUCCESS */;
+            });
+            this.poll_oneoff = syscallWrap(this, 'poll_oneoff', function (_in, _out, _sub, _nevents) {
+                return 52 /* WasiErrno.ENOSYS */;
+            });
+            this.proc_exit = syscallWrap(this, 'proc_exit', function (_rval) {
+                return 0 /* WasiErrno.ESUCCESS */;
+            });
+            this.proc_raise = syscallWrap(this, 'proc_raise', function (_sig) {
+                return 52 /* WasiErrno.ENOSYS */;
+            });
+            this.sched_yield = syscallWrap(this, 'sched_yield', function () {
+                return 0 /* WasiErrno.ESUCCESS */;
+            });
+            this.random_get = typeof crypto !== 'undefined' && typeof crypto.getRandomValues === 'function'
+                ? syscallWrap(this, 'random_get', function (buf, buf_len) {
+                    buf = Number(buf);
+                    if (buf === 0) {
+                        return 28 /* WasiErrno.EINVAL */;
+                    }
+                    buf_len = Number(buf_len);
+                    const { HEAPU8 } = getMemory(this);
+                    let pos;
+                    const stride = 65536;
+                    for (pos = 0; pos + stride < buf_len; pos += stride) {
+                        crypto.getRandomValues(HEAPU8.subarray(buf + pos, buf + pos + stride));
+                    }
+                    crypto.getRandomValues(HEAPU8.subarray(buf + pos, buf + buf_len));
+                    return 0 /* WasiErrno.ESUCCESS */;
+                })
+                : syscallWrap(this, 'random_get', function (buf, buf_len) {
+                    buf = Number(buf);
+                    if (buf === 0) {
+                        return 28 /* WasiErrno.EINVAL */;
+                    }
+                    buf_len = Number(buf_len);
+                    const { view } = getMemory(this);
+                    for (let i = buf; i < buf + buf_len; ++i) {
+                        view.setUint8(i, Math.floor(Math.random() * 256));
+                    }
+                    return 0 /* WasiErrno.ESUCCESS */;
+                });
+            this.sock_recv = syscallWrap(this, 'sock_recv', function () {
+                return 58 /* WasiErrno.ENOTSUP */;
+            });
+            this.sock_send = syscallWrap(this, 'sock_send', function () {
+                return 58 /* WasiErrno.ENOTSUP */;
+            });
+            this.sock_shutdown = syscallWrap(this, 'sock_shutdown', function () {
+                return 58 /* WasiErrno.ENOTSUP */;
+            });
+            _wasi.set(this, {
+                fds,
+                args,
+                env
+            });
+            if (fs)
+                _fs.set(this, fs);
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const _this = this;
+            function defineImport(name, syncVersion, asyncVersion, parameterType, returnType) {
+                if (asyncFs) {
+                    if (asyncify) {
+                        _this[name] = asyncify.wrapImportFunction(syscallWrap(_this, name, asyncVersion));
+                    }
+                    else {
+                        _this[name] = wrapAsyncImport(syscallWrap(_this, name, asyncVersion), parameterType, returnType);
+                    }
+                }
+                else {
+                    _this[name] = syscallWrap(_this, name, syncVersion);
+                }
+            }
+            defineImport('fd_allocate', function fd_allocate(fd, offset, len) {
+                const wasi = _wasi.get(this);
+                const fs = getFs(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_ALLOCATE, BigInt(0));
+                const stat = fs.fstatSync(fileDescriptor.fd, { bigint: true });
+                if (stat.size < offset + len) {
+                    fs.ftruncateSync(fileDescriptor.fd, Number(offset + len));
+                }
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, async function fd_allocate(fd, offset, len) {
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_ALLOCATE, BigInt(0));
+                const h = fileDescriptor.fd;
+                const stat = await h.stat({ bigint: true });
+                if (stat.size < offset + len) {
+                    await h.truncate(Number(offset + len));
+                }
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, ['i32', 'i64', 'f64'], ['i32']);
+            defineImport('fd_close', function fd_close(fd) {
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, BigInt(0), BigInt(0));
+                const fs = getFs(this);
+                fs.closeSync(fileDescriptor.fd);
+                wasi.fds.remove(fd);
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, async function fd_close(fd) {
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, BigInt(0), BigInt(0));
+                await fileDescriptor.fd.close();
+                wasi.fds.remove(fd);
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, ['i32'], ['i32']);
+            defineImport('fd_datasync', function fd_datasync(fd) {
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_DATASYNC, BigInt(0));
+                const fs = getFs(this);
+                fs.fdatasyncSync(fileDescriptor.fd);
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, async function fd_datasync(fd) {
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_DATASYNC, BigInt(0));
+                await fileDescriptor.fd.datasync();
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, ['i32'], ['i32']);
+            defineImport('fd_filestat_get', function fd_filestat_get(fd, buf) {
+                buf = Number(buf);
+                if (buf === 0)
+                    return 28 /* WasiErrno.EINVAL */;
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_FILESTAT_GET, BigInt(0));
+                const fs = getFs(this);
+                const stat = fs.fstatSync(fileDescriptor.fd, { bigint: true });
+                const { view } = getMemory(this);
+                toFileStat(view, buf, stat);
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, async function fd_filestat_get(fd, buf) {
+                buf = Number(buf);
+                if (buf === 0)
+                    return 28 /* WasiErrno.EINVAL */;
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_FILESTAT_GET, BigInt(0));
+                const h = fileDescriptor.fd;
+                const stat = await h.stat({ bigint: true });
+                const { view } = getMemory(this);
+                toFileStat(view, buf, stat);
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, ['i32', 'i32'], ['i32']);
+            defineImport('fd_filestat_set_size', function fd_filestat_set_size(fd, size) {
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_FILESTAT_SET_SIZE, BigInt(0));
+                const fs = getFs(this);
+                fs.ftruncateSync(fileDescriptor.fd, Number(size));
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, async function fd_filestat_set_size(fd, size) {
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_FILESTAT_SET_SIZE, BigInt(0));
+                const h = fileDescriptor.fd;
+                await h.truncate(Number(size));
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, ['i32', 'i64'], ['i32']);
+            function fdFilestatGetTimes(fd, atim, mtim, flags) {
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_FILESTAT_SET_TIMES, BigInt(0));
+                if ((flags & 2 /* WasiFstFlag.SET_ATIM_NOW */) === 2 /* WasiFstFlag.SET_ATIM_NOW */) {
+                    atim = BigInt(Date.now() * 1000000);
+                }
+                if ((flags & 8 /* WasiFstFlag.SET_MTIM_NOW */) === 8 /* WasiFstFlag.SET_MTIM_NOW */) {
+                    mtim = BigInt(Date.now() * 1000000);
+                }
+                return { fileDescriptor, atim, mtim };
+            }
+            defineImport('fd_filestat_set_times', function fd_filestat_set_times(fd, atim, mtim, flags) {
+                const { fileDescriptor, atim: atimRes, mtim: mtimRes } = fdFilestatGetTimes.call(this, fd, atim, mtim, flags);
+                const fs = getFs(this);
+                fs.futimesSync(fileDescriptor.fd, Number(atimRes), Number(mtimRes));
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, async function fd_filestat_set_times(fd, atim, mtim, flags) {
+                const { fileDescriptor, atim: atimRes, mtim: mtimRes } = fdFilestatGetTimes.call(this, fd, atim, mtim, flags);
+                const h = fileDescriptor.fd;
+                await h.utimes(Number(atimRes), Number(mtimRes));
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, ['i32', 'i64', 'i64', 'i32'], ['i32']);
+            defineImport('fd_pread', function fd_pread(fd, iovs, iovslen, offset, size) {
+                iovs = Number(iovs);
+                size = Number(size);
+                if (iovs === 0 || size === 0) {
+                    return 28 /* WasiErrno.EINVAL */;
+                }
+                const { HEAPU8, view } = getMemory(this);
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_READ | WasiRights.FD_SEEK, BigInt(0));
+                let totalSize = 0;
+                const ioVecs = Array.from({ length: Number(iovslen) }, (_, i) => {
+                    const offset = iovs + (i * 8);
+                    const buf = view.getInt32(offset, true);
+                    const bufLen = view.getUint32(offset + 4, true);
+                    totalSize += bufLen;
+                    return HEAPU8.subarray(buf, buf + bufLen);
+                });
+                let nread = 0;
+                const buffer = new Uint8Array(totalSize);
+                buffer._isBuffer = true;
+                const fs = getFs(this);
+                const bytesRead = fs.readSync(fileDescriptor.fd, buffer, 0, buffer.length, Number(offset));
+                nread = buffer ? copyMemory(ioVecs, buffer.subarray(0, bytesRead)) : 0;
+                view.setUint32(size, nread, true);
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, async function (fd, iovs, iovslen, offset, size) {
+                iovs = Number(iovs);
+                size = Number(size);
+                if (iovs === 0 || size === 0) {
+                    return 28 /* WasiErrno.EINVAL */;
+                }
+                const { HEAPU8, view } = getMemory(this);
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_READ | WasiRights.FD_SEEK, BigInt(0));
+                let totalSize = 0;
+                const ioVecs = Array.from({ length: Number(iovslen) }, (_, i) => {
+                    const offset = iovs + (i * 8);
+                    const buf = view.getInt32(offset, true);
+                    const bufLen = view.getUint32(offset + 4, true);
+                    totalSize += bufLen;
+                    return HEAPU8.subarray(buf, buf + bufLen);
+                });
+                let nread = 0;
+                const buffer = new Uint8Array(totalSize);
+                buffer._isBuffer = true;
+                const { bytesRead } = await fileDescriptor.fd.read(buffer, 0, buffer.length, Number(offset));
+                nread = buffer ? copyMemory(ioVecs, buffer.subarray(0, bytesRead)) : 0;
+                view.setUint32(size, nread, true);
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, ['i32', 'i32', 'i32', 'i64', 'i32'], ['i32']);
+            defineImport('fd_pwrite', function fd_pwrite(fd, iovs, iovslen, offset, size) {
+                iovs = Number(iovs);
+                size = Number(size);
+                if (iovs === 0 || size === 0) {
+                    return 28 /* WasiErrno.EINVAL */;
+                }
+                const { HEAPU8, view } = getMemory(this);
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_WRITE | WasiRights.FD_SEEK, BigInt(0));
+                const buffer = concatBuffer(Array.from({ length: Number(iovslen) }, (_, i) => {
+                    const offset = iovs + (i * 8);
+                    const buf = view.getInt32(offset, true);
+                    const bufLen = view.getUint32(offset + 4, true);
+                    return HEAPU8.subarray(buf, buf + bufLen);
+                }));
+                const fs = getFs(this);
+                const nwritten = fs.writeSync(fileDescriptor.fd, buffer, 0, buffer.length, Number(offset));
+                view.setUint32(size, nwritten, true);
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, async function fd_pwrite(fd, iovs, iovslen, offset, size) {
+                iovs = Number(iovs);
+                size = Number(size);
+                if (iovs === 0 || size === 0) {
+                    return 28 /* WasiErrno.EINVAL */;
+                }
+                const { HEAPU8, view } = getMemory(this);
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_WRITE | WasiRights.FD_SEEK, BigInt(0));
+                const buffer = concatBuffer(Array.from({ length: Number(iovslen) }, (_, i) => {
+                    const offset = iovs + (i * 8);
+                    const buf = view.getInt32(offset, true);
+                    const bufLen = view.getUint32(offset + 4, true);
+                    return HEAPU8.subarray(buf, buf + bufLen);
+                }));
+                const { bytesWritten } = await fileDescriptor.fd.write(buffer, 0, buffer.length, Number(offset));
+                view.setUint32(size, bytesWritten, true);
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, ['i32', 'i32', 'i32', 'i64', 'i32'], ['i32']);
+            defineImport('fd_read', function fd_read(fd, iovs, iovslen, size) {
+                iovs = Number(iovs);
+                size = Number(size);
+                if (iovs === 0 || size === 0) {
+                    return 28 /* WasiErrno.EINVAL */;
+                }
+                const { HEAPU8, view } = getMemory(this);
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_READ, BigInt(0));
+                let totalSize = 0;
+                const ioVecs = Array.from({ length: Number(iovslen) }, (_, i) => {
+                    const offset = iovs + (i * 8);
+                    const buf = view.getInt32(offset, true);
+                    const bufLen = view.getUint32(offset + 4, true);
+                    totalSize += bufLen;
+                    return HEAPU8.subarray(buf, buf + bufLen);
+                });
+                let buffer;
+                let nread = 0;
+                if (fd === 0) {
+                    if (typeof window === 'undefined' || typeof window.prompt !== 'function') {
+                        return 58 /* WasiErrno.ENOTSUP */;
+                    }
+                    buffer = readStdin();
+                    nread = buffer ? copyMemory(ioVecs, buffer) : 0;
+                }
+                else {
+                    buffer = new Uint8Array(totalSize);
+                    buffer._isBuffer = true;
+                    const fs = getFs(this);
+                    const bytesRead = fs.readSync(fileDescriptor.fd, buffer, 0, buffer.length, Number(fileDescriptor.pos));
+                    nread = buffer ? copyMemory(ioVecs, buffer.subarray(0, bytesRead)) : 0;
+                    fileDescriptor.pos += BigInt(nread);
+                }
+                view.setUint32(size, nread, true);
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, async function fd_read(fd, iovs, iovslen, size) {
+                iovs = Number(iovs);
+                size = Number(size);
+                if (iovs === 0 || size === 0) {
+                    return 28 /* WasiErrno.EINVAL */;
+                }
+                const { HEAPU8, view } = getMemory(this);
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_READ, BigInt(0));
+                let totalSize = 0;
+                const ioVecs = Array.from({ length: Number(iovslen) }, (_, i) => {
+                    const offset = iovs + (i * 8);
+                    const buf = view.getInt32(offset, true);
+                    const bufLen = view.getUint32(offset + 4, true);
+                    totalSize += bufLen;
+                    return HEAPU8.subarray(buf, buf + bufLen);
+                });
+                let buffer;
+                let nread = 0;
+                if (fd === 0) {
+                    if (typeof window === 'undefined' || typeof window.prompt !== 'function') {
+                        return 58 /* WasiErrno.ENOTSUP */;
+                    }
+                    buffer = readStdin();
+                    nread = buffer ? copyMemory(ioVecs, buffer) : 0;
+                }
+                else {
+                    buffer = new Uint8Array(totalSize);
+                    buffer._isBuffer = true;
+                    const { bytesRead } = await fileDescriptor.fd.read(buffer, 0, buffer.length, Number(fileDescriptor.pos));
+                    nread = buffer ? copyMemory(ioVecs, buffer.subarray(0, bytesRead)) : 0;
+                    fileDescriptor.pos += BigInt(nread);
+                }
+                view.setUint32(size, nread, true);
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, ['i32', 'i32', 'i32', 'i32'], ['i32']);
+            defineImport('fd_readdir', function fd_readdir(fd, buf, buf_len, cookie, bufused) {
                 buf = Number(buf);
                 buf_len = Number(buf_len);
                 bufused = Number(bufused);
@@ -1384,28 +1675,79 @@
                 }
                 view.setUint32(bufused, bufferUsed, true);
                 return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.fd_renumber = syscallWrap('fd_renumber', function (from, to) {
+            }, async function fd_readdir(fd, buf, buf_len, cookie, bufused) {
+                buf = Number(buf);
+                buf_len = Number(buf_len);
+                bufused = Number(bufused);
+                if (buf === 0 || bufused === 0)
+                    return 0 /* WasiErrno.ESUCCESS */;
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_READDIR, BigInt(0));
+                const fs = getFs(this);
+                const entries = await fs.promises.readdir(fileDescriptor.realPath, { withFileTypes: true });
+                const { HEAPU8, view } = getMemory(this);
+                let bufferUsed = 0;
+                for (let i = Number(cookie); i < entries.length; i++) {
+                    const nameData = encoder.encode(entries[i].name);
+                    const entryInfo = await fs.promises.stat(resolve(fileDescriptor.realPath, entries[i].name), { bigint: true });
+                    const entryData = new Uint8Array(24 + nameData.byteLength);
+                    const entryView = new DataView(entryData.buffer);
+                    entryView.setBigUint64(0, BigInt(i + 1), true);
+                    entryView.setBigUint64(8, BigInt(entryInfo.ino ? entryInfo.ino : 0), true);
+                    entryView.setUint32(16, nameData.byteLength, true);
+                    let type;
+                    if (entries[i].isFile()) {
+                        type = 4 /* WasiFileType.REGULAR_FILE */;
+                    }
+                    else if (entries[i].isDirectory()) {
+                        type = 3 /* WasiFileType.DIRECTORY */;
+                    }
+                    else if (entries[i].isSymbolicLink()) {
+                        type = 7 /* WasiFileType.SYMBOLIC_LINK */;
+                    }
+                    else if (entries[i].isCharacterDevice()) {
+                        type = 2 /* WasiFileType.CHARACTER_DEVICE */;
+                    }
+                    else if (entries[i].isBlockDevice()) {
+                        type = 1 /* WasiFileType.BLOCK_DEVICE */;
+                    }
+                    else if (entries[i].isSocket()) {
+                        type = 6 /* WasiFileType.SOCKET_STREAM */;
+                    }
+                    else {
+                        type = 0 /* WasiFileType.UNKNOWN */;
+                    }
+                    entryView.setUint8(20, type);
+                    entryData.set(nameData, 24);
+                    const data = entryData.slice(0, Math.min(entryData.length, buf_len - bufferUsed));
+                    HEAPU8.set(data, buf + bufferUsed);
+                    bufferUsed += data.byteLength;
+                }
+                view.setUint32(bufused, bufferUsed, true);
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, ['i32', 'i32', 'i32', 'i64', 'i32'], ['i32']);
+            defineImport('fd_renumber', function fd_renumber(from, to) {
                 const wasi = _wasi.get(this);
                 wasi.fds.renumber(to, from);
                 return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.fd_sync = syscallWrap('fd_sync', function (fd) {
+            }, async function fd_renumber(from, to) {
+                const wasi = _wasi.get(this);
+                await wasi.fds.renumber(to, from);
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, ['i32', 'i32'], ['i32']);
+            defineImport('fd_sync', function fd_sync(fd) {
                 const wasi = _wasi.get(this);
                 const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_SYNC, BigInt(0));
                 const fs = getFs(this);
                 fs.fsyncSync(fileDescriptor.fd);
                 return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.fd_tell = syscallWrap('fd_tell', function (fd, offset) {
+            }, async function fd_sync(fd) {
                 const wasi = _wasi.get(this);
-                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_TELL, BigInt(0));
-                const pos = BigInt(fileDescriptor.pos);
-                const { view } = getMemory(this);
-                view.setBigUint64(Number(offset), pos, true);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_SYNC, BigInt(0));
+                await fileDescriptor.fd.sync();
                 return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.fd_write = syscallWrap('fd_write', function (fd, iovs, iovslen, size) {
+            }, ['i32'], ['i32']);
+            defineImport('fd_write', function fd_write(fd, iovs, iovslen, size) {
                 iovs = Number(iovs);
                 size = Number(size);
                 if (iovs === 0 || size === 0) {
@@ -1431,8 +1773,33 @@
                 }
                 view.setUint32(size, nwritten, true);
                 return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.path_create_directory = syscallWrap('path_create_directory', function (fd, path, path_len) {
+            }, async function fd_write(fd, iovs, iovslen, size) {
+                iovs = Number(iovs);
+                size = Number(size);
+                if (iovs === 0 || size === 0) {
+                    return 28 /* WasiErrno.EINVAL */;
+                }
+                const { HEAPU8, view } = getMemory(this);
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_WRITE, BigInt(0));
+                const buffer = concatBuffer(Array.from({ length: Number(iovslen) }, (_, i) => {
+                    const offset = iovs + (i * 8);
+                    const buf = view.getInt32(offset, true);
+                    const bufLen = view.getUint32(offset + 4, true);
+                    return HEAPU8.subarray(buf, buf + bufLen);
+                }));
+                let nwritten;
+                if (fd === 1 || fd === 2) {
+                    nwritten = fileDescriptor.write(buffer);
+                }
+                else {
+                    nwritten = await (await (fileDescriptor.fd.write(buffer, 0, buffer.length, Number(fileDescriptor.pos)))).bytesWritten;
+                    fileDescriptor.pos += BigInt(nwritten);
+                }
+                view.setUint32(size, nwritten, true);
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, ['i32', 'i32', 'i32', 'i32'], ['i32']);
+            defineImport('path_create_directory', function path_create_directory(fd, path, path_len) {
                 path = Number(path);
                 path_len = Number(path_len);
                 if (path === 0) {
@@ -1446,8 +1813,22 @@
                 const fs = getFs(this);
                 fs.mkdirSync(pathString);
                 return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.path_filestat_get = syscallWrap('path_filestat_get', function (fd, flags, path, path_len, filestat) {
+            }, async function path_create_directory(fd, path, path_len) {
+                path = Number(path);
+                path_len = Number(path_len);
+                if (path === 0) {
+                    return 28 /* WasiErrno.EINVAL */;
+                }
+                const { HEAPU8 } = getMemory(this);
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_CREATE_DIRECTORY, BigInt(0));
+                let pathString = decoder.decode(HEAPU8.subarray(path, path + path_len));
+                pathString = resolve(fileDescriptor.realPath, pathString);
+                const fs = getFs(this);
+                await fs.promises.mkdir(pathString);
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, ['i32', 'i32', 'i32'], ['i32']);
+            defineImport('path_filestat_get', function path_filestat_get(fd, flags, path, path_len, filestat) {
                 path = Number(path);
                 path_len = Number(path_len);
                 filestat = Number(filestat);
@@ -1469,8 +1850,30 @@
                 }
                 toFileStat(view, filestat, stat);
                 return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.path_filestat_set_times = syscallWrap('path_filestat_set_times', function (fd, flags, path, path_len, atim, mtim, fst_flags) {
+            }, async function path_filestat_get(fd, flags, path, path_len, filestat) {
+                path = Number(path);
+                path_len = Number(path_len);
+                filestat = Number(filestat);
+                if (path === 0 || filestat === 0) {
+                    return 28 /* WasiErrno.EINVAL */;
+                }
+                const { HEAPU8, view } = getMemory(this);
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_FILESTAT_GET, BigInt(0));
+                let pathString = decoder.decode(HEAPU8.subarray(path, path + path_len));
+                const fs = getFs(this);
+                pathString = resolve(fileDescriptor.realPath, pathString);
+                let stat;
+                if ((flags & 1) === 1) {
+                    stat = await fs.promises.stat(pathString, { bigint: true });
+                }
+                else {
+                    stat = await fs.promises.lstat(pathString, { bigint: true });
+                }
+                toFileStat(view, filestat, stat);
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, ['i32', 'i32', 'i32', 'i32', 'i32'], ['i32']);
+            defineImport('path_filestat_set_times', function path_filestat_set_times(fd, flags, path, path_len, atim, mtim, fst_flags) {
                 path = Number(path);
                 path_len = Number(path_len);
                 if (path === 0)
@@ -1485,7 +1888,7 @@
                 const wasi = _wasi.get(this);
                 const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_FILESTAT_SET_TIMES, BigInt(0));
                 const fs = getFs(this);
-                const resolvedPath = resolvePath(fs, fileDescriptor, decoder.decode(HEAPU8.subarray(path, path + path_len)), flags);
+                const resolvedPath = resolvePathSync(fs, fileDescriptor, decoder.decode(HEAPU8.subarray(path, path + path_len)), flags);
                 if ((fst_flags & 2 /* WasiFstFlag.SET_ATIM_NOW */) === 2 /* WasiFstFlag.SET_ATIM_NOW */) {
                     atim = BigInt(Date.now() * 1000000);
                 }
@@ -1494,8 +1897,32 @@
                 }
                 fs.utimesSync(resolvedPath, Number(atim), Number(mtim));
                 return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.path_link = syscallWrap('path_link', function (old_fd, old_flags, old_path, old_path_len, new_fd, new_path, new_path_len) {
+            }, async function path_filestat_set_times(fd, flags, path, path_len, atim, mtim, fst_flags) {
+                path = Number(path);
+                path_len = Number(path_len);
+                if (path === 0)
+                    return 28 /* WasiErrno.EINVAL */;
+                if ((fst_flags) & ~(1 /* WasiFstFlag.SET_ATIM */ |
+                    2 /* WasiFstFlag.SET_ATIM_NOW */ |
+                    4 /* WasiFstFlag.SET_MTIM */ |
+                    8 /* WasiFstFlag.SET_MTIM_NOW */)) {
+                    return 28 /* WasiErrno.EINVAL */;
+                }
+                const { HEAPU8 } = getMemory(this);
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_FILESTAT_SET_TIMES, BigInt(0));
+                const fs = getFs(this);
+                const resolvedPath = await resolvePathAsync(fs, fileDescriptor, decoder.decode(HEAPU8.subarray(path, path + path_len)), flags);
+                if ((fst_flags & 2 /* WasiFstFlag.SET_ATIM_NOW */) === 2 /* WasiFstFlag.SET_ATIM_NOW */) {
+                    atim = BigInt(Date.now() * 1000000);
+                }
+                if ((fst_flags & 8 /* WasiFstFlag.SET_MTIM_NOW */) === 8 /* WasiFstFlag.SET_MTIM_NOW */) {
+                    mtim = BigInt(Date.now() * 1000000);
+                }
+                await fs.promises.utimes(resolvedPath, Number(atim), Number(mtim));
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, ['i32', 'i32', 'i32', 'i32', 'i64', 'i64', 'i32'], ['i32']);
+            defineImport('path_link', function path_link(old_fd, old_flags, old_path, old_path_len, new_fd, new_path, new_path_len) {
                 old_path = Number(old_path);
                 old_path_len = Number(old_path_len);
                 new_path = Number(new_path);
@@ -1515,20 +1942,36 @@
                 }
                 const { HEAPU8 } = getMemory(this);
                 const fs = getFs(this);
-                const resolvedOldPath = resolvePath(fs, oldWrap, decoder.decode(HEAPU8.subarray(old_path, old_path + old_path_len)), old_flags);
+                const resolvedOldPath = resolvePathSync(fs, oldWrap, decoder.decode(HEAPU8.subarray(old_path, old_path + old_path_len)), old_flags);
                 const resolvedNewPath = resolve(newWrap.realPath, decoder.decode(HEAPU8.subarray(new_path, new_path + new_path_len)));
                 fs.linkSync(resolvedOldPath, resolvedNewPath);
                 return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.path_open = syscallWrap('path_open', function (dirfd, dirflags, path, path_len, o_flags, fs_rights_base, fs_rights_inheriting, fs_flags, fd) {
-                path = Number(path);
-                fd = Number(fd);
-                if (path === 0 || fd === 0) {
+            }, async function path_link(old_fd, old_flags, old_path, old_path_len, new_fd, new_path, new_path_len) {
+                old_path = Number(old_path);
+                old_path_len = Number(old_path_len);
+                new_path = Number(new_path);
+                new_path_len = Number(new_path_len);
+                if (old_path === 0 || new_path === 0) {
                     return 28 /* WasiErrno.EINVAL */;
                 }
-                path_len = Number(path_len);
-                fs_rights_base = BigInt(fs_rights_base);
-                fs_rights_base = BigInt(fs_rights_base);
+                const wasi = _wasi.get(this);
+                let oldWrap;
+                let newWrap;
+                if (old_fd === new_fd) {
+                    oldWrap = newWrap = wasi.fds.get(old_fd, WasiRights.PATH_LINK_SOURCE | WasiRights.PATH_LINK_TARGET, BigInt(0));
+                }
+                else {
+                    oldWrap = wasi.fds.get(old_fd, WasiRights.PATH_LINK_SOURCE, BigInt(0));
+                    newWrap = wasi.fds.get(new_fd, WasiRights.PATH_LINK_TARGET, BigInt(0));
+                }
+                const { HEAPU8 } = getMemory(this);
+                const fs = getFs(this);
+                const resolvedOldPath = await resolvePathAsync(fs, oldWrap, decoder.decode(HEAPU8.subarray(old_path, old_path + old_path_len)), old_flags);
+                const resolvedNewPath = resolve(newWrap.realPath, decoder.decode(HEAPU8.subarray(new_path, new_path + new_path_len)));
+                await fs.promises.link(resolvedOldPath, resolvedNewPath);
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, ['i32', 'i32', 'i32', 'i32', 'i32', 'i32', 'i32'], ['i32']);
+            function pathOpen(o_flags, fs_rights_base, fs_rights_inheriting, fs_flags) {
                 const read = (fs_rights_base & (WasiRights.FD_READ |
                     WasiRights.FD_READDIR)) !== BigInt(0);
                 const write = (fs_rights_base & (WasiRights.FD_DATASYNC |
@@ -1573,32 +2016,78 @@
                 if (write && (flags & (1024 /* FileControlFlag.O_APPEND */ | 512 /* FileControlFlag.O_TRUNC */)) === 0) {
                     needed_inheriting |= WasiRights.FD_SEEK;
                 }
+                return { flags, needed_base, needed_inheriting };
+            }
+            defineImport('path_open', function path_open(dirfd, dirflags, path, path_len, o_flags, fs_rights_base, fs_rights_inheriting, fs_flags, fd) {
+                path = Number(path);
+                fd = Number(fd);
+                if (path === 0 || fd === 0) {
+                    return 28 /* WasiErrno.EINVAL */;
+                }
+                path_len = Number(path_len);
+                fs_rights_base = BigInt(fs_rights_base);
+                fs_rights_inheriting = BigInt(fs_rights_inheriting);
+                const { flags: flagsRes, needed_base: neededBase, needed_inheriting: neededInheriting } = pathOpen(o_flags, fs_rights_base, fs_rights_inheriting, fs_flags);
                 const wasi = _wasi.get(this);
-                const fileDescriptor = wasi.fds.get(dirfd, needed_base, needed_inheriting);
+                const fileDescriptor = wasi.fds.get(dirfd, neededBase, neededInheriting);
                 const memory = getMemory(this);
                 const HEAPU8 = memory.HEAPU8;
                 const pathString = decoder.decode(HEAPU8.subarray(path, path + path_len));
                 const fs = getFs(this);
-                const resolved_path = resolvePath(fs, fileDescriptor, pathString, dirflags);
-                const r = fs.openSync(resolved_path, flags, 0o666);
+                const resolved_path = resolvePathSync(fs, fileDescriptor, pathString, dirflags);
+                const r = fs.openSync(resolved_path, flagsRes, 0o666);
                 const filetype = wasi.fds.getFileTypeByFd(r);
                 if ((o_flags & 2 /* WasiFileControlFlag.O_DIRECTORY */) !== 0 && filetype !== 3 /* WasiFileType.DIRECTORY */) {
                     return 54 /* WasiErrno.ENOTDIR */;
                 }
-                const { base: max_base, inheriting: max_inheriting } = getRights(wasi.fds.stdio, r, flags, filetype);
+                const { base: max_base, inheriting: max_inheriting } = getRights(wasi.fds.stdio, r, flagsRes, filetype);
                 const wrap = wasi.fds.insert(r, resolved_path, resolved_path, filetype, fs_rights_base & max_base, fs_rights_inheriting & max_inheriting, 0);
                 const stat = fs.fstatSync(r, { bigint: true });
                 if (stat.isFile()) {
                     wrap.size = stat.size;
-                    if ((flags & 1024 /* FileControlFlag.O_APPEND */) !== 0) {
+                    if ((flagsRes & 1024 /* FileControlFlag.O_APPEND */) !== 0) {
                         wrap.pos = stat.size;
                     }
                 }
                 const view = memory.view;
                 view.setInt32(fd, wrap.id, true);
                 return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.path_readlink = syscallWrap('path_readlink', function (fd, path, path_len, buf, buf_len, bufused) {
+            }, async function path_open(dirfd, dirflags, path, path_len, o_flags, fs_rights_base, fs_rights_inheriting, fs_flags, fd) {
+                path = Number(path);
+                fd = Number(fd);
+                if (path === 0 || fd === 0) {
+                    return 28 /* WasiErrno.EINVAL */;
+                }
+                path_len = Number(path_len);
+                fs_rights_base = BigInt(fs_rights_base);
+                fs_rights_inheriting = BigInt(fs_rights_inheriting);
+                const { flags: flagsRes, needed_base: neededBase, needed_inheriting: neededInheriting } = pathOpen(o_flags, fs_rights_base, fs_rights_inheriting, fs_flags);
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(dirfd, neededBase, neededInheriting);
+                const memory = getMemory(this);
+                const HEAPU8 = memory.HEAPU8;
+                const pathString = decoder.decode(HEAPU8.subarray(path, path + path_len));
+                const fs = getFs(this);
+                const resolved_path = await resolvePathAsync(fs, fileDescriptor, pathString, dirflags);
+                const r = await fs.promises.open(resolved_path, flagsRes, 0o666);
+                const filetype = await wasi.fds.getFileTypeByFd(r);
+                if ((o_flags & 2 /* WasiFileControlFlag.O_DIRECTORY */) !== 0 && filetype !== 3 /* WasiFileType.DIRECTORY */) {
+                    return 54 /* WasiErrno.ENOTDIR */;
+                }
+                const { base: max_base, inheriting: max_inheriting } = getRights(wasi.fds.stdio, r.fd, flagsRes, filetype);
+                const wrap = wasi.fds.insert(r, resolved_path, resolved_path, filetype, fs_rights_base & max_base, fs_rights_inheriting & max_inheriting, 0);
+                const stat = await r.stat({ bigint: true });
+                if (stat.isFile()) {
+                    wrap.size = stat.size;
+                    if ((flagsRes & 1024 /* FileControlFlag.O_APPEND */) !== 0) {
+                        wrap.pos = stat.size;
+                    }
+                }
+                const view = memory.view;
+                view.setInt32(fd, wrap.id, true);
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, ['i32', 'i32', 'i32', 'i32', 'i32', 'i64', 'i64', 'i32', 'i32'], ['i32']);
+            defineImport('path_readlink', function path_readlink(fd, path, path_len, buf, buf_len, bufused) {
                 path = Number(path);
                 path_len = Number(path_len);
                 buf = Number(buf);
@@ -1622,8 +2111,32 @@
                 HEAPU8[buf + len] = 0;
                 view.setUint32(bufused, len + 1, true);
                 return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.path_remove_directory = syscallWrap('path_remove_directory', function (fd, path, path_len) {
+            }, async function path_readlink(fd, path, path_len, buf, buf_len, bufused) {
+                path = Number(path);
+                path_len = Number(path_len);
+                buf = Number(buf);
+                buf_len = Number(buf_len);
+                bufused = Number(bufused);
+                if (path === 0 || buf === 0 || bufused === 0) {
+                    return 28 /* WasiErrno.EINVAL */;
+                }
+                const { HEAPU8, view } = getMemory(this);
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_READLINK, BigInt(0));
+                let pathString = decoder.decode(HEAPU8.subarray(path, path + path_len));
+                pathString = resolve(fileDescriptor.realPath, pathString);
+                const fs = getFs(this);
+                const link = await fs.promises.readlink(pathString);
+                const linkData = encoder.encode(link);
+                const len = Math.min(linkData.length, buf_len);
+                if (len >= buf_len)
+                    return 42 /* WasiErrno.ENOBUFS */;
+                HEAPU8.set(linkData.subarray(0, len), buf);
+                HEAPU8[buf + len] = 0;
+                view.setUint32(bufused, len + 1, true);
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, ['i32', 'i32', 'i32', 'i32', 'i32', 'i32'], ['i32']);
+            defineImport('path_remove_directory', function path_remove_directory(fd, path, path_len) {
                 path = Number(path);
                 path_len = Number(path_len);
                 if (path === 0) {
@@ -1637,8 +2150,22 @@
                 const fs = getFs(this);
                 fs.rmdirSync(pathString);
                 return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.path_rename = syscallWrap('path_rename', function (old_fd, old_path, old_path_len, new_fd, new_path, new_path_len) {
+            }, async function path_remove_directory(fd, path, path_len) {
+                path = Number(path);
+                path_len = Number(path_len);
+                if (path === 0) {
+                    return 28 /* WasiErrno.EINVAL */;
+                }
+                const { HEAPU8 } = getMemory(this);
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_REMOVE_DIRECTORY, BigInt(0));
+                let pathString = decoder.decode(HEAPU8.subarray(path, path + path_len));
+                pathString = resolve(fileDescriptor.realPath, pathString);
+                const fs = getFs(this);
+                await fs.promises.rmdir(pathString);
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, ['i32', 'i32', 'i32'], ['i32']);
+            defineImport('path_rename', function path_rename(old_fd, old_path, old_path_len, new_fd, new_path, new_path_len) {
                 old_path = Number(old_path);
                 old_path_len = Number(old_path_len);
                 new_path = Number(new_path);
@@ -1662,8 +2189,32 @@
                 const fs = getFs(this);
                 fs.renameSync(resolvedOldPath, resolvedNewPath);
                 return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.path_symlink = syscallWrap('path_symlink', function (old_path, old_path_len, fd, new_path, new_path_len) {
+            }, async function path_rename(old_fd, old_path, old_path_len, new_fd, new_path, new_path_len) {
+                old_path = Number(old_path);
+                old_path_len = Number(old_path_len);
+                new_path = Number(new_path);
+                new_path_len = Number(new_path_len);
+                if (old_path === 0 || new_path === 0) {
+                    return 28 /* WasiErrno.EINVAL */;
+                }
+                const wasi = _wasi.get(this);
+                let oldWrap;
+                let newWrap;
+                if (old_fd === new_fd) {
+                    oldWrap = newWrap = wasi.fds.get(old_fd, WasiRights.PATH_RENAME_SOURCE | WasiRights.PATH_RENAME_TARGET, BigInt(0));
+                }
+                else {
+                    oldWrap = wasi.fds.get(old_fd, WasiRights.PATH_RENAME_SOURCE, BigInt(0));
+                    newWrap = wasi.fds.get(new_fd, WasiRights.PATH_RENAME_TARGET, BigInt(0));
+                }
+                const { HEAPU8 } = getMemory(this);
+                const resolvedOldPath = resolve(oldWrap.realPath, decoder.decode(HEAPU8.subarray(old_path, old_path + old_path_len)));
+                const resolvedNewPath = resolve(newWrap.realPath, decoder.decode(HEAPU8.subarray(new_path, new_path + new_path_len)));
+                const fs = getFs(this);
+                await fs.promises.rename(resolvedOldPath, resolvedNewPath);
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, ['i32', 'i32', 'i32', 'i32', 'i32', 'i32'], ['i32']);
+            defineImport('path_symlink', function path_symlink(old_path, old_path_len, fd, new_path, new_path_len) {
                 old_path = Number(old_path);
                 old_path_len = Number(old_path_len);
                 new_path = Number(new_path);
@@ -1680,8 +2231,25 @@
                 const fs = getFs(this);
                 fs.symlinkSync(oldPath, newPath);
                 return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.path_unlink_file = syscallWrap('path_unlink_file', function (fd, path, path_len) {
+            }, async function path_symlink(old_path, old_path_len, fd, new_path, new_path_len) {
+                old_path = Number(old_path);
+                old_path_len = Number(old_path_len);
+                new_path = Number(new_path);
+                new_path_len = Number(new_path_len);
+                if (old_path === 0 || new_path === 0) {
+                    return 28 /* WasiErrno.EINVAL */;
+                }
+                const { HEAPU8 } = getMemory(this);
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_SYMLINK, BigInt(0));
+                const oldPath = decoder.decode(HEAPU8.subarray(old_path, old_path + old_path_len));
+                let newPath = decoder.decode(HEAPU8.subarray(new_path, new_path + new_path_len));
+                newPath = resolve(fileDescriptor.realPath, newPath);
+                const fs = getFs(this);
+                await fs.promises.symlink(oldPath, newPath);
+                return 0 /* WasiErrno.ESUCCESS */;
+            }, ['i32', 'i32', 'i32', 'i32', 'i32'], ['i32']);
+            defineImport('path_unlink_file', function path_unlink_file(fd, path, path_len) {
                 path = Number(path);
                 path_len = Number(path_len);
                 if (path === 0) {
@@ -1695,58 +2263,30 @@
                 const fs = getFs(this);
                 fs.unlinkSync(pathString);
                 return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.poll_oneoff = syscallWrap('poll_oneoff', function (_in, _out, _sub, _nevents) {
-                return 52 /* WasiErrno.ENOSYS */;
-            });
-            this.proc_exit = syscallWrap('proc_exit', function (_rval) {
-                return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.proc_raise = syscallWrap('proc_raise', function (_sig) {
-                return 52 /* WasiErrno.ENOSYS */;
-            });
-            this.sched_yield = syscallWrap('sched_yield', function () {
+            }, async function path_unlink_file(fd, path, path_len) {
+                path = Number(path);
+                path_len = Number(path_len);
+                if (path === 0) {
+                    return 28 /* WasiErrno.EINVAL */;
+                }
+                const { HEAPU8 } = getMemory(this);
+                const wasi = _wasi.get(this);
+                const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_UNLINK_FILE, BigInt(0));
+                let pathString = decoder.decode(HEAPU8.subarray(path, path + path_len));
+                pathString = resolve(fileDescriptor.realPath, pathString);
+                const fs = getFs(this);
+                await fs.promises.unlink(pathString);
                 return 0 /* WasiErrno.ESUCCESS */;
-            });
-            this.random_get = typeof crypto !== 'undefined' && typeof crypto.getRandomValues === 'function'
-                ? syscallWrap('random_get', function (buf, buf_len) {
-                    buf = Number(buf);
-                    if (buf === 0) {
-                        return 28 /* WasiErrno.EINVAL */;
-                    }
-                    buf_len = Number(buf_len);
-                    const { HEAPU8 } = getMemory(this);
-                    let pos;
-                    const stride = 65536;
-                    for (pos = 0; pos + stride < buf_len; pos += stride) {
-                        crypto.getRandomValues(HEAPU8.subarray(buf + pos, buf + pos + stride));
-                    }
-                    crypto.getRandomValues(HEAPU8.subarray(buf + pos, buf + buf_len));
-                    return 0 /* WasiErrno.ESUCCESS */;
-                })
-                : syscallWrap('random_get', function (buf, buf_len) {
-                    buf = Number(buf);
-                    if (buf === 0) {
-                        return 28 /* WasiErrno.EINVAL */;
-                    }
-                    buf_len = Number(buf_len);
-                    const { view } = getMemory(this);
-                    for (let i = buf; i < buf + buf_len; ++i) {
-                        view.setUint8(i, Math.floor(Math.random() * 256));
-                    }
-                    return 0 /* WasiErrno.ESUCCESS */;
-                });
-            this.sock_recv = syscallWrap('sock_recv', function () {
-                return 58 /* WasiErrno.ENOTSUP */;
-            });
-            this.sock_send = syscallWrap('sock_send', function () {
-                return 58 /* WasiErrno.ENOTSUP */;
-            });
-            this.sock_shutdown = syscallWrap('sock_shutdown', function () {
-                return 58 /* WasiErrno.ENOTSUP */;
-            });
-            const fs = filesystem ? filesystem.fs : undefined;
-            const fds = new FileDescriptorTable({
+            }, ['i32', 'i32', 'i32'], ['i32']);
+            this._setMemory = function setMemory(m) {
+                if (!(m instanceof _WebAssembly.Memory)) {
+                    throw new TypeError('"instance.exports.memory" property must be a WebAssembly.Memory');
+                }
+                _memory.set(_this, extendMemory(m));
+            };
+        }
+        static createSync(args, env, preopens, stdio, fs, print, printErr) {
+            const fds = new SyncTable({
                 size: 3,
                 in: stdio[0],
                 out: stdio[1],
@@ -1755,13 +2295,7 @@
                 print,
                 printErr
             });
-            _wasi.set(this, {
-                fds,
-                args,
-                env
-            });
-            if (fs)
-                _fs.set(this, fs);
+            const _this = new WASI$1(args, env, fds, false, fs);
             if (preopens.length > 0) {
                 for (let i = 0; i < preopens.length; ++i) {
                     const realPath = fs.realpathSync(preopens[i].realPath, 'utf8');
@@ -1769,6 +2303,27 @@
                     fds.insertPreopen(fd, preopens[i].mappedPath, realPath);
                 }
             }
+            return _this;
+        }
+        static async createAsync(args, env, preopens, stdio, fs, print, printErr, asyncify) {
+            const fds = new AsyncTable({
+                size: 3,
+                in: stdio[0],
+                out: stdio[1],
+                err: stdio[2],
+                print,
+                printErr
+            });
+            const _this = new WASI$1(args, env, fds, true, fs, asyncify);
+            if (preopens.length > 0) {
+                for (let i = 0; i < preopens.length; ++i) {
+                    const entry = preopens[i];
+                    const realPath = await fs.promises.realpath(entry.realPath);
+                    const fd = await fs.promises.open(realPath, 'r', 0o666);
+                    await fds.insertPreopen(fd, entry.mappedPath, realPath);
+                }
+            }
+            return _this;
         }
     }
 
@@ -1785,74 +2340,105 @@
     }
     // /** @public */
     // export type WasiSnapshotPreview1 = Omit<_WASI, '_setMemory'>
-    /** @public */
-    class WASI {
-        constructor(options = kEmptyObject) {
-            var _a;
-            validateObject(options, 'options');
-            if (options.args !== undefined) {
-                validateArray(options.args, 'options.args');
-            }
-            const args = ((_a = options.args) !== null && _a !== void 0 ? _a : []).map(String);
-            const env = [];
-            if (options.env !== undefined) {
-                validateObject(options.env, 'options.env');
-                Object.entries(options.env).forEach(({ 0: key, 1: value }) => {
-                    if (value !== undefined) {
-                        env.push(`${key}=${value}`);
-                    }
-                });
-            }
-            const preopens = [];
-            if (options.preopens !== undefined) {
-                validateObject(options.preopens, 'options.preopens');
-                Object.entries(options.preopens).forEach(({ 0: key, 1: value }) => preopens.push({ mappedPath: String(key), realPath: String(value) }));
-            }
-            if (preopens.length > 0) {
-                if (options.filesystem === undefined) {
-                    throw new Error('filesystem is disabled, can not preopen directory');
-                }
-            }
-            if (options.filesystem !== undefined) {
-                validateObject(options.filesystem, 'options.filesystem');
-                validateString(options.filesystem.type, 'options.filesystem.type');
-                if (options.filesystem.type !== 'memfs') {
-                    throw new Error(`Filesystem type ${options.filesystem.type} is not supported, only "memfs" is supported currently`);
-                }
-                try {
-                    validateObject(options.filesystem.fs, 'options.filesystem.fs');
-                }
-                catch (_) {
-                    throw new Error('Node.js fs like implementation is not provided');
+    function validateOptions(options) {
+        var _a;
+        validateObject(options, 'options');
+        if (options.args !== undefined) {
+            validateArray(options.args, 'options.args');
+        }
+        const args = ((_a = options.args) !== null && _a !== void 0 ? _a : []).map(String);
+        const env = [];
+        if (options.env !== undefined) {
+            validateObject(options.env, 'options.env');
+            Object.entries(options.env).forEach(({ 0: key, 1: value }) => {
+                if (value !== undefined) {
+                    env.push(`${key}=${value}`);
                 }
+            });
+        }
+        const preopens = [];
+        if (options.preopens !== undefined) {
+            validateObject(options.preopens, 'options.preopens');
+            Object.entries(options.preopens).forEach(({ 0: key, 1: value }) => preopens.push({ mappedPath: String(key), realPath: String(value) }));
+        }
+        if (preopens.length > 0) {
+            if (options.fs === undefined) {
+                throw new Error('filesystem is disabled, can not preopen directory');
             }
-            if (options.print !== undefined)
-                validateFunction(options.print, 'options.print');
-            if (options.printErr !== undefined)
-                validateFunction(options.printErr, 'options.printErr');
-            // const { stdin = 0, stdout = 1, stderr = 2 } = options
-            // validateInt32(stdin, 'options.stdin', 0)
-            // validateInt32(stdout, 'options.stdout', 0)
-            // validateInt32(stderr, 'options.stderr', 0)
-            // const stdio = [stdin, stdout, stderr] as const
-            const stdio = [0, 1, 2];
-            const wrap = new WASI$1(args, env, preopens, stdio, options.filesystem, options.print, options.printErr);
-            for (const prop in wrap) {
-                wrap[prop] = wrap[prop].bind(wrap);
-            }
-            if (options.returnOnExit !== undefined) {
-                validateBoolean(options.returnOnExit, 'options.returnOnExit');
-                if (options.returnOnExit) {
-                    wrap.proc_exit = wasiReturnOnProcExit.bind(this);
-                }
+            try {
+                validateObject(options.fs, 'options.fs');
             }
-            this[kSetMemory] = wrap._setMemory;
-            delete wrap._setMemory;
+            catch (_) {
+                throw new TypeError('Node.js fs like implementation is not provided');
+            }
+        }
+        // if (options.filesystem !== undefined) {
+        //   validateObject(options.filesystem, 'options.filesystem')
+        //   validateString(options.filesystem.type, 'options.filesystem.type')
+        //   if (options.filesystem.type !== 'memfs' && options.filesystem.type !== 'file-system-access-api') {
+        //     throw new Error(`Filesystem type ${(options.filesystem as any).type as string} is not supported, only "memfs" and "file-system-access-api" is supported currently`)
+        //   }
+        //   try {
+        //     validateObject(options.filesystem.fs, 'options.filesystem.fs')
+        //   } catch (_) {
+        //     throw new Error('Node.js fs like implementation is not provided')
+        //   }
+        // }
+        if (options.print !== undefined)
+            validateFunction(options.print, 'options.print');
+        if (options.printErr !== undefined)
+            validateFunction(options.printErr, 'options.printErr');
+        if (options.returnOnExit !== undefined) {
+            validateBoolean(options.returnOnExit, 'options.returnOnExit');
+        }
+        // const { stdin = 0, stdout = 1, stderr = 2 } = options
+        // validateInt32(stdin, 'options.stdin', 0)
+        // validateInt32(stdout, 'options.stdout', 0)
+        // validateInt32(stderr, 'options.stderr', 0)
+        // const stdio = [stdin, stdout, stderr] as const
+        const stdio = [0, 1, 2];
+        return {
+            args,
+            env,
+            preopens,
+            stdio
+        };
+    }
+    /** @public */
+    class WASI {
+        constructor(setMemory, wrap) {
+            this[kSetMemory] = setMemory;
             this.wasiImport = wrap;
             this[kStarted] = false;
             this[kExitCode] = 0;
             this[kInstance] = undefined;
         }
+        static createSync(options = kEmptyObject) {
+            const { args, env, preopens, stdio } = validateOptions(options);
+            const wrap = WASI$1.createSync(args, env, preopens, stdio, options.fs, options.print, options.printErr);
+            const setMemory = wrap._setMemory;
+            delete wrap._setMemory;
+            const _this = new WASI(setMemory, wrap);
+            if (options.returnOnExit) {
+                wrap.proc_exit = wasiReturnOnProcExit.bind(_this);
+            }
+            return _this;
+        }
+        static async createAsync(options = kEmptyObject) {
+            const { args, env, preopens, stdio } = validateOptions(options);
+            if (options.asyncify !== undefined) {
+                validateObject(options.asyncify, 'options.asyncify');
+                validateFunction(options.asyncify.wrapImportFunction, 'options.asyncify.wrapImportFunction');
+            }
+            const wrap = await WASI$1.createAsync(args, env, preopens, stdio, options.fs, options.print, options.printErr, options.asyncify);
+            const setMemory = wrap._setMemory;
+            delete wrap._setMemory;
+            const _this = new WASI(setMemory, wrap);
+            if (options.returnOnExit) {
+                wrap.proc_exit = wasiReturnOnProcExit.bind(_this);
+            }
+            return _this;
+        }
         // Must not export _initialize, must export _start
         start(instance) {
             if (this[kStarted]) {
@@ -1903,48 +2489,12 @@
         throw kExitCode;
     }
 
-    function checkWebAssemblyFunction() {
-        const WebAssemblyFunction = _WebAssembly.Function;
-        if (typeof WebAssemblyFunction !== 'function') {
-            throw new Error('WebAssembly.Function is not supported in this environment.' +
-                ' If you are using V8 based browser like Chrome, try to specify' +
-                ' --js-flag="--wasm-staging --experimental-wasm-stack-switching"');
-        }
-        return WebAssemblyFunction;
-    }
-    /** @public */
-    function wrapAsyncImport(f, parameterType, returnType) {
-        const WebAssemblyFunction = checkWebAssemblyFunction();
-        if (typeof f !== 'function') {
-            throw new TypeError('Function required');
-        }
-        const parameters = parameterType.slice(0);
-        parameters.unshift('externref');
-        return new WebAssemblyFunction({ parameters, results: returnType }, f, { suspending: 'first' });
-    }
-    /** @public */
-    function wrapAsyncExport(f) {
-        const WebAssemblyFunction = checkWebAssemblyFunction();
-        if (typeof f !== 'function') {
-            throw new TypeError('Function required');
-        }
-        return new WebAssemblyFunction({ parameters: [...WebAssemblyFunction.type(f).parameters.slice(1)], results: ['externref'] }, f, { promising: 'first' });
-    }
-    /** @public */
-    function wrapExports(exports, needWrap) {
-        return wrapInstanceExports(exports, (exportValue, name) => {
-            let ignore = typeof exportValue !== 'function';
-            if (Array.isArray(needWrap)) {
-                ignore = ignore || (needWrap.indexOf(name) === -1);
-            }
-            return ignore ? exportValue : wrapAsyncExport(exportValue);
-        });
-    }
-
     exports.Asyncify = Asyncify;
     exports.Memory = Memory;
     exports.WASI = WASI;
     exports.WebAssemblyMemory = WebAssemblyMemory;
+    exports.asyncifyLoad = asyncifyLoad;
+    exports.asyncifyLoadSync = asyncifyLoadSync;
     exports.extendMemory = extendMemory;
     exports.load = load;
     exports.loadSync = loadSync;