@php-wasm/node 3.0.54 → 3.1.1

package/index.cjs

@@ -30,8 +30,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // packages/php-wasm/node/src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  FileLock: () => FileLock,
-  FileLockManagerForNode: () => FileLockManagerForNode,
+  FileLockManagerForPosix: () => FileLockManagerForPosix,
+  FileLockManagerForWindows: () => FileLockManagerForWindows,
+  bindUserSpace: () => bindUserSpace,
   createNodeFsMountHandler: () => createNodeFsMountHandler,
   getPHPLoaderModule: () => getPHPLoaderModule,
   loadNodeRuntime: () => loadNodeRuntime,
@@ -423,16 +424,1152 @@ async function withNetworking(phpModuleArgs = {}) {
 }
 
 // packages/php-wasm/node/src/lib/load-runtime.ts
-var import_universal10 = require("@php-wasm/universal");
+var import_universal12 = require("@php-wasm/universal");
+
+// packages/php-wasm/node/src/lib/wasm-user-space.ts
+var import_promises = require("dns/promises");
+function bindUserSpace({ fileLockManager }, {
+  pid,
+  memory: { HEAP16, HEAP64, HEAP32 },
+  constants: {
+    F_RDLCK,
+    F_WRLCK,
+    F_UNLCK,
+    F_GETFL,
+    O_ACCMODE,
+    O_RDONLY,
+    O_WRONLY,
+    O_APPEND,
+    O_NONBLOCK,
+    F_SETFL,
+    F_GETLK,
+    F_SETLK,
+    F_SETLKW,
+    SEEK_SET,
+    SEEK_CUR,
+    SEEK_END,
+    LOCK_SH,
+    LOCK_EX,
+    LOCK_NB,
+    LOCK_UN
+  },
+  errnoCodes: { EBADF, EINVAL, EAGAIN, EWOULDBLOCK },
+  wasmImports: { builtin_fcntl64, builtin_fd_close, js_wasm_trace },
+  wasmExports: { wasm_get_end_offset },
+  syscalls: { getStreamFromFD },
+  FS,
+  PROXYFS,
+  NODEFS
+}) {
+  class VarArgsAccessor {
+    constructor(argsAddr) {
+      this.argsAddr = argsAddr;
+    }
+    getNextAsPointer() {
+      return this.getNextAsInt();
+    }
+    getNextAsInt() {
+      const fourByteOffset = this.argsAddr >> 2;
+      const value = HEAP32[fourByteOffset];
+      this.argsAddr += 4;
+      return value;
+    }
+  }
+  const locking = {
+    /*
+     * This is a set of possibly locked file descriptors.
+     *
+     * When a file descriptor is closed, we need to release any associated held by this process.
+     * Instead of trying remember and forget file descriptors as they are locked and unlocked,
+     * we just track file descriptors we have locked before and try an unlock when they are closed.
+     */
+    maybeLockedFds: /* @__PURE__ */ new Set(),
+    lockStateToFcntl: {
+      shared: F_RDLCK,
+      exclusive: F_WRLCK,
+      unlocked: F_UNLCK
+    },
+    fcntlToLockState: {
+      [F_RDLCK]: "shared",
+      [F_WRLCK]: "exclusive",
+      [F_UNLCK]: "unlocked"
+    },
+    is_path_to_shared_fs(path2) {
+      const { node } = FS.lookupPath(path2, { noent_okay: true });
+      if (!node) {
+        return false;
+      }
+      if (node.mount.type !== PROXYFS) {
+        return !!node.isSharedFS;
+      }
+      const nodePath = PROXYFS.realPath(node);
+      const backingFs = node?.mount?.opts?.["fs"];
+      if (backingFs) {
+        const { node: backingNode } = backingFs.lookupPath(nodePath, {
+          noent_okay: true
+        });
+        return !!backingNode?.isSharedFS;
+      }
+      return false;
+    },
+    get_fd_access_mode(fd) {
+      return builtin_fcntl64(fd, F_GETFL) & O_ACCMODE;
+    },
+    get_vfs_path_from_fd(fd) {
+      try {
+        return [FS.readlink(`/proc/self/fd/${fd}`), 0];
+      } catch {
+        return [null, EBADF];
+      }
+    },
+    get_native_path_from_vfs_path(vfsPath) {
+      const { node } = FS.lookupPath(vfsPath, {
+        noent_okay: true
+      });
+      if (!node) {
+        throw new Error(`No node found for VFS path ${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}`
+        );
+      }
+    },
+    get_native_fd_from_emscripten_fd(fd) {
+      try {
+        const stream = getStreamFromFD(fd);
+        if (stream.nfd === void 0) {
+          return [null, EBADF];
+        }
+        return [stream.nfd, 0];
+      } catch {
+        return [null, EBADF];
+      }
+    },
+    check_lock_params(fd, l_type) {
+      const accessMode = locking.get_fd_access_mode(fd);
+      if (l_type === F_WRLCK && accessMode === O_RDONLY || l_type === F_RDLCK && accessMode === O_WRONLY) {
+        js_wasm_trace(
+          "check_lock_params(%d, %d, %d) EBADF",
+          fd,
+          l_type,
+          accessMode
+        );
+        return EBADF;
+      }
+      return 0;
+    }
+  };
+  const emscripten_flock_l_type_offset = 0;
+  const emscripten_flock_l_whence_offset = 2;
+  const emscripten_flock_l_start_offset = 8;
+  const emscripten_flock_l_len_offset = 16;
+  const emscripten_flock_l_pid_offset = 24;
+  function readFlockStruct(flockStructAddress) {
+    return {
+      l_type: HEAP16[
+        // Shift right by 1 to divide by 2^1.
+        flockStructAddress + emscripten_flock_l_type_offset >> 1
+      ],
+      l_whence: HEAP16[
+        // Shift right by 1 to divide by 2^1.
+        flockStructAddress + emscripten_flock_l_whence_offset >> 1
+      ],
+      l_start: HEAP64[
+        // Shift right by 3 to divide by 2^3.
+        flockStructAddress + emscripten_flock_l_start_offset >> 3
+      ],
+      l_len: HEAP64[
+        // Shift right by 3 to divide by 2^3.
+        flockStructAddress + emscripten_flock_l_len_offset >> 3
+      ],
+      l_pid: HEAP32[
+        // Shift right by 2 to divide by 2^2.
+        flockStructAddress + emscripten_flock_l_pid_offset >> 2
+      ]
+    };
+  }
+  function updateFlockStruct(flockStructAddress, fields) {
+    if (fields.l_type !== void 0) {
+      HEAP16[
+        // Shift right by 1 to divide by 2^1.
+        flockStructAddress + emscripten_flock_l_type_offset >> 1
+      ] = fields.l_type;
+    }
+    if (fields.l_whence !== void 0) {
+      HEAP16[
+        // Shift right by 1 to divide by 2^1.
+        flockStructAddress + emscripten_flock_l_whence_offset >> 1
+      ] = fields.l_whence;
+    }
+    if (fields.l_start !== void 0) {
+      HEAP64[
+        // Shift right by 3 to divide by 2^3.
+        flockStructAddress + emscripten_flock_l_start_offset >> 3
+      ] = fields.l_start;
+    }
+    if (fields.l_len !== void 0) {
+      HEAP64[
+        // Shift right by 3 to divide by 2^3.
+        flockStructAddress + emscripten_flock_l_len_offset >> 3
+      ] = fields.l_len;
+    }
+    if (fields.l_pid !== void 0) {
+      HEAP32[
+        // Shift right by 2 to divide by 2^2.
+        flockStructAddress + emscripten_flock_l_pid_offset >> 2
+      ] = fields.l_pid;
+    }
+  }
+  function getBaseAddress(fd, whence, startOffset) {
+    let baseAddress;
+    switch (whence) {
+      case SEEK_SET:
+        baseAddress = 0n;
+        break;
+      case SEEK_CUR:
+        try {
+          const stream = getStreamFromFD(fd);
+          baseAddress = FS.llseek(stream, 0, whence);
+        } catch (e) {
+          js_wasm_trace(
+            "get_base_address(%d, %d, %d) getStreamFromFD error %s",
+            fd,
+            whence,
+            startOffset,
+            e
+          );
+          return [null, EINVAL];
+        }
+        break;
+      case SEEK_END:
+        baseAddress = wasm_get_end_offset(fd);
+        break;
+      default:
+        return [null, EINVAL];
+    }
+    if (baseAddress == -1) {
+      return [null, EBADF];
+    }
+    const resolvedOffset = baseAddress + startOffset;
+    if (resolvedOffset < 0) {
+      return [null, EINVAL];
+    }
+    return [resolvedOffset, 0];
+  }
+  function fcntl64(fd, cmd, varargs) {
+    js_wasm_trace("fcntl64(%d, %d)", fd, cmd);
+    if (!fileLockManager) {
+      js_wasm_trace(
+        "fcntl64(%d, %d) file lock manager is not available. delegate to Emscripten builtin fcntl64.",
+        fd,
+        cmd
+      );
+      return builtin_fcntl64(fd, cmd, varargs);
+    }
+    switch (cmd) {
+      case F_GETLK: {
+        const reportUnlockedFileByDefault = function reportUnlockedFileByDefault2() {
+          updateFlockStruct(flockStructAddr, {
+            l_type: F_UNLCK
+          });
+          return 0;
+        };
+        js_wasm_trace("fcntl(%d, F_GETLK)", fd);
+        const [vfsPath, vfsPathErrno] = locking.get_vfs_path_from_fd(fd);
+        if (vfsPathErrno !== 0) {
+          js_wasm_trace(
+            "fcntl(%d, F_GETLK) %s get_vfs_path_from_fd errno %d",
+            fd,
+            vfsPath,
+            vfsPathErrno
+          );
+          return -EBADF;
+        }
+        const varArgsAccessor = new VarArgsAccessor(varargs);
+        const flockStructAddr = varArgsAccessor.getNextAsPointer();
+        if (!locking.is_path_to_shared_fs(vfsPath) || fileLockManager === void 0) {
+          js_wasm_trace(
+            "fcntl(%d, F_GETLK) locking is not implemented for non-NodeFS path '%s'",
+            fd,
+            vfsPath
+          );
+          return reportUnlockedFileByDefault();
+        }
+        const flockStruct = readFlockStruct(flockStructAddr);
+        if (!(flockStruct.l_type in locking.fcntlToLockState)) {
+          return -EINVAL;
+        }
+        const paramsCheckErrno = locking.check_lock_params(
+          fd,
+          flockStruct.l_type
+        );
+        if (paramsCheckErrno !== 0) {
+          js_wasm_trace(
+            "fcntl(%d, F_GETLK) %s check_lock_params errno %d",
+            fd,
+            vfsPath,
+            paramsCheckErrno
+          );
+          return -EINVAL;
+        }
+        const requestedLockType = locking.fcntlToLockState[flockStruct.l_type];
+        const [absoluteStartOffset, baseAddressErrno] = getBaseAddress(
+          fd,
+          flockStruct.l_whence,
+          flockStruct.l_start
+        );
+        if (baseAddressErrno !== 0) {
+          js_wasm_trace(
+            "fcntl(%d, F_GETLK) %s get_base_address errno %d",
+            fd,
+            vfsPath,
+            baseAddressErrno
+          );
+          return -EINVAL;
+        }
+        const [nativeFd, nativeFdErrno] = locking.get_native_fd_from_emscripten_fd(fd);
+        if (nativeFdErrno !== 0) {
+          js_wasm_trace(
+            "fcntl(%d, F_GETLK) get_native_fd_from_emscripten_fd errno %d",
+            fd,
+            nativeFdErrno
+          );
+          return -nativeFdErrno;
+        }
+        try {
+          const nativeFilePath = locking.get_native_path_from_vfs_path(vfsPath);
+          const conflictingLock = fileLockManager.findFirstConflictingByteRangeLock(
+            nativeFilePath,
+            {
+              type: requestedLockType,
+              start: absoluteStartOffset,
+              end: absoluteStartOffset + flockStruct.l_len,
+              pid,
+              fd: nativeFd
+            }
+          );
+          if (conflictingLock === void 0) {
+            js_wasm_trace(
+              "fcntl(%d, F_GETLK) %s findFirstConflictingByteRangeLock type=unlocked start=0x%x end=0x%x",
+              fd,
+              vfsPath,
+              absoluteStartOffset,
+              absoluteStartOffset + flockStruct.l_len
+            );
+            updateFlockStruct(flockStructAddr, {
+              l_type: F_UNLCK
+            });
+            return 0;
+          }
+          js_wasm_trace(
+            "fcntl(%d, F_GETLK) %s findFirstConflictingByteRangeLock type=%s start=0x%x end=0x%x conflictingLock %d",
+            fd,
+            vfsPath,
+            conflictingLock.type,
+            conflictingLock.start,
+            conflictingLock.end,
+            conflictingLock.pid
+          );
+          const fcntlLockState = locking.lockStateToFcntl[conflictingLock.type];
+          updateFlockStruct(flockStructAddr, {
+            l_type: fcntlLockState,
+            l_whence: SEEK_SET,
+            l_start: conflictingLock.start,
+            l_len: BigInt(
+              conflictingLock.end - conflictingLock.start
+            ),
+            l_pid: conflictingLock.pid
+          });
+          return 0;
+        } catch (e) {
+          js_wasm_trace(
+            "fcntl(%d, F_GETLK) %s findFirstConflictingByteRangeLock error %s",
+            fd,
+            vfsPath,
+            e
+          );
+          return -EINVAL;
+        }
+      }
+      case F_SETLKW:
+      case F_SETLK: {
+        js_wasm_trace("fcntl(%d, F_SETLK)", fd);
+        const [vfsPath, vfsPathErrno] = locking.get_vfs_path_from_fd(fd);
+        if (vfsPathErrno !== 0) {
+          js_wasm_trace(
+            "fcntl(%d, F_SETLK) %s get_vfs_path_from_fd errno %d",
+            fd,
+            vfsPath,
+            vfsPathErrno
+          );
+          return -vfsPathErrno;
+        }
+        if (!locking.is_path_to_shared_fs(vfsPath)) {
+          js_wasm_trace(
+            "fcntl(%d, F_SETLK) locking is not implemented for non-NodeFS path %s",
+            fd,
+            vfsPath
+          );
+          return 0;
+        }
+        const varArgsAccessor = new VarArgsAccessor(varargs);
+        const flockStructAddr = varArgsAccessor.getNextAsPointer();
+        const flockStruct = readFlockStruct(flockStructAddr);
+        const [absoluteStartOffset, baseAddressErrno] = getBaseAddress(
+          fd,
+          flockStruct.l_whence,
+          flockStruct.l_start
+        );
+        if (baseAddressErrno !== 0) {
+          js_wasm_trace(
+            "fcntl(%d, F_SETLK) %s get_base_address errno %d",
+            fd,
+            vfsPath,
+            baseAddressErrno
+          );
+          return -EINVAL;
+        }
+        if (!(flockStruct.l_type in locking.fcntlToLockState)) {
+          js_wasm_trace(
+            "fcntl(%d, F_SETLK) %s invalid lock type %d",
+            fd,
+            vfsPath,
+            flockStruct.l_type
+          );
+          return -EINVAL;
+        }
+        const paramsCheckErrno = locking.check_lock_params(
+          fd,
+          flockStruct.l_type
+        );
+        if (paramsCheckErrno !== 0) {
+          js_wasm_trace(
+            "fcntl(%d, F_SETLK) %s check_lock_params errno %d",
+            fd,
+            vfsPath,
+            paramsCheckErrno
+          );
+          return -paramsCheckErrno;
+        }
+        const [nativeFd, nativeFdErrno] = locking.get_native_fd_from_emscripten_fd(fd);
+        if (nativeFdErrno !== 0) {
+          js_wasm_trace(
+            "fcntl(%d, F_SETLK) get_native_fd_from_emscripten_fd errno %d",
+            fd,
+            nativeFdErrno
+          );
+          return -nativeFdErrno;
+        }
+        const requestedLockType = locking.fcntlToLockState[flockStruct.l_type];
+        const rangeLock = {
+          type: requestedLockType,
+          start: absoluteStartOffset,
+          end: absoluteStartOffset + flockStruct.l_len,
+          pid,
+          fd: nativeFd
+        };
+        try {
+          const nativeFilePath = locking.get_native_path_from_vfs_path(vfsPath);
+          js_wasm_trace(
+            "fcntl(%d, F_SETLK) %s calling lockFileByteRange for range lock %s",
+            fd,
+            vfsPath,
+            rangeLock
+          );
+          const waitForLock = cmd === F_SETLKW;
+          const succeeded = fileLockManager.lockFileByteRange(
+            nativeFilePath,
+            rangeLock,
+            waitForLock
+          );
+          if (succeeded) {
+            locking.maybeLockedFds.add(nativeFd);
+          }
+          js_wasm_trace(
+            "fcntl(%d, F_SETLK) %s lockFileByteRange returned %d for range lock %s",
+            fd,
+            vfsPath,
+            succeeded,
+            rangeLock
+          );
+          return succeeded ? 0 : -EAGAIN;
+        } catch (e) {
+          js_wasm_trace(
+            "fcntl(%d, F_SETLK) %s lockFileByteRange error %s for range lock %s",
+            fd,
+            vfsPath,
+            e,
+            rangeLock
+          );
+          return -EINVAL;
+        }
+      }
+      case F_SETFL: {
+        let arg = 0;
+        if (varargs !== void 0) {
+          const varArgsAccessor = new VarArgsAccessor(varargs);
+          arg = varArgsAccessor.getNextAsInt();
+        }
+        const stream = getStreamFromFD(fd);
+        const SETFL_MASK = O_APPEND | O_NONBLOCK;
+        stream.flags = arg & SETFL_MASK | stream.flags & ~SETFL_MASK;
+        return 0;
+      }
+      default:
+        return builtin_fcntl64(fd, cmd, varargs);
+    }
+  }
+  function flock(fd, op) {
+    js_wasm_trace("flock(%d, %d)", fd, op);
+    if (!fileLockManager) {
+      js_wasm_trace(
+        "flock(%d, %d) file lock manager is not available. succeed by default as Emscripten does.",
+        fd,
+        op
+      );
+      return 0;
+    }
+    const flockToLockOpType = {
+      [LOCK_SH]: "shared",
+      [LOCK_EX]: "exclusive",
+      [LOCK_UN]: "unlock"
+    };
+    const [vfsPath, vfsPathErrno] = locking.get_vfs_path_from_fd(fd);
+    if (vfsPathErrno !== 0) {
+      js_wasm_trace(
+        "flock(%d, %d) get_vfs_path_from_fd errno %d",
+        fd,
+        op,
+        vfsPath,
+        vfsPathErrno
+      );
+      return -vfsPathErrno;
+    }
+    if (!locking.is_path_to_shared_fs(vfsPath)) {
+      js_wasm_trace(
+        "flock(%d, %d) locking is not implemented for non-NodeFS path %s",
+        fd,
+        op,
+        vfsPath
+      );
+      return 0;
+    }
+    const paramsCheckErrno = locking.check_lock_params(fd, op);
+    if (paramsCheckErrno !== 0) {
+      js_wasm_trace(
+        "flock(%d, %d) %s check_lock_params errno %d",
+        fd,
+        op,
+        vfsPath,
+        paramsCheckErrno
+      );
+      return -paramsCheckErrno;
+    }
+    const maskedOp = op & (LOCK_SH | LOCK_EX | LOCK_UN);
+    const waitForLock = (op & LOCK_NB) === 0;
+    if (maskedOp === 0) {
+      js_wasm_trace("flock(%d, %d) invalid flock() operation", fd, op);
+      return -EINVAL;
+    }
+    const lockOpType = flockToLockOpType[maskedOp];
+    if (lockOpType === void 0) {
+      js_wasm_trace("flock(%d, %d) invalid flock() operation", fd, op);
+      return -EINVAL;
+    }
+    const [nativeFd, nativeFdErrno] = locking.get_native_fd_from_emscripten_fd(fd);
+    if (nativeFdErrno !== 0) {
+      js_wasm_trace(
+        "js_flock(%d, %d) get_native_fd_from_emscripten_fd errno %d",
+        fd,
+        op,
+        nativeFdErrno
+      );
+      return -nativeFdErrno;
+    }
+    try {
+      const nativeFilePath = locking.get_native_path_from_vfs_path(vfsPath);
+      const succeeded = fileLockManager.lockWholeFile(nativeFilePath, {
+        type: lockOpType,
+        pid,
+        fd: nativeFd,
+        waitForLock
+      });
+      js_wasm_trace(
+        "flock(%d, %d) lockWholeFile %s returned %d",
+        fd,
+        op,
+        vfsPath,
+        succeeded
+      );
+      if (succeeded) {
+        locking.maybeLockedFds.add(nativeFd);
+      }
+      return succeeded ? 0 : -EWOULDBLOCK;
+    } catch (e) {
+      js_wasm_trace("flock(%d, %d) lockWholeFile error %s", fd, op, e);
+      return -EINVAL;
+    }
+  }
+  function fd_close(fd) {
+    if (!fileLockManager) {
+      js_wasm_trace(
+        "fd_close(%d) file lock manager is not available. delegate to Emscripten builtin fd_close.",
+        fd
+      );
+      return builtin_fd_close(fd);
+    }
+    const [vfsPath, vfsPathResolutionErrno] = locking.get_vfs_path_from_fd(fd);
+    const [nativeFd, nativeFdErrno] = locking.get_native_fd_from_emscripten_fd(fd);
+    const fdCloseResult = builtin_fd_close(fd);
+    if (fdCloseResult !== 0) {
+      js_wasm_trace(
+        "fd_close(%d) %s result %d",
+        fd,
+        vfsPath,
+        fdCloseResult
+      );
+      return fdCloseResult;
+    }
+    if (!locking.maybeLockedFds.has(nativeFd)) {
+      js_wasm_trace(
+        "fd_close(%d) not in maybe-locked-list %s result %d",
+        fd,
+        vfsPath,
+        fdCloseResult
+      );
+      return fdCloseResult;
+    }
+    if (vfsPathResolutionErrno !== 0) {
+      js_wasm_trace(
+        "fd_close(%d) get_vfs_path_from_fd error %d",
+        fd,
+        vfsPathResolutionErrno
+      );
+      return fdCloseResult;
+    }
+    if (nativeFdErrno !== 0) {
+      js_wasm_trace(
+        "fd_close(%d) %s get_native_fd_from_emscripten_fd error %d",
+        fd,
+        vfsPath,
+        nativeFdErrno
+      );
+      return fdCloseResult;
+    }
+    if (!locking.is_path_to_shared_fs(vfsPath)) {
+      return fdCloseResult;
+    }
+    try {
+      js_wasm_trace("fd_close(%d) %s release locks", fd, vfsPath);
+      const nativeFilePath = locking.get_native_path_from_vfs_path(vfsPath);
+      fileLockManager.releaseLocksOnFdClose(
+        pid,
+        nativeFd,
+        nativeFilePath
+      );
+      js_wasm_trace("fd_close(%d) %s release locks success", fd, vfsPath);
+    } catch (e) {
+      js_wasm_trace("fd_close(%d) %s error '%s'", fd, vfsPath, e);
+    }
+    return fdCloseResult;
+  }
+  function js_release_file_locks() {
+    js_wasm_trace("js_release_file_locks()");
+    if (pid === void 0) {
+      js_wasm_trace("js_release_file_locks pid is undefined");
+      return;
+    }
+    if (fileLockManager === void 0) {
+      js_wasm_trace(
+        "js_release_file_locks file lock manager is undefined"
+      );
+      return;
+    }
+    try {
+      fileLockManager.releaseLocksForProcess(pid);
+      js_wasm_trace("js_release_file_locks succeeded");
+    } catch (e) {
+      js_wasm_trace("js_release_file_locks error %s", e);
+    }
+  }
+  async function gethostbyname(hostname) {
+    const { address } = await (0, import_promises.lookup)(hostname, {
+      family: 4,
+      verbatim: false
+    });
+    return address;
+  }
+  return {
+    fcntl64,
+    flock,
+    fd_close,
+    js_release_file_locks,
+    gethostbyname
+  };
+}
+
+// packages/php-wasm/node/src/lib/load-runtime.ts
 var import_fs5 = __toESM(require("fs"), 1);
 
+// packages/php-wasm/node/src/lib/file-lock-manager-for-posix.ts
+var import_universal2 = require("@php-wasm/universal");
+var import_fs_ext_extra_prebuilt = require("fs-ext-extra-prebuilt");
+var import_logger2 = require("@php-wasm/logger");
+function isLockDenialError(e) {
+  if (e && typeof e === "object" && "code" in e) {
+    const code = e.code;
+    return code === "EWOULDBLOCK" || code === "EAGAIN" || code === "EACCES";
+  }
+  return false;
+}
+var FileLockManagerForPosix = class {
+  constructor() {
+    this.wholeFileLockMap = /* @__PURE__ */ new Map();
+    this.rangeLockedFds = /* @__PURE__ */ new Map();
+  }
+  lockWholeFile(path2, op) {
+    const opType = op.type === "unlock" ? "un" : op.waitForLock ? op.type === "exclusive" ? "ex" : "sh" : op.type === "exclusive" ? "exnb" : "shnb";
+    try {
+      (0, import_fs_ext_extra_prebuilt.flockSync)(op.fd, opType);
+      if (op.type === "unlock") {
+        this.wholeFileLockMap.get(op.pid)?.delete(op.fd);
+      } else {
+        if (!this.wholeFileLockMap.has(op.pid)) {
+          this.wholeFileLockMap.set(op.pid, /* @__PURE__ */ new Map());
+        }
+        this.wholeFileLockMap.get(op.pid).set(op.fd, {
+          ...op,
+          path: path2
+        });
+      }
+      return true;
+    } catch (e) {
+      if (!isLockDenialError(e)) {
+        import_logger2.logger.warn("flock(): unexpected error", e);
+      }
+      return false;
+    }
+  }
+  lockFileByteRange(path2, op, waitForLock) {
+    if (op.start === op.end) {
+      op = {
+        ...op,
+        end: import_universal2.MAX_ADDRESSABLE_FILE_OFFSET
+      };
+    }
+    const fcntlCmd = waitForLock ? "setlkw" : "setlk";
+    const fcntlOp = op.type === "unlocked" ? import_fs_ext_extra_prebuilt.constants.F_UNLCK : op.type === "exclusive" ? import_fs_ext_extra_prebuilt.constants.F_WRLCK : import_fs_ext_extra_prebuilt.constants.F_RDLCK;
+    try {
+      (0, import_fs_ext_extra_prebuilt.fcntlSync)(
+        op.fd,
+        fcntlCmd,
+        fcntlOp,
+        Number(op.start),
+        Number(op.end - op.start)
+      );
+      if (!this.rangeLockedFds.has(op.pid)) {
+        this.rangeLockedFds.set(op.pid, /* @__PURE__ */ new Map());
+      }
+      const pidMap = this.rangeLockedFds.get(op.pid);
+      if (!pidMap.has(path2)) {
+        pidMap.set(path2, /* @__PURE__ */ new Set());
+      }
+      pidMap.get(path2).add(op.fd);
+      return true;
+    } catch (e) {
+      if (!isLockDenialError(e)) {
+        import_logger2.logger.warn("fcntl(): unexpected error", e);
+      }
+      return false;
+    }
+  }
+  findFirstConflictingByteRangeLock(path2, op) {
+    if (op.type === "unlocked") {
+      return void 0;
+    }
+    const obtainedLock = this.lockFileByteRange(path2, op, false);
+    if (obtainedLock) {
+      this.lockFileByteRange(path2, { ...op, type: "unlocked" }, true);
+      return void 0;
+    }
+    return {
+      type: "exclusive",
+      start: 0n,
+      end: 0xffffffffffffffffn,
+      pid: -1
+    };
+  }
+  releaseLocksForProcess(targetPid) {
+    const fdMap = this.wholeFileLockMap.get(targetPid);
+    if (fdMap) {
+      for (const storedLock of fdMap.values()) {
+        try {
+          this.lockWholeFile(storedLock.path, {
+            ...storedLock,
+            type: "unlock"
+          });
+        } catch (e) {
+          import_logger2.logger.error(
+            `releaseLocksForProcess: failed to unlock whole-file lock for pid=${targetPid} fd=${storedLock.fd}`,
+            e
+          );
+        }
+      }
+      this.wholeFileLockMap.delete(targetPid);
+    }
+    for (const [path2, fdSet] of this.rangeLockedFds.get(targetPid) ?? []) {
+      for (const fd of fdSet) {
+        try {
+          this.lockFileByteRange(
+            path2,
+            {
+              pid: targetPid,
+              fd,
+              type: "unlocked",
+              start: 0n,
+              end: import_universal2.MAX_ADDRESSABLE_FILE_OFFSET
+            },
+            false
+          );
+        } catch (e) {
+          import_logger2.logger.error(
+            `releaseLocksForProcess: failed to unlock byte range for pid=${targetPid} fd=${fd} path=${path2}`,
+            e
+          );
+        }
+      }
+    }
+    this.rangeLockedFds.delete(targetPid);
+  }
+  releaseLocksOnFdClose(targetPid, targetFd, targetPath) {
+    this.wholeFileLockMap.get(targetPid)?.delete(targetFd);
+    this.rangeLockedFds.get(targetPid)?.delete(targetPath);
+  }
+};
+
+// packages/php-wasm/node/src/lib/file-lock-manager-for-windows.ts
+var import_fs_ext_extra_prebuilt2 = require("fs-ext-extra-prebuilt");
+var import_logger3 = require("@php-wasm/logger");
+var import_universal3 = require("@php-wasm/universal");
+function toLowAndHigh32BitNumbers(num) {
+  const low = Number(num & 0xffffffffn);
+  const high = Number(num >> 32n & 0xffffffffn);
+  return [low, high];
+}
+function isErrnoError(e) {
+  return e !== null && typeof e === "object" && ("errno" in e || "code" in e || "syscall" in e);
+}
+function tryLockFileExSync(fd, flags, start, end) {
+  const [offsetLow, offsetHigh] = toLowAndHigh32BitNumbers(start);
+  const [lengthLow, lengthHigh] = toLowAndHigh32BitNumbers(end - start);
+  try {
+    (0, import_fs_ext_extra_prebuilt2.lockFileExSync)(fd, flags, offsetLow, offsetHigh, lengthLow, lengthHigh);
+    return true;
+  } catch (e) {
+    if (!isErrnoError(e)) {
+      throw e;
+    }
+    return false;
+  }
+}
+function tryUnlockFileExSync(fd, start, end) {
+  const [offsetLow, offsetHigh] = toLowAndHigh32BitNumbers(start);
+  const [lengthLow, lengthHigh] = toLowAndHigh32BitNumbers(end - start);
+  try {
+    (0, import_fs_ext_extra_prebuilt2.unlockFileExSync)(fd, offsetLow, offsetHigh, lengthLow, lengthHigh);
+    return true;
+  } catch (e) {
+    if (!isErrnoError(e)) {
+      throw e;
+    }
+    return false;
+  }
+}
+var FileLockManagerForWindows = class {
+  constructor() {
+    this.wholeFileLockMap = /* @__PURE__ */ new Map();
+    this.rangeLockedFds = /* @__PURE__ */ new Map();
+  }
+  lockWholeFile(path2, op) {
+    const start = 0n;
+    const end = 2n ** 64n - 1n;
+    if (op.type === "unlock") {
+      const success2 = tryUnlockFileExSync(op.fd, start, end);
+      if (success2) {
+        this.wholeFileLockMap.get(op.pid)?.delete(op.fd);
+        if (this.wholeFileLockMap.get(op.pid)?.size === 0) {
+          this.wholeFileLockMap.delete(op.pid);
+        }
+      } else {
+        import_logger3.logger.warn(
+          `lockWholeFile: unlock failed for pid=${op.pid} fd=${op.fd} path=${path2}`
+        );
+      }
+      return success2;
+    }
+    const preexistingLock = this.wholeFileLockMap.get(op.pid)?.get(op.fd);
+    if (op.type === preexistingLock?.type) {
+      return true;
+    }
+    let flags = 0;
+    if (!op.waitForLock) {
+      flags |= import_fs_ext_extra_prebuilt2.constants.LOCKFILE_FAIL_IMMEDIATELY;
+    }
+    let success = false;
+    if (op.type === "shared") {
+      success = tryLockFileExSync(op.fd, flags, start, end);
+      if (success && preexistingLock?.type === "exclusive") {
+        const exclusiveUnlockSuccess = tryUnlockFileExSync(
+          op.fd,
+          start,
+          end
+        );
+        if (!exclusiveUnlockSuccess) {
+          const message = "Failed to unlock preexisting exclusive lock after failing to obtain shared lock";
+          import_logger3.logger.error(message);
+          throw new Error(message);
+        }
+      }
+    } else if (op.type === "exclusive") {
+      flags |= import_fs_ext_extra_prebuilt2.constants.LOCKFILE_EXCLUSIVE_LOCK;
+      let sharedUnlockSuccess;
+      if (preexistingLock?.type === "shared") {
+        sharedUnlockSuccess = tryUnlockFileExSync(op.fd, start, end);
+        if (!sharedUnlockSuccess) {
+          import_logger3.logger.warn(
+            `lockWholeFile: failed to release shared lock before exclusive upgrade for pid=${op.pid} fd=${op.fd}`
+          );
+        }
+      }
+      success = tryLockFileExSync(op.fd, flags, start, end);
+      if (!success) {
+        import_logger3.logger.debug(
+          `lockWholeFile: failed to obtain exclusive lock for pid=${op.pid} fd=${op.fd}`
+        );
+      }
+      if (!success && sharedUnlockSuccess) {
+        const sharedReLockResult = tryLockFileExSync(
+          op.fd,
+          // Wait to restore the shared lock.
+          0,
+          start,
+          end
+        );
+        if (!sharedReLockResult) {
+          const message = "Failed to re-lock preexisting shared lock after failing to obtain exclusive lock";
+          import_logger3.logger.error(message);
+          throw new Error(message);
+        }
+      }
+    } else {
+      throw new Error(`Unexpected wholeFileLock() op: '${op.type}'`);
+    }
+    if (success) {
+      if (!this.wholeFileLockMap.has(op.pid)) {
+        this.wholeFileLockMap.set(op.pid, /* @__PURE__ */ new Map());
+      }
+      this.wholeFileLockMap.get(op.pid).set(op.fd, {
+        ...op,
+        path: path2
+      });
+    }
+    return success;
+  }
+  lockFileByteRange(path2, op, waitForLock) {
+    if (op.start === op.end) {
+      op = {
+        ...op,
+        end: import_universal3.MAX_ADDRESSABLE_FILE_OFFSET
+      };
+    }
+    if (!this.rangeLockedFds.has(path2)) {
+      this.rangeLockedFds.set(path2, new import_universal3.FileLockIntervalTree());
+    }
+    const lockedRangeTree = this.rangeLockedFds.get(path2);
+    const overlappingLocks = lockedRangeTree.findOverlapping(op);
+    let preexistingLock;
+    if (overlappingLocks.length === 1 && overlappingLocks[0].pid === op.pid && // NOTE: FD shouldn't matter for fcntl() F_SETLK because it is a process-level lock,
+    // but it matters for Windows where locks are fd-specific.
+    overlappingLocks[0].fd === op.fd && overlappingLocks[0].start === op.start && overlappingLocks[0].end === op.end) {
+      preexistingLock = overlappingLocks[0];
+    }
+    if (op.type === preexistingLock?.type) {
+      return true;
+    }
+    let flags = 0;
+    if (!waitForLock) {
+      flags |= import_fs_ext_extra_prebuilt2.constants.LOCKFILE_FAIL_IMMEDIATELY;
+    }
+    if (op.type === "shared") {
+      const success = tryLockFileExSync(op.fd, flags, op.start, op.end);
+      if (!success) {
+        return false;
+      }
+      if (preexistingLock?.type === "exclusive") {
+        const releasedPreexistingExclusiveLock = tryUnlockFileExSync(
+          preexistingLock.fd,
+          preexistingLock.start,
+          preexistingLock.end
+        );
+        if (!releasedPreexistingExclusiveLock) {
+          const message = "Failed to unlock preexisting exclusive lock after obtaining a shared lock";
+          import_logger3.logger.error(message);
+          throw new Error(message);
+        }
+        lockedRangeTree.remove(preexistingLock);
+      }
+      lockedRangeTree.insert(op);
+      return true;
+    } else if (op.type === "exclusive") {
+      let sharedUnlockSuccess;
+      if (preexistingLock?.type === "shared") {
+        sharedUnlockSuccess = tryUnlockFileExSync(
+          op.fd,
+          op.start,
+          op.end
+        );
+      }
+      if (op.type === "exclusive") {
+        flags |= import_fs_ext_extra_prebuilt2.constants.LOCKFILE_EXCLUSIVE_LOCK;
+      }
+      const success = tryLockFileExSync(op.fd, flags, op.start, op.end);
+      if (!success) {
+        if (preexistingLock && sharedUnlockSuccess) {
+          const sharedRelockSuccess = tryLockFileExSync(
+            op.fd,
+            0,
+            op.start,
+            op.end
+          );
+          if (!sharedRelockSuccess) {
+            const message = "Failed to re-lock preexisting shared lock after failing to obtain exclusive lock";
+            import_logger3.logger.error(message);
+            throw new Error(message);
+          }
+        }
+        return false;
+      }
+      lockedRangeTree.insert(op);
+      return true;
+    } else {
+      const intersectingLocksForThisProcess = overlappingLocks.filter((lock) => lock.pid === op.pid).filter((lock) => lock.start >= op.start && lock.end <= op.end);
+      for (const lock of intersectingLocksForThisProcess) {
+        const success = tryUnlockFileExSync(
+          lock.fd,
+          lock.start,
+          lock.end
+        );
+        if (!success) {
+          import_logger3.logger.warn(
+            `lockFileByteRange: unlock failed for pid=${op.pid} fd=${lock.fd} range=[${lock.start},${lock.end}]`
+          );
+          return false;
+        }
+        lockedRangeTree.remove(lock);
+      }
+      return true;
+    }
+  }
+  findFirstConflictingByteRangeLock(path2, op) {
+    if (op.type === "unlocked") {
+      return void 0;
+    }
+    const obtainedLock = !!this.lockFileByteRange(path2, op, false);
+    this.lockFileByteRange(path2, { ...op, type: "unlocked" }, false);
+    if (obtainedLock) {
+      return void 0;
+    }
+    return {
+      type: "exclusive",
+      start: 0n,
+      end: 0xffffffffffffffffn,
+      pid: -1
+    };
+  }
+  releaseLocksForProcess(targetPid) {
+    const fdMap = this.wholeFileLockMap.get(targetPid);
+    if (fdMap) {
+      for (const storedLock of fdMap.values()) {
+        try {
+          this.lockWholeFile(storedLock.path, {
+            ...storedLock,
+            type: "unlock"
+          });
+        } catch (e) {
+          import_logger3.logger.error(
+            `releaseLocksForProcess: failed to unlock whole-file lock for pid=${targetPid} fd=${storedLock.fd}`,
+            e
+          );
+        }
+      }
+      this.wholeFileLockMap.delete(targetPid);
+    }
+    for (const [path2, lockedRangeTree] of this.rangeLockedFds.entries()) {
+      const rangesLockedByTargetPid = lockedRangeTree.findLocksForProcess(targetPid);
+      for (const op of rangesLockedByTargetPid) {
+        try {
+          this.lockFileByteRange(
+            path2,
+            { ...op, type: "unlocked" },
+            false
+          );
+        } catch (e) {
+          import_logger3.logger.error(
+            `releaseLocksForProcess: failed to unlock byte range for pid=${targetPid} fd=${op.fd} path=${path2}`,
+            e
+          );
+        }
+        lockedRangeTree.remove(op);
+      }
+    }
+  }
+  releaseLocksOnFdClose(targetPid, targetFd, targetPath) {
+    const storedLock = this.wholeFileLockMap.get(targetPid)?.get(targetFd);
+    if (storedLock) {
+      this.lockWholeFile(storedLock.path, {
+        ...storedLock,
+        type: "unlock"
+      });
+    }
+    this.wholeFileLockMap.get(targetPid)?.delete(targetFd);
+    const lockedRangeTree = this.rangeLockedFds.get(targetPath);
+    for (const op of lockedRangeTree?.findLocksForProcess(targetPid) ?? []) {
+      this.lockFileByteRange(
+        targetPath,
+        {
+          ...op,
+          type: "unlocked",
+          // Use a dummy FD because we're releasing locks for
+          // all FDs on this file (POSIX semantics), not just
+          // the one being closed.
+          fd: -1
+        },
+        false
+      );
+      lockedRangeTree.remove(op);
+    }
+  }
+};
+
 // packages/php-wasm/node/src/lib/extensions/xdebug/with-xdebug.ts
-var import_universal3 = require("@php-wasm/universal");
+var import_universal5 = require("@php-wasm/universal");
 var import_fs = __toESM(require("fs"), 1);
 
 // packages/php-wasm/node/src/lib/extensions/xdebug/get-xdebug-extension-module.ts
-var import_universal2 = require("@php-wasm/universal");
-async function getXdebugExtensionModule(version = import_universal2.LatestSupportedPHPVersion) {
+var import_universal4 = require("@php-wasm/universal");
+async function getXdebugExtensionModule(version = import_universal4.LatestSupportedPHPVersion) {
   switch (version) {
     case "8.5":
       return (await import("@php-wasm/node-8-5")).getXdebugExtensionPath();
@@ -453,7 +1590,7 @@ async function getXdebugExtensionModule(version = import_universal2.LatestSuppor
 }
 
 // packages/php-wasm/node/src/lib/extensions/xdebug/with-xdebug.ts
-async function withXdebug(version = import_universal3.LatestSupportedPHPVersion, options, xdebugOptions) {
+async function withXdebug(version = import_universal5.LatestSupportedPHPVersion, options, xdebugOptions) {
   const fileName = "xdebug.so";
   const filePath = await getXdebugExtensionModule(version);
   const extension = import_fs.default.readFileSync(filePath);
@@ -467,13 +1604,13 @@ async function withXdebug(version = import_universal3.LatestSupportedPHPVersion,
       if (options.onRuntimeInitialized) {
         options.onRuntimeInitialized(phpRuntime);
       }
-      if (!import_universal3.FSHelpers.fileExists(
+      if (!import_universal5.FSHelpers.fileExists(
         phpRuntime.FS,
         "/internal/shared/extensions"
       )) {
         phpRuntime.FS.mkdirTree("/internal/shared/extensions");
       }
-      if (!import_universal3.FSHelpers.fileExists(
+      if (!import_universal5.FSHelpers.fileExists(
         phpRuntime.FS,
         `/internal/shared/extensions/${fileName}`
       )) {
@@ -482,7 +1619,7 @@ async function withXdebug(version = import_universal3.LatestSupportedPHPVersion,
           new Uint8Array(extension)
         );
       }
-      if (!import_universal3.FSHelpers.fileExists(
+      if (!import_universal5.FSHelpers.fileExists(
         phpRuntime.FS,
         "/internal/shared/extensions/xdebug.ini"
       )) {
@@ -512,13 +1649,13 @@ async function withXdebug(version = import_universal3.LatestSupportedPHPVersion,
 }
 
 // packages/php-wasm/node/src/lib/extensions/intl/with-intl.ts
-var import_universal5 = require("@php-wasm/universal");
+var import_universal7 = require("@php-wasm/universal");
 var import_fs2 = __toESM(require("fs"), 1);
 var import_path = __toESM(require("path"), 1);
 
 // packages/php-wasm/node/src/lib/extensions/intl/get-intl-extension-module.ts
-var import_universal4 = require("@php-wasm/universal");
-async function getIntlExtensionModule(version = import_universal4.LatestSupportedPHPVersion) {
+var import_universal6 = require("@php-wasm/universal");
+async function getIntlExtensionModule(version = import_universal6.LatestSupportedPHPVersion) {
   switch (version) {
     case "8.5":
       return (await import("@php-wasm/node-8-5")).getIntlExtensionPath();
@@ -540,7 +1677,7 @@ async function getIntlExtensionModule(version = import_universal4.LatestSupporte
 
 // packages/php-wasm/node/src/lib/extensions/intl/with-intl.ts
 var import_meta = {};
-async function withIntl(version = import_universal5.LatestSupportedPHPVersion, options) {
+async function withIntl(version = import_universal7.LatestSupportedPHPVersion, options) {
   const extensionName = "intl.so";
   const extensionPath = await getIntlExtensionModule(version);
   const extension = import_fs2.default.readFileSync(extensionPath);
@@ -559,13 +1696,13 @@ async function withIntl(version = import_universal5.LatestSupportedPHPVersion, o
       if (options.onRuntimeInitialized) {
         options.onRuntimeInitialized(phpRuntime);
       }
-      if (!import_universal5.FSHelpers.fileExists(
+      if (!import_universal7.FSHelpers.fileExists(
         phpRuntime.FS,
         "/internal/shared/extensions"
       )) {
         phpRuntime.FS.mkdirTree("/internal/shared/extensions");
       }
-      if (!import_universal5.FSHelpers.fileExists(
+      if (!import_universal7.FSHelpers.fileExists(
         phpRuntime.FS,
         `/internal/shared/extensions/${extensionName}`
       )) {
@@ -574,7 +1711,7 @@ async function withIntl(version = import_universal5.LatestSupportedPHPVersion, o
           new Uint8Array(extension)
         );
       }
-      if (!import_universal5.FSHelpers.fileExists(
+      if (!import_universal7.FSHelpers.fileExists(
         phpRuntime.FS,
         "/internal/shared/extensions/intl.ini"
       )) {
@@ -585,7 +1722,7 @@ async function withIntl(version = import_universal5.LatestSupportedPHPVersion, o
           ].join("\n")
         );
       }
-      if (!import_universal5.FSHelpers.fileExists(
+      if (!import_universal7.FSHelpers.fileExists(
         phpRuntime.FS,
         `${phpRuntime.ENV.ICU_DATA}/${dataName}`
       )) {
@@ -600,12 +1737,12 @@ async function withIntl(version = import_universal5.LatestSupportedPHPVersion, o
 }
 
 // packages/php-wasm/node/src/lib/extensions/redis/with-redis.ts
-var import_universal7 = require("@php-wasm/universal");
+var import_universal9 = require("@php-wasm/universal");
 var import_fs3 = __toESM(require("fs"), 1);
 
 // packages/php-wasm/node/src/lib/extensions/redis/get-redis-extension-module.ts
-var import_universal6 = require("@php-wasm/universal");
-async function getRedisExtensionModule(version = import_universal6.LatestSupportedPHPVersion) {
+var import_universal8 = require("@php-wasm/universal");
+async function getRedisExtensionModule(version = import_universal8.LatestSupportedPHPVersion) {
   switch (version) {
     case "8.5":
       return (await import("@php-wasm/node-8-5")).getRedisExtensionPath();
@@ -626,7 +1763,7 @@ async function getRedisExtensionModule(version = import_universal6.LatestSupport
 }
 
 // packages/php-wasm/node/src/lib/extensions/redis/with-redis.ts
-async function withRedis(version = import_universal7.LatestSupportedPHPVersion, options) {
+async function withRedis(version = import_universal9.LatestSupportedPHPVersion, options) {
   const extensionName = "redis.so";
   const extensionPath = await getRedisExtensionModule(version);
   const extension = import_fs3.default.readFileSync(extensionPath);
@@ -640,13 +1777,13 @@ async function withRedis(version = import_universal7.LatestSupportedPHPVersion,
       if (options.onRuntimeInitialized) {
         options.onRuntimeInitialized(phpRuntime);
       }
-      if (!import_universal7.FSHelpers.fileExists(
+      if (!import_universal9.FSHelpers.fileExists(
         phpRuntime.FS,
         "/internal/shared/extensions"
       )) {
         phpRuntime.FS.mkdirTree("/internal/shared/extensions");
       }
-      if (!import_universal7.FSHelpers.fileExists(
+      if (!import_universal9.FSHelpers.fileExists(
         phpRuntime.FS,
         `/internal/shared/extensions/${extensionName}`
       )) {
@@ -655,7 +1792,7 @@ async function withRedis(version = import_universal7.LatestSupportedPHPVersion,
           new Uint8Array(extension)
         );
       }
-      if (!import_universal7.FSHelpers.fileExists(
+      if (!import_universal9.FSHelpers.fileExists(
         phpRuntime.FS,
         "/internal/shared/extensions/redis.ini"
       )) {
@@ -671,12 +1808,12 @@ async function withRedis(version = import_universal7.LatestSupportedPHPVersion,
 }
 
 // packages/php-wasm/node/src/lib/extensions/memcached/with-memcached.ts
-var import_universal9 = require("@php-wasm/universal");
+var import_universal11 = require("@php-wasm/universal");
 var import_fs4 = __toESM(require("fs"), 1);
 
 // packages/php-wasm/node/src/lib/extensions/memcached/get-memcached-extension-module.ts
-var import_universal8 = require("@php-wasm/universal");
-async function getMemcachedExtensionModule(version = import_universal8.LatestSupportedPHPVersion) {
+var import_universal10 = require("@php-wasm/universal");
+async function getMemcachedExtensionModule(version = import_universal10.LatestSupportedPHPVersion) {
   switch (version) {
     case "8.5":
       return (await import("@php-wasm/node-8-5")).getMemcachedExtensionPath();
@@ -697,7 +1834,7 @@ async function getMemcachedExtensionModule(version = import_universal8.LatestSup
 }
 
 // packages/php-wasm/node/src/lib/extensions/memcached/with-memcached.ts
-async function withMemcached(version = import_universal9.LatestSupportedPHPVersion, options) {
+async function withMemcached(version = import_universal11.LatestSupportedPHPVersion, options) {
   const extensionName = "memcached.so";
   const extensionPath = await getMemcachedExtensionModule(version);
   const extension = import_fs4.default.readFileSync(extensionPath);
@@ -711,13 +1848,13 @@ async function withMemcached(version = import_universal9.LatestSupportedPHPVersi
       if (options.onRuntimeInitialized) {
         options.onRuntimeInitialized(phpRuntime);
       }
-      if (!import_universal9.FSHelpers.fileExists(
+      if (!import_universal11.FSHelpers.fileExists(
         phpRuntime.FS,
         "/internal/shared/extensions"
       )) {
         phpRuntime.FS.mkdirTree("/internal/shared/extensions");
       }
-      if (!import_universal9.FSHelpers.fileExists(
+      if (!import_universal11.FSHelpers.fileExists(
         phpRuntime.FS,
         `/internal/shared/extensions/${extensionName}`
       )) {
@@ -726,7 +1863,7 @@ async function withMemcached(version = import_universal9.LatestSupportedPHPVersi
           new Uint8Array(extension)
         );
       }
-      if (!import_universal9.FSHelpers.fileExists(
+      if (!import_universal11.FSHelpers.fileExists(
         phpRuntime.FS,
         "/internal/shared/extensions/memcached.ini"
       )) {
@@ -743,6 +1880,7 @@ async function withMemcached(version = import_universal9.LatestSupportedPHPVersi
 
 // packages/php-wasm/node/src/lib/load-runtime.ts
 var import_util = require("@php-wasm/util");
+var import_os = require("os");
 async function loadNodeRuntime(phpVersion, options = {}) {
   let emscriptenOptions = {
     /**
@@ -753,6 +1891,14 @@ async function loadNodeRuntime(phpVersion, options = {}) {
     quit: function(code, error) {
       throw error;
     },
+    bindUserSpace: (userSpaceContext) => {
+      const nativeFileLockManager = (0, import_os.platform)() === "win32" ? new FileLockManagerForWindows() : new FileLockManagerForPosix();
+      const fileLockManager = options.fileLockManager ? new import_universal12.FileLockManagerComposite({
+        nativeLockManager: nativeFileLockManager,
+        wasmLockManager: options.fileLockManager
+      }) : nativeFileLockManager;
+      return bindUserSpace({ fileLockManager }, userSpaceContext);
+    },
     ...options.emscriptenOptions || {},
     onRuntimeInitialized: (phpRuntime) => {
       if (options?.followSymlinks === true) {
@@ -768,7 +1914,7 @@ async function loadNodeRuntime(phpVersion, options = {}) {
             normalizedPath
           );
           if (import_fs5.default.existsSync(absoluteSourcePath)) {
-            if (!import_universal10.FSHelpers.fileExists(
+            if (!import_universal12.FSHelpers.fileExists(
               phpRuntime.FS,
               symlinkMountPath
             )) {
@@ -824,7 +1970,7 @@ async function loadNodeRuntime(phpVersion, options = {}) {
   }
   emscriptenOptions = await withNetworking(emscriptenOptions);
   const phpLoaderModule = await getPHPLoaderModule(phpVersion);
-  const runtimeId = await (0, import_universal10.loadPHPRuntime)(phpLoaderModule, emscriptenOptions);
+  const runtimeId = await (0, import_universal12.loadPHPRuntime)(phpLoaderModule, emscriptenOptions);
   return runtimeId;
 }
 
@@ -832,14 +1978,14 @@ async function loadNodeRuntime(phpVersion, options = {}) {
 var import_node_fs = require("node:fs");
 
 // packages/php-wasm/node/src/lib/node-fs-mount.ts
-var import_universal11 = require("@php-wasm/universal");
+var import_universal13 = require("@php-wasm/universal");
 var import_util2 = require("@php-wasm/util");
 var import_fs6 = require("fs");
 var import_path2 = require("path");
 function createNodeFsMountHandler(localPath) {
   return function(php, FS, vfsMountPoint) {
     let removeVfsNode = false;
-    if (!import_universal11.FSHelpers.fileExists(FS, vfsMountPoint)) {
+    if (!import_universal13.FSHelpers.fileExists(FS, vfsMountPoint)) {
       const lstat = (0, import_fs6.lstatSync)(localPath);
       if (lstat.isFile() || lstat.isSymbolicLink()) {
         FS.mkdirTree((0, import_path2.dirname)(vfsMountPoint));
@@ -853,9 +1999,9 @@ function createNodeFsMountHandler(localPath) {
       }
       removeVfsNode = true;
     }
-    let lookup2;
+    let lookup3;
     try {
-      lookup2 = FS.lookupPath(vfsMountPoint);
+      lookup3 = FS.lookupPath(vfsMountPoint);
     } catch (e) {
       const error = e;
       if (error.errno === 44) {
@@ -869,7 +2015,7 @@ function createNodeFsMountHandler(localPath) {
     return () => {
       FS.unmount(vfsMountPoint);
       if (removeVfsNode) {
-        if (FS.isDir(lookup2.node.mode)) {
+        if (FS.isDir(lookup3.node.mode)) {
           if ((0, import_util2.isParentOf)(vfsMountPoint, FS.cwd())) {
             throw new Error(
               `Cannot remove the VFS directory "${vfsMountPoint}" on umount cleanup \u2013 it is a parent of the CWD "${FS.cwd()}". Change CWD before unmounting or explicitly disable post-unmount node cleanup with createNodeFsMountHandler(path, {cleanupNodesOnUnmount: false}).`
@@ -923,642 +2069,11 @@ function statPathFollowSymlinks(path2) {
   }
   return stat;
 }
-
-// packages/php-wasm/node/src/lib/file-lock-manager-for-node.ts
-var import_logger2 = require("@php-wasm/logger");
-var import_fs7 = require("fs");
-var MAX_64BIT_OFFSET = BigInt(2n ** 64n - 1n);
-var FileLockManagerForNode = class {
-  /**
-   * Create a new FileLockManagerForNode instance.
-   *
-   * @param nativeFlockSync A synchronous flock() function to lock files via the host OS.
-   */
-  constructor(nativeFlockSync = function flockSyncNoOp() {
-  }) {
-    this.nativeFlockSync = nativeFlockSync;
-    this.locks = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Lock the whole file.
-   *
-   * @param path The path to the file to lock. This should be the path
-   *             of the file in the native filesystem.
-   * @param op The whole file lock operation to perform.
-   * @returns True if the lock was granted, false otherwise.
-   */
-  lockWholeFile(path2, op) {
-    if (this.locks.get(path2) === void 0) {
-      if (op.type === "unlock") {
-        return true;
-      }
-      const maybeLock = FileLock.maybeCreate(
-        path2,
-        op.type,
-        this.nativeFlockSync
-      );
-      if (maybeLock === void 0) {
-        return false;
-      }
-      this.locks.set(path2, maybeLock);
-    }
-    const lock = this.locks.get(path2);
-    const result = lock.lockWholeFile(op);
-    this.forgetPathIfUnlocked(path2);
-    return result;
-  }
-  /**
-   * Lock a byte range.
-   *
-   * @param path The path to the file to lock. This should be the path
-   *             of the file in the native filesystem.
-   * @param requestedLock The byte range lock to perform.
-   * @returns True if the lock was granted, false otherwise.
-   */
-  lockFileByteRange(path2, requestedLock) {
-    if (!this.locks.has(path2)) {
-      if (requestedLock.type === "unlocked") {
-        return true;
-      }
-      const maybeLock = FileLock.maybeCreate(
-        path2,
-        requestedLock.type,
-        this.nativeFlockSync
-      );
-      if (maybeLock === void 0) {
-        return false;
-      }
-      this.locks.set(path2, maybeLock);
-    }
-    const lock = this.locks.get(path2);
-    return lock.lockFileByteRange(requestedLock);
-  }
-  /**
-   * Find the first conflicting byte range lock.
-   *
-   * @param path The path to the file to find the conflicting lock for.
-   * @param desiredLock The desired byte range lock.
-   * @returns The first conflicting byte range lock, or undefined if no conflicting lock exists.
-   */
-  findFirstConflictingByteRangeLock(path2, desiredLock) {
-    const lock = this.locks.get(path2);
-    if (lock === void 0) {
-      return void 0;
-    }
-    return lock.findFirstConflictingByteRangeLock(desiredLock);
-  }
-  /**
-   * Release all locks for the given process.
-   *
-   * @param pid The process ID to release locks for.
-   */
-  releaseLocksForProcess(pid) {
-    for (const [path2, lock] of this.locks.entries()) {
-      lock.releaseLocksForProcess(pid);
-      this.forgetPathIfUnlocked(path2);
-    }
-  }
-  /**
-   * Release all locks for the given process and file descriptor.
-   *
-   * @param pid The process ID to release locks for.
-   * @param fd The file descriptor to release locks for.
-   * @param path The path to the file to release locks for.
-   */
-  releaseLocksForProcessFd(pid, fd, nativePath) {
-    const lock = this.locks.get(nativePath);
-    if (!lock) {
-      return;
-    }
-    lock.releaseLocksForProcessFd(pid, fd);
-    this.forgetPathIfUnlocked(nativePath);
-  }
-  /**
-   * Forget the path if it is unlocked.
-   *
-   * @param path The path to the file to forget.
-   */
-  forgetPathIfUnlocked(path2) {
-    const lock = this.locks.get(path2);
-    if (!lock) {
-      return;
-    }
-    if (lock.isUnlocked()) {
-      lock.dispose();
-      this.locks.delete(path2);
-    }
-  }
-};
-var FileLock = class _FileLock {
-  /**
-   * Create a new FileLock instance for the given file and mode.
-   * Fail if the underlying native file lock cannot be acquired.
-   *
-   * @param path The path to the file to lock
-   * @param mode The type of lock to acquire
-   * @returns A FileLock instance if the lock was acquired, undefined otherwise
-   */
-  static maybeCreate(path2, mode, nativeFlockSync) {
-    let fd;
-    try {
-      fd = (0, import_fs7.openSync)(path2, "a+");
-      const flockFlags = mode === "exclusive" ? "exnb" : "shnb";
-      nativeFlockSync(fd, flockFlags);
-      const nativeLock = { fd, mode, nativeFlockSync };
-      return new _FileLock(nativeLock);
-    } catch {
-      if (fd !== void 0) {
-        try {
-          (0, import_fs7.closeSync)(fd);
-        } catch (error) {
-          import_logger2.logger.error(
-            "Error closing locking file descriptor",
-            error
-          );
-        }
-      }
-      return void 0;
-    }
-  }
-  constructor(nativeLock) {
-    this.nativeLock = nativeLock;
-    this.rangeLocks = new FileLockIntervalTree();
-    this.wholeFileLock = { type: "unlocked" };
-  }
-  /**
-   * Close the file descriptor and release the native lock.
-   *
-   * @TODO Replace this with a Symbol.dispose property once supported by all JS runtimes.
-   */
-  dispose() {
-    try {
-      (0, import_fs7.closeSync)(this.nativeLock.fd);
-    } catch (error) {
-      import_logger2.logger.error("Error closing locking file descriptor", error);
-    }
-  }
-  /**
-   * Lock the whole file.
-   *
-   * This method corresponds to the flock() function.
-   *
-   * @param op The whole file lock operation to perform.
-   * @returns True if the lock was granted, false otherwise.
-   */
-  lockWholeFile(op) {
-    if (op.type === "unlock") {
-      const originalType = this.wholeFileLock.type;
-      if (originalType === "unlocked") {
-      } else if (this.wholeFileLock.type === "exclusive" && this.wholeFileLock.pid === op.pid && this.wholeFileLock.fd === op.fd) {
-        this.wholeFileLock = { type: "unlocked" };
-      } else if (this.wholeFileLock.type === "shared" && this.wholeFileLock.pidFds.has(op.pid) && this.wholeFileLock.pidFds.get(op.pid).has(op.fd)) {
-        this.wholeFileLock.pidFds.get(op.pid).delete(op.fd);
-        if (this.wholeFileLock.pidFds.get(op.pid).size === 0) {
-          this.wholeFileLock.pidFds.delete(op.pid);
-        }
-        if (this.wholeFileLock.pidFds.size === 0) {
-          this.wholeFileLock = { type: "unlocked" };
-        }
-      }
-      if (!this.ensureCompatibleNativeLock()) {
-        import_logger2.logger.error(
-          "Unable to update native lock after removing a whole file lock."
-        );
-      }
-      return true;
-    }
-    if (this.isThereAConflictWithRequestedWholeFileLock(op)) {
-      return false;
-    }
-    if (!this.ensureCompatibleNativeLock({
-      overrideWholeFileLockType: op.type
-    })) {
-      return false;
-    }
-    if (op.type === "exclusive") {
-      this.wholeFileLock = {
-        type: "exclusive",
-        pid: op.pid,
-        fd: op.fd
-      };
-      return true;
-    }
-    if (op.type === "shared") {
-      if (this.wholeFileLock.type !== "shared") {
-        this.wholeFileLock = {
-          type: "shared",
-          pidFds: /* @__PURE__ */ new Map()
-        };
-      }
-      const sharedLock = this.wholeFileLock;
-      if (!sharedLock.pidFds.has(op.pid)) {
-        sharedLock.pidFds.set(op.pid, /* @__PURE__ */ new Set());
-      }
-      sharedLock.pidFds.get(op.pid).add(op.fd);
-      return true;
-    }
-    throw new Error(`Unexpected wholeFileLock() op: '${op.type}'`);
-  }
-  /**
-   * Lock a byte range.
-   *
-   * This method corresponds to the fcntl() F_SETLK command.
-   *
-   * @param requestedLock The byte range lock to perform.
-   * @returns True if the lock was granted, false otherwise.
-   */
-  lockFileByteRange(requestedLock) {
-    if (requestedLock.start === requestedLock.end) {
-      requestedLock = {
-        ...requestedLock,
-        end: MAX_64BIT_OFFSET
-      };
-    }
-    if (requestedLock.type === "unlocked") {
-      const overlappingLocksBySameProcess = this.rangeLocks.findOverlapping(requestedLock).filter((lock) => lock.pid === requestedLock.pid);
-      for (const overlappingLock of overlappingLocksBySameProcess) {
-        this.rangeLocks.remove(overlappingLock);
-        if (overlappingLock.start < requestedLock.start) {
-          this.rangeLocks.insert({
-            ...overlappingLock,
-            end: requestedLock.start
-          });
-        }
-        if (overlappingLock.end > requestedLock.end) {
-          this.rangeLocks.insert({
-            ...overlappingLock,
-            start: requestedLock.end
-          });
-        }
-      }
-      if (!this.ensureCompatibleNativeLock()) {
-        import_logger2.logger.error(
-          "Unable to update native lock after removing a byte range lock."
-        );
-      }
-      return true;
-    }
-    if (this.isThereAConflictWithRequestedRangeLock(requestedLock)) {
-      return false;
-    }
-    if (!this.ensureCompatibleNativeLock({
-      overrideRangeLockType: requestedLock.type
-    })) {
-      return false;
-    }
-    const overlappingLocksFromSameProcess = this.rangeLocks.findOverlapping(requestedLock).filter((lock) => lock.pid === requestedLock.pid);
-    let minStart = requestedLock.start;
-    let maxEnd = requestedLock.end;
-    for (const overlappingLock of overlappingLocksFromSameProcess) {
-      this.rangeLocks.remove(overlappingLock);
-      if (overlappingLock.start < minStart) {
-        minStart = overlappingLock.start;
-      }
-      if (overlappingLock.end > maxEnd) {
-        maxEnd = overlappingLock.end;
-      }
-    }
-    const mergedLock = {
-      ...requestedLock,
-      start: minStart,
-      end: maxEnd
-    };
-    this.rangeLocks.insert(mergedLock);
-    return true;
-  }
-  /**
-   * Find the first conflicting byte range lock.
-   *
-   * This method corresponds to the fcntl() F_GETLK command.
-   *
-   * @param desiredLock The desired byte range lock.
-   * @returns The first conflicting byte range lock, or undefined if no conflicting lock exists.
-   */
-  findFirstConflictingByteRangeLock(desiredLock) {
-    const overlappingLocks = this.rangeLocks.findOverlapping(desiredLock);
-    const firstConflictingRangeLock = overlappingLocks.find(
-      (lock) => lock.pid !== desiredLock.pid && (desiredLock.type === "exclusive" || lock.type === "exclusive")
-    );
-    if (firstConflictingRangeLock) {
-      return firstConflictingRangeLock;
-    }
-    if (this.wholeFileLock.type === "unlocked") {
-      return void 0;
-    }
-    const wfl = this.wholeFileLock;
-    if (wfl.type === "exclusive" || desiredLock.type === "exclusive") {
-      return {
-        type: this.wholeFileLock.type,
-        start: 0n,
-        end: 0n,
-        pid: -1
-      };
-    }
-    return void 0;
-  }
-  /**
-   * Release all locks for the given process.
-   *
-   * @param pid The process ID to release locks for.
-   */
-  releaseLocksForProcess(pid) {
-    for (const rangeLock of this.rangeLocks.findLocksForProcess(pid)) {
-      this.lockFileByteRange({
-        ...rangeLock,
-        type: "unlocked"
-      });
-    }
-    if (this.wholeFileLock.type === "exclusive" && this.wholeFileLock.pid === pid) {
-      this.lockWholeFile({
-        pid,
-        fd: this.wholeFileLock.fd,
-        type: "unlock"
-      });
-    } else if (this.wholeFileLock.type === "shared" && this.wholeFileLock.pidFds.has(pid)) {
-      for (const fd of this.wholeFileLock.pidFds.get(pid)) {
-        this.lockWholeFile({
-          pid,
-          fd,
-          type: "unlock"
-        });
-      }
-    }
-  }
-  /**
-   * Release all locks for the given process and file descriptor.
-   *
-   * @param pid The process ID to release locks for.
-   * @param fd The file descriptor to release locks for.
-   */
-  releaseLocksForProcessFd(pid, fd) {
-    for (const rangeLock of this.rangeLocks.findLocksForProcess(pid)) {
-      this.lockFileByteRange({
-        ...rangeLock,
-        type: "unlocked"
-      });
-    }
-    this.lockWholeFile({
-      pid,
-      fd,
-      type: "unlock"
-    });
-  }
-  /**
-   * Check if the file lock is unlocked.
-   *
-   * @returns True if the file lock is unlocked, false otherwise.
-   */
-  isUnlocked() {
-    return this.wholeFileLock.type === "unlocked" && this.rangeLocks.isEmpty();
-  }
-  /**
-   * Ensure that the native lock is compatible with the php-wasm lock,
-   * upgrading or downgrading as needed.
-   *
-   * @param overrideWholeFileLockType If provided, use this type for the whole file lock.
-   * @param overrideRangeLockType If provided, use this type for the range lock.
-   * @returns True if the native lock was upgraded or downgraded, false otherwise.
-   */
-  ensureCompatibleNativeLock({
-    overrideWholeFileLockType,
-    overrideRangeLockType
-  } = {}) {
-    const wholeFileLockType = overrideWholeFileLockType ?? this.wholeFileLock.type;
-    const rangeLockType = overrideRangeLockType ?? this.rangeLocks.findStrictestExistingLockType();
-    let requiredNativeLockType;
-    if (wholeFileLockType === "exclusive" || rangeLockType === "exclusive") {
-      requiredNativeLockType = "exclusive";
-    } else if (wholeFileLockType === "shared" || rangeLockType === "shared") {
-      requiredNativeLockType = "shared";
-    } else {
-      requiredNativeLockType = "unlock";
-    }
-    if (this.nativeLock.mode === requiredNativeLockType) {
-      return true;
-    }
-    const flockFlags = requiredNativeLockType === "exclusive" && "exnb" || requiredNativeLockType === "shared" && "shnb" || "un";
-    try {
-      this.nativeLock.nativeFlockSync(this.nativeLock.fd, flockFlags);
-      this.nativeLock.mode = requiredNativeLockType;
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * 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.
-   */
-  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) {
-    this.left = null;
-    this.right = null;
-    this.range = range;
-    this.max = range.end;
-  }
-};
-var FileLockIntervalTree = class {
-  constructor() {
-    this.root = null;
-  }
-  isEmpty() {
-    return this.root === null;
-  }
-  /**
-   * Insert a new locked range into the tree
-   */
-  insert(range) {
-    this.root = this.insertNode(this.root, range);
-  }
-  /**
-   * Find all ranges that overlap with the given range
-   */
-  findOverlapping(range) {
-    const result = [];
-    this.findOverlappingRanges(this.root, range, result);
-    return result;
-  }
-  /**
-   * Remove a lock range from the tree
-   */
-  remove(range) {
-    this.root = this.removeNode(this.root, range);
-  }
-  /**
-   * Find all ranges locked by the given process.
-   *
-   * @param pid The process ID to find locks for.
-   * @returns All locked ranges for the given process.
-   */
-  findLocksForProcess(pid) {
-    const result = [];
-    this.findLocksForProcessInNode(this.root, pid, result);
-    return result;
-  }
-  /**
-   * Find the strictest existing lock type in the range lock tree.
-   *
-   * @returns The strictest existing lock type, or 'unlocked' if no locks exist.
-   */
-  findStrictestExistingLockType() {
-    let maxType = "unlocked";
-    const traverse = (node) => {
-      if (!node) {
-        return;
-      }
-      if (node.range.type === "exclusive") {
-        maxType = "exclusive";
-        return;
-      }
-      if (node.range.type === "shared") {
-        maxType = "shared";
-      }
-      traverse(node.left);
-      traverse(node.right);
-    };
-    traverse(this.root);
-    return maxType;
-  }
-  insertNode(node, range) {
-    if (!node) {
-      return new IntervalNode(range);
-    }
-    if (range.start < node.range.start) {
-      node.left = this.insertNode(node.left, range);
-    } else {
-      node.right = this.insertNode(node.right, range);
-    }
-    node.max = this.bigintMax(node.max, range.end);
-    return node;
-  }
-  bigintMax(...args) {
-    return args.reduce((max, current) => {
-      return current > max ? current : max;
-    }, args[0]);
-  }
-  findOverlappingRanges(node, range, result) {
-    if (!node) {
-      return;
-    }
-    if (this.doRangesOverlap(node.range, range)) {
-      result.push(node.range);
-    }
-    if (node.left && node.left.max >= range.start) {
-      this.findOverlappingRanges(node.left, range, result);
-    }
-    if (node.right && node.range.start <= range.end) {
-      this.findOverlappingRanges(node.right, range, result);
-    }
-  }
-  doRangesOverlap(a, b) {
-    return a.start < b.end && b.start < a.end;
-  }
-  removeNode(node, range) {
-    if (!node) {
-      return null;
-    }
-    if (this.areRangesEqual(node.range, range)) {
-      if (!node.left) {
-        return node.right;
-      }
-      if (!node.right) {
-        return node.left;
-      }
-      const successor = this.findMin(node.right);
-      node.range = successor.range;
-      node.right = this.removeNode(node.right, successor.range);
-    } else if (range.start < node.range.start) {
-      node.left = this.removeNode(node.left, range);
-    } else {
-      node.right = this.removeNode(node.right, range);
-    }
-    node.max = node.range.end;
-    if (node.left) {
-      node.max = this.bigintMax(node.max, node.left.max);
-    }
-    if (node.right) {
-      node.max = this.bigintMax(node.max, node.right.max);
-    }
-    return node;
-  }
-  findMin(node) {
-    let current = node;
-    while (current.left) {
-      current = current.left;
-    }
-    return current;
-  }
-  areRangesEqual(a, b) {
-    return a.start === b.start && a.end === b.end && a.pid === b.pid;
-  }
-  findLocksForProcessInNode(node, pid, result) {
-    if (!node) {
-      return;
-    }
-    if (node.range.pid === pid) {
-      result.push(node.range);
-    }
-    this.findLocksForProcessInNode(node.left, pid, result);
-    this.findLocksForProcessInNode(node.right, pid, result);
-  }
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  FileLock,
-  FileLockManagerForNode,
+  FileLockManagerForPosix,
+  FileLockManagerForWindows,
+  bindUserSpace,
   createNodeFsMountHandler,
   getPHPLoaderModule,
   loadNodeRuntime,