@tailwindcss/oxide-wasm32-wasi 4.2.4 → 4.3.1

package/node_modules/@napi-rs/wasm-runtime/fs-proxy.js

@@ -15,6 +15,21 @@ const getType = (value) => {
   return -1
 }
 
+const RESPONSE_HEADER_SIZE = 16
+const RESPONSE_PAYLOAD_SIZE = 10240
+const RESPONSE_BUFFER_SIZE = RESPONSE_HEADER_SIZE + RESPONSE_PAYLOAD_SIZE
+
+/**
+ * @param {Int32Array} sab
+ * @param {Uint8Array} payload
+ */
+const writeResponsePayload = (sab, payload) => {
+  if (payload.length > RESPONSE_PAYLOAD_SIZE) {
+    throw new RangeError('payload overflow')
+  }
+  new Uint8Array(sab.buffer).set(payload, RESPONSE_HEADER_SIZE)
+}
+
 /**
  * @param {import('memfs').IFs} memfs
  * @param {any} value
@@ -89,9 +104,7 @@ const encodeValue = (memfs, value, type) => {
       return view
     }
     case 9: {
-      const view = new BigInt64Array(1)
-      view[0] = value
-      return new Uint8Array(view.buffer)
+      return new TextEncoder().encode(String(value))
     }
     case -1:
     default:
@@ -176,8 +189,9 @@ const decodeValue = (memfs, payload, type) => {
     }
     return obj
   }
-  if (type === 9)
-    return new BigInt64Array(payload.buffer, payload.byteOffset, 1)[0]
+  if (type === 9) {
+    return BigInt(new TextDecoder().decode(payload.slice()))
+  }
   throw new Error('unsupported data')
 }
 
@@ -192,7 +206,7 @@ export const createOnMessage = (fs) =>
       /**
        * 0..4                    status(int32_t):        21(waiting) 0(success) 1(error)
        * 5..8                    type(napi_valuetype):   0(undefined) 1(null) 2(boolean) 3(number) 4(string) 6(jsonstring) 9(bigint) -1(unsupported)
-       * 9..16                   payload_size(uint32_t)  <= 1024
+       * 9..16                   payload_size(uint32_t)  <= 10240
        * 16..16 + payload_size   payload_content
        */
       const { sab, type, payload } = e.data.__fs__
@@ -203,14 +217,35 @@ export const createOnMessage = (fs) =>
         Atomics.store(sab, 1, t)
         const v = encodeValue(fs, ret, t)
         Atomics.store(sab, 2, v.length)
-        new Uint8Array(sab.buffer).set(v, 16)
+        writeResponsePayload(sab, v)
         Atomics.store(sab, 0, 0) // success
       } catch (/** @type {any} */ err) {
-        const t = getType(err)
+        let t = getType(err)
+        let v
+        try {
+          if (t === -1) {
+            throw new Error('unsupported data')
+          }
+          v = encodeValue(fs, err, t)
+        } catch {
+          const fallback = (() => {
+            try {
+              return String(err)
+            } catch {
+              return 'Unserializable thrown value'
+            }
+          })()
+          t = getType(fallback)
+          v = encodeValue(fs, fallback, t)
+        }
+        if (v.length > RESPONSE_PAYLOAD_SIZE) {
+          const overflowErr = new RangeError('payload overflow')
+          t = getType(overflowErr)
+          v = encodeValue(fs, overflowErr, t)
+        }
         Atomics.store(sab, 1, t)
-        const v = encodeValue(fs, err, t)
         Atomics.store(sab, 2, v.length)
-        new Uint8Array(sab.buffer).set(v, 16)
+        writeResponsePayload(sab, v)
         Atomics.store(sab, 0, 1) // error
       } finally {
         Atomics.notify(sab, 0)
@@ -230,7 +265,7 @@ export const createFsProxy = (memfs) =>
          * @param {any[]} args
          */
         return function (...args) {
-          const sab = new SharedArrayBuffer(16 + 10240)
+          const sab = new SharedArrayBuffer(RESPONSE_BUFFER_SIZE)
           const i32arr = new Int32Array(sab)
           Atomics.store(i32arr, 0, 21)
 
@@ -247,7 +282,7 @@ export const createFsProxy = (memfs) =>
           const status = Atomics.load(i32arr, 0)
           const type = Atomics.load(i32arr, 1)
           const size = Atomics.load(i32arr, 2)
-          const content = new Uint8Array(sab, 16, size)
+          const content = new Uint8Array(sab, RESPONSE_HEADER_SIZE, size)
           const value = decodeValue(memfs, content, type)
           if (status === 1) {
             throw value

package/node_modules/@napi-rs/wasm-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@napi-rs/wasm-runtime",
-  "version": "1.1.1",
+  "version": "1.1.4",
   "type": "module",
   "description": "Runtime and polyfill for wasm targets",
   "homepage": "https://napi.rs/",
@@ -11,7 +11,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/napi-rs/napi-rs.git",
-    "directory": "wasi-runtime"
+    "directory": "wasm-runtime"
   },
   "license": "MIT",
   "publishConfig": {
@@ -44,10 +44,12 @@
     "tslib": "^2.8.1"
   },
   "dependencies": {
-    "@emnapi/core": "^1.7.1",
-    "@emnapi/runtime": "^1.7.1",
     "@tybys/wasm-util": "^0.10.1"
   },
+  "peerDependencies": {
+    "@emnapi/core": "^1.7.1",
+    "@emnapi/runtime": "^1.7.1"
+  },
   "scripts": {
     "build": "rollup -c rollup.config.js",
     "test": "node --test"

package/node_modules/@tybys/wasm-util/dist/wasm-util.esm-bundler.js

@@ -306,6 +306,141 @@ function asyncifyLoadSync(asyncify, buffer, imports) {
 
 const CHAR_DOT = 46; /* . */
 const CHAR_FORWARD_SLASH = 47; /* / */
+const CHAR_BACKWARD_SLASH = 92; /* \ */
+const CHAR_COLON = 58; /* : */
+const CHAR_UPPERCASE_A = 65; /* A */
+const CHAR_UPPERCASE_Z = 90; /* Z */
+const CHAR_LOWERCASE_A = 97; /* a */
+const CHAR_LOWERCASE_Z = 122; /* z */
+function isPathSeparatorWin(code) {
+    return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+}
+function isWindowsDeviceRoot(code) {
+    return (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z) ||
+        (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z);
+}
+const _isWin32 = typeof process !== 'undefined' && process.platform === 'win32';
+/**
+ * Windows variant of `resolve()`. Mirrors Node's `path.win32.resolve`
+ * semantics enough for the WASI shim's needs (drive-letter absolutes
+ * + UNC paths + per-drive cwd lookups via `process.env`/`process.cwd`).
+ *
+ * Why this is needed: on Windows, `FileDescriptor.realPath` is the
+ * host realpath returned by `fs.realpathSync(realPath, 'utf8')` — the
+ * backslash form `D:\…`. The POSIX-only `resolveImpl` below only
+ * treats `/` as a separator, reads `D` as non-`/`, decides realPath
+ * is "relative", and produces a garbage joined path. Downstream
+ * `fs.openSync(garbage)` then returns `EINVAL` and the WASI caller
+ * sees a permanent failure. This function gives us the correct
+ * Windows-style resolution without taking a Node-only `path` import
+ * (which would break browser bundles of this package).
+ *
+ * Cribbed from Node's `lib/path.js` `win32.resolve()` (MIT-licensed),
+ * trimmed to what WASI realpath resolution actually exercises.
+ */
+function resolveWin32(args) {
+    let resolvedDevice = '';
+    let resolvedTail = '';
+    let resolvedAbsolute = false;
+    for (let i = args.length - 1; i >= -1; i--) {
+        let path;
+        if (i >= 0) {
+            path = args[i];
+            validateString(path, 'path');
+            if (path.length === 0)
+                continue;
+        }
+        else if (resolvedDevice.length === 0) {
+            path = (typeof process !== 'undefined' && typeof process.cwd === 'function')
+                ? process.cwd()
+                : '';
+        }
+        else {
+            // Look up per-drive cwd via the `=X:` env var convention; fall back
+            // to the global cwd if absent.
+            const envKey = `=${resolvedDevice}`;
+            const env = (typeof process !== 'undefined') ? process.env : undefined;
+            path = (env && typeof env[envKey] === 'string')
+                ? env[envKey]
+                : (typeof process !== 'undefined' && typeof process.cwd === 'function')
+                    ? process.cwd()
+                    : '';
+            if (path === undefined ||
+                (path.slice(0, 2).toLowerCase() !== resolvedDevice.toLowerCase() &&
+                    path.charCodeAt(2) === CHAR_BACKWARD_SLASH)) {
+                path = `${resolvedDevice}\\`;
+            }
+        }
+        const len = path.length;
+        let rootEnd = 0;
+        let device = '';
+        let isAbsolute = false;
+        const code = path.charCodeAt(0);
+        if (len === 1) {
+            if (isPathSeparatorWin(code)) {
+                rootEnd = 1;
+                isAbsolute = true;
+            }
+        }
+        else if (isPathSeparatorWin(code)) {
+            isAbsolute = true;
+            if (isPathSeparatorWin(path.charCodeAt(1))) {
+                // UNC path: `\\server\share\…`
+                let j = 2;
+                let last = j;
+                while (j < len && !isPathSeparatorWin(path.charCodeAt(j)))
+                    j++;
+                if (j < len && j !== last) {
+                    const firstPart = path.slice(last, j);
+                    last = j;
+                    while (j < len && isPathSeparatorWin(path.charCodeAt(j)))
+                        j++;
+                    if (j < len && j !== last) {
+                        last = j;
+                        while (j < len && !isPathSeparatorWin(path.charCodeAt(j)))
+                            j++;
+                        if (j === len || j !== last) {
+                            device = `\\\\${firstPart}\\${path.slice(last, j)}`;
+                            rootEnd = j;
+                        }
+                    }
+                }
+            }
+            else {
+                rootEnd = 1;
+            }
+        }
+        else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
+            device = path.slice(0, 2);
+            rootEnd = 2;
+            if (len > 2 && isPathSeparatorWin(path.charCodeAt(2))) {
+                isAbsolute = true;
+                rootEnd = 3;
+            }
+        }
+        if (device.length > 0) {
+            if (resolvedDevice.length > 0) {
+                if (device.toLowerCase() !== resolvedDevice.toLowerCase())
+                    continue;
+            }
+            else {
+                resolvedDevice = device;
+            }
+        }
+        if (resolvedAbsolute) {
+            if (resolvedDevice.length > 0)
+                break;
+        }
+        else {
+            resolvedTail = `${path.slice(rootEnd)}\\${resolvedTail}`;
+            resolvedAbsolute = isAbsolute;
+            if (isAbsolute && resolvedDevice.length > 0)
+                break;
+        }
+    }
+    resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, '\\', isPathSeparatorWin);
+    return resolvedDevice + (resolvedAbsolute ? '\\' : '') + resolvedTail || '.';
+}
 function isPosixPathSeparator(code) {
     return code === CHAR_FORWARD_SLASH;
 }
@@ -381,6 +516,13 @@ function normalizeString(path, allowAboveRoot, separator, isPathSeparator) {
     return res;
 }
 function resolve(...args) {
+    // On Windows, host paths are `D:\…` style. The POSIX-only resolver
+    // below treats `D` as a non-`/` character and produces garbage; route
+    // to the Windows-aware variant. POSIX hosts (Linux/macOS/browser)
+    // run the original code path unchanged — `_isWin32` is constant-folded
+    // away on those targets.
+    if (_isWin32)
+        return resolveWin32(args);
     let resolvedPath = '';
     let resolvedAbsolute = false;
     for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
@@ -1017,6 +1159,26 @@ function wrapExports(exports, needWrap) {
     });
 }
 
+// Linux fcntl flag bits ↔ Windows libuv flag bits. `pathOpen()` builds
+// `flagsRes` using Linux constants (O_CREAT=0x40, O_EXCL=0x80,
+// O_APPEND=0x400). Windows libuv expects different bits (O_CREAT=0x100,
+// O_EXCL=0x400, O_APPEND=0x8). Without translation,
+// `fs.openSync(path, 0x241 /* L:WRONLY|CREAT|TRUNC */)` is rejected
+// with EINVAL because Linux's 0x40 happens to mean O_TEMPORARY on
+// Windows — and O_TEMPORARY without O_CREAT is invalid.
+const _isWin32Flags = typeof process !== 'undefined' && process.platform === 'win32';
+function _toWinOpenFlags(f) {
+    let r = f & 3; // RDONLY/WRONLY/RDWR — same on both
+    if ((f & 0x40) !== 0)
+        r |= 0x100; // O_CREAT:  Linux 0x40  -> Windows 0x100
+    if ((f & 0x80) !== 0)
+        r |= 0x400; // O_EXCL:   Linux 0x80  -> Windows 0x400
+    if ((f & 0x200) !== 0)
+        r |= 0x200; // O_TRUNC:  same value on both
+    if ((f & 0x400) !== 0)
+        r |= 0x8; // O_APPEND: Linux 0x400 -> Windows 0x8
+    return r;
+}
 function copyMemory(targets, src) {
     if (targets.length === 0 || src.length === 0)
         return 0;
@@ -2273,7 +2435,7 @@ class WASI$1 {
             const pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len));
             const fs = getFs(this);
             const resolved_path = resolvePathSync(fs, fileDescriptor, pathString, dirflags);
-            const r = fs.openSync(resolved_path, flagsRes, 0o666);
+            const r = fs.openSync(resolved_path, _isWin32Flags ? _toWinOpenFlags(flagsRes) : flagsRes, 0o666);
             const filetype = wasi.fds.getFileTypeByFd(r);
             if ((filetype !== 3 /* WasiFileType.DIRECTORY */) &&
                 ((o_flags & 2 /* WasiFileControlFlag.O_DIRECTORY */) !== 0 ||
@@ -2309,7 +2471,7 @@ class WASI$1 {
             const pathString = decoder.decode(unsharedSlice(HEAPU8, 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 r = await fs.promises.open(resolved_path, _isWin32Flags ? _toWinOpenFlags(flagsRes) : 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 */;

package/node_modules/@tybys/wasm-util/dist/wasm-util.esm.js

@@ -306,6 +306,141 @@ function asyncifyLoadSync(asyncify, buffer, imports) {
 
 const CHAR_DOT = 46; /* . */
 const CHAR_FORWARD_SLASH = 47; /* / */
+const CHAR_BACKWARD_SLASH = 92; /* \ */
+const CHAR_COLON = 58; /* : */
+const CHAR_UPPERCASE_A = 65; /* A */
+const CHAR_UPPERCASE_Z = 90; /* Z */
+const CHAR_LOWERCASE_A = 97; /* a */
+const CHAR_LOWERCASE_Z = 122; /* z */
+function isPathSeparatorWin(code) {
+    return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+}
+function isWindowsDeviceRoot(code) {
+    return (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z) ||
+        (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z);
+}
+const _isWin32 = typeof process !== 'undefined' && process.platform === 'win32';
+/**
+ * Windows variant of `resolve()`. Mirrors Node's `path.win32.resolve`
+ * semantics enough for the WASI shim's needs (drive-letter absolutes
+ * + UNC paths + per-drive cwd lookups via `process.env`/`process.cwd`).
+ *
+ * Why this is needed: on Windows, `FileDescriptor.realPath` is the
+ * host realpath returned by `fs.realpathSync(realPath, 'utf8')` — the
+ * backslash form `D:\…`. The POSIX-only `resolveImpl` below only
+ * treats `/` as a separator, reads `D` as non-`/`, decides realPath
+ * is "relative", and produces a garbage joined path. Downstream
+ * `fs.openSync(garbage)` then returns `EINVAL` and the WASI caller
+ * sees a permanent failure. This function gives us the correct
+ * Windows-style resolution without taking a Node-only `path` import
+ * (which would break browser bundles of this package).
+ *
+ * Cribbed from Node's `lib/path.js` `win32.resolve()` (MIT-licensed),
+ * trimmed to what WASI realpath resolution actually exercises.
+ */
+function resolveWin32(args) {
+    let resolvedDevice = '';
+    let resolvedTail = '';
+    let resolvedAbsolute = false;
+    for (let i = args.length - 1; i >= -1; i--) {
+        let path;
+        if (i >= 0) {
+            path = args[i];
+            validateString(path, 'path');
+            if (path.length === 0)
+                continue;
+        }
+        else if (resolvedDevice.length === 0) {
+            path = (typeof process !== 'undefined' && typeof process.cwd === 'function')
+                ? process.cwd()
+                : '';
+        }
+        else {
+            // Look up per-drive cwd via the `=X:` env var convention; fall back
+            // to the global cwd if absent.
+            const envKey = `=${resolvedDevice}`;
+            const env = (typeof process !== 'undefined') ? process.env : undefined;
+            path = (env && typeof env[envKey] === 'string')
+                ? env[envKey]
+                : (typeof process !== 'undefined' && typeof process.cwd === 'function')
+                    ? process.cwd()
+                    : '';
+            if (path === undefined ||
+                (path.slice(0, 2).toLowerCase() !== resolvedDevice.toLowerCase() &&
+                    path.charCodeAt(2) === CHAR_BACKWARD_SLASH)) {
+                path = `${resolvedDevice}\\`;
+            }
+        }
+        const len = path.length;
+        let rootEnd = 0;
+        let device = '';
+        let isAbsolute = false;
+        const code = path.charCodeAt(0);
+        if (len === 1) {
+            if (isPathSeparatorWin(code)) {
+                rootEnd = 1;
+                isAbsolute = true;
+            }
+        }
+        else if (isPathSeparatorWin(code)) {
+            isAbsolute = true;
+            if (isPathSeparatorWin(path.charCodeAt(1))) {
+                // UNC path: `\\server\share\…`
+                let j = 2;
+                let last = j;
+                while (j < len && !isPathSeparatorWin(path.charCodeAt(j)))
+                    j++;
+                if (j < len && j !== last) {
+                    const firstPart = path.slice(last, j);
+                    last = j;
+                    while (j < len && isPathSeparatorWin(path.charCodeAt(j)))
+                        j++;
+                    if (j < len && j !== last) {
+                        last = j;
+                        while (j < len && !isPathSeparatorWin(path.charCodeAt(j)))
+                            j++;
+                        if (j === len || j !== last) {
+                            device = `\\\\${firstPart}\\${path.slice(last, j)}`;
+                            rootEnd = j;
+                        }
+                    }
+                }
+            }
+            else {
+                rootEnd = 1;
+            }
+        }
+        else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
+            device = path.slice(0, 2);
+            rootEnd = 2;
+            if (len > 2 && isPathSeparatorWin(path.charCodeAt(2))) {
+                isAbsolute = true;
+                rootEnd = 3;
+            }
+        }
+        if (device.length > 0) {
+            if (resolvedDevice.length > 0) {
+                if (device.toLowerCase() !== resolvedDevice.toLowerCase())
+                    continue;
+            }
+            else {
+                resolvedDevice = device;
+            }
+        }
+        if (resolvedAbsolute) {
+            if (resolvedDevice.length > 0)
+                break;
+        }
+        else {
+            resolvedTail = `${path.slice(rootEnd)}\\${resolvedTail}`;
+            resolvedAbsolute = isAbsolute;
+            if (isAbsolute && resolvedDevice.length > 0)
+                break;
+        }
+    }
+    resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, '\\', isPathSeparatorWin);
+    return resolvedDevice + (resolvedAbsolute ? '\\' : '') + resolvedTail || '.';
+}
 function isPosixPathSeparator(code) {
     return code === CHAR_FORWARD_SLASH;
 }
@@ -381,6 +516,13 @@ function normalizeString(path, allowAboveRoot, separator, isPathSeparator) {
     return res;
 }
 function resolve(...args) {
+    // On Windows, host paths are `D:\…` style. The POSIX-only resolver
+    // below treats `D` as a non-`/` character and produces garbage; route
+    // to the Windows-aware variant. POSIX hosts (Linux/macOS/browser)
+    // run the original code path unchanged — `_isWin32` is constant-folded
+    // away on those targets.
+    if (_isWin32)
+        return resolveWin32(args);
     let resolvedPath = '';
     let resolvedAbsolute = false;
     for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
@@ -1017,6 +1159,26 @@ function wrapExports(exports, needWrap) {
     });
 }
 
+// Linux fcntl flag bits ↔ Windows libuv flag bits. `pathOpen()` builds
+// `flagsRes` using Linux constants (O_CREAT=0x40, O_EXCL=0x80,
+// O_APPEND=0x400). Windows libuv expects different bits (O_CREAT=0x100,
+// O_EXCL=0x400, O_APPEND=0x8). Without translation,
+// `fs.openSync(path, 0x241 /* L:WRONLY|CREAT|TRUNC */)` is rejected
+// with EINVAL because Linux's 0x40 happens to mean O_TEMPORARY on
+// Windows — and O_TEMPORARY without O_CREAT is invalid.
+const _isWin32Flags = typeof process !== 'undefined' && process.platform === 'win32';
+function _toWinOpenFlags(f) {
+    let r = f & 3; // RDONLY/WRONLY/RDWR — same on both
+    if ((f & 0x40) !== 0)
+        r |= 0x100; // O_CREAT:  Linux 0x40  -> Windows 0x100
+    if ((f & 0x80) !== 0)
+        r |= 0x400; // O_EXCL:   Linux 0x80  -> Windows 0x400
+    if ((f & 0x200) !== 0)
+        r |= 0x200; // O_TRUNC:  same value on both
+    if ((f & 0x400) !== 0)
+        r |= 0x8; // O_APPEND: Linux 0x400 -> Windows 0x8
+    return r;
+}
 function copyMemory(targets, src) {
     if (targets.length === 0 || src.length === 0)
         return 0;
@@ -2273,7 +2435,7 @@ class WASI$1 {
             const pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len));
             const fs = getFs(this);
             const resolved_path = resolvePathSync(fs, fileDescriptor, pathString, dirflags);
-            const r = fs.openSync(resolved_path, flagsRes, 0o666);
+            const r = fs.openSync(resolved_path, _isWin32Flags ? _toWinOpenFlags(flagsRes) : flagsRes, 0o666);
             const filetype = wasi.fds.getFileTypeByFd(r);
             if ((filetype !== 3 /* WasiFileType.DIRECTORY */) &&
                 ((o_flags & 2 /* WasiFileControlFlag.O_DIRECTORY */) !== 0 ||
@@ -2309,7 +2471,7 @@ class WASI$1 {
             const pathString = decoder.decode(unsharedSlice(HEAPU8, 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 r = await fs.promises.open(resolved_path, _isWin32Flags ? _toWinOpenFlags(flagsRes) : 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 */;