@volter/browser-wali 0.1.9 → 0.1.11

package/dist/filesystem.js

@@ -1,3 +1,4 @@
+import { realtimeMilliseconds } from "./monotonic-clock.js";
 import { WaliDescriptionRegistry, WaliProcessDescriptorTable } from "./descriptors.js";
 import { createProcessFilesystemMutationGuard } from "@volter/browser-runtime/browser-process-filesystem-policy.js";
 import { BufferedWaliStdin } from "./stdin.js";
@@ -16,6 +17,7 @@ const O_DIRECTORY = 0x1_0000;
 const SEEK_SET = 0;
 const SEEK_CUR = 1;
 const SEEK_END = 2;
+const O_CLOEXEC_FLAG = 0x80000;
 const F_GETLK = 5;
 const F_SETLK = 6;
 const F_SETLKW = 7;
@@ -80,6 +82,11 @@ export class WaliFileDescriptorTable {
             readFileSync: fs.readFileSync.bind(fs), readFile: fs.readFile.bind(fs),
             readdirSync: fs.readdirSync.bind(fs),
             writeFileSync: (path, bytes) => fs.writeFileSync(this.assertWritable(path), bytes),
+            ...(fs.readRangeSync ? { readRangeSync: fs.readRangeSync.bind(fs) } : {}),
+            ...(fs.linkTargetSync ? { linkTargetSync: fs.linkTargetSync.bind(fs) } : {}),
+            ...(fs.viewRangeSync ? { viewRangeSync: fs.viewRangeSync.bind(fs) } : {}),
+            ...(fs.writeRangeSync ? { writeRangeSync: (path, offset, data) => fs.writeRangeSync(this.assertWritable(path), offset, data) } : {}),
+            ...(fs.truncateSync ? { truncateSync: (path, length) => fs.truncateSync(this.assertWritable(path), length) } : {}),
             mkdirSync: (path, settings) => fs.mkdirSync(this.assertWritable(path), settings),
             unlinkSync: (path) => fs.unlinkSync(this.assertWritable(path)),
             rmdirSync: (path) => fs.rmdirSync(this.assertWritable(path)),
@@ -97,6 +104,8 @@ export class WaliFileDescriptorTable {
                 this.specialDescriptors.set(fd, { stdio: fd });
         }
     }
+    /** Whether this table holds `fd` as an open file or directory of its own: no pipe, socket, special or stdio stream. */
+    ownsFile(fd) { return this.files.has(fd); }
     imports() {
         return {
             SYS_open: (path, flags, mode) => this.open(this.readCString(Number(path)), Number(flags), Number(mode)),
@@ -142,7 +151,13 @@ export class WaliFileDescriptorTable {
             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)),
+            // As Linux: EINVAL for any flag but O_CLOEXEC and for dup3(fd, fd); O_CLOEXEC marks the new descriptor.
+            SYS_dup3: (fd, target, flags) => {
+                const requested = Number(flags);
+                if ((requested & ~O_CLOEXEC_FLAG) !== 0 || Number(fd) === Number(target))
+                    return -22n;
+                return this.markCloseOnExec(this.dup(Number(fd), Number(target)), requested);
+            },
             // 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)),
@@ -196,7 +211,10 @@ export class WaliFileDescriptorTable {
         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);
+        // The range, not the whole file sliced: a mapping is read in pieces, and
+        // each piece copied the file entire (2026-09-27, Blender reading a `.blend`).
+        const fs = this.fs();
+        return fs.readRangeSync ? fs.readRangeSync(file.path, offset, length) : fs.readFileSync(file.path).slice(offset, offset + length);
     }
     mappingPath(fd) {
         const file = this.files.get(fd);
@@ -220,6 +238,17 @@ export class WaliFileDescriptorTable {
             return false;
         }
     }
+    /** `fd` marked close-on-exec when `flags` carry O_CLOEXEC (open's and dup3's flags); `fd` returned. */
+    markCloseOnExecNumber(fd, flags) {
+        if (flags & O_CLOEXEC_FLAG)
+            this.descriptors.entries[fd].flags = 1;
+        return fd;
+    }
+    markCloseOnExec(result, flags) {
+        if (result >= 0n)
+            this.markCloseOnExecNumber(Number(result), flags);
+        return result;
+    }
     allocateSpecial(descriptor, minimum = 3) {
         const fd = this.allocateFd(Math.max(minimum, this.options.specialDescriptorMinimum ?? 3));
         this.specialDescriptors.set(fd, descriptor);
@@ -272,8 +301,22 @@ export class WaliFileDescriptorTable {
             throw errno("ENOSYS");
         return this.guestFilesystem;
     }
-    memoryBytes() { return new Uint8Array(this.options.memory().buffer); }
-    memoryView() { return new DataView(this.options.memory().buffer); }
+    // The views over the program's memory, made again only when its buffer is
+    // another (a grow): two new views per syscall, and more for a stat, were
+    // allocated for the same bytes (2026-09-28).
+    viewedBuffer;
+    viewedBytes = new Uint8Array();
+    viewedData = new DataView(new ArrayBuffer(0));
+    memoryBytes() { this.viewMemory(); return this.viewedBytes; }
+    memoryView() { this.viewMemory(); return this.viewedData; }
+    viewMemory() {
+        const buffer = this.options.memory().buffer;
+        if (buffer === this.viewedBuffer)
+            return;
+        this.viewedBuffer = buffer;
+        this.viewedBytes = new Uint8Array(buffer);
+        this.viewedData = new DataView(buffer);
+    }
     copyOut(pointer, length) {
         assertRange(this.options.memory(), pointer, length);
         return this.memoryBytes().slice(pointer, pointer + length);
@@ -289,10 +332,20 @@ export class WaliFileDescriptorTable {
         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)));
+        // A path is almost always ASCII, read here a code unit at a time; any
+        // other goes through one decoder, over a copy, since a browser's
+        // TextDecoder rejects views backed by SharedArrayBuffer and the copy is a
+        // stable snapshot while another pthread may write process memory. A new
+        // decoder and an element-wise copy for every path were a measurable part
+        // of every path syscall (2026-09-27).
+        let text = "";
+        for (let index = pointer; index < end; index += 1) {
+            const unit = bytes[index];
+            if (unit >= 0x80)
+                return strictDecoder.decode(bytes.slice(pointer, end));
+            text += String.fromCharCode(unit);
+        }
+        return text;
     }
     resolve(path) { return normalizePath(this.cwd, path); }
     resolveAt(dirfd, path) {
@@ -322,16 +375,19 @@ export class WaliFileDescriptorTable {
         }
     }
     openResolved(path, flags, mode) {
+        // O_CLOEXEC is recorded here for every kind of descriptor open makes: musl
+        // no longer follows it with F_SETFD (musl 0003), which was the only thing
+        // marking these special files (review of dfd87b6).
         if (path === "/dev/null") {
-            return this.allocateSpecial({
+            return this.markCloseOnExecNumber(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,
-            });
+            }), flags);
         }
         if (path === "/dev/urandom" || path === "/dev/random") {
-            return this.allocateSpecial({
+            return this.markCloseOnExecNumber(this.allocateSpecial({
                 read: (length) => {
                     if (!Number.isSafeInteger(length) || length < 0)
                         return -22n;
@@ -344,10 +400,12 @@ export class WaliFileDescriptorTable {
                 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,
-            });
+            }), flags);
         }
         const fs = this.fs();
-        const exists = fs.existsSync(path);
+        // One lookup where the store answers ENOENT from statSync (a snapshot store's); exists-then-stat resolved it twice.
+        let found = fs.linkTargetSync ? statIfPresent(fs, path) : fs.existsSync(path) ? fs.statSync(path) : undefined;
+        const exists = found !== undefined;
         if ((flags & O_ACCMODE) !== 0 || (!exists && (flags & O_CREAT)))
             this.assertWritable(path);
         if (!exists && !(flags & O_CREAT))
@@ -358,21 +416,28 @@ export class WaliFileDescriptorTable {
             fs.writeFileSync(path, new Uint8Array());
             fs.chmodSync?.(path, mode & 0o7777);
             this.options.fileLocks?.created?.(path);
+            found = fs.statSync(path);
         }
-        const stat = fs.statSync(path);
+        const stat = found;
         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 truncated = (flags & O_TRUNC) !== 0 && (flags & O_ACCMODE) !== 0 && stat.isFile();
+        if (truncated) {
+            if (fs.truncateSync)
+                fs.truncateSync(path, 0);
+            else
+                fs.writeFileSync(path, new Uint8Array());
+        }
         const fd = this.allocateFd();
-        const size = stat.isFile() ? fs.statSync(path).size : 0;
+        const directory = stat.isDirectory();
         this.files.set(fd, {
             path,
             flags,
-            position: flags & O_APPEND ? size : 0,
-            directory: stat.isDirectory(),
+            // The stat above is the file's size unless this open emptied it.
+            position: flags & O_APPEND && !truncated && stat.isFile() ? stat.size : 0,
+            directory,
             description: this.nextDescription++,
         });
         this.descriptors.entries[fd].flags = flags & 0x80000 ? 1 : 0;
@@ -419,9 +484,21 @@ export class WaliFileDescriptorTable {
         const file = this.files.get(fd);
         if (!file)
             return -9n;
+        // The open description this descriptor names, which a dup shares: its
+        // locks go when no descriptor of this process names it any more. Asked of
+        // the table's count, not by walking every descriptor slot: the table's slots run to
+        // the highest descriptor (60,000 and up for a thread's local ones), and
+        // that walk was 104 ms of 184 in 1,000 small-file opens in Blender's
+        // Python (2026-09-27).
+        const shared = this.descriptors.get(fd);
         this.files.delete(fd);
         this.releasePosixLocks(file.path);
-        if (![...this.files.values()].some((candidate) => candidate.description === file.description)) {
+        // This process's own descriptors, as before: the lock owners are recorded
+        // per process, so a count across processes (a fork's child holding the
+        // same description) left the owner held by nobody (review of f066d0a).
+        // Nothing to name when this process holds no owner's lock, which is every
+        // close of a file never locked: the owners' strings were most of a close.
+        if (this.lockingOwners.size > 0 && (!shared || !this.descriptors.names(shared.id))) {
             this.releaseLockOwner(this.lockOwner("ofd", file));
             this.releaseLockOwner(this.lockOwner("flock", file));
         }
@@ -457,9 +534,12 @@ export class WaliFileDescriptorTable {
             if ((file.flags & O_ACCMODE) === O_WRONLY)
                 throw errno("EBADF");
             const fs = this.fs();
-            const chunk = fs.readRangeSync
-                ? fs.readRangeSync(file.path, file.position, length)
-                : fs.readFileSync(file.path).subarray(file.position, file.position + length);
+            // A view where the filesystem offers one: copied into the program's memory at once, so one copy, not two.
+            const chunk = fs.viewRangeSync
+                ? fs.viewRangeSync(file.path, file.position, length)
+                : fs.readRangeSync
+                    ? fs.readRangeSync(file.path, file.position, length)
+                    : fs.readFileSync(file.path).subarray(file.position, file.position + length);
             this.copyIn(pointer, chunk);
             file.position += chunk.byteLength;
             return BigInt(chunk.byteLength);
@@ -470,13 +550,12 @@ export class WaliFileDescriptorTable {
     }
     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);
+                return this.options.emit(stdio, this.copyOut(pointer, length));
             const special = this.specialDescriptors.get(fd);
             if (special)
-                return special.write?.(chunk) ?? -9n;
+                return special.write?.(this.copyOut(pointer, length)) ?? -9n;
             const file = this.files.get(fd);
             if (!file)
                 throw errno("EBADF");
@@ -488,10 +567,13 @@ export class WaliFileDescriptorTable {
             if (fs.writeRangeSync) {
                 if (file.flags & O_APPEND)
                     file.position = fs.statSync(file.path).size;
-                fs.writeRangeSync(file.path, file.position, chunk);
-                file.position += chunk.byteLength;
-                return BigInt(chunk.byteLength);
+                // A view, not a copy: the file copies what it keeps (2026-09-27, one copy of every write fewer).
+                assertRange(this.options.memory(), pointer, length);
+                fs.writeRangeSync(file.path, file.position, this.memoryBytes().subarray(pointer, pointer + length));
+                file.position += length;
+                return BigInt(length);
             }
+            const chunk = this.copyOut(pointer, length);
             const current = fs.readFileSync(file.path);
             if (file.flags & O_APPEND)
                 file.position = current.byteLength;
@@ -633,7 +715,13 @@ export class WaliFileDescriptorTable {
                 throw errno("EBADF");
             if (!Number.isSafeInteger(length) || length < 0)
                 throw errno("EINVAL");
-            const current = this.fs().readFileSync(file.path);
+            const fs = this.fs();
+            if (fs.truncateSync) {
+                if (fs.statSync(file.path).size !== length)
+                    fs.truncateSync(file.path, length);
+                return 0n;
+            }
+            const current = fs.readFileSync(file.path);
             if (current.byteLength === length)
                 return 0n;
             const resized = new Uint8Array(length);
@@ -649,7 +737,8 @@ export class WaliFileDescriptorTable {
         try {
             const resolved = this.resolveFilesystemPath(this.resolve(path), !lstat);
             const fs = this.fs();
-            if (!fs.existsSync(resolved))
+            // A snapshot store's statSync answers ENOENT itself: asking existsSync first resolved the path twice.
+            if (!fs.linkTargetSync && !fs.existsSync(resolved))
                 throw errno("ENOENT");
             const target = lstat ? this.readSymlink(resolved) : undefined;
             writeStat(this.memoryView(), pointer, target === undefined
@@ -668,7 +757,7 @@ export class WaliFileDescriptorTable {
             const noFollow = Boolean(flags & AT_SYMLINK_NOFOLLOW);
             const resolved = this.resolveFilesystemPath(this.resolveAt(dirfd, path), !noFollow);
             const fs = this.fs();
-            if (!fs.existsSync(resolved))
+            if (!fs.linkTargetSync && !fs.existsSync(resolved))
                 throw errno("ENOENT");
             const target = noFollow ? this.readSymlink(resolved) : undefined;
             writeStat(this.memoryView(), pointer, target === undefined ? fs.statSync(resolved) : syntheticSymlinkStat(target));
@@ -859,7 +948,7 @@ export class WaliFileDescriptorTable {
             const path = this.resolveFilesystemPath(unresolved, !(flags & AT_SYMLINK_NOFOLLOW));
             const filesystem = this.fs();
             const stat = filesystem.statSync(path);
-            const now = Date.now();
+            const now = realtimeMilliseconds();
             const readTime = (index, fallback) => {
                 if (timesPointer === 0)
                     return now;
@@ -1198,6 +1287,9 @@ export class WaliFileDescriptorTable {
 function normalizePath(cwd, path) {
     if (!path)
         return cwd;
+    // Most paths a program names are already normal: itself, without the split.
+    if (isNormalPath(path))
+        return path;
     const components = [];
     const value = path.startsWith("/") ? path : `${cwd}/${path}`;
     for (const component of value.replaceAll("\\", "/").split("/")) {
@@ -1210,6 +1302,28 @@ function normalizePath(cwd, path) {
     }
     return `/${components.join("/")}`;
 }
+/** Absolute, no empty, `.` or `..` component, no trailing slash, and no backslash (which `normalizePath` turns into one). */
+function isNormalPath(path) {
+    if (path.charCodeAt(0) !== 47)
+        return false;
+    if (path.length === 1)
+        return true;
+    let start = 1;
+    for (let index = 1; index <= path.length; index += 1) {
+        const code = index < path.length ? path.charCodeAt(index) : 47;
+        if (code === 92)
+            return false;
+        if (code !== 47)
+            continue;
+        const length = index - start;
+        if (length === 0)
+            return false;
+        if (path.charCodeAt(start) === 46 && (length === 1 || (length === 2 && path.charCodeAt(start + 1) === 46)))
+            return false;
+        start = index + 1;
+    }
+    return true;
+}
 function alignTo(value, alignment) {
     return Math.ceil(value / alignment) * alignment;
 }
@@ -1227,25 +1341,46 @@ function assertRange(memory, pointer, length) {
         || pointer + length > memory.buffer.byteLength)
         throw new WebAssembly.RuntimeError("WALI filesystem memory access is out of bounds.");
 }
+/** The stat of `path`, or undefined when the store says ENOENT; any other failure is thrown. */
+function statIfPresent(fs, path) {
+    try {
+        return fs.statSync(path);
+    }
+    catch (error) {
+        if (/\bENOENT\b/u.test(error instanceof Error ? error.message : String(error)))
+            return undefined;
+        throw error;
+    }
+}
 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);
+    // Every field written once, and the 64-bit ones as two words: a stat is
+    // one of a program's commonest calls, and zeroing the struct a word at a
+    // time and then allocating a BigInt per 64-bit field was a third of it
+    // (2026-09-28). The padding and the reserved tail are the only bytes zeroed.
+    setUint64(view, pointer, stat.dev ?? 1);
+    setUint64(view, pointer + 8, stat.ino ?? 1);
+    setUint64(view, pointer + 16, stat.nlink ?? 1);
     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());
+    view.setUint32(pointer + 36, 0, true);
+    setUint64(view, pointer + 40, stat.rdev ?? 0);
+    setUint64(view, pointer + 48, stat.size);
+    setUint64(view, pointer + 56, stat.blksize ?? 4096);
+    setUint64(view, pointer + 64, stat.blocks ?? Math.ceil(stat.size / 512));
+    writeStatTime(view, pointer + 72, stat.atimeMs ?? stat.mtimeMs ?? realtimeMilliseconds());
+    writeStatTime(view, pointer + 88, stat.mtimeMs ?? realtimeMilliseconds());
+    writeStatTime(view, pointer + 104, stat.ctimeMs ?? stat.mtimeMs ?? realtimeMilliseconds());
+    for (let offset = 120; offset < 144; offset += 4)
+        view.setUint32(pointer + offset, 0, true);
+}
+/** A 64-bit little-endian field from a safe integer, as two words: two's complement for a negative one, as setBigInt64 wrote it. */
+function setUint64(view, pointer, value) {
+    view.setUint32(pointer, value >>> 0, true);
+    view.setUint32(pointer + 4, Math.floor(value / 0x1_0000_0000) >>> 0, true);
 }
 function syntheticSymlinkStat(target) {
     return {
@@ -1272,9 +1407,10 @@ function writeStatfs(view, pointer) {
     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);
+    // Seconds by floor and nanoseconds in [0, 1e9), as a timespec is, before 1970 too.
+    const seconds = Math.floor(milliseconds / 1_000);
+    setUint64(view, pointer, seconds);
+    setUint64(view, pointer + 8, Math.min(999_999_999, Math.floor((milliseconds - seconds * 1_000) * 1_000_000)));
 }
 function syntheticTerminalStat() {
     return {
@@ -1282,24 +1418,36 @@ function syntheticTerminalStat() {
         isDirectory: () => false,
         size: 0,
         mode: 0o020666,
-        mtimeMs: Date.now(),
+        mtimeMs: realtimeMilliseconds(),
     };
 }
+/**
+ * One error per errno, made once: a syscall's error is thrown to be caught
+ * and turned into its number, and building an Error (its stack captured) for
+ * every missing path Python probed was 34 ms of Blender's start (2026-09-27).
+ */
+const strictDecoder = new TextDecoder("utf-8", { fatal: true });
+const errnoErrors = new Map();
 function errno(errnoName) {
-    return Object.assign(new Error(errnoName), { errnoName });
+    let error = errnoErrors.get(errnoName);
+    if (!error) {
+        error = Object.assign(new Error(errnoName), { errnoName });
+        errnoErrors.set(errnoName, error);
+    }
+    return error;
 }
+const ERRNO_NUMBERS = {
+    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,
+};
 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,
-    };
+    // The errno's own name first, and the message parsed only for an error that has none.
+    const named = typeof error === "object" && error !== null
+        ? ("errnoName" in error ? String(error.errnoName) : "code" in error ? String(error.code) : undefined) : undefined;
+    const name = named ?? /\b(E[A-Z]+)\b/u.exec(error instanceof Error ? error.message : String(error))?.[1] ?? "";
+    const code = ERRNO_NUMBERS;
     if (name in code)
         return -code[name];
     if (error instanceof WebAssembly.RuntimeError || error instanceof RangeError)