@volter/browser-wali 0.1.0

package/dist/filesystem.js

@@ -0,0 +1,1179 @@
+import { BufferedWaliStdin } from "./stdin.js";
+import { readWaliSymlink, resolveWaliSymlinkPath, writeWaliSymlink } from "./symlink.js";
+const AT_FDCWD = -100;
+const O_ACCMODE = 3;
+const O_WRONLY = 1;
+const O_RDWR = 2;
+const O_CREAT = 0x40;
+const O_EXCL = 0x80;
+const O_TRUNC = 0x200;
+const O_APPEND = 0x400;
+const O_NONBLOCK = 0x800;
+const O_DIRECTORY = 0x1_0000;
+const SEEK_SET = 0;
+const SEEK_CUR = 1;
+const SEEK_END = 2;
+const F_GETLK = 5;
+const F_SETLK = 6;
+const F_SETLKW = 7;
+const F_OFD_GETLK = 36;
+const F_OFD_SETLK = 37;
+const F_OFD_SETLKW = 38;
+const F_UNLCK = 2;
+const F_RDLCK = 0;
+const F_WRLCK = 1;
+const LOCK_SH = 1;
+const LOCK_EX = 2;
+const LOCK_NB = 4;
+const LOCK_UN = 8;
+const AT_SYMLINK_NOFOLLOW = 0x100;
+const AT_REMOVEDIR = 0x200;
+const UTIME_NOW = 0x3fffffffn;
+const UTIME_OMIT = 0x3ffffffen;
+const S_IFREG = 0o100000;
+const S_IFDIR = 0o040000;
+const S_IFLNK = 0o120000;
+export function createStdioAliasRegistry() {
+    const aliases = new Int32Array(new SharedArrayBuffer(65_536 * Int32Array.BYTES_PER_ELEMENT));
+    aliases.fill(-1);
+    aliases[0] = 0;
+    aliases[1] = 1;
+    aliases[2] = 2;
+    return aliases;
+}
+export class WaliFileDescriptorTable {
+    options;
+    files = new Map();
+    specialDescriptors = new Map();
+    stdioAliases = new Map();
+    descriptorStatusFlags = new Map();
+    stdin;
+    nextFd = 3;
+    nextDescription = 1;
+    cwd;
+    constructor(options) {
+        this.options = options;
+        this.cwd = normalizePath("/", options.cwd);
+        this.stdin = "read" in options.stdin ? options.stdin : new BufferedWaliStdin(options.stdin);
+    }
+    imports() {
+        return {
+            SYS_open: (path, flags, mode) => this.open(this.readCString(Number(path)), Number(flags), Number(mode)),
+            SYS_openat: (dirfd, path, flags, mode) => this.openAt(Number(dirfd), this.readCString(Number(path)), Number(flags), Number(mode)),
+            SYS_close: (fd) => this.close(Number(fd)),
+            SYS_read: (fd, pointer, length) => this.read(Number(fd), Number(pointer), Number(length)),
+            SYS_pread64: (fd, pointer, length, offset) => this.pread(Number(fd), Number(pointer), Number(length), Number(offset)),
+            SYS_write: (fd, pointer, length) => this.write(Number(fd), Number(pointer), Number(length)),
+            SYS_pwrite64: (fd, pointer, length, offset) => this.pwrite(Number(fd), Number(pointer), Number(length), Number(offset)),
+            SYS_readv: (fd, iov, count) => this.readv(Number(fd), Number(iov), Number(count)),
+            SYS_writev: (fd, iov, count) => this.writev(Number(fd), Number(iov), Number(count)),
+            SYS_lseek: (fd, offset, whence) => this.lseek(Number(fd), Number(offset), Number(whence)),
+            SYS_ftruncate: (fd, length) => this.ftruncate(Number(fd), Number(length)),
+            SYS_fstat: (fd, stat) => this.fstat(Number(fd), Number(stat)),
+            SYS_stat: (path, stat) => this.stat(this.readCString(Number(path)), Number(stat), false),
+            SYS_lstat: (path, stat) => this.stat(this.readCString(Number(path)), Number(stat), true),
+            SYS_newfstatat: (dirfd, path, stat, flags) => this.statAt(Number(dirfd), this.readCString(Number(path)), Number(stat), Number(flags)),
+            SYS_access: (path) => this.access(this.readCString(Number(path))),
+            SYS_faccessat: (dirfd, path) => this.accessAt(Number(dirfd), this.readCString(Number(path))),
+            SYS_faccessat2: (dirfd, path) => this.accessAt(Number(dirfd), this.readCString(Number(path))),
+            SYS_chmod: (path, mode) => this.chmod(this.readCString(Number(path)), Number(mode)),
+            SYS_fchmod: (fd, mode) => this.fchmod(Number(fd), Number(mode)),
+            SYS_fchmodat: (dirfd, path, mode, flags) => this.chmodAt(Number(dirfd), this.readCString(Number(path)), Number(mode), Number(flags)),
+            SYS_chdir: (path) => this.chdir(this.readCString(Number(path))),
+            SYS_fchdir: (fd) => this.fchdir(Number(fd)),
+            SYS_getcwd: (pointer, size) => this.getcwd(Number(pointer), Number(size)),
+            SYS_mkdir: (path, mode) => this.mkdir(this.readCString(Number(path)), Number(mode)),
+            SYS_mkdirat: (dirfd, path, mode) => this.mkdirAt(Number(dirfd), this.readCString(Number(path)), Number(mode)),
+            SYS_statfs: (path, stat) => this.statfs(this.readCString(Number(path)), Number(stat)),
+            SYS_fstatfs: (fd, stat) => this.fstatfs(Number(fd), Number(stat)),
+            SYS_inotify_init: () => this.inotifyInit(),
+            SYS_inotify_init1: () => this.inotifyInit(),
+            SYS_inotify_add_watch: (fd, path) => this.inotifyAddWatch(Number(fd), this.readCString(Number(path))),
+            SYS_inotify_rm_watch: (fd) => this.specialDescriptors.has(Number(fd)) ? 0n : -9n,
+            SYS_rmdir: (path) => this.mutate(() => this.fs().rmdirSync(this.resolveFilesystemPath(this.resolve(this.readCString(Number(path))), false))),
+            SYS_unlink: (path) => this.mutate(() => this.fs().unlinkSync(this.resolveFilesystemPath(this.resolve(this.readCString(Number(path))), false))),
+            SYS_unlinkat: (dirfd, path, flags) => this.unlinkAt(Number(dirfd), this.readCString(Number(path)), Number(flags)),
+            SYS_rename: (from, to) => this.rename(this.readCString(Number(from)), this.readCString(Number(to))),
+            SYS_utimensat: (dirfd, path, times, flags) => this.utimensat(Number(dirfd), Number(path), Number(times), Number(flags)),
+            SYS_symlink: (target, link) => this.symlink(this.readCString(Number(target)), this.readCString(Number(link)), AT_FDCWD),
+            SYS_symlinkat: (target, dirfd, link) => this.symlink(this.readCString(Number(target)), this.readCString(Number(link)), Number(dirfd)),
+            SYS_readlink: (path, pointer, size) => this.readlink(this.readCString(Number(path)), Number(pointer), Number(size), AT_FDCWD),
+            SYS_readlinkat: (dirfd, path, pointer, size) => this.readlink(this.readCString(Number(path)), Number(pointer), Number(size), Number(dirfd)),
+            SYS_dup: (fd) => this.dup(Number(fd)),
+            SYS_dup2: (fd, target) => this.dup(Number(fd), Number(target)),
+            SYS_dup3: (fd, target) => this.dup(Number(fd), Number(target)),
+            // fcntl's third parameter is variadic. WALI transports the ABI register
+            // as i64, so its upper 32 bits are unspecified for integer arguments.
+            SYS_fcntl: (fd, command, argument) => this.fcntl(Number(fd), Number(command), lowSigned32(argument)),
+            SYS_poll: (fds, count, timeout) => this.poll(Number(fds), Number(count), Number(timeout)),
+            SYS_getdents64: (fd, pointer, count) => this.getdents64(Number(fd), Number(pointer), Number(count)),
+            SYS_fsync: (fd) => this.hasFd(Number(fd)) ? 0n : -9n,
+            SYS_fdatasync: (fd) => this.hasFd(Number(fd)) ? 0n : -9n,
+            SYS_flock: (fd, operation) => this.flock(Number(fd), Number(operation)),
+        };
+    }
+    writeEnvironmentFile(env, pid) {
+        if (!this.options.filesystem || Object.keys(env).length === 0)
+            return;
+        const path = `/tmp/.browser-runtime-wali-env-${pid}`;
+        try {
+            this.options.filesystem.mkdirSync("/tmp", { recursive: true });
+        }
+        catch { /* already present */ }
+        const lines = Object.entries(env).map(([name, value]) => {
+            if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(name) || /[\u0000\r\n]/u.test(value))
+                throw new Error(`Invalid WALI environment entry: ${name}`);
+            return `${name}=${value}`;
+        });
+        this.options.filesystem.writeFileSync(path, `${lines.join("\n")}\n`);
+        return path;
+    }
+    copyCString(pointer, value, limit) {
+        const encoded = new TextEncoder().encode(`${value}\0`);
+        if (limit < encoded.byteLength)
+            return 0;
+        this.copyIn(pointer, encoded);
+        return 1;
+    }
+    readForMapping(fd, offset, length) {
+        const file = this.files.get(fd);
+        if (!file || file.directory || offset < 0 || length < 0)
+            return;
+        return this.fs().readFileSync(file.path).slice(offset, offset + length);
+    }
+    mappingPath(fd) {
+        const file = this.files.get(fd);
+        return file && !file.directory ? file.path : undefined;
+    }
+    writeForMapping(path, offset, value) {
+        try {
+            if (!Number.isSafeInteger(offset) || offset < 0 || !this.fs().existsSync(path))
+                return false;
+            const stat = this.fs().statSync(path);
+            if (!stat.isFile())
+                return false;
+            const current = this.fs().readFileSync(path);
+            const next = new Uint8Array(Math.max(current.byteLength, offset + value.byteLength));
+            next.set(current);
+            next.set(value, offset);
+            this.fs().writeFileSync(path, next);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    allocateSpecial(descriptor, minimum = 3) {
+        const fd = this.allocateFd(Math.max(minimum, this.options.specialDescriptorMinimum ?? 3));
+        this.specialDescriptors.set(fd, descriptor);
+        return fd;
+    }
+    exportBrowserProcessPipe(fd) {
+        return this.specialDescriptors.get(fd)?.browserProcessPipe;
+    }
+    currentWorkingDirectory() { return this.cwd; }
+    ioctl(fd, request) {
+        if (!this.hasFd(fd))
+            return;
+        // FIONBIO/FIOCLEX/FIONCLEX only mutate descriptor flags. Browser pipes
+        // are already nonblocking and close-on-exec is handled by the spawn ABI.
+        if (request === 0x5421 || request === 0x5451 || request === 0x5450)
+            return 0n;
+        return;
+    }
+    pollDescriptor(fd, events) {
+        if (fd < 0 || !this.hasFd(fd))
+            return 0x20;
+        const special = this.specialDescriptors.get(fd);
+        if (special)
+            return special.poll?.(events) ?? 0;
+        const stdio = this.stdioFd(fd);
+        let returned = 0;
+        if ((events & 0x1) && stdio === 0 && this.stdin.poll())
+            returned |= 0x1;
+        if ((events & 0x4) && stdio !== 0)
+            returned |= 0x4;
+        return returned;
+    }
+    fs() {
+        if (!this.options.filesystem)
+            throw errno("ENOSYS");
+        return this.options.filesystem;
+    }
+    memoryBytes() { return new Uint8Array(this.options.memory().buffer); }
+    memoryView() { return new DataView(this.options.memory().buffer); }
+    copyOut(pointer, length) {
+        assertRange(this.options.memory(), pointer, length);
+        return this.memoryBytes().slice(pointer, pointer + length);
+    }
+    copyIn(pointer, value) {
+        assertRange(this.options.memory(), pointer, value.byteLength);
+        this.memoryBytes().set(value, pointer);
+    }
+    readCString(pointer) {
+        const bytes = this.memoryBytes();
+        if (!Number.isSafeInteger(pointer) || pointer < 0 || pointer >= bytes.byteLength)
+            throw new WebAssembly.RuntimeError("WALI string pointer is out of bounds.");
+        const end = bytes.indexOf(0, pointer);
+        if (end < 0 || end - pointer > 1_048_576)
+            throw new WebAssembly.RuntimeError("WALI string is not null terminated.");
+        // Browser TextDecoder deliberately rejects views backed by
+        // SharedArrayBuffer. Copying the short C string also gives the decoder a
+        // stable snapshot while another pthread may write process memory.
+        return new TextDecoder("utf-8", { fatal: true }).decode(Uint8Array.from(bytes.subarray(pointer, end)));
+    }
+    resolve(path) { return normalizePath(this.cwd, path); }
+    resolveAt(dirfd, path) {
+        if (path.startsWith("/"))
+            return normalizePath("/", path);
+        if (dirfd === AT_FDCWD)
+            return this.resolve(path);
+        const directory = this.files.get(dirfd);
+        if (!directory?.directory)
+            throw errno("ENOTDIR");
+        return normalizePath(directory.path, path);
+    }
+    open(path, flags, mode) {
+        try {
+            return BigInt(this.openResolved(this.resolveFilesystemPath(this.resolve(path)), flags, mode));
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    openAt(dirfd, path, flags, mode) {
+        try {
+            return BigInt(this.openResolved(this.resolveFilesystemPath(this.resolveAt(dirfd, path)), flags, mode));
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    openResolved(path, flags, mode) {
+        if (path === "/dev/null") {
+            return this.allocateSpecial({
+                read: () => new Uint8Array(),
+                write: (value) => BigInt(value.byteLength),
+                poll: (events) => ((events & 1) ? 1 : 0) | ((events & 4) ? 4 : 0),
+                fcntl: (command) => command === 3 ? BigInt(flags) : [1, 2, 4].includes(command) ? 0n : -22n,
+            });
+        }
+        if (path === "/dev/urandom" || path === "/dev/random") {
+            return this.allocateSpecial({
+                read: (length) => {
+                    if (!Number.isSafeInteger(length) || length < 0)
+                        return -22n;
+                    const value = new Uint8Array(length);
+                    for (let offset = 0; offset < value.byteLength; offset += 65_536) {
+                        crypto.getRandomValues(value.subarray(offset, Math.min(offset + 65_536, value.byteLength)));
+                    }
+                    return value;
+                },
+                write: (value) => BigInt(value.byteLength),
+                poll: (events) => ((events & 1) ? 1 : 0) | ((events & 4) ? 4 : 0),
+                fcntl: (command) => command === 3 ? BigInt(flags) : [1, 2, 4].includes(command) ? 0n : -22n,
+            });
+        }
+        const fs = this.fs();
+        const exists = fs.existsSync(path);
+        if (!exists && !(flags & O_CREAT))
+            throw errno("ENOENT");
+        if (exists && (flags & O_CREAT) && (flags & O_EXCL))
+            throw errno("EEXIST");
+        if (!exists) {
+            fs.writeFileSync(path, new Uint8Array());
+            fs.chmodSync?.(path, mode & 0o7777);
+            this.options.fileLocks?.created?.(path);
+        }
+        const stat = fs.statSync(path);
+        if ((flags & O_DIRECTORY) && !stat.isDirectory())
+            throw errno("ENOTDIR");
+        if (stat.isDirectory() && (flags & O_ACCMODE) !== 0)
+            throw errno("EISDIR");
+        if ((flags & O_TRUNC) && (flags & O_ACCMODE) !== 0 && stat.isFile())
+            fs.writeFileSync(path, new Uint8Array());
+        const fd = this.allocateFd();
+        const size = stat.isFile() ? fs.statSync(path).size : 0;
+        this.files.set(fd, {
+            path,
+            flags,
+            position: flags & O_APPEND ? size : 0,
+            directory: stat.isDirectory(),
+            description: this.nextDescription++,
+        });
+        return fd;
+    }
+    allocateFd(minimum = 3) {
+        this.nextFd = Math.max(this.nextFd, minimum);
+        while (this.files.has(this.nextFd) || this.specialDescriptors.has(this.nextFd)
+            || this.stdioFd(this.nextFd) !== undefined)
+            this.nextFd += 1;
+        if (this.nextFd > (this.options.descriptorMaximum ?? 65_535))
+            throw errno("EMFILE");
+        return this.nextFd++;
+    }
+    close(fd) {
+        if (fd >= 0 && fd <= 2)
+            return 0n;
+        if (this.stdioAliases.delete(fd)) {
+            this.descriptorStatusFlags.delete(fd);
+            this.setSharedStdioAlias(fd, undefined);
+            return 0n;
+        }
+        const special = this.specialDescriptors.get(fd);
+        if (special) {
+            special.close?.();
+            this.specialDescriptors.delete(fd);
+            return 0n;
+        }
+        const file = this.files.get(fd);
+        if (!file)
+            return -9n;
+        this.files.delete(fd);
+        this.releasePosixLocks(file.path);
+        if (![...this.files.values()].some((candidate) => candidate.description === file.description)) {
+            this.releaseLockOwner(this.lockOwner("ofd", file));
+            this.releaseLockOwner(this.lockOwner("flock", file));
+        }
+        return 0n;
+    }
+    read(fd, pointer, length) {
+        try {
+            if (length < 0)
+                throw errno("EINVAL");
+            if (this.stdioFd(fd) === 0) {
+                if ((this.statusFlags(fd) & O_NONBLOCK) && !this.stdin.poll())
+                    return -11n;
+                const chunk = this.stdin.read(length);
+                this.copyIn(pointer, chunk);
+                return BigInt(chunk.byteLength);
+            }
+            const special = this.specialDescriptors.get(fd);
+            if (special) {
+                const value = special.read?.(length);
+                if (value === undefined)
+                    throw errno("EBADF");
+                if (typeof value === "bigint")
+                    return value;
+                const chunk = value.subarray(0, length);
+                this.copyIn(pointer, chunk);
+                return BigInt(chunk.byteLength);
+            }
+            const file = this.files.get(fd);
+            if (!file)
+                throw errno("EBADF");
+            if (file.directory)
+                throw errno("EISDIR");
+            if ((file.flags & O_ACCMODE) === O_WRONLY)
+                throw errno("EBADF");
+            const content = this.fs().readFileSync(file.path);
+            const chunk = content.subarray(file.position, file.position + length);
+            this.copyIn(pointer, chunk);
+            file.position += chunk.byteLength;
+            return BigInt(chunk.byteLength);
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    write(fd, pointer, length) {
+        try {
+            const chunk = this.copyOut(pointer, length);
+            const stdio = this.stdioFd(fd);
+            if (stdio === 1 || stdio === 2)
+                return this.options.emit(stdio, chunk);
+            const special = this.specialDescriptors.get(fd);
+            if (special)
+                return special.write?.(chunk) ?? -9n;
+            const file = this.files.get(fd);
+            if (!file)
+                throw errno("EBADF");
+            if (file.directory)
+                throw errno("EISDIR");
+            if ((file.flags & O_ACCMODE) === 0)
+                throw errno("EBADF");
+            const current = this.fs().readFileSync(file.path);
+            if (file.flags & O_APPEND)
+                file.position = current.byteLength;
+            const size = Math.max(current.byteLength, file.position + chunk.byteLength);
+            const next = new Uint8Array(size);
+            next.set(current);
+            next.set(chunk, file.position);
+            this.fs().writeFileSync(file.path, next);
+            file.position += chunk.byteLength;
+            return BigInt(chunk.byteLength);
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    pread(fd, pointer, length, offset) {
+        const file = this.files.get(fd);
+        if (!file)
+            return -9n;
+        if (file.directory || !Number.isSafeInteger(offset) || offset < 0)
+            return -22n;
+        const position = file.position;
+        file.position = offset;
+        try {
+            return this.read(fd, pointer, length);
+        }
+        finally {
+            file.position = position;
+        }
+    }
+    pwrite(fd, pointer, length, offset) {
+        const file = this.files.get(fd);
+        if (!file)
+            return -9n;
+        if (file.directory || !Number.isSafeInteger(offset) || offset < 0)
+            return -22n;
+        const position = file.position;
+        const flags = file.flags;
+        file.position = offset;
+        file.flags &= ~O_APPEND;
+        try {
+            return this.write(fd, pointer, length);
+        }
+        finally {
+            file.position = position;
+            file.flags = flags;
+        }
+    }
+    readv(fd, pointer, count) {
+        let total = 0n;
+        for (let index = 0; index < count; index += 1) {
+            const offset = pointer + index * 8;
+            assertRange(this.options.memory(), offset, 8);
+            const result = this.read(fd, this.memoryView().getUint32(offset, true), this.memoryView().getUint32(offset + 4, true));
+            if (result < 0n)
+                return total > 0n ? total : result;
+            total += result;
+            if (result === 0n)
+                break;
+        }
+        return total;
+    }
+    writev(fd, pointer, count) {
+        let total = 0n;
+        for (let index = 0; index < count; index += 1) {
+            const offset = pointer + index * 8;
+            assertRange(this.options.memory(), offset, 8);
+            const result = this.write(fd, this.memoryView().getUint32(offset, true), this.memoryView().getUint32(offset + 4, true));
+            if (result < 0n)
+                return total > 0n ? total : result;
+            total += result;
+        }
+        return total;
+    }
+    getdents64(fd, pointer, count) {
+        try {
+            const directory = this.files.get(fd);
+            if (!directory)
+                throw errno("EBADF");
+            if (!directory.directory)
+                throw errno("ENOTDIR");
+            const entries = [".", "..", ...this.fs().readdirSync(directory.path)];
+            let written = 0;
+            while (directory.position < entries.length) {
+                const name = entries[directory.position];
+                const nameBytes = new TextEncoder().encode(name);
+                const recordLength = alignTo(19 + nameBytes.byteLength + 1, 8);
+                if (recordLength > count - written) {
+                    if (written === 0)
+                        throw errno("EINVAL");
+                    break;
+                }
+                const record = pointer + written;
+                assertRange(this.options.memory(), record, recordLength);
+                const entryPath = name === "." ? directory.path : name === ".."
+                    ? normalizePath(directory.path, "..") : normalizePath(directory.path, name);
+                const stat = this.fs().statSync(entryPath);
+                this.memoryView().setBigUint64(record, BigInt(directory.position + 1), true);
+                this.memoryView().setBigInt64(record + 8, BigInt(directory.position + 1), true);
+                this.memoryView().setUint16(record + 16, recordLength, true);
+                this.memoryView().setUint8(record + 18, stat.isDirectory() ? 4 : 8);
+                this.memoryBytes().fill(0, record + 19, record + recordLength);
+                this.memoryBytes().set(nameBytes, record + 19);
+                directory.position += 1;
+                written += recordLength;
+            }
+            return BigInt(written);
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    lseek(fd, offset, whence) {
+        try {
+            const file = this.files.get(fd);
+            if (!file)
+                throw errno("EBADF");
+            if (file.directory)
+                throw errno("EINVAL");
+            const base = whence === SEEK_SET ? 0 : whence === SEEK_CUR ? file.position
+                : whence === SEEK_END ? this.fs().statSync(file.path).size : undefined;
+            if (base === undefined || base + offset < 0)
+                throw errno("EINVAL");
+            file.position = base + offset;
+            return BigInt(file.position);
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    ftruncate(fd, length) {
+        try {
+            const file = this.files.get(fd);
+            if (!file)
+                throw errno("EBADF");
+            if (file.directory)
+                throw errno("EISDIR");
+            if ((file.flags & O_ACCMODE) === 0)
+                throw errno("EBADF");
+            if (!Number.isSafeInteger(length) || length < 0)
+                throw errno("EINVAL");
+            const current = this.fs().readFileSync(file.path);
+            if (current.byteLength === length)
+                return 0n;
+            const resized = new Uint8Array(length);
+            resized.set(current.subarray(0, length));
+            this.fs().writeFileSync(file.path, resized);
+            return 0n;
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    stat(path, pointer, lstat) {
+        try {
+            const resolved = this.resolveFilesystemPath(this.resolve(path), !lstat);
+            const fs = this.fs();
+            if (!fs.existsSync(resolved))
+                throw errno("ENOENT");
+            const target = lstat ? this.readSymlink(resolved) : undefined;
+            writeStat(this.memoryView(), pointer, target === undefined
+                ? (lstat && fs.lstatSync ? fs.lstatSync(resolved) : fs.statSync(resolved))
+                : syntheticSymlinkStat(target));
+            return 0n;
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    statAt(dirfd, path, pointer, flags) {
+        try {
+            if (flags & ~AT_SYMLINK_NOFOLLOW)
+                throw errno("EINVAL");
+            const noFollow = Boolean(flags & AT_SYMLINK_NOFOLLOW);
+            const resolved = this.resolveFilesystemPath(this.resolveAt(dirfd, path), !noFollow);
+            const fs = this.fs();
+            if (!fs.existsSync(resolved))
+                throw errno("ENOENT");
+            const target = noFollow ? this.readSymlink(resolved) : undefined;
+            writeStat(this.memoryView(), pointer, target === undefined ? fs.statSync(resolved) : syntheticSymlinkStat(target));
+            return 0n;
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    fstat(fd, pointer) {
+        try {
+            if (this.stdioFd(fd) !== undefined) {
+                writeStat(this.memoryView(), pointer, syntheticTerminalStat());
+                return 0n;
+            }
+            const file = this.files.get(fd);
+            if (!file)
+                throw errno("EBADF");
+            writeStat(this.memoryView(), pointer, this.fs().statSync(file.path));
+            return 0n;
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    access(path) {
+        try {
+            return this.fs().existsSync(this.resolveFilesystemPath(this.resolve(path))) ? 0n : -2n;
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    accessAt(dirfd, path) {
+        try {
+            return this.fs().existsSync(this.resolveFilesystemPath(this.resolveAt(dirfd, path))) ? 0n : -2n;
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    chmod(path, mode) {
+        try {
+            const resolved = this.resolveFilesystemPath(this.resolve(path));
+            if (!this.fs().existsSync(resolved))
+                return -2n;
+            this.fs().chmodSync?.(resolved, mode & 0o7777);
+            return 0n;
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    chmodAt(dirfd, path, mode, flags) {
+        try {
+            if (flags & ~AT_SYMLINK_NOFOLLOW)
+                throw errno("EINVAL");
+            const resolved = this.resolveFilesystemPath(this.resolveAt(dirfd, path), !(flags & AT_SYMLINK_NOFOLLOW));
+            if (!this.fs().existsSync(resolved))
+                return -2n;
+            this.fs().chmodSync?.(resolved, mode & 0o7777);
+            return 0n;
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    fchmod(fd, mode) {
+        if (this.stdioFd(fd) !== undefined || this.specialDescriptors.has(fd))
+            return 0n;
+        const file = this.files.get(fd);
+        if (!file)
+            return -9n;
+        try {
+            this.fs().chmodSync?.(file.path, mode & 0o7777);
+            return 0n;
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    chdir(path) {
+        try {
+            const resolved = this.resolveFilesystemPath(this.resolve(path));
+            if (!this.fs().statSync(resolved).isDirectory())
+                throw errno("ENOTDIR");
+            this.cwd = resolved;
+            return 0n;
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    fchdir(fd) {
+        const file = this.files.get(fd);
+        if (!file)
+            return -9n;
+        if (!file.directory)
+            return -20n;
+        this.cwd = file.path;
+        return 0n;
+    }
+    getcwd(pointer, size) {
+        const encoded = new TextEncoder().encode(`${this.cwd}\0`);
+        if (encoded.byteLength > size)
+            return -34n;
+        this.copyIn(pointer, encoded);
+        return BigInt(encoded.byteLength);
+    }
+    mkdir(path, mode) {
+        return this.mutate(() => {
+            const resolved = this.resolveFilesystemPath(this.resolve(path), false);
+            this.fs().mkdirSync(resolved);
+            this.fs().chmodSync?.(resolved, mode & 0o7777);
+        });
+    }
+    mkdirAt(dirfd, path, mode) {
+        try {
+            const resolved = this.resolveFilesystemPath(this.resolveAt(dirfd, path), false);
+            this.fs().mkdirSync(resolved);
+            this.fs().chmodSync?.(resolved, mode & 0o7777);
+            return 0n;
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    statfs(path, pointer) {
+        try {
+            if (!this.fs().existsSync(this.resolveFilesystemPath(this.resolve(path))))
+                throw errno("ENOENT");
+            writeStatfs(this.memoryView(), pointer);
+            return 0n;
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    fstatfs(fd, pointer) {
+        if (!this.hasFd(fd))
+            return -9n;
+        writeStatfs(this.memoryView(), pointer);
+        return 0n;
+    }
+    inotifyInit() {
+        return BigInt(this.allocateSpecial({
+            read: () => -11n,
+            poll: () => 0,
+            fcntl: (command) => command === 3 ? 0n : [1, 2, 4].includes(command) ? 0n : -22n,
+        }));
+    }
+    inotifyAddWatch(fd, path) {
+        if (!this.specialDescriptors.has(fd))
+            return -9n;
+        try {
+            return this.fs().existsSync(this.resolveFilesystemPath(this.resolve(path))) ? 1n : -2n;
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    unlinkAt(dirfd, path, flags) {
+        try {
+            if (flags & ~AT_REMOVEDIR)
+                throw errno("EINVAL");
+            const resolved = this.resolveFilesystemPath(this.resolveAt(dirfd, path), false);
+            if (flags & AT_REMOVEDIR)
+                this.fs().rmdirSync(resolved);
+            else
+                this.fs().unlinkSync(resolved);
+            return 0n;
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    rename(from, to) {
+        return this.mutate(() => this.fs().renameSync(this.resolveFilesystemPath(this.resolve(from), false), this.resolveFilesystemPath(this.resolve(to), false)));
+    }
+    utimensat(dirfd, pathPointer, timesPointer, flags) {
+        try {
+            if (flags & ~AT_SYMLINK_NOFOLLOW)
+                throw errno("EINVAL");
+            const descriptor = pathPointer === 0 ? this.files.get(dirfd) : undefined;
+            if (pathPointer === 0 && !descriptor)
+                throw errno("EBADF");
+            const unresolved = descriptor?.path ?? this.resolveAt(dirfd, this.readCString(pathPointer));
+            const path = this.resolveFilesystemPath(unresolved, !(flags & AT_SYMLINK_NOFOLLOW));
+            const filesystem = this.fs();
+            const stat = filesystem.statSync(path);
+            const now = Date.now();
+            const readTime = (index, fallback) => {
+                if (timesPointer === 0)
+                    return now;
+                const pointer = timesPointer + index * 16;
+                assertRange(this.options.memory(), pointer, 16);
+                const seconds = this.memoryView().getBigInt64(pointer, true);
+                const nanoseconds = this.memoryView().getBigInt64(pointer + 8, true);
+                if (nanoseconds === UTIME_NOW)
+                    return now;
+                if (nanoseconds === UTIME_OMIT)
+                    return fallback;
+                if (nanoseconds < 0 || nanoseconds >= 1000000000n)
+                    throw errno("EINVAL");
+                const milliseconds = Number(seconds) * 1_000 + Number(nanoseconds) / 1_000_000;
+                if (!Number.isFinite(milliseconds))
+                    throw errno("EINVAL");
+                return milliseconds;
+            };
+            const atimeMs = readTime(0, stat.atimeMs ?? stat.mtimeMs ?? now);
+            const mtimeMs = readTime(1, stat.mtimeMs ?? now);
+            if (filesystem.utimesSync)
+                filesystem.utimesSync(path, atimeMs, mtimeMs);
+            else if (stat.isFile())
+                filesystem.writeFileSync(path, filesystem.readFileSync(path));
+            return 0n;
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    readlink(path, pointer, size, dirfd) {
+        try {
+            if (!Number.isSafeInteger(size) || size < 0)
+                throw errno("EINVAL");
+            const resolved = this.resolveAt(dirfd, path);
+            let target;
+            if (resolved === "/proc/self/exe")
+                target = this.options.executablePath ?? "/usr/bin/wali-program";
+            const descriptorMatch = /^\/proc\/self\/fd\/(\d+)$/u.exec(resolved);
+            if (!target && descriptorMatch) {
+                const descriptor = this.files.get(Number(descriptorMatch[1]));
+                if (descriptor)
+                    target = descriptor.path;
+            }
+            target ??= this.readSymlink(resolved);
+            // musl realpath(3) probes every path component with readlink(2).
+            // Existing non-symlinks must report EINVAL; ENOENT means the component
+            // itself is missing and makes canonicalization fail.
+            if (!target)
+                return this.fs().existsSync(resolved) ? -22n : -2n;
+            const encoded = new TextEncoder().encode(target).subarray(0, size);
+            this.copyIn(pointer, encoded);
+            return BigInt(encoded.byteLength);
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    symlink(target, link, dirfd) {
+        try {
+            const resolved = this.resolveFilesystemPath(this.resolveAt(dirfd, link), false);
+            writeWaliSymlink(this.fs(), target, resolved);
+            return 0n;
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    resolveFilesystemPath(path, followFinal = true) {
+        return resolveWaliSymlinkPath(this.fs(), path, followFinal);
+    }
+    readSymlink(path) {
+        return readWaliSymlink(this.fs(), path);
+    }
+    dup(fd, target, minimum = 3) {
+        const maximum = this.options.descriptorMaximum ?? 65_535;
+        const stdio = this.stdioFd(fd);
+        if (stdio !== undefined) {
+            const next = target ?? this.allocateFd(minimum);
+            if (next < 0 || next > maximum)
+                return -9n;
+            if (next === fd)
+                return BigInt(next);
+            this.stdioAliases.set(next, stdio);
+            this.descriptorStatusFlags.set(next, this.statusFlags(fd));
+            this.setSharedStdioAlias(next, stdio);
+            return BigInt(next);
+        }
+        const file = this.files.get(fd);
+        if (!file)
+            return -9n;
+        const next = target ?? this.allocateFd(minimum);
+        if (next < 0 || next > maximum)
+            return -9n;
+        this.files.set(next, { ...file });
+        return BigInt(next);
+    }
+    fcntl(fd, command, argument) {
+        if (!this.hasFd(fd))
+            return -9n;
+        const special = this.specialDescriptors.get(fd);
+        if (special) {
+            if (command === 0 || command === 1030) {
+                return special.duplicate?.(Math.max(argument, 3), command === 1030) ?? -22n;
+            }
+            return special.fcntl?.(command, argument) ?? -22n;
+        }
+        const file = this.files.get(fd);
+        if (command === 0 || command === 1030)
+            return this.dup(fd, undefined, Math.max(argument, 3));
+        if (command === 1 || command === 2)
+            return 0n;
+        if (command === 3)
+            return BigInt(this.statusFlags(fd));
+        if (command === 4) {
+            const stdio = this.stdioFd(fd);
+            if (stdio !== undefined)
+                this.descriptorStatusFlags.set(fd, argument);
+            else {
+                const file = this.files.get(fd);
+                if (file)
+                    file.flags = (file.flags & O_ACCMODE) | (argument & ~O_ACCMODE);
+            }
+            return 0n;
+        }
+        if (command === F_GETLK || command === F_OFD_GETLK
+            || command === F_SETLK || command === F_SETLKW
+            || command === F_OFD_SETLK || command === F_OFD_SETLKW) {
+            return file ? this.recordLock(file, command, argument) : -9n;
+        }
+        return -22n;
+    }
+    recordLock(file, command, pointer) {
+        try {
+            const requested = this.readRecordLock(file, pointer);
+            const namespace = command >= F_OFD_GETLK ? "ofd" : "posix";
+            const owner = this.lockOwner(namespace, file);
+            const client = this.options.fileLocks;
+            if (!client || !owner) {
+                if (command === F_GETLK || command === F_OFD_GETLK)
+                    this.memoryView().setInt16(pointer, F_UNLCK, true);
+                return 0n;
+            }
+            if (requested.mode === undefined) {
+                return BigInt(client.request({ operation: "unlock", owner, namespace, path: file.path, range: requested.range }).result);
+            }
+            if (command === F_GETLK || command === F_OFD_GETLK) {
+                const response = client.request({
+                    operation: "query", owner, namespace, path: file.path, range: requested.range,
+                    mode: requested.mode, pid: this.options.pid ?? 1,
+                });
+                if (response.result < 0)
+                    return BigInt(response.result);
+                if (!response.conflict)
+                    this.memoryView().setInt16(pointer, F_UNLCK, true);
+                else
+                    this.writeRecordLock(pointer, response.conflict.mode, response.conflict, response.conflict.pid);
+                return 0n;
+            }
+            const blocking = command === F_SETLKW || command === F_OFD_SETLKW;
+            return BigInt(client.request({
+                operation: "set", owner, namespace, path: file.path, range: requested.range,
+                mode: requested.mode, pid: this.options.pid ?? 1, blocking,
+            }).result);
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    readRecordLock(file, pointer) {
+        assertRange(this.options.memory(), pointer, 28);
+        const view = this.memoryView();
+        const type = view.getInt16(pointer, true);
+        const whence = view.getInt16(pointer + 2, true);
+        const offset = safeOffset(view.getBigInt64(pointer + 8, true));
+        const length = safeOffset(view.getBigInt64(pointer + 16, true));
+        const base = whence === SEEK_SET ? 0 : whence === SEEK_CUR ? file.position
+            : whence === SEEK_END ? this.fs().statSync(file.path).size : undefined;
+        if (base === undefined)
+            throw errno("EINVAL");
+        let start = base + offset;
+        let end;
+        if (length < 0) {
+            end = start;
+            start += length;
+        }
+        else if (length > 0)
+            end = start + length;
+        if (!Number.isSafeInteger(start) || start < 0 || (end !== undefined && (!Number.isSafeInteger(end) || end <= start))) {
+            throw errno("EINVAL");
+        }
+        const mode = type === F_RDLCK ? "read" : type === F_WRLCK ? "write" : type === F_UNLCK ? undefined : false;
+        if (mode === false)
+            throw errno("EINVAL");
+        return { ...(mode ? { mode } : {}), range: { start, ...(end === undefined ? {} : { end }) } };
+    }
+    writeRecordLock(pointer, mode, range, pid) {
+        const view = this.memoryView();
+        view.setInt16(pointer, mode === "read" ? F_RDLCK : F_WRLCK, true);
+        view.setInt16(pointer + 2, SEEK_SET, true);
+        view.setBigInt64(pointer + 8, BigInt(range.start), true);
+        view.setBigInt64(pointer + 16, BigInt(range.end === undefined ? 0 : range.end - range.start), true);
+        view.setInt32(pointer + 24, pid, true);
+    }
+    flock(fd, operation) {
+        const file = this.files.get(fd);
+        if (!file)
+            return this.hasFd(fd) ? 0n : -9n;
+        const client = this.options.fileLocks;
+        const owner = this.lockOwner("flock", file);
+        if (!client || !owner)
+            return 0n;
+        if (operation & LOCK_UN) {
+            return BigInt(client.request({
+                operation: "unlock", owner, namespace: "flock", path: file.path, range: { start: 0 },
+            }).result);
+        }
+        const mode = operation & LOCK_EX ? "write" : operation & LOCK_SH ? "read" : undefined;
+        if (!mode || operation & ~(LOCK_SH | LOCK_EX | LOCK_NB | LOCK_UN))
+            return -22n;
+        return BigInt(client.request({
+            operation: "set", owner, namespace: "flock", path: file.path, range: { start: 0 },
+            mode, pid: this.options.pid ?? 1, blocking: !(operation & LOCK_NB),
+        }).result);
+    }
+    lockOwner(namespace, file) {
+        const base = this.options.lockOwner;
+        if (!base)
+            return;
+        return namespace === "posix" ? `${base}:posix` : `${base}:${namespace}:${file.description}`;
+    }
+    releasePosixLocks(path) {
+        const owner = this.options.lockOwner ? `${this.options.lockOwner}:posix` : undefined;
+        if (!owner || !this.options.fileLocks)
+            return;
+        this.options.fileLocks.request({
+            operation: "unlock", owner, namespace: "posix", path, range: { start: 0 },
+        });
+    }
+    releaseLockOwner(owner) {
+        if (owner && this.options.fileLocks)
+            this.options.fileLocks.request({ operation: "release-owner", owner });
+    }
+    poll(pointer, count, timeout) {
+        if (!Number.isSafeInteger(count) || count < 0)
+            return -22n;
+        if (!Number.isSafeInteger(timeout))
+            return -22n;
+        const scan = () => {
+            let ready = 0;
+            for (let index = 0; index < count; index += 1) {
+                const offset = pointer + index * 8;
+                assertRange(this.options.memory(), offset, 8);
+                const fd = this.memoryView().getInt32(offset, true);
+                const events = this.memoryView().getInt16(offset + 4, true);
+                const returned = this.pollDescriptor(fd, events);
+                this.memoryView().setInt16(offset + 6, returned, true);
+                if (returned !== 0)
+                    ready += 1;
+            }
+            return ready;
+        };
+        const ready = scan();
+        if (ready !== 0 || timeout === 0)
+            return BigInt(ready);
+        this.stdin.wait?.(timeout);
+        return BigInt(scan());
+    }
+    hasFd(fd) {
+        return (fd >= 0 && fd <= 2) || this.stdioAliases.has(fd)
+            || this.files.has(fd) || this.specialDescriptors.has(fd);
+    }
+    stdioFd(fd) {
+        if (fd >= 0 && fd <= 2)
+            return fd;
+        const local = this.stdioAliases.get(fd);
+        if (local !== undefined)
+            return local;
+        const shared = this.options.stdioAliasRegistry?.[fd];
+        return shared === 0 || shared === 1 || shared === 2 ? shared : undefined;
+    }
+    setSharedStdioAlias(fd, target) {
+        if (fd < 0 || fd >= (this.options.stdioAliasRegistry?.length ?? 0))
+            return;
+        Atomics.store(this.options.stdioAliasRegistry, fd, target ?? -1);
+    }
+    statusFlags(fd) {
+        const stored = this.descriptorStatusFlags.get(fd);
+        if (stored !== undefined)
+            return stored;
+        const stdio = this.stdioFd(fd);
+        if (stdio !== undefined)
+            return stdio === 0 ? 0 : O_WRONLY;
+        return this.files.get(fd)?.flags ?? O_RDWR;
+    }
+    mutate(operation) {
+        try {
+            operation();
+            return 0n;
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+}
+function normalizePath(cwd, path) {
+    if (!path)
+        return cwd;
+    const components = [];
+    const value = path.startsWith("/") ? path : `${cwd}/${path}`;
+    for (const component of value.replaceAll("\\", "/").split("/")) {
+        if (!component || component === ".")
+            continue;
+        if (component === "..")
+            components.pop();
+        else
+            components.push(component);
+    }
+    return `/${components.join("/")}`;
+}
+function alignTo(value, alignment) {
+    return Math.ceil(value / alignment) * alignment;
+}
+function lowSigned32(value) {
+    return Number(BigInt.asIntN(32, typeof value === "bigint" ? value : BigInt(value)));
+}
+function safeOffset(value) {
+    const result = Number(value);
+    if (!Number.isSafeInteger(result))
+        throw errno("EINVAL");
+    return result;
+}
+function assertRange(memory, pointer, length) {
+    if (!Number.isSafeInteger(pointer) || !Number.isSafeInteger(length) || pointer < 0 || length < 0
+        || pointer + length > memory.buffer.byteLength)
+        throw new WebAssembly.RuntimeError("WALI filesystem memory access is out of bounds.");
+}
+function writeStat(view, pointer, stat) {
+    if (pointer < 0 || pointer + 144 > view.byteLength)
+        throw new WebAssembly.RuntimeError("WALI stat pointer is out of bounds.");
+    for (let offset = 0; offset < 144; offset += 4)
+        view.setUint32(pointer + offset, 0, true);
+    view.setBigUint64(pointer, BigInt(stat.dev ?? 1), true);
+    view.setBigUint64(pointer + 8, BigInt(stat.ino ?? 1), true);
+    view.setBigUint64(pointer + 16, BigInt(stat.nlink ?? 1), true);
+    const kind = stat.isSymbolicLink?.() ? S_IFLNK : stat.isDirectory() ? S_IFDIR : S_IFREG;
+    view.setUint32(pointer + 24, kind | (stat.mode ?? (stat.isDirectory() ? 0o755 : 0o644)), true);
+    view.setUint32(pointer + 28, stat.uid ?? 1000, true);
+    view.setUint32(pointer + 32, stat.gid ?? 1000, true);
+    view.setBigUint64(pointer + 40, BigInt(stat.rdev ?? 0), true);
+    view.setBigInt64(pointer + 48, BigInt(stat.size), true);
+    view.setBigInt64(pointer + 56, BigInt(stat.blksize ?? 4096), true);
+    view.setBigInt64(pointer + 64, BigInt(stat.blocks ?? Math.ceil(stat.size / 512)), true);
+    writeStatTime(view, pointer + 72, stat.atimeMs ?? stat.mtimeMs ?? Date.now());
+    writeStatTime(view, pointer + 88, stat.mtimeMs ?? Date.now());
+    writeStatTime(view, pointer + 104, stat.ctimeMs ?? stat.mtimeMs ?? Date.now());
+}
+function syntheticSymlinkStat(target) {
+    return {
+        isFile: () => false,
+        isDirectory: () => false,
+        isSymbolicLink: () => true,
+        size: new TextEncoder().encode(target).byteLength,
+        mode: 0o777,
+    };
+}
+function writeStatfs(view, pointer) {
+    if (pointer < 0 || pointer + 120 > view.byteLength)
+        throw new WebAssembly.RuntimeError("WALI statfs pointer is out of bounds.");
+    for (let offset = 0; offset < 120; offset += 4)
+        view.setUint32(pointer + offset, 0, true);
+    view.setBigInt64(pointer, 0x01021994n, true); // TMPFS_MAGIC
+    view.setBigInt64(pointer + 8, 4096n, true);
+    view.setBigUint64(pointer + 16, 262144n, true);
+    view.setBigUint64(pointer + 24, 196608n, true);
+    view.setBigUint64(pointer + 32, 196608n, true);
+    view.setBigUint64(pointer + 40, 1048576n, true);
+    view.setBigUint64(pointer + 48, 1048000n, true);
+    view.setBigUint64(pointer + 64, 255n, true);
+    view.setBigUint64(pointer + 72, 4096n, true);
+}
+function writeStatTime(view, pointer, milliseconds) {
+    const nanoseconds = BigInt(Math.floor(milliseconds * 1_000_000));
+    view.setBigInt64(pointer, nanoseconds / 1000000000n, true);
+    view.setBigInt64(pointer + 8, nanoseconds % 1000000000n, true);
+}
+function syntheticTerminalStat() {
+    return {
+        isFile: () => false,
+        isDirectory: () => false,
+        size: 0,
+        mode: 0o020666,
+        mtimeMs: Date.now(),
+    };
+}
+function errno(errnoName) {
+    return Object.assign(new Error(errnoName), { errnoName });
+}
+function negativeErrno(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const name = typeof error === "object" && error !== null
+        ? ("errnoName" in error ? String(error.errnoName) : "code" in error ? String(error.code)
+            : /\b(E[A-Z]+)\b/u.exec(message)?.[1] ?? "")
+        : /\b(E[A-Z]+)\b/u.exec(message)?.[1] ?? "";
+    const code = {
+        EPERM: 1n, ENOENT: 2n, EIO: 5n, EAGAIN: 11n, ENOMEM: 12n, EACCES: 13n,
+        EFAULT: 14n, EBUSY: 16n, EEXIST: 17n, EXDEV: 18n, ENOTDIR: 20n, EISDIR: 21n,
+        EINVAL: 22n, EMFILE: 24n, ENOSPC: 28n, ESPIPE: 29n, EROFS: 30n, ERANGE: 34n,
+        ENOSYS: 38n, ENOTEMPTY: 39n, ELOOP: 40n, ENAMETOOLONG: 36n,
+    };
+    if (name in code)
+        return -code[name];
+    if (error instanceof WebAssembly.RuntimeError || error instanceof RangeError)
+        throw error;
+    return -5n;
+}
+//# sourceMappingURL=filesystem.js.map