@php-wasm/node 2.0.5 → 2.0.7

package/index.js

@@ -677,7 +677,7 @@ function init2(RuntimeName, PHPLoader) {
   };
   var wasmTableMirror = [];
   var wasmTable = new WebAssembly.Table({
-    initial: 16555,
+    initial: 16556,
     element: "anyfunc"
   });
   var getWasmTableEntry = (funcPtr) => {
@@ -5752,27 +5752,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");
@@ -5787,8 +5781,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");
@@ -25208,13 +25217,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;
@@ -28059,15 +28068,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);
@@ -28083,9 +28092,9 @@ var dependencyFilename, dependenciesTotalSize, phpVersionString;
 var init_php_8_4 = __esm({
   "packages/php-wasm/node/jspi/php_8_4.js"() {
     "use strict";
-    dependencyFilename = path.join(__dirname + "/jspi", "8_4_10", "php_8_4.wasm");
-    dependenciesTotalSize = 36372438;
-    phpVersionString = "8.4.10";
+    dependencyFilename = path.join(__dirname + "/jspi", "8_4_11", "php_8_4.wasm");
+    dependenciesTotalSize = 36373389;
+    phpVersionString = "8.4.11";
   }
 });
 
@@ -28746,7 +28755,7 @@ function init3(RuntimeName, PHPLoader) {
   };
   var wasmTableMirror = [];
   var wasmTable = new WebAssembly.Table({
-    initial: 15738,
+    initial: 15739,
     element: "anyfunc"
   });
   var getWasmTableEntry = (funcPtr) => {
@@ -33821,27 +33830,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");
@@ -33856,8 +33859,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");
@@ -53277,13 +53295,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;
@@ -56128,15 +56146,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);
@@ -56152,9 +56170,9 @@ var dependencyFilename2, dependenciesTotalSize2, phpVersionString2;
 var init_php_8_3 = __esm({
   "packages/php-wasm/node/jspi/php_8_3.js"() {
     "use strict";
-    dependencyFilename2 = path2.join(__dirname + "/jspi", "8_3_23", "php_8_3.wasm");
-    dependenciesTotalSize2 = 32571921;
-    phpVersionString2 = "8.3.23";
+    dependencyFilename2 = path2.join(__dirname + "/jspi", "8_3_24", "php_8_3.wasm");
+    dependenciesTotalSize2 = 32572592;
+    phpVersionString2 = "8.3.24";
   }
 });
 
@@ -61890,27 +61908,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");
@@ -61925,8 +61937,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");
@@ -84197,15 +84224,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);
@@ -89959,27 +89986,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");
@@ -89994,8 +90015,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");
@@ -112266,15 +112302,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);
@@ -118028,27 +118064,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");
@@ -118063,8 +118093,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");
@@ -140335,15 +140380,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);
@@ -146097,27 +146142,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");
@@ -146132,8 +146171,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");
@@ -168404,15 +168458,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);
@@ -174166,27 +174220,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");
@@ -174201,8 +174249,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");
@@ -196473,15 +196536,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);
@@ -202235,27 +202298,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");
@@ -202270,8 +202327,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");
@@ -224542,15 +224614,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);
@@ -225225,7 +225297,7 @@ function init10(RuntimeName, PHPLoader) {
   };
   var wasmTableMirror = [];
   var wasmTable = new WebAssembly.Table({
-    initial: 16954,
+    initial: 16955,
     element: "anyfunc"
   });
   var getWasmTableEntry = (funcPtr) => {
@@ -230397,27 +230469,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");
@@ -230432,8 +230498,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");
@@ -250297,13 +250378,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;
@@ -253565,15 +253646,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);
@@ -253589,9 +253670,9 @@ var dependencyFilename9, dependenciesTotalSize9, phpVersionString9;
 var init_php_8_42 = __esm({
   "packages/php-wasm/node/asyncify/php_8_4.js"() {
     "use strict";
-    dependencyFilename9 = path9.join(__dirname + "/asyncify", "8_4_10", "php_8_4.wasm");
-    dependenciesTotalSize9 = 36942485;
-    phpVersionString9 = "8.4.10";
+    dependencyFilename9 = path9.join(__dirname + "/asyncify", "8_4_11", "php_8_4.wasm");
+    dependenciesTotalSize9 = 36942530;
+    phpVersionString9 = "8.4.11";
   }
 });
 
@@ -254106,7 +254187,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;
   };
@@ -254248,7 +254329,7 @@ function init11(RuntimeName, PHPLoader) {
   };
   var wasmTableMirror = [];
   var wasmTable = new WebAssembly.Table({
-    initial: 16130,
+    initial: 16131,
     element: "anyfunc"
   });
   var getWasmTableEntry = (funcPtr) => {
@@ -254869,11 +254950,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) === "/",
@@ -259420,27 +259501,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");
@@ -259455,8 +259530,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");
@@ -279320,13 +279410,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;
@@ -282601,15 +282691,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);
@@ -282625,9 +282715,9 @@ var dependencyFilename10, dependenciesTotalSize10, phpVersionString10;
 var init_php_8_32 = __esm({
   "packages/php-wasm/node/asyncify/php_8_3.js"() {
     "use strict";
-    dependencyFilename10 = path10.join(__dirname + "/asyncify", "8_3_23", "php_8_3.wasm");
-    dependenciesTotalSize10 = 33145262;
-    phpVersionString10 = "8.3.23";
+    dependencyFilename10 = path10.join(__dirname + "/asyncify", "8_3_24", "php_8_3.wasm");
+    dependenciesTotalSize10 = 33144925;
+    phpVersionString10 = "8.3.24";
   }
 });
 
@@ -288456,27 +288546,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");
@@ -288491,8 +288575,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");
@@ -311637,15 +311736,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);
@@ -317492,27 +317591,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");
@@ -317527,8 +317620,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");
@@ -340673,15 +340781,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);
@@ -346528,27 +346636,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");
@@ -346563,8 +346665,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");
@@ -369696,15 +369813,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);
@@ -375551,27 +375668,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");
@@ -375586,8 +375697,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");
@@ -398706,15 +398832,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);
@@ -404561,27 +404687,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");
@@ -404596,8 +404716,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");
@@ -427703,15 +427838,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);
@@ -433558,27 +433693,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");
@@ -433593,8 +433722,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");
@@ -456686,15 +456830,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);
@@ -457809,12 +457953,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({
@@ -457885,7 +458024,7 @@ var FileLock = class _FileLock {
       }
       return true;
     }
-    if (this.doesAConflictingLockExist(requestedLock)) {
+    if (this.isThereAConflictWithRequestedRangeLock(requestedLock)) {
       return false;
     }
     if (!this.ensureCompatibleNativeLock({
@@ -458033,14 +458172,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) {