@php-wasm/node 2.0.5 → 2.0.7

package/index.cjs

@@ -685,7 +685,7 @@ function init2(RuntimeName, PHPLoader) {
   };
   var wasmTableMirror = [];
   var wasmTable = new WebAssembly.Table({
-    initial: 16555,
+    initial: 16556,
     element: "anyfunc"
   });
   var getWasmTableEntry = (funcPtr) => {
@@ -5760,27 +5760,21 @@ function init2(RuntimeName, PHPLoader) {
       1: "exclusive",
       2: "unlocked"
     },
-    is_shared_fs_node(node) {
-      if (node?.isSharedFS) {
-        return true;
-      }
-      if (!node?.mount?.opts?.fs?.lookupPath || !node?.mount?.type?.realPath) {
-        return false;
-      }
-      if (node.mount.type !== NODEFS) {
-        return false;
-      }
-      const vfsPath = node.mount.type.realPath(node);
-      try {
-        const underlyingNode = node.mount.opts.fs.lookupPath(vfsPath)?.node;
-        return !!underlyingNode?.isSharedFS;
-      } catch (e) {
-        return false;
-      }
-    },
     is_path_to_shared_fs(path33) {
-      const { node } = FS.lookupPath(path33);
-      return locking.is_shared_fs_node(node);
+      _js_wasm_trace("is_path_to_shared_fs(%s)", path33);
+      const { node } = FS.lookupPath(path33, { noent_okay: true });
+      if (node.mount.type !== PROXYFS) {
+        return !!node.isSharedFS;
+      }
+      const nodePath2 = PROXYFS.realPath(node);
+      const backingFs = node?.mount?.opts?.fs;
+      if (backingFs) {
+        const { node: backingNode } = backingFs.lookupPath(nodePath2, {
+          noent_okay: true
+        });
+        return !!backingNode?.isSharedFS;
+      }
+      return false;
     },
     get_fd_access_mode(fd) {
       const emscripten_F_GETFL = Number("3");
@@ -5795,8 +5789,23 @@ function init2(RuntimeName, PHPLoader) {
       }
     },
     get_native_path_from_vfs_path(vfsPath) {
-      const { node } = FS.lookupPath(vfsPath);
-      return NODEFS.realPath(node);
+      const { node } = FS.lookupPath(vfsPath, {});
+      if (node.mount.type === NODEFS) {
+        return NODEFS.realPath(node);
+      } else if (node.mount.type === PROXYFS) {
+        const { node: backingNode, path: backingPath } = node.mount.opts.fs.lookupPath(vfsPath);
+        _js_wasm_trace(
+          "backingNode for %s: %s",
+          vfsPath,
+          backingPath,
+          backingNode
+        );
+        return backingNode.mount.type.realPath(backingNode);
+      } else {
+        throw new Error(
+          `Unsupported filesystem type for path ${vfsPath}`
+        );
+      }
     },
     check_lock_params(fd, l_type) {
       const emscripten_O_RDONLY = Number("0");
@@ -25216,13 +25225,13 @@ ${e}`);
   Module["createContext"] = Browser.createContext;
   registerPostMainLoop(() => SDL.audio?.queueNewAudioData?.());
   var ASM_CONSTS = {
-    16328094: ($0) => {
+    16328046: ($0) => {
       if (!$0) {
         AL.alcErr = 40964;
         return 1;
       }
     },
-    16328142: ($0) => {
+    16328094: ($0) => {
       if (!AL.currentCtx) {
         err("alGetProcAddress() called without a valid context");
         return 1;
@@ -28067,15 +28076,15 @@ ${e}`);
   PHPLoader["malloc"] = _malloc;
   PHPLoader["free"] = typeof _free === "function" ? _free : PHPLoader["_wasm_free"];
   if (typeof NODEFS === "object") {
-    const originalCreateNode = NODEFS.createNode;
+    const originalNodeFsCreateNode = NODEFS.createNode;
     NODEFS.createNode = function createNodeWithSharedFlag() {
-      const node = originalCreateNode.apply(NODEFS, arguments);
+      const node = originalNodeFsCreateNode.apply(NODEFS, arguments);
       node.isSharedFS = true;
       return node;
     };
     var originalHashAddNode = FS.hashAddNode;
     FS.hashAddNode = function hashAddNodeIfNotSharedFS(node) {
-      if (typeof locking === "object" && locking?.is_shared_fs_node(node)) {
+      if (node?.isSharedFS) {
         return;
       }
       return originalHashAddNode.apply(FS, arguments);
@@ -28093,9 +28102,9 @@ var init_php_8_4 = __esm({
     "use strict";
     import_module = require("module");
     import_path = __toESM(require("path"), 1);
-    dependencyFilename = import_path.default.join(__dirname + "/jspi", "8_4_10", "php_8_4.wasm");
-    dependenciesTotalSize = 36372438;
-    phpVersionString = "8.4.10";
+    dependencyFilename = import_path.default.join(__dirname + "/jspi", "8_4_11", "php_8_4.wasm");
+    dependenciesTotalSize = 36373389;
+    phpVersionString = "8.4.11";
   }
 });
 
@@ -28754,7 +28763,7 @@ function init3(RuntimeName, PHPLoader) {
   };
   var wasmTableMirror = [];
   var wasmTable = new WebAssembly.Table({
-    initial: 15738,
+    initial: 15739,
     element: "anyfunc"
   });
   var getWasmTableEntry = (funcPtr) => {
@@ -33829,27 +33838,21 @@ function init3(RuntimeName, PHPLoader) {
       1: "exclusive",
       2: "unlocked"
     },
-    is_shared_fs_node(node) {
-      if (node?.isSharedFS) {
-        return true;
-      }
-      if (!node?.mount?.opts?.fs?.lookupPath || !node?.mount?.type?.realPath) {
-        return false;
-      }
-      if (node.mount.type !== NODEFS) {
-        return false;
-      }
-      const vfsPath = node.mount.type.realPath(node);
-      try {
-        const underlyingNode = node.mount.opts.fs.lookupPath(vfsPath)?.node;
-        return !!underlyingNode?.isSharedFS;
-      } catch (e) {
-        return false;
-      }
-    },
     is_path_to_shared_fs(path33) {
-      const { node } = FS.lookupPath(path33);
-      return locking.is_shared_fs_node(node);
+      _js_wasm_trace("is_path_to_shared_fs(%s)", path33);
+      const { node } = FS.lookupPath(path33, { noent_okay: true });
+      if (node.mount.type !== PROXYFS) {
+        return !!node.isSharedFS;
+      }
+      const nodePath2 = PROXYFS.realPath(node);
+      const backingFs = node?.mount?.opts?.fs;
+      if (backingFs) {
+        const { node: backingNode } = backingFs.lookupPath(nodePath2, {
+          noent_okay: true
+        });
+        return !!backingNode?.isSharedFS;
+      }
+      return false;
     },
     get_fd_access_mode(fd) {
       const emscripten_F_GETFL = Number("3");
@@ -33864,8 +33867,23 @@ function init3(RuntimeName, PHPLoader) {
       }
     },
     get_native_path_from_vfs_path(vfsPath) {
-      const { node } = FS.lookupPath(vfsPath);
-      return NODEFS.realPath(node);
+      const { node } = FS.lookupPath(vfsPath, {});
+      if (node.mount.type === NODEFS) {
+        return NODEFS.realPath(node);
+      } else if (node.mount.type === PROXYFS) {
+        const { node: backingNode, path: backingPath } = node.mount.opts.fs.lookupPath(vfsPath);
+        _js_wasm_trace(
+          "backingNode for %s: %s",
+          vfsPath,
+          backingPath,
+          backingNode
+        );
+        return backingNode.mount.type.realPath(backingNode);
+      } else {
+        throw new Error(
+          `Unsupported filesystem type for path ${vfsPath}`
+        );
+      }
     },
     check_lock_params(fd, l_type) {
       const emscripten_O_RDONLY = Number("0");
@@ -53285,13 +53303,13 @@ ${e}`);
   Module["createContext"] = Browser.createContext;
   registerPostMainLoop(() => SDL.audio?.queueNewAudioData?.());
   var ASM_CONSTS = {
-    13232622: ($0) => {
+    13232510: ($0) => {
       if (!$0) {
         AL.alcErr = 40964;
         return 1;
       }
     },
-    13232670: ($0) => {
+    13232558: ($0) => {
       if (!AL.currentCtx) {
         err("alGetProcAddress() called without a valid context");
         return 1;
@@ -56136,15 +56154,15 @@ ${e}`);
   PHPLoader["malloc"] = _malloc;
   PHPLoader["free"] = typeof _free === "function" ? _free : PHPLoader["_wasm_free"];
   if (typeof NODEFS === "object") {
-    const originalCreateNode = NODEFS.createNode;
+    const originalNodeFsCreateNode = NODEFS.createNode;
     NODEFS.createNode = function createNodeWithSharedFlag() {
-      const node = originalCreateNode.apply(NODEFS, arguments);
+      const node = originalNodeFsCreateNode.apply(NODEFS, arguments);
       node.isSharedFS = true;
       return node;
     };
     var originalHashAddNode = FS.hashAddNode;
     FS.hashAddNode = function hashAddNodeIfNotSharedFS(node) {
-      if (typeof locking === "object" && locking?.is_shared_fs_node(node)) {
+      if (node?.isSharedFS) {
         return;
       }
       return originalHashAddNode.apply(FS, arguments);
@@ -56162,9 +56180,9 @@ var init_php_8_3 = __esm({
     "use strict";
     import_module2 = require("module");
     import_path2 = __toESM(require("path"), 1);
-    dependencyFilename2 = import_path2.default.join(__dirname + "/jspi", "8_3_23", "php_8_3.wasm");
-    dependenciesTotalSize2 = 32571921;
-    phpVersionString2 = "8.3.23";
+    dependencyFilename2 = import_path2.default.join(__dirname + "/jspi", "8_3_24", "php_8_3.wasm");
+    dependenciesTotalSize2 = 32572592;
+    phpVersionString2 = "8.3.24";
   }
 });
 
@@ -61898,27 +61916,21 @@ function init4(RuntimeName, PHPLoader) {
       1: "exclusive",
       2: "unlocked"
     },
-    is_shared_fs_node(node) {
-      if (node?.isSharedFS) {
-        return true;
-      }
-      if (!node?.mount?.opts?.fs?.lookupPath || !node?.mount?.type?.realPath) {
-        return false;
-      }
-      if (node.mount.type !== NODEFS) {
-        return false;
-      }
-      const vfsPath = node.mount.type.realPath(node);
-      try {
-        const underlyingNode = node.mount.opts.fs.lookupPath(vfsPath)?.node;
-        return !!underlyingNode?.isSharedFS;
-      } catch (e) {
-        return false;
-      }
-    },
     is_path_to_shared_fs(path33) {
-      const { node } = FS.lookupPath(path33);
-      return locking.is_shared_fs_node(node);
+      _js_wasm_trace("is_path_to_shared_fs(%s)", path33);
+      const { node } = FS.lookupPath(path33, { noent_okay: true });
+      if (node.mount.type !== PROXYFS) {
+        return !!node.isSharedFS;
+      }
+      const nodePath2 = PROXYFS.realPath(node);
+      const backingFs = node?.mount?.opts?.fs;
+      if (backingFs) {
+        const { node: backingNode } = backingFs.lookupPath(nodePath2, {
+          noent_okay: true
+        });
+        return !!backingNode?.isSharedFS;
+      }
+      return false;
     },
     get_fd_access_mode(fd) {
       const emscripten_F_GETFL = Number("3");
@@ -61933,8 +61945,23 @@ function init4(RuntimeName, PHPLoader) {
       }
     },
     get_native_path_from_vfs_path(vfsPath) {
-      const { node } = FS.lookupPath(vfsPath);
-      return NODEFS.realPath(node);
+      const { node } = FS.lookupPath(vfsPath, {});
+      if (node.mount.type === NODEFS) {
+        return NODEFS.realPath(node);
+      } else if (node.mount.type === PROXYFS) {
+        const { node: backingNode, path: backingPath } = node.mount.opts.fs.lookupPath(vfsPath);
+        _js_wasm_trace(
+          "backingNode for %s: %s",
+          vfsPath,
+          backingPath,
+          backingNode
+        );
+        return backingNode.mount.type.realPath(backingNode);
+      } else {
+        throw new Error(
+          `Unsupported filesystem type for path ${vfsPath}`
+        );
+      }
     },
     check_lock_params(fd, l_type) {
       const emscripten_O_RDONLY = Number("0");
@@ -84205,15 +84232,15 @@ ${e}`);
   PHPLoader["malloc"] = _malloc;
   PHPLoader["free"] = typeof _free === "function" ? _free : PHPLoader["_wasm_free"];
   if (typeof NODEFS === "object") {
-    const originalCreateNode = NODEFS.createNode;
+    const originalNodeFsCreateNode = NODEFS.createNode;
     NODEFS.createNode = function createNodeWithSharedFlag() {
-      const node = originalCreateNode.apply(NODEFS, arguments);
+      const node = originalNodeFsCreateNode.apply(NODEFS, arguments);
       node.isSharedFS = true;
       return node;
     };
     var originalHashAddNode = FS.hashAddNode;
     FS.hashAddNode = function hashAddNodeIfNotSharedFS(node) {
-      if (typeof locking === "object" && locking?.is_shared_fs_node(node)) {
+      if (node?.isSharedFS) {
         return;
       }
       return originalHashAddNode.apply(FS, arguments);
@@ -89967,27 +89994,21 @@ function init5(RuntimeName, PHPLoader) {
       1: "exclusive",
       2: "unlocked"
     },
-    is_shared_fs_node(node) {
-      if (node?.isSharedFS) {
-        return true;
-      }
-      if (!node?.mount?.opts?.fs?.lookupPath || !node?.mount?.type?.realPath) {
-        return false;
-      }
-      if (node.mount.type !== NODEFS) {
-        return false;
-      }
-      const vfsPath = node.mount.type.realPath(node);
-      try {
-        const underlyingNode = node.mount.opts.fs.lookupPath(vfsPath)?.node;
-        return !!underlyingNode?.isSharedFS;
-      } catch (e) {
-        return false;
-      }
-    },
     is_path_to_shared_fs(path33) {
-      const { node } = FS.lookupPath(path33);
-      return locking.is_shared_fs_node(node);
+      _js_wasm_trace("is_path_to_shared_fs(%s)", path33);
+      const { node } = FS.lookupPath(path33, { noent_okay: true });
+      if (node.mount.type !== PROXYFS) {
+        return !!node.isSharedFS;
+      }
+      const nodePath2 = PROXYFS.realPath(node);
+      const backingFs = node?.mount?.opts?.fs;
+      if (backingFs) {
+        const { node: backingNode } = backingFs.lookupPath(nodePath2, {
+          noent_okay: true
+        });
+        return !!backingNode?.isSharedFS;
+      }
+      return false;
     },
     get_fd_access_mode(fd) {
       const emscripten_F_GETFL = Number("3");
@@ -90002,8 +90023,23 @@ function init5(RuntimeName, PHPLoader) {
       }
     },
     get_native_path_from_vfs_path(vfsPath) {
-      const { node } = FS.lookupPath(vfsPath);
-      return NODEFS.realPath(node);
+      const { node } = FS.lookupPath(vfsPath, {});
+      if (node.mount.type === NODEFS) {
+        return NODEFS.realPath(node);
+      } else if (node.mount.type === PROXYFS) {
+        const { node: backingNode, path: backingPath } = node.mount.opts.fs.lookupPath(vfsPath);
+        _js_wasm_trace(
+          "backingNode for %s: %s",
+          vfsPath,
+          backingPath,
+          backingNode
+        );
+        return backingNode.mount.type.realPath(backingNode);
+      } else {
+        throw new Error(
+          `Unsupported filesystem type for path ${vfsPath}`
+        );
+      }
     },
     check_lock_params(fd, l_type) {
       const emscripten_O_RDONLY = Number("0");
@@ -112274,15 +112310,15 @@ ${e}`);
   PHPLoader["malloc"] = _malloc;
   PHPLoader["free"] = typeof _free === "function" ? _free : PHPLoader["_wasm_free"];
   if (typeof NODEFS === "object") {
-    const originalCreateNode = NODEFS.createNode;
+    const originalNodeFsCreateNode = NODEFS.createNode;
     NODEFS.createNode = function createNodeWithSharedFlag() {
-      const node = originalCreateNode.apply(NODEFS, arguments);
+      const node = originalNodeFsCreateNode.apply(NODEFS, arguments);
       node.isSharedFS = true;
       return node;
     };
     var originalHashAddNode = FS.hashAddNode;
     FS.hashAddNode = function hashAddNodeIfNotSharedFS(node) {
-      if (typeof locking === "object" && locking?.is_shared_fs_node(node)) {
+      if (node?.isSharedFS) {
         return;
       }
       return originalHashAddNode.apply(FS, arguments);
@@ -118036,27 +118072,21 @@ function init6(RuntimeName, PHPLoader) {
       1: "exclusive",
       2: "unlocked"
     },
-    is_shared_fs_node(node) {
-      if (node?.isSharedFS) {
-        return true;
-      }
-      if (!node?.mount?.opts?.fs?.lookupPath || !node?.mount?.type?.realPath) {
-        return false;
-      }
-      if (node.mount.type !== NODEFS) {
-        return false;
-      }
-      const vfsPath = node.mount.type.realPath(node);
-      try {
-        const underlyingNode = node.mount.opts.fs.lookupPath(vfsPath)?.node;
-        return !!underlyingNode?.isSharedFS;
-      } catch (e) {
-        return false;
-      }
-    },
     is_path_to_shared_fs(path33) {
-      const { node } = FS.lookupPath(path33);
-      return locking.is_shared_fs_node(node);
+      _js_wasm_trace("is_path_to_shared_fs(%s)", path33);
+      const { node } = FS.lookupPath(path33, { noent_okay: true });
+      if (node.mount.type !== PROXYFS) {
+        return !!node.isSharedFS;
+      }
+      const nodePath2 = PROXYFS.realPath(node);
+      const backingFs = node?.mount?.opts?.fs;
+      if (backingFs) {
+        const { node: backingNode } = backingFs.lookupPath(nodePath2, {
+          noent_okay: true
+        });
+        return !!backingNode?.isSharedFS;
+      }
+      return false;
     },
     get_fd_access_mode(fd) {
       const emscripten_F_GETFL = Number("3");
@@ -118071,8 +118101,23 @@ function init6(RuntimeName, PHPLoader) {
       }
     },
     get_native_path_from_vfs_path(vfsPath) {
-      const { node } = FS.lookupPath(vfsPath);
-      return NODEFS.realPath(node);
+      const { node } = FS.lookupPath(vfsPath, {});
+      if (node.mount.type === NODEFS) {
+        return NODEFS.realPath(node);
+      } else if (node.mount.type === PROXYFS) {
+        const { node: backingNode, path: backingPath } = node.mount.opts.fs.lookupPath(vfsPath);
+        _js_wasm_trace(
+          "backingNode for %s: %s",
+          vfsPath,
+          backingPath,
+          backingNode
+        );
+        return backingNode.mount.type.realPath(backingNode);
+      } else {
+        throw new Error(
+          `Unsupported filesystem type for path ${vfsPath}`
+        );
+      }
     },
     check_lock_params(fd, l_type) {
       const emscripten_O_RDONLY = Number("0");
@@ -140343,15 +140388,15 @@ ${e}`);
   PHPLoader["malloc"] = _malloc;
   PHPLoader["free"] = typeof _free === "function" ? _free : PHPLoader["_wasm_free"];
   if (typeof NODEFS === "object") {
-    const originalCreateNode = NODEFS.createNode;
+    const originalNodeFsCreateNode = NODEFS.createNode;
     NODEFS.createNode = function createNodeWithSharedFlag() {
-      const node = originalCreateNode.apply(NODEFS, arguments);
+      const node = originalNodeFsCreateNode.apply(NODEFS, arguments);
       node.isSharedFS = true;
       return node;
     };
     var originalHashAddNode = FS.hashAddNode;
     FS.hashAddNode = function hashAddNodeIfNotSharedFS(node) {
-      if (typeof locking === "object" && locking?.is_shared_fs_node(node)) {
+      if (node?.isSharedFS) {
         return;
       }
       return originalHashAddNode.apply(FS, arguments);
@@ -146105,27 +146150,21 @@ function init7(RuntimeName, PHPLoader) {
       1: "exclusive",
       2: "unlocked"
     },
-    is_shared_fs_node(node) {
-      if (node?.isSharedFS) {
-        return true;
-      }
-      if (!node?.mount?.opts?.fs?.lookupPath || !node?.mount?.type?.realPath) {
-        return false;
-      }
-      if (node.mount.type !== NODEFS) {
-        return false;
-      }
-      const vfsPath = node.mount.type.realPath(node);
-      try {
-        const underlyingNode = node.mount.opts.fs.lookupPath(vfsPath)?.node;
-        return !!underlyingNode?.isSharedFS;
-      } catch (e) {
-        return false;
-      }
-    },
     is_path_to_shared_fs(path33) {
-      const { node } = FS.lookupPath(path33);
-      return locking.is_shared_fs_node(node);
+      _js_wasm_trace("is_path_to_shared_fs(%s)", path33);
+      const { node } = FS.lookupPath(path33, { noent_okay: true });
+      if (node.mount.type !== PROXYFS) {
+        return !!node.isSharedFS;
+      }
+      const nodePath2 = PROXYFS.realPath(node);
+      const backingFs = node?.mount?.opts?.fs;
+      if (backingFs) {
+        const { node: backingNode } = backingFs.lookupPath(nodePath2, {
+          noent_okay: true
+        });
+        return !!backingNode?.isSharedFS;
+      }
+      return false;
     },
     get_fd_access_mode(fd) {
       const emscripten_F_GETFL = Number("3");
@@ -146140,8 +146179,23 @@ function init7(RuntimeName, PHPLoader) {
       }
     },
     get_native_path_from_vfs_path(vfsPath) {
-      const { node } = FS.lookupPath(vfsPath);
-      return NODEFS.realPath(node);
+      const { node } = FS.lookupPath(vfsPath, {});
+      if (node.mount.type === NODEFS) {
+        return NODEFS.realPath(node);
+      } else if (node.mount.type === PROXYFS) {
+        const { node: backingNode, path: backingPath } = node.mount.opts.fs.lookupPath(vfsPath);
+        _js_wasm_trace(
+          "backingNode for %s: %s",
+          vfsPath,
+          backingPath,
+          backingNode
+        );
+        return backingNode.mount.type.realPath(backingNode);
+      } else {
+        throw new Error(
+          `Unsupported filesystem type for path ${vfsPath}`
+        );
+      }
     },
     check_lock_params(fd, l_type) {
       const emscripten_O_RDONLY = Number("0");
@@ -168412,15 +168466,15 @@ ${e}`);
   PHPLoader["malloc"] = _malloc;
   PHPLoader["free"] = typeof _free === "function" ? _free : PHPLoader["_wasm_free"];
   if (typeof NODEFS === "object") {
-    const originalCreateNode = NODEFS.createNode;
+    const originalNodeFsCreateNode = NODEFS.createNode;
     NODEFS.createNode = function createNodeWithSharedFlag() {
-      const node = originalCreateNode.apply(NODEFS, arguments);
+      const node = originalNodeFsCreateNode.apply(NODEFS, arguments);
       node.isSharedFS = true;
       return node;
     };
     var originalHashAddNode = FS.hashAddNode;
     FS.hashAddNode = function hashAddNodeIfNotSharedFS(node) {
-      if (typeof locking === "object" && locking?.is_shared_fs_node(node)) {
+      if (node?.isSharedFS) {
         return;
       }
       return originalHashAddNode.apply(FS, arguments);
@@ -174174,27 +174228,21 @@ function init8(RuntimeName, PHPLoader) {
       1: "exclusive",
       2: "unlocked"
     },
-    is_shared_fs_node(node) {
-      if (node?.isSharedFS) {
-        return true;
-      }
-      if (!node?.mount?.opts?.fs?.lookupPath || !node?.mount?.type?.realPath) {
-        return false;
-      }
-      if (node.mount.type !== NODEFS) {
-        return false;
-      }
-      const vfsPath = node.mount.type.realPath(node);
-      try {
-        const underlyingNode = node.mount.opts.fs.lookupPath(vfsPath)?.node;
-        return !!underlyingNode?.isSharedFS;
-      } catch (e) {
-        return false;
-      }
-    },
     is_path_to_shared_fs(path33) {
-      const { node } = FS.lookupPath(path33);
-      return locking.is_shared_fs_node(node);
+      _js_wasm_trace("is_path_to_shared_fs(%s)", path33);
+      const { node } = FS.lookupPath(path33, { noent_okay: true });
+      if (node.mount.type !== PROXYFS) {
+        return !!node.isSharedFS;
+      }
+      const nodePath2 = PROXYFS.realPath(node);
+      const backingFs = node?.mount?.opts?.fs;
+      if (backingFs) {
+        const { node: backingNode } = backingFs.lookupPath(nodePath2, {
+          noent_okay: true
+        });
+        return !!backingNode?.isSharedFS;
+      }
+      return false;
     },
     get_fd_access_mode(fd) {
       const emscripten_F_GETFL = Number("3");
@@ -174209,8 +174257,23 @@ function init8(RuntimeName, PHPLoader) {
       }
     },
     get_native_path_from_vfs_path(vfsPath) {
-      const { node } = FS.lookupPath(vfsPath);
-      return NODEFS.realPath(node);
+      const { node } = FS.lookupPath(vfsPath, {});
+      if (node.mount.type === NODEFS) {
+        return NODEFS.realPath(node);
+      } else if (node.mount.type === PROXYFS) {
+        const { node: backingNode, path: backingPath } = node.mount.opts.fs.lookupPath(vfsPath);
+        _js_wasm_trace(
+          "backingNode for %s: %s",
+          vfsPath,
+          backingPath,
+          backingNode
+        );
+        return backingNode.mount.type.realPath(backingNode);
+      } else {
+        throw new Error(
+          `Unsupported filesystem type for path ${vfsPath}`
+        );
+      }
     },
     check_lock_params(fd, l_type) {
       const emscripten_O_RDONLY = Number("0");
@@ -196481,15 +196544,15 @@ ${e}`);
   PHPLoader["malloc"] = _malloc;
   PHPLoader["free"] = typeof _free === "function" ? _free : PHPLoader["_wasm_free"];
   if (typeof NODEFS === "object") {
-    const originalCreateNode = NODEFS.createNode;
+    const originalNodeFsCreateNode = NODEFS.createNode;
     NODEFS.createNode = function createNodeWithSharedFlag() {
-      const node = originalCreateNode.apply(NODEFS, arguments);
+      const node = originalNodeFsCreateNode.apply(NODEFS, arguments);
       node.isSharedFS = true;
       return node;
     };
     var originalHashAddNode = FS.hashAddNode;
     FS.hashAddNode = function hashAddNodeIfNotSharedFS(node) {
-      if (typeof locking === "object" && locking?.is_shared_fs_node(node)) {
+      if (node?.isSharedFS) {
         return;
       }
       return originalHashAddNode.apply(FS, arguments);
@@ -202243,27 +202306,21 @@ function init9(RuntimeName, PHPLoader) {
       1: "exclusive",
       2: "unlocked"
     },
-    is_shared_fs_node(node) {
-      if (node?.isSharedFS) {
-        return true;
-      }
-      if (!node?.mount?.opts?.fs?.lookupPath || !node?.mount?.type?.realPath) {
-        return false;
-      }
-      if (node.mount.type !== NODEFS) {
-        return false;
-      }
-      const vfsPath = node.mount.type.realPath(node);
-      try {
-        const underlyingNode = node.mount.opts.fs.lookupPath(vfsPath)?.node;
-        return !!underlyingNode?.isSharedFS;
-      } catch (e) {
-        return false;
-      }
-    },
     is_path_to_shared_fs(path33) {
-      const { node } = FS.lookupPath(path33);
-      return locking.is_shared_fs_node(node);
+      _js_wasm_trace("is_path_to_shared_fs(%s)", path33);
+      const { node } = FS.lookupPath(path33, { noent_okay: true });
+      if (node.mount.type !== PROXYFS) {
+        return !!node.isSharedFS;
+      }
+      const nodePath2 = PROXYFS.realPath(node);
+      const backingFs = node?.mount?.opts?.fs;
+      if (backingFs) {
+        const { node: backingNode } = backingFs.lookupPath(nodePath2, {
+          noent_okay: true
+        });
+        return !!backingNode?.isSharedFS;
+      }
+      return false;
     },
     get_fd_access_mode(fd) {
       const emscripten_F_GETFL = Number("3");
@@ -202278,8 +202335,23 @@ function init9(RuntimeName, PHPLoader) {
       }
     },
     get_native_path_from_vfs_path(vfsPath) {
-      const { node } = FS.lookupPath(vfsPath);
-      return NODEFS.realPath(node);
+      const { node } = FS.lookupPath(vfsPath, {});
+      if (node.mount.type === NODEFS) {
+        return NODEFS.realPath(node);
+      } else if (node.mount.type === PROXYFS) {
+        const { node: backingNode, path: backingPath } = node.mount.opts.fs.lookupPath(vfsPath);
+        _js_wasm_trace(
+          "backingNode for %s: %s",
+          vfsPath,
+          backingPath,
+          backingNode
+        );
+        return backingNode.mount.type.realPath(backingNode);
+      } else {
+        throw new Error(
+          `Unsupported filesystem type for path ${vfsPath}`
+        );
+      }
     },
     check_lock_params(fd, l_type) {
       const emscripten_O_RDONLY = Number("0");
@@ -224550,15 +224622,15 @@ ${e}`);
   PHPLoader["malloc"] = _malloc;
   PHPLoader["free"] = typeof _free === "function" ? _free : PHPLoader["_wasm_free"];
   if (typeof NODEFS === "object") {
-    const originalCreateNode = NODEFS.createNode;
+    const originalNodeFsCreateNode = NODEFS.createNode;
     NODEFS.createNode = function createNodeWithSharedFlag() {
-      const node = originalCreateNode.apply(NODEFS, arguments);
+      const node = originalNodeFsCreateNode.apply(NODEFS, arguments);
       node.isSharedFS = true;
       return node;
     };
     var originalHashAddNode = FS.hashAddNode;
     FS.hashAddNode = function hashAddNodeIfNotSharedFS(node) {
-      if (typeof locking === "object" && locking?.is_shared_fs_node(node)) {
+      if (node?.isSharedFS) {
         return;
       }
       return originalHashAddNode.apply(FS, arguments);
@@ -225233,7 +225305,7 @@ function init10(RuntimeName, PHPLoader) {
   };
   var wasmTableMirror = [];
   var wasmTable = new WebAssembly.Table({
-    initial: 16954,
+    initial: 16955,
     element: "anyfunc"
   });
   var getWasmTableEntry = (funcPtr) => {
@@ -230405,27 +230477,21 @@ function init10(RuntimeName, PHPLoader) {
       1: "exclusive",
       2: "unlocked"
     },
-    is_shared_fs_node(node) {
-      if (node?.isSharedFS) {
-        return true;
-      }
-      if (!node?.mount?.opts?.fs?.lookupPath || !node?.mount?.type?.realPath) {
-        return false;
-      }
-      if (node.mount.type !== NODEFS) {
-        return false;
-      }
-      const vfsPath = node.mount.type.realPath(node);
-      try {
-        const underlyingNode = node.mount.opts.fs.lookupPath(vfsPath)?.node;
-        return !!underlyingNode?.isSharedFS;
-      } catch (e) {
-        return false;
-      }
-    },
     is_path_to_shared_fs(path33) {
-      const { node } = FS.lookupPath(path33);
-      return locking.is_shared_fs_node(node);
+      _js_wasm_trace("is_path_to_shared_fs(%s)", path33);
+      const { node } = FS.lookupPath(path33, { noent_okay: true });
+      if (node.mount.type !== PROXYFS) {
+        return !!node.isSharedFS;
+      }
+      const nodePath2 = PROXYFS.realPath(node);
+      const backingFs = node?.mount?.opts?.fs;
+      if (backingFs) {
+        const { node: backingNode } = backingFs.lookupPath(nodePath2, {
+          noent_okay: true
+        });
+        return !!backingNode?.isSharedFS;
+      }
+      return false;
     },
     get_fd_access_mode(fd) {
       const emscripten_F_GETFL = Number("3");
@@ -230440,8 +230506,23 @@ function init10(RuntimeName, PHPLoader) {
       }
     },
     get_native_path_from_vfs_path(vfsPath) {
-      const { node } = FS.lookupPath(vfsPath);
-      return NODEFS.realPath(node);
+      const { node } = FS.lookupPath(vfsPath, {});
+      if (node.mount.type === NODEFS) {
+        return NODEFS.realPath(node);
+      } else if (node.mount.type === PROXYFS) {
+        const { node: backingNode, path: backingPath } = node.mount.opts.fs.lookupPath(vfsPath);
+        _js_wasm_trace(
+          "backingNode for %s: %s",
+          vfsPath,
+          backingPath,
+          backingNode
+        );
+        return backingNode.mount.type.realPath(backingNode);
+      } else {
+        throw new Error(
+          `Unsupported filesystem type for path ${vfsPath}`
+        );
+      }
     },
     check_lock_params(fd, l_type) {
       const emscripten_O_RDONLY = Number("0");
@@ -250305,13 +250386,13 @@ ${e}`);
   Module["createContext"] = Browser.createContext;
   registerPostMainLoop(() => SDL.audio?.queueNewAudioData?.());
   var ASM_CONSTS = {
-    16327533: ($0) => {
+    16327421: ($0) => {
       if (!$0) {
         AL.alcErr = 40964;
         return 1;
       }
     },
-    16327581: ($0) => {
+    16327469: ($0) => {
       if (!AL.currentCtx) {
         err("alGetProcAddress() called without a valid context");
         return 1;
@@ -253573,15 +253654,15 @@ ${e}`);
   PHPLoader["malloc"] = _malloc;
   PHPLoader["free"] = typeof _free === "function" ? _free : PHPLoader["_wasm_free"];
   if (typeof NODEFS === "object") {
-    const originalCreateNode = NODEFS.createNode;
+    const originalNodeFsCreateNode = NODEFS.createNode;
     NODEFS.createNode = function createNodeWithSharedFlag() {
-      const node = originalCreateNode.apply(NODEFS, arguments);
+      const node = originalNodeFsCreateNode.apply(NODEFS, arguments);
       node.isSharedFS = true;
       return node;
     };
     var originalHashAddNode = FS.hashAddNode;
     FS.hashAddNode = function hashAddNodeIfNotSharedFS(node) {
-      if (typeof locking === "object" && locking?.is_shared_fs_node(node)) {
+      if (node?.isSharedFS) {
         return;
       }
       return originalHashAddNode.apply(FS, arguments);
@@ -253599,9 +253680,9 @@ var init_php_8_42 = __esm({
     "use strict";
     import_module9 = require("module");
     import_path9 = __toESM(require("path"), 1);
-    dependencyFilename9 = import_path9.default.join(__dirname + "/asyncify", "8_4_10", "php_8_4.wasm");
-    dependenciesTotalSize9 = 36942485;
-    phpVersionString9 = "8.4.10";
+    dependencyFilename9 = import_path9.default.join(__dirname + "/asyncify", "8_4_11", "php_8_4.wasm");
+    dependenciesTotalSize9 = 36942530;
+    phpVersionString9 = "8.4.11";
   }
 });
 
@@ -254114,7 +254195,7 @@ function init11(RuntimeName, PHPLoader) {
       newDSO("__main__", 0, wasmImports);
     }
   };
-  var ___heap_base = 15213312;
+  var ___heap_base = 15213248;
   var alignMemory = (size, alignment) => {
     return Math.ceil(size / alignment) * alignment;
   };
@@ -254256,7 +254337,7 @@ function init11(RuntimeName, PHPLoader) {
   };
   var wasmTableMirror = [];
   var wasmTable = new WebAssembly.Table({
-    initial: 16130,
+    initial: 16131,
     element: "anyfunc"
   });
   var getWasmTableEntry = (funcPtr) => {
@@ -254877,11 +254958,11 @@ function init11(RuntimeName, PHPLoader) {
     { value: "i32", mutable: false },
     1024
   );
-  var ___stack_high = 15213312;
-  var ___stack_low = 14164736;
+  var ___stack_high = 15213248;
+  var ___stack_low = 14164672;
   var ___stack_pointer = new WebAssembly.Global(
     { value: "i32", mutable: true },
-    15213312
+    15213248
   );
   var PATH = {
     isAbs: (path33) => path33.charAt(0) === "/",
@@ -259428,27 +259509,21 @@ function init11(RuntimeName, PHPLoader) {
       1: "exclusive",
       2: "unlocked"
     },
-    is_shared_fs_node(node) {
-      if (node?.isSharedFS) {
-        return true;
-      }
-      if (!node?.mount?.opts?.fs?.lookupPath || !node?.mount?.type?.realPath) {
-        return false;
-      }
-      if (node.mount.type !== NODEFS) {
-        return false;
-      }
-      const vfsPath = node.mount.type.realPath(node);
-      try {
-        const underlyingNode = node.mount.opts.fs.lookupPath(vfsPath)?.node;
-        return !!underlyingNode?.isSharedFS;
-      } catch (e) {
-        return false;
-      }
-    },
     is_path_to_shared_fs(path33) {
-      const { node } = FS.lookupPath(path33);
-      return locking.is_shared_fs_node(node);
+      _js_wasm_trace("is_path_to_shared_fs(%s)", path33);
+      const { node } = FS.lookupPath(path33, { noent_okay: true });
+      if (node.mount.type !== PROXYFS) {
+        return !!node.isSharedFS;
+      }
+      const nodePath2 = PROXYFS.realPath(node);
+      const backingFs = node?.mount?.opts?.fs;
+      if (backingFs) {
+        const { node: backingNode } = backingFs.lookupPath(nodePath2, {
+          noent_okay: true
+        });
+        return !!backingNode?.isSharedFS;
+      }
+      return false;
     },
     get_fd_access_mode(fd) {
       const emscripten_F_GETFL = Number("3");
@@ -259463,8 +259538,23 @@ function init11(RuntimeName, PHPLoader) {
       }
     },
     get_native_path_from_vfs_path(vfsPath) {
-      const { node } = FS.lookupPath(vfsPath);
-      return NODEFS.realPath(node);
+      const { node } = FS.lookupPath(vfsPath, {});
+      if (node.mount.type === NODEFS) {
+        return NODEFS.realPath(node);
+      } else if (node.mount.type === PROXYFS) {
+        const { node: backingNode, path: backingPath } = node.mount.opts.fs.lookupPath(vfsPath);
+        _js_wasm_trace(
+          "backingNode for %s: %s",
+          vfsPath,
+          backingPath,
+          backingNode
+        );
+        return backingNode.mount.type.realPath(backingNode);
+      } else {
+        throw new Error(
+          `Unsupported filesystem type for path ${vfsPath}`
+        );
+      }
     },
     check_lock_params(fd, l_type) {
       const emscripten_O_RDONLY = Number("0");
@@ -279328,13 +279418,13 @@ ${e}`);
   Module["createContext"] = Browser.createContext;
   registerPostMainLoop(() => SDL.audio?.queueNewAudioData?.());
   var ASM_CONSTS = {
-    13232061: ($0) => {
+    13231949: ($0) => {
       if (!$0) {
         AL.alcErr = 40964;
         return 1;
       }
     },
-    13232109: ($0) => {
+    13231997: ($0) => {
       if (!AL.currentCtx) {
         err("alGetProcAddress() called without a valid context");
         return 1;
@@ -282609,15 +282699,15 @@ ${e}`);
   PHPLoader["malloc"] = _malloc;
   PHPLoader["free"] = typeof _free === "function" ? _free : PHPLoader["_wasm_free"];
   if (typeof NODEFS === "object") {
-    const originalCreateNode = NODEFS.createNode;
+    const originalNodeFsCreateNode = NODEFS.createNode;
     NODEFS.createNode = function createNodeWithSharedFlag() {
-      const node = originalCreateNode.apply(NODEFS, arguments);
+      const node = originalNodeFsCreateNode.apply(NODEFS, arguments);
       node.isSharedFS = true;
       return node;
     };
     var originalHashAddNode = FS.hashAddNode;
     FS.hashAddNode = function hashAddNodeIfNotSharedFS(node) {
-      if (typeof locking === "object" && locking?.is_shared_fs_node(node)) {
+      if (node?.isSharedFS) {
         return;
       }
       return originalHashAddNode.apply(FS, arguments);
@@ -282635,9 +282725,9 @@ var init_php_8_32 = __esm({
     "use strict";
     import_module10 = require("module");
     import_path10 = __toESM(require("path"), 1);
-    dependencyFilename10 = import_path10.default.join(__dirname + "/asyncify", "8_3_23", "php_8_3.wasm");
-    dependenciesTotalSize10 = 33145262;
-    phpVersionString10 = "8.3.23";
+    dependencyFilename10 = import_path10.default.join(__dirname + "/asyncify", "8_3_24", "php_8_3.wasm");
+    dependenciesTotalSize10 = 33144925;
+    phpVersionString10 = "8.3.24";
   }
 });
 
@@ -288464,27 +288554,21 @@ function init12(RuntimeName, PHPLoader) {
       1: "exclusive",
       2: "unlocked"
     },
-    is_shared_fs_node(node) {
-      if (node?.isSharedFS) {
-        return true;
-      }
-      if (!node?.mount?.opts?.fs?.lookupPath || !node?.mount?.type?.realPath) {
-        return false;
-      }
-      if (node.mount.type !== NODEFS) {
-        return false;
-      }
-      const vfsPath = node.mount.type.realPath(node);
-      try {
-        const underlyingNode = node.mount.opts.fs.lookupPath(vfsPath)?.node;
-        return !!underlyingNode?.isSharedFS;
-      } catch (e) {
-        return false;
-      }
-    },
     is_path_to_shared_fs(path33) {
-      const { node } = FS.lookupPath(path33);
-      return locking.is_shared_fs_node(node);
+      _js_wasm_trace("is_path_to_shared_fs(%s)", path33);
+      const { node } = FS.lookupPath(path33, { noent_okay: true });
+      if (node.mount.type !== PROXYFS) {
+        return !!node.isSharedFS;
+      }
+      const nodePath2 = PROXYFS.realPath(node);
+      const backingFs = node?.mount?.opts?.fs;
+      if (backingFs) {
+        const { node: backingNode } = backingFs.lookupPath(nodePath2, {
+          noent_okay: true
+        });
+        return !!backingNode?.isSharedFS;
+      }
+      return false;
     },
     get_fd_access_mode(fd) {
       const emscripten_F_GETFL = Number("3");
@@ -288499,8 +288583,23 @@ function init12(RuntimeName, PHPLoader) {
       }
     },
     get_native_path_from_vfs_path(vfsPath) {
-      const { node } = FS.lookupPath(vfsPath);
-      return NODEFS.realPath(node);
+      const { node } = FS.lookupPath(vfsPath, {});
+      if (node.mount.type === NODEFS) {
+        return NODEFS.realPath(node);
+      } else if (node.mount.type === PROXYFS) {
+        const { node: backingNode, path: backingPath } = node.mount.opts.fs.lookupPath(vfsPath);
+        _js_wasm_trace(
+          "backingNode for %s: %s",
+          vfsPath,
+          backingPath,
+          backingNode
+        );
+        return backingNode.mount.type.realPath(backingNode);
+      } else {
+        throw new Error(
+          `Unsupported filesystem type for path ${vfsPath}`
+        );
+      }
     },
     check_lock_params(fd, l_type) {
       const emscripten_O_RDONLY = Number("0");
@@ -311645,15 +311744,15 @@ ${e}`);
   PHPLoader["malloc"] = _malloc;
   PHPLoader["free"] = typeof _free === "function" ? _free : PHPLoader["_wasm_free"];
   if (typeof NODEFS === "object") {
-    const originalCreateNode = NODEFS.createNode;
+    const originalNodeFsCreateNode = NODEFS.createNode;
     NODEFS.createNode = function createNodeWithSharedFlag() {
-      const node = originalCreateNode.apply(NODEFS, arguments);
+      const node = originalNodeFsCreateNode.apply(NODEFS, arguments);
       node.isSharedFS = true;
       return node;
     };
     var originalHashAddNode = FS.hashAddNode;
     FS.hashAddNode = function hashAddNodeIfNotSharedFS(node) {
-      if (typeof locking === "object" && locking?.is_shared_fs_node(node)) {
+      if (node?.isSharedFS) {
         return;
       }
       return originalHashAddNode.apply(FS, arguments);
@@ -317500,27 +317599,21 @@ function init13(RuntimeName, PHPLoader) {
       1: "exclusive",
       2: "unlocked"
     },
-    is_shared_fs_node(node) {
-      if (node?.isSharedFS) {
-        return true;
-      }
-      if (!node?.mount?.opts?.fs?.lookupPath || !node?.mount?.type?.realPath) {
-        return false;
-      }
-      if (node.mount.type !== NODEFS) {
-        return false;
-      }
-      const vfsPath = node.mount.type.realPath(node);
-      try {
-        const underlyingNode = node.mount.opts.fs.lookupPath(vfsPath)?.node;
-        return !!underlyingNode?.isSharedFS;
-      } catch (e) {
-        return false;
-      }
-    },
     is_path_to_shared_fs(path33) {
-      const { node } = FS.lookupPath(path33);
-      return locking.is_shared_fs_node(node);
+      _js_wasm_trace("is_path_to_shared_fs(%s)", path33);
+      const { node } = FS.lookupPath(path33, { noent_okay: true });
+      if (node.mount.type !== PROXYFS) {
+        return !!node.isSharedFS;
+      }
+      const nodePath2 = PROXYFS.realPath(node);
+      const backingFs = node?.mount?.opts?.fs;
+      if (backingFs) {
+        const { node: backingNode } = backingFs.lookupPath(nodePath2, {
+          noent_okay: true
+        });
+        return !!backingNode?.isSharedFS;
+      }
+      return false;
     },
     get_fd_access_mode(fd) {
       const emscripten_F_GETFL = Number("3");
@@ -317535,8 +317628,23 @@ function init13(RuntimeName, PHPLoader) {
       }
     },
     get_native_path_from_vfs_path(vfsPath) {
-      const { node } = FS.lookupPath(vfsPath);
-      return NODEFS.realPath(node);
+      const { node } = FS.lookupPath(vfsPath, {});
+      if (node.mount.type === NODEFS) {
+        return NODEFS.realPath(node);
+      } else if (node.mount.type === PROXYFS) {
+        const { node: backingNode, path: backingPath } = node.mount.opts.fs.lookupPath(vfsPath);
+        _js_wasm_trace(
+          "backingNode for %s: %s",
+          vfsPath,
+          backingPath,
+          backingNode
+        );
+        return backingNode.mount.type.realPath(backingNode);
+      } else {
+        throw new Error(
+          `Unsupported filesystem type for path ${vfsPath}`
+        );
+      }
     },
     check_lock_params(fd, l_type) {
       const emscripten_O_RDONLY = Number("0");
@@ -340681,15 +340789,15 @@ ${e}`);
   PHPLoader["malloc"] = _malloc;
   PHPLoader["free"] = typeof _free === "function" ? _free : PHPLoader["_wasm_free"];
   if (typeof NODEFS === "object") {
-    const originalCreateNode = NODEFS.createNode;
+    const originalNodeFsCreateNode = NODEFS.createNode;
     NODEFS.createNode = function createNodeWithSharedFlag() {
-      const node = originalCreateNode.apply(NODEFS, arguments);
+      const node = originalNodeFsCreateNode.apply(NODEFS, arguments);
       node.isSharedFS = true;
       return node;
     };
     var originalHashAddNode = FS.hashAddNode;
     FS.hashAddNode = function hashAddNodeIfNotSharedFS(node) {
-      if (typeof locking === "object" && locking?.is_shared_fs_node(node)) {
+      if (node?.isSharedFS) {
         return;
       }
       return originalHashAddNode.apply(FS, arguments);
@@ -346536,27 +346644,21 @@ function init14(RuntimeName, PHPLoader) {
       1: "exclusive",
       2: "unlocked"
     },
-    is_shared_fs_node(node) {
-      if (node?.isSharedFS) {
-        return true;
-      }
-      if (!node?.mount?.opts?.fs?.lookupPath || !node?.mount?.type?.realPath) {
-        return false;
-      }
-      if (node.mount.type !== NODEFS) {
-        return false;
-      }
-      const vfsPath = node.mount.type.realPath(node);
-      try {
-        const underlyingNode = node.mount.opts.fs.lookupPath(vfsPath)?.node;
-        return !!underlyingNode?.isSharedFS;
-      } catch (e) {
-        return false;
-      }
-    },
     is_path_to_shared_fs(path33) {
-      const { node } = FS.lookupPath(path33);
-      return locking.is_shared_fs_node(node);
+      _js_wasm_trace("is_path_to_shared_fs(%s)", path33);
+      const { node } = FS.lookupPath(path33, { noent_okay: true });
+      if (node.mount.type !== PROXYFS) {
+        return !!node.isSharedFS;
+      }
+      const nodePath2 = PROXYFS.realPath(node);
+      const backingFs = node?.mount?.opts?.fs;
+      if (backingFs) {
+        const { node: backingNode } = backingFs.lookupPath(nodePath2, {
+          noent_okay: true
+        });
+        return !!backingNode?.isSharedFS;
+      }
+      return false;
     },
     get_fd_access_mode(fd) {
       const emscripten_F_GETFL = Number("3");
@@ -346571,8 +346673,23 @@ function init14(RuntimeName, PHPLoader) {
       }
     },
     get_native_path_from_vfs_path(vfsPath) {
-      const { node } = FS.lookupPath(vfsPath);
-      return NODEFS.realPath(node);
+      const { node } = FS.lookupPath(vfsPath, {});
+      if (node.mount.type === NODEFS) {
+        return NODEFS.realPath(node);
+      } else if (node.mount.type === PROXYFS) {
+        const { node: backingNode, path: backingPath } = node.mount.opts.fs.lookupPath(vfsPath);
+        _js_wasm_trace(
+          "backingNode for %s: %s",
+          vfsPath,
+          backingPath,
+          backingNode
+        );
+        return backingNode.mount.type.realPath(backingNode);
+      } else {
+        throw new Error(
+          `Unsupported filesystem type for path ${vfsPath}`
+        );
+      }
     },
     check_lock_params(fd, l_type) {
       const emscripten_O_RDONLY = Number("0");
@@ -369704,15 +369821,15 @@ ${e}`);
   PHPLoader["malloc"] = _malloc;
   PHPLoader["free"] = typeof _free === "function" ? _free : PHPLoader["_wasm_free"];
   if (typeof NODEFS === "object") {
-    const originalCreateNode = NODEFS.createNode;
+    const originalNodeFsCreateNode = NODEFS.createNode;
     NODEFS.createNode = function createNodeWithSharedFlag() {
-      const node = originalCreateNode.apply(NODEFS, arguments);
+      const node = originalNodeFsCreateNode.apply(NODEFS, arguments);
       node.isSharedFS = true;
       return node;
     };
     var originalHashAddNode = FS.hashAddNode;
     FS.hashAddNode = function hashAddNodeIfNotSharedFS(node) {
-      if (typeof locking === "object" && locking?.is_shared_fs_node(node)) {
+      if (node?.isSharedFS) {
         return;
       }
       return originalHashAddNode.apply(FS, arguments);
@@ -375559,27 +375676,21 @@ function init15(RuntimeName, PHPLoader) {
       1: "exclusive",
       2: "unlocked"
     },
-    is_shared_fs_node(node) {
-      if (node?.isSharedFS) {
-        return true;
-      }
-      if (!node?.mount?.opts?.fs?.lookupPath || !node?.mount?.type?.realPath) {
-        return false;
-      }
-      if (node.mount.type !== NODEFS) {
-        return false;
-      }
-      const vfsPath = node.mount.type.realPath(node);
-      try {
-        const underlyingNode = node.mount.opts.fs.lookupPath(vfsPath)?.node;
-        return !!underlyingNode?.isSharedFS;
-      } catch (e) {
-        return false;
-      }
-    },
     is_path_to_shared_fs(path33) {
-      const { node } = FS.lookupPath(path33);
-      return locking.is_shared_fs_node(node);
+      _js_wasm_trace("is_path_to_shared_fs(%s)", path33);
+      const { node } = FS.lookupPath(path33, { noent_okay: true });
+      if (node.mount.type !== PROXYFS) {
+        return !!node.isSharedFS;
+      }
+      const nodePath2 = PROXYFS.realPath(node);
+      const backingFs = node?.mount?.opts?.fs;
+      if (backingFs) {
+        const { node: backingNode } = backingFs.lookupPath(nodePath2, {
+          noent_okay: true
+        });
+        return !!backingNode?.isSharedFS;
+      }
+      return false;
     },
     get_fd_access_mode(fd) {
       const emscripten_F_GETFL = Number("3");
@@ -375594,8 +375705,23 @@ function init15(RuntimeName, PHPLoader) {
       }
     },
     get_native_path_from_vfs_path(vfsPath) {
-      const { node } = FS.lookupPath(vfsPath);
-      return NODEFS.realPath(node);
+      const { node } = FS.lookupPath(vfsPath, {});
+      if (node.mount.type === NODEFS) {
+        return NODEFS.realPath(node);
+      } else if (node.mount.type === PROXYFS) {
+        const { node: backingNode, path: backingPath } = node.mount.opts.fs.lookupPath(vfsPath);
+        _js_wasm_trace(
+          "backingNode for %s: %s",
+          vfsPath,
+          backingPath,
+          backingNode
+        );
+        return backingNode.mount.type.realPath(backingNode);
+      } else {
+        throw new Error(
+          `Unsupported filesystem type for path ${vfsPath}`
+        );
+      }
     },
     check_lock_params(fd, l_type) {
       const emscripten_O_RDONLY = Number("0");
@@ -398714,15 +398840,15 @@ ${e}`);
   PHPLoader["malloc"] = _malloc;
   PHPLoader["free"] = typeof _free === "function" ? _free : PHPLoader["_wasm_free"];
   if (typeof NODEFS === "object") {
-    const originalCreateNode = NODEFS.createNode;
+    const originalNodeFsCreateNode = NODEFS.createNode;
     NODEFS.createNode = function createNodeWithSharedFlag() {
-      const node = originalCreateNode.apply(NODEFS, arguments);
+      const node = originalNodeFsCreateNode.apply(NODEFS, arguments);
       node.isSharedFS = true;
       return node;
     };
     var originalHashAddNode = FS.hashAddNode;
     FS.hashAddNode = function hashAddNodeIfNotSharedFS(node) {
-      if (typeof locking === "object" && locking?.is_shared_fs_node(node)) {
+      if (node?.isSharedFS) {
         return;
       }
       return originalHashAddNode.apply(FS, arguments);
@@ -404569,27 +404695,21 @@ function init16(RuntimeName, PHPLoader) {
       1: "exclusive",
       2: "unlocked"
     },
-    is_shared_fs_node(node) {
-      if (node?.isSharedFS) {
-        return true;
-      }
-      if (!node?.mount?.opts?.fs?.lookupPath || !node?.mount?.type?.realPath) {
-        return false;
-      }
-      if (node.mount.type !== NODEFS) {
-        return false;
-      }
-      const vfsPath = node.mount.type.realPath(node);
-      try {
-        const underlyingNode = node.mount.opts.fs.lookupPath(vfsPath)?.node;
-        return !!underlyingNode?.isSharedFS;
-      } catch (e) {
-        return false;
-      }
-    },
     is_path_to_shared_fs(path33) {
-      const { node } = FS.lookupPath(path33);
-      return locking.is_shared_fs_node(node);
+      _js_wasm_trace("is_path_to_shared_fs(%s)", path33);
+      const { node } = FS.lookupPath(path33, { noent_okay: true });
+      if (node.mount.type !== PROXYFS) {
+        return !!node.isSharedFS;
+      }
+      const nodePath2 = PROXYFS.realPath(node);
+      const backingFs = node?.mount?.opts?.fs;
+      if (backingFs) {
+        const { node: backingNode } = backingFs.lookupPath(nodePath2, {
+          noent_okay: true
+        });
+        return !!backingNode?.isSharedFS;
+      }
+      return false;
     },
     get_fd_access_mode(fd) {
       const emscripten_F_GETFL = Number("3");
@@ -404604,8 +404724,23 @@ function init16(RuntimeName, PHPLoader) {
       }
     },
     get_native_path_from_vfs_path(vfsPath) {
-      const { node } = FS.lookupPath(vfsPath);
-      return NODEFS.realPath(node);
+      const { node } = FS.lookupPath(vfsPath, {});
+      if (node.mount.type === NODEFS) {
+        return NODEFS.realPath(node);
+      } else if (node.mount.type === PROXYFS) {
+        const { node: backingNode, path: backingPath } = node.mount.opts.fs.lookupPath(vfsPath);
+        _js_wasm_trace(
+          "backingNode for %s: %s",
+          vfsPath,
+          backingPath,
+          backingNode
+        );
+        return backingNode.mount.type.realPath(backingNode);
+      } else {
+        throw new Error(
+          `Unsupported filesystem type for path ${vfsPath}`
+        );
+      }
     },
     check_lock_params(fd, l_type) {
       const emscripten_O_RDONLY = Number("0");
@@ -427711,15 +427846,15 @@ ${e}`);
   PHPLoader["malloc"] = _malloc;
   PHPLoader["free"] = typeof _free === "function" ? _free : PHPLoader["_wasm_free"];
   if (typeof NODEFS === "object") {
-    const originalCreateNode = NODEFS.createNode;
+    const originalNodeFsCreateNode = NODEFS.createNode;
     NODEFS.createNode = function createNodeWithSharedFlag() {
-      const node = originalCreateNode.apply(NODEFS, arguments);
+      const node = originalNodeFsCreateNode.apply(NODEFS, arguments);
       node.isSharedFS = true;
       return node;
     };
     var originalHashAddNode = FS.hashAddNode;
     FS.hashAddNode = function hashAddNodeIfNotSharedFS(node) {
-      if (typeof locking === "object" && locking?.is_shared_fs_node(node)) {
+      if (node?.isSharedFS) {
         return;
       }
       return originalHashAddNode.apply(FS, arguments);
@@ -433566,27 +433701,21 @@ function init17(RuntimeName, PHPLoader) {
       1: "exclusive",
       2: "unlocked"
     },
-    is_shared_fs_node(node) {
-      if (node?.isSharedFS) {
-        return true;
-      }
-      if (!node?.mount?.opts?.fs?.lookupPath || !node?.mount?.type?.realPath) {
-        return false;
-      }
-      if (node.mount.type !== NODEFS) {
-        return false;
-      }
-      const vfsPath = node.mount.type.realPath(node);
-      try {
-        const underlyingNode = node.mount.opts.fs.lookupPath(vfsPath)?.node;
-        return !!underlyingNode?.isSharedFS;
-      } catch (e) {
-        return false;
-      }
-    },
     is_path_to_shared_fs(path33) {
-      const { node } = FS.lookupPath(path33);
-      return locking.is_shared_fs_node(node);
+      _js_wasm_trace("is_path_to_shared_fs(%s)", path33);
+      const { node } = FS.lookupPath(path33, { noent_okay: true });
+      if (node.mount.type !== PROXYFS) {
+        return !!node.isSharedFS;
+      }
+      const nodePath2 = PROXYFS.realPath(node);
+      const backingFs = node?.mount?.opts?.fs;
+      if (backingFs) {
+        const { node: backingNode } = backingFs.lookupPath(nodePath2, {
+          noent_okay: true
+        });
+        return !!backingNode?.isSharedFS;
+      }
+      return false;
     },
     get_fd_access_mode(fd) {
       const emscripten_F_GETFL = Number("3");
@@ -433601,8 +433730,23 @@ function init17(RuntimeName, PHPLoader) {
       }
     },
     get_native_path_from_vfs_path(vfsPath) {
-      const { node } = FS.lookupPath(vfsPath);
-      return NODEFS.realPath(node);
+      const { node } = FS.lookupPath(vfsPath, {});
+      if (node.mount.type === NODEFS) {
+        return NODEFS.realPath(node);
+      } else if (node.mount.type === PROXYFS) {
+        const { node: backingNode, path: backingPath } = node.mount.opts.fs.lookupPath(vfsPath);
+        _js_wasm_trace(
+          "backingNode for %s: %s",
+          vfsPath,
+          backingPath,
+          backingNode
+        );
+        return backingNode.mount.type.realPath(backingNode);
+      } else {
+        throw new Error(
+          `Unsupported filesystem type for path ${vfsPath}`
+        );
+      }
     },
     check_lock_params(fd, l_type) {
       const emscripten_O_RDONLY = Number("0");
@@ -456694,15 +456838,15 @@ ${e}`);
   PHPLoader["malloc"] = _malloc;
   PHPLoader["free"] = typeof _free === "function" ? _free : PHPLoader["_wasm_free"];
   if (typeof NODEFS === "object") {
-    const originalCreateNode = NODEFS.createNode;
+    const originalNodeFsCreateNode = NODEFS.createNode;
     NODEFS.createNode = function createNodeWithSharedFlag() {
-      const node = originalCreateNode.apply(NODEFS, arguments);
+      const node = originalNodeFsCreateNode.apply(NODEFS, arguments);
       node.isSharedFS = true;
       return node;
     };
     var originalHashAddNode = FS.hashAddNode;
     FS.hashAddNode = function hashAddNodeIfNotSharedFS(node) {
-      if (typeof locking === "object" && locking?.is_shared_fs_node(node)) {
+      if (node?.isSharedFS) {
         return;
       }
       return originalHashAddNode.apply(FS, arguments);
@@ -457831,12 +457975,7 @@ var FileLock = class _FileLock {
       }
       return true;
     }
-    if (this.doesAConflictingLockExist({
-      type: op.type,
-      start: 0n,
-      end: MAX_64BIT_OFFSET,
-      pid: op.pid
-    })) {
+    if (this.isThereAConflictWithRequestedWholeFileLock(op)) {
       return false;
     }
     if (!this.ensureCompatibleNativeLock({
@@ -457907,7 +458046,7 @@ var FileLock = class _FileLock {
       }
       return true;
     }
-    if (this.doesAConflictingLockExist(requestedLock)) {
+    if (this.isThereAConflictWithRequestedRangeLock(requestedLock)) {
       return false;
     }
     if (!this.ensureCompatibleNativeLock({
@@ -458055,14 +458194,61 @@ var FileLock = class _FileLock {
     }
   }
   /**
-   * Check if a conflicting lock exists.
+   * Check if a lock exists that conflicts with the requested range lock.
    *
    * @param requestedLock The desired byte range lock.
    * @returns True if a conflicting lock exists, false otherwise.
    */
-  doesAConflictingLockExist(requestedLock) {
+  isThereAConflictWithRequestedRangeLock(requestedLock) {
     return this.findFirstConflictingByteRangeLock(requestedLock) !== void 0;
   }
+  /**
+   * Check if a lock exists that conflicts with the requested whole-file lock.
+   *
+   * @param requestedLock The desired whole-file lock.
+   * @returns True if a conflicting lock exists, false otherwise.
+   */
+  isThereAConflictWithRequestedWholeFileLock(requestedLock) {
+    if (requestedLock.type === "exclusive") {
+      if (this.wholeFileLock.type === "exclusive" && (this.wholeFileLock.fd !== requestedLock.fd || this.wholeFileLock.pid !== requestedLock.pid)) {
+        return true;
+      }
+      if (this.wholeFileLock.type === "shared" && Array.from(this.wholeFileLock.pidFds).some(
+        ([pid]) => pid !== requestedLock.pid
+      )) {
+        return true;
+      }
+      const overlappingLocks = this.rangeLocks.findOverlapping({
+        type: "unlocked",
+        start: 0n,
+        end: MAX_64BIT_OFFSET,
+        pid: -1
+      });
+      if (overlappingLocks.length > 0) {
+        return true;
+      }
+      return false;
+    }
+    if (requestedLock.type === "shared") {
+      if (this.wholeFileLock.type === "exclusive" && this.wholeFileLock.pid !== requestedLock.pid) {
+        return true;
+      }
+      const overlappingLocks = this.rangeLocks.findOverlapping({
+        type: "unlocked",
+        start: 0n,
+        end: MAX_64BIT_OFFSET,
+        pid: -1
+      });
+      const exclusiveRangeLocks = overlappingLocks.filter(
+        (lock) => lock.type === "exclusive"
+      );
+      if (exclusiveRangeLocks.length > 0) {
+        return true;
+      }
+      return false;
+    }
+    return false;
+  }
 };
 var IntervalNode = class {
   constructor(range) {