@php-wasm/node 3.1.20 → 3.1.22

package/index.cjs

@@ -37,8 +37,7 @@ __export(src_exports, {
   getPHPLoaderModule: () => getPHPLoaderModule,
   loadNodeRuntime: () => loadNodeRuntime,
   useHostFilesystem: () => useHostFilesystem,
-  withNetworking: () => withNetworking,
-  withXdebug: () => withXdebug
+  withNetworking: () => withNetworking
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -61,6 +60,8 @@ async function getPHPLoaderModule(version = import_universal.LatestSupportedPHPV
         return (await import("@php-wasm/node-8-0")).getPHPLoaderModule();
       case "7.4":
         return (await import("@php-wasm/node-7-4")).getPHPLoaderModule();
+      case "5.2":
+        return (await import("@php-wasm/node-5-2")).getPHPLoaderModule();
     }
     throw new Error(`Unsupported PHP version ${version}`);
   } catch (errorCandidate) {
@@ -423,7 +424,7 @@ async function withNetworking(phpModuleArgs = {}) {
 }
 
 // packages/php-wasm/node/src/lib/load-runtime.ts
-var import_universal12 = require("@php-wasm/universal");
+var import_universal9 = require("@php-wasm/universal");
 
 // packages/php-wasm/node/src/lib/wasm-user-space.ts
 var import_promises = require("dns/promises");
@@ -493,8 +494,8 @@ function bindUserSpace({ fileLockManager }, {
       [F_WRLCK]: "exclusive",
       [F_UNLCK]: "unlocked"
     },
-    is_path_to_shared_fs(path2) {
-      const { node } = FS.lookupPath(path2, { noent_okay: true });
+    is_path_to_shared_fs(path3) {
+      const { node } = FS.lookupPath(path3, { noent_okay: true });
       if (!node) {
         return false;
       }
@@ -1125,7 +1126,7 @@ function bindUserSpace({ fileLockManager }, {
 }
 
 // packages/php-wasm/node/src/lib/load-runtime.ts
-var import_fs5 = __toESM(require("fs"), 1);
+var import_fs2 = __toESM(require("fs"), 1);
 
 // packages/php-wasm/node/src/lib/file-lock-manager-for-posix.ts
 var import_universal2 = require("@php-wasm/universal");
@@ -1143,7 +1144,7 @@ var FileLockManagerForPosix = class {
     this.wholeFileLockMap = /* @__PURE__ */ new Map();
     this.rangeLockedFds = /* @__PURE__ */ new Map();
   }
-  lockWholeFile(path2, op) {
+  lockWholeFile(path3, 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);
@@ -1155,7 +1156,7 @@ var FileLockManagerForPosix = class {
         }
         this.wholeFileLockMap.get(op.pid).set(op.fd, {
           ...op,
-          path: path2
+          path: path3
         });
       }
       return true;
@@ -1166,7 +1167,7 @@ var FileLockManagerForPosix = class {
       return false;
     }
   }
-  lockFileByteRange(path2, op, waitForLock) {
+  lockFileByteRange(path3, op, waitForLock) {
     if (op.start === op.end) {
       op = {
         ...op,
@@ -1187,10 +1188,10 @@ var FileLockManagerForPosix = class {
         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());
+      if (!pidMap.has(path3)) {
+        pidMap.set(path3, /* @__PURE__ */ new Set());
       }
-      pidMap.get(path2).add(op.fd);
+      pidMap.get(path3).add(op.fd);
       return true;
     } catch (e) {
       if (!isLockDenialError(e)) {
@@ -1199,13 +1200,13 @@ var FileLockManagerForPosix = class {
       return false;
     }
   }
-  findFirstConflictingByteRangeLock(path2, op) {
+  findFirstConflictingByteRangeLock(path3, op) {
     if (op.type === "unlocked") {
       return void 0;
     }
-    const obtainedLock = this.lockFileByteRange(path2, op, false);
+    const obtainedLock = this.lockFileByteRange(path3, op, false);
     if (obtainedLock) {
-      this.lockFileByteRange(path2, { ...op, type: "unlocked" }, true);
+      this.lockFileByteRange(path3, { ...op, type: "unlocked" }, true);
       return void 0;
     }
     return {
@@ -1233,11 +1234,11 @@ var FileLockManagerForPosix = class {
       }
       this.wholeFileLockMap.delete(targetPid);
     }
-    for (const [path2, fdSet] of this.rangeLockedFds.get(targetPid) ?? []) {
+    for (const [path3, fdSet] of this.rangeLockedFds.get(targetPid) ?? []) {
       for (const fd of fdSet) {
         try {
           this.lockFileByteRange(
-            path2,
+            path3,
             {
               pid: targetPid,
               fd,
@@ -1249,7 +1250,7 @@ var FileLockManagerForPosix = class {
           );
         } catch (e) {
           import_logger2.logger.error(
-            `releaseLocksForProcess: failed to unlock byte range for pid=${targetPid} fd=${fd} path=${path2}`,
+            `releaseLocksForProcess: failed to unlock byte range for pid=${targetPid} fd=${fd} path=${path3}`,
             e
           );
         }
@@ -1306,7 +1307,7 @@ var FileLockManagerForWindows = class {
     this.wholeFileLockMap = /* @__PURE__ */ new Map();
     this.rangeLockedFds = /* @__PURE__ */ new Map();
   }
-  lockWholeFile(path2, op) {
+  lockWholeFile(path3, op) {
     const start = 0n;
     const end = 2n ** 64n - 1n;
     if (op.type === "unlock") {
@@ -1318,7 +1319,7 @@ var FileLockManagerForWindows = class {
         }
       } else {
         import_logger3.logger.warn(
-          `lockWholeFile: unlock failed for pid=${op.pid} fd=${op.fd} path=${path2}`
+          `lockWholeFile: unlock failed for pid=${op.pid} fd=${op.fd} path=${path3}`
         );
       }
       return success2;
@@ -1386,22 +1387,22 @@ var FileLockManagerForWindows = class {
       }
       this.wholeFileLockMap.get(op.pid).set(op.fd, {
         ...op,
-        path: path2
+        path: path3
       });
     }
     return success;
   }
-  lockFileByteRange(path2, op, waitForLock) {
+  lockFileByteRange(path3, 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());
+    if (!this.rangeLockedFds.has(path3)) {
+      this.rangeLockedFds.set(path3, new import_universal3.FileLockIntervalTree());
     }
-    const lockedRangeTree = this.rangeLockedFds.get(path2);
+    const lockedRangeTree = this.rangeLockedFds.get(path3);
     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,
@@ -1486,12 +1487,12 @@ var FileLockManagerForWindows = class {
       return true;
     }
   }
-  findFirstConflictingByteRangeLock(path2, op) {
+  findFirstConflictingByteRangeLock(path3, op) {
     if (op.type === "unlocked") {
       return void 0;
     }
-    const obtainedLock = !!this.lockFileByteRange(path2, op, false);
-    this.lockFileByteRange(path2, { ...op, type: "unlocked" }, false);
+    const obtainedLock = !!this.lockFileByteRange(path3, op, false);
+    this.lockFileByteRange(path3, { ...op, type: "unlocked" }, false);
     if (obtainedLock) {
       return void 0;
     }
@@ -1520,18 +1521,18 @@ var FileLockManagerForWindows = class {
       }
       this.wholeFileLockMap.delete(targetPid);
     }
-    for (const [path2, lockedRangeTree] of this.rangeLockedFds.entries()) {
+    for (const [path3, lockedRangeTree] of this.rangeLockedFds.entries()) {
       const rangesLockedByTargetPid = lockedRangeTree.findLocksForProcess(targetPid);
       for (const op of rangesLockedByTargetPid) {
         try {
           this.lockFileByteRange(
-            path2,
+            path3,
             { ...op, type: "unlocked" },
             false
           );
         } catch (e) {
           import_logger3.logger.error(
-            `releaseLocksForProcess: failed to unlock byte range for pid=${targetPid} fd=${op.fd} path=${path2}`,
+            `releaseLocksForProcess: failed to unlock byte range for pid=${targetPid} fd=${op.fd} path=${path3}`,
             e
           );
         }
@@ -1567,200 +1568,59 @@ var FileLockManagerForWindows = class {
   }
 };
 
-// packages/php-wasm/node/src/lib/extensions/xdebug/with-xdebug.ts
+// packages/php-wasm/node/src/lib/extensions/load-extensions.ts
 var import_cli_util = require("@php-wasm/cli-util");
-var import_universal5 = require("@php-wasm/universal");
+var import_universal8 = require("@php-wasm/universal");
 var import_fs = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
 
-// packages/php-wasm/node/src/lib/extensions/xdebug/get-xdebug-extension-module.ts
+// packages/php-wasm/node/src/lib/extensions/intl/get-intl-extension-module.ts
 var import_universal4 = require("@php-wasm/universal");
-async function getXdebugExtensionModule(version = import_universal4.LatestSupportedPHPVersion) {
+async function getIntlExtensionModule(version = import_universal4.LatestSupportedPHPVersion) {
   switch (version) {
     case "8.5":
-      return (await import("@php-wasm/node-8-5")).getXdebugExtensionPath();
+      return (await import("@php-wasm/node-8-5")).getIntlExtensionPath();
     case "8.4":
-      return (await import("@php-wasm/node-8-4")).getXdebugExtensionPath();
+      return (await import("@php-wasm/node-8-4")).getIntlExtensionPath();
     case "8.3":
-      return (await import("@php-wasm/node-8-3")).getXdebugExtensionPath();
+      return (await import("@php-wasm/node-8-3")).getIntlExtensionPath();
     case "8.2":
-      return (await import("@php-wasm/node-8-2")).getXdebugExtensionPath();
+      return (await import("@php-wasm/node-8-2")).getIntlExtensionPath();
     case "8.1":
-      return (await import("@php-wasm/node-8-1")).getXdebugExtensionPath();
+      return (await import("@php-wasm/node-8-1")).getIntlExtensionPath();
     case "8.0":
-      return (await import("@php-wasm/node-8-0")).getXdebugExtensionPath();
+      return (await import("@php-wasm/node-8-0")).getIntlExtensionPath();
     case "7.4":
-      return (await import("@php-wasm/node-7-4")).getXdebugExtensionPath();
+      return (await import("@php-wasm/node-7-4")).getIntlExtensionPath();
   }
   throw new Error(`Unsupported PHP version ${version}`);
 }
 
-// packages/php-wasm/node/src/lib/extensions/xdebug/with-xdebug.ts
-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);
-  return {
-    ...options,
-    ENV: {
-      ...options.ENV,
-      PHP_INI_SCAN_DIR: "/internal/shared/extensions"
-    },
-    onRuntimeInitialized: (phpRuntime) => {
-      if (options.onRuntimeInitialized) {
-        options.onRuntimeInitialized(phpRuntime);
-      }
-      if (!import_universal5.FSHelpers.fileExists(
-        phpRuntime.FS,
-        "/internal/shared/extensions"
-      )) {
-        phpRuntime.FS.mkdirTree("/internal/shared/extensions");
-      }
-      if (!import_universal5.FSHelpers.fileExists(
-        phpRuntime.FS,
-        `/internal/shared/extensions/${fileName}`
-      )) {
-        phpRuntime.FS.writeFile(
-          `/internal/shared/extensions/${fileName}`,
-          new Uint8Array(extension)
-        );
-      }
-      if (!import_universal5.FSHelpers.fileExists(
-        phpRuntime.FS,
-        "/internal/shared/extensions/xdebug.ini"
-      )) {
-        const ideKey = xdebugOptions.ideKey || import_cli_util.DEFAULT_IDE_KEY;
-        phpRuntime.FS.writeFile(
-          "/internal/shared/extensions/xdebug.ini",
-          [
-            "zend_extension=/internal/shared/extensions/xdebug.so",
-            "xdebug.mode=debug,develop",
-            "xdebug.start_with_request=yes",
-            `xdebug.idekey="${ideKey}"`,
-            // Path mapping is only available starting
-            // from Xdebug 3.5, which is used by PHP 8.5+
-            // Previous versions will ignore this entry.
-            "xdebug.path_mapping=yes"
-          ].join("\n")
-        );
-      }
-      const isPHP85orHigher = import_universal5.SupportedPHPVersionsList.indexOf(version) <= import_universal5.SupportedPHPVersions.indexOf("8.5");
-      if (isPHP85orHigher) {
-        const { pathMappings, pathSkippings } = xdebugOptions;
-        if (!pathMappings && !pathSkippings)
-          return;
-        phpRuntime.FS.mkdir("/.xdebug");
-        if (pathMappings) {
-          phpRuntime.FS.writeFile(
-            "/.xdebug/path.map",
-            pathMappings.map((map) => `${map.vfsPath} = ${map.hostPath}`).join("\n")
-          );
-        }
-        if (pathSkippings) {
-          phpRuntime.FS.writeFile(
-            "/.xdebug/skip.map",
-            pathSkippings.map((path2) => `${path2} = SKIP`).join("\n")
-          );
-        }
-      }
-    }
-  };
-}
-
-// packages/php-wasm/node/src/lib/extensions/intl/with-intl.ts
-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_universal6 = require("@php-wasm/universal");
-async function getIntlExtensionModule(version = import_universal6.LatestSupportedPHPVersion) {
+// packages/php-wasm/node/src/lib/extensions/memcached/get-memcached-extension-module.ts
+var import_universal5 = require("@php-wasm/universal");
+async function getMemcachedExtensionModule(version = import_universal5.LatestSupportedPHPVersion) {
   switch (version) {
     case "8.5":
-      return (await import("@php-wasm/node-8-5")).getIntlExtensionPath();
+      return (await import("@php-wasm/node-8-5")).getMemcachedExtensionPath();
     case "8.4":
-      return (await import("@php-wasm/node-8-4")).getIntlExtensionPath();
+      return (await import("@php-wasm/node-8-4")).getMemcachedExtensionPath();
     case "8.3":
-      return (await import("@php-wasm/node-8-3")).getIntlExtensionPath();
+      return (await import("@php-wasm/node-8-3")).getMemcachedExtensionPath();
     case "8.2":
-      return (await import("@php-wasm/node-8-2")).getIntlExtensionPath();
+      return (await import("@php-wasm/node-8-2")).getMemcachedExtensionPath();
     case "8.1":
-      return (await import("@php-wasm/node-8-1")).getIntlExtensionPath();
+      return (await import("@php-wasm/node-8-1")).getMemcachedExtensionPath();
     case "8.0":
-      return (await import("@php-wasm/node-8-0")).getIntlExtensionPath();
+      return (await import("@php-wasm/node-8-0")).getMemcachedExtensionPath();
     case "7.4":
-      return (await import("@php-wasm/node-7-4")).getIntlExtensionPath();
+      return (await import("@php-wasm/node-7-4")).getMemcachedExtensionPath();
   }
   throw new Error(`Unsupported PHP version ${version}`);
 }
 
-// packages/php-wasm/node/src/lib/extensions/intl/with-intl.ts
-var import_meta = {};
-async function withIntl(version = import_universal7.LatestSupportedPHPVersion, options) {
-  const extensionName = "intl.so";
-  const extensionPath = await getIntlExtensionModule(version);
-  const extension = import_fs2.default.readFileSync(extensionPath);
-  const dataName = "icu.dat";
-  const moduleDir = typeof __dirname !== "undefined" ? __dirname : import_meta.dirname;
-  const dataPath = import_path.default.join(moduleDir, "shared", dataName);
-  const ICUData = import_fs2.default.readFileSync(dataPath);
-  return {
-    ...options,
-    ENV: {
-      ...options.ENV,
-      PHP_INI_SCAN_DIR: "/internal/shared/extensions",
-      ICU_DATA: "/internal/shared"
-    },
-    onRuntimeInitialized: (phpRuntime) => {
-      if (options.onRuntimeInitialized) {
-        options.onRuntimeInitialized(phpRuntime);
-      }
-      if (!import_universal7.FSHelpers.fileExists(
-        phpRuntime.FS,
-        "/internal/shared/extensions"
-      )) {
-        phpRuntime.FS.mkdirTree("/internal/shared/extensions");
-      }
-      if (!import_universal7.FSHelpers.fileExists(
-        phpRuntime.FS,
-        `/internal/shared/extensions/${extensionName}`
-      )) {
-        phpRuntime.FS.writeFile(
-          `/internal/shared/extensions/${extensionName}`,
-          new Uint8Array(extension)
-        );
-      }
-      if (!import_universal7.FSHelpers.fileExists(
-        phpRuntime.FS,
-        "/internal/shared/extensions/intl.ini"
-      )) {
-        phpRuntime.FS.writeFile(
-          "/internal/shared/extensions/intl.ini",
-          [
-            `extension=/internal/shared/extensions/${extensionName}`
-          ].join("\n")
-        );
-      }
-      if (!import_universal7.FSHelpers.fileExists(
-        phpRuntime.FS,
-        `${phpRuntime.ENV.ICU_DATA}/${dataName}`
-      )) {
-        phpRuntime.FS.mkdirTree(phpRuntime.ENV.ICU_DATA);
-        phpRuntime.FS.writeFile(
-          `${phpRuntime.ENV.ICU_DATA}/icudt74l.dat`,
-          new Uint8Array(ICUData)
-        );
-      }
-    }
-  };
-}
-
-// packages/php-wasm/node/src/lib/extensions/redis/with-redis.ts
-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_universal8 = require("@php-wasm/universal");
-async function getRedisExtensionModule(version = import_universal8.LatestSupportedPHPVersion) {
+var import_universal6 = require("@php-wasm/universal");
+async function getRedisExtensionModule(version = import_universal6.LatestSupportedPHPVersion) {
   switch (version) {
     case "8.5":
       return (await import("@php-wasm/node-8-5")).getRedisExtensionPath();
@@ -1780,131 +1640,258 @@ async function getRedisExtensionModule(version = import_universal8.LatestSupport
   throw new Error(`Unsupported PHP version ${version}`);
 }
 
-// packages/php-wasm/node/src/lib/extensions/redis/with-redis.ts
-async function withRedis(version = import_universal9.LatestSupportedPHPVersion, options) {
-  const extensionName = "redis.so";
-  const extensionPath = await getRedisExtensionModule(version);
-  const extension = import_fs3.default.readFileSync(extensionPath);
-  return {
-    ...options,
-    ENV: {
-      ...options.ENV,
-      PHP_INI_SCAN_DIR: "/internal/shared/extensions"
-    },
-    onRuntimeInitialized: (phpRuntime) => {
-      if (options.onRuntimeInitialized) {
-        options.onRuntimeInitialized(phpRuntime);
-      }
-      if (!import_universal9.FSHelpers.fileExists(
-        phpRuntime.FS,
-        "/internal/shared/extensions"
-      )) {
-        phpRuntime.FS.mkdirTree("/internal/shared/extensions");
-      }
-      if (!import_universal9.FSHelpers.fileExists(
-        phpRuntime.FS,
-        `/internal/shared/extensions/${extensionName}`
-      )) {
-        phpRuntime.FS.writeFile(
-          `/internal/shared/extensions/${extensionName}`,
-          new Uint8Array(extension)
-        );
-      }
-      if (!import_universal9.FSHelpers.fileExists(
-        phpRuntime.FS,
-        "/internal/shared/extensions/redis.ini"
-      )) {
-        phpRuntime.FS.writeFile(
-          "/internal/shared/extensions/redis.ini",
-          [
-            `extension=/internal/shared/extensions/${extensionName}`
-          ].join("\n")
-        );
-      }
-    }
-  };
-}
-
-// packages/php-wasm/node/src/lib/extensions/memcached/with-memcached.ts
-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_universal10 = require("@php-wasm/universal");
-async function getMemcachedExtensionModule(version = import_universal10.LatestSupportedPHPVersion) {
+// packages/php-wasm/node/src/lib/extensions/xdebug/get-xdebug-extension-module.ts
+var import_universal7 = require("@php-wasm/universal");
+async function getXdebugExtensionModule(version = import_universal7.LatestSupportedPHPVersion) {
   switch (version) {
     case "8.5":
-      return (await import("@php-wasm/node-8-5")).getMemcachedExtensionPath();
+      return (await import("@php-wasm/node-8-5")).getXdebugExtensionPath();
     case "8.4":
-      return (await import("@php-wasm/node-8-4")).getMemcachedExtensionPath();
+      return (await import("@php-wasm/node-8-4")).getXdebugExtensionPath();
     case "8.3":
-      return (await import("@php-wasm/node-8-3")).getMemcachedExtensionPath();
+      return (await import("@php-wasm/node-8-3")).getXdebugExtensionPath();
     case "8.2":
-      return (await import("@php-wasm/node-8-2")).getMemcachedExtensionPath();
+      return (await import("@php-wasm/node-8-2")).getXdebugExtensionPath();
     case "8.1":
-      return (await import("@php-wasm/node-8-1")).getMemcachedExtensionPath();
+      return (await import("@php-wasm/node-8-1")).getXdebugExtensionPath();
     case "8.0":
-      return (await import("@php-wasm/node-8-0")).getMemcachedExtensionPath();
+      return (await import("@php-wasm/node-8-0")).getXdebugExtensionPath();
     case "7.4":
-      return (await import("@php-wasm/node-7-4")).getMemcachedExtensionPath();
+      return (await import("@php-wasm/node-7-4")).getXdebugExtensionPath();
   }
   throw new Error(`Unsupported PHP version ${version}`);
 }
 
-// packages/php-wasm/node/src/lib/extensions/memcached/with-memcached.ts
-async function withMemcached(version = import_universal11.LatestSupportedPHPVersion, options) {
-  const extensionName = "memcached.so";
-  const extensionPath = await getMemcachedExtensionModule(version);
-  const extension = import_fs4.default.readFileSync(extensionPath);
+// packages/php-wasm/node/src/lib/extensions/node-extension-resources.ts
+var import_promises2 = require("fs/promises");
+var import_path = __toESM(require("path"), 1);
+var import_url = require("url");
+function normalizeNodeExtensionSource(source) {
+  if (source.format === "url") {
+    return {
+      ...source,
+      url: toNodeResourceUrl(source.url)
+    };
+  }
+  if (source.format !== "manifest") {
+    return source;
+  }
+  if ("manifest" in source) {
+    return source.baseUrl ? {
+      ...source,
+      baseUrl: toNodeResourceUrl(source.baseUrl)
+    } : source;
+  }
   return {
-    ...options,
-    ENV: {
-      ...options.ENV,
-      PHP_INI_SCAN_DIR: "/internal/shared/extensions"
-    },
-    onRuntimeInitialized: (phpRuntime) => {
-      if (options.onRuntimeInitialized) {
-        options.onRuntimeInitialized(phpRuntime);
-      }
-      if (!import_universal11.FSHelpers.fileExists(
-        phpRuntime.FS,
-        "/internal/shared/extensions"
-      )) {
-        phpRuntime.FS.mkdirTree("/internal/shared/extensions");
-      }
-      if (!import_universal11.FSHelpers.fileExists(
-        phpRuntime.FS,
-        `/internal/shared/extensions/${extensionName}`
-      )) {
-        phpRuntime.FS.writeFile(
-          `/internal/shared/extensions/${extensionName}`,
-          new Uint8Array(extension)
-        );
-      }
-      if (!import_universal11.FSHelpers.fileExists(
-        phpRuntime.FS,
-        "/internal/shared/extensions/memcached.ini"
-      )) {
-        phpRuntime.FS.writeFile(
-          "/internal/shared/extensions/memcached.ini",
-          [
-            `extension=/internal/shared/extensions/${extensionName}`
-          ].join("\n")
-        );
-      }
+    ...source,
+    manifestUrl: toNodeResourceUrl(source.manifestUrl)
+  };
+}
+async function fetchNodeExtensionResource(input) {
+  const url = input instanceof Request ? new URL(input.url) : input instanceof URL ? input : toNodeResourceUrl(String(input));
+  if (url.protocol === "file:") {
+    try {
+      return new Response(await (0, import_promises2.readFile)((0, import_url.fileURLToPath)(url)));
+    } catch (error) {
+      return new Response(String(error), {
+        status: 404,
+        statusText: "Not Found"
+      });
+    }
+  }
+  return fetch(input);
+}
+function toNodeResourceUrl(urlOrPath) {
+  if (urlOrPath instanceof URL) {
+    return urlOrPath;
+  }
+  try {
+    const url = new URL(urlOrPath);
+    if (url.protocol === "http:" || url.protocol === "https:" || url.protocol === "file:") {
+      return url;
     }
+  } catch {
+  }
+  return (0, import_url.pathToFileURL)(import_path.default.resolve(urlOrPath));
+}
+
+// packages/php-wasm/node/src/lib/extensions/load-extensions.ts
+var import_meta = {};
+async function withPHPExtensions(version, asyncMode, options, extensions = []) {
+  if (!extensions.length) {
+    return options;
+  }
+  const resolvedExtensions = await Promise.all(
+    extensions.map(
+      (extension) => resolveRuntimePHPExtension(version, asyncMode, extension)
+    )
+  );
+  return (0, import_universal8.withResolvedPHPExtensions)(options, resolvedExtensions);
+}
+async function resolveRuntimePHPExtension(version, asyncMode, extension) {
+  if (typeof extension === "object" && "source" in extension) {
+    return await (0, import_universal8.resolvePHPExtension)({
+      ...extension,
+      source: normalizeNodeExtensionSource(extension.source),
+      phpVersion: version,
+      asyncMode,
+      fetch: extension.fetch ?? fetchNodeExtensionResource
+    });
+  }
+  const builtIn = typeof extension === "string" ? { name: extension } : extension;
+  switch (builtIn.name) {
+    case "intl": {
+      const extensionPath = await getIntlExtensionModule(version);
+      const soBytes = new Uint8Array(import_fs.default.readFileSync(extensionPath));
+      const dataName = "icu.dat";
+      const moduleDir = typeof __dirname !== "undefined" ? __dirname : import_meta.dirname;
+      const ICUData = import_fs.default.readFileSync(
+        resolveIntlDataPath(moduleDir, dataName)
+      );
+      return await (0, import_universal8.resolvePHPExtension)({
+        source: {
+          format: "so",
+          name: "intl",
+          bytes: soBytes
+        },
+        phpVersion: version,
+        asyncMode,
+        env: {
+          ICU_DATA: "/internal/shared"
+        },
+        extraFiles: {
+          targetPath: "/internal/shared",
+          files: {
+            // The Intl extension looks for the hard-coded ICU data name.
+            "icudt74l.dat": new Uint8Array(ICUData)
+          }
+        }
+      });
+    }
+    case "redis": {
+      const extensionPath = await getRedisExtensionModule(version);
+      return await (0, import_universal8.resolvePHPExtension)({
+        source: {
+          format: "so",
+          name: "redis",
+          bytes: new Uint8Array(import_fs.default.readFileSync(extensionPath))
+        },
+        phpVersion: version,
+        asyncMode
+      });
+    }
+    case "memcached": {
+      const extensionPath = await getMemcachedExtensionModule(version);
+      return await (0, import_universal8.resolvePHPExtension)({
+        source: {
+          format: "so",
+          name: "memcached",
+          bytes: new Uint8Array(import_fs.default.readFileSync(extensionPath))
+        },
+        phpVersion: version,
+        asyncMode
+      });
+    }
+    case "xdebug": {
+      const xdebugOptions = builtIn.options ?? {};
+      const filePath = await getXdebugExtensionModule(version);
+      const ideKey = xdebugOptions.ideKey || import_cli_util.DEFAULT_IDE_KEY;
+      return await (0, import_universal8.resolvePHPExtension)({
+        source: {
+          format: "so",
+          name: "xdebug",
+          bytes: new Uint8Array(import_fs.default.readFileSync(filePath))
+        },
+        phpVersion: version,
+        asyncMode,
+        loadWithIniDirective: "zend_extension",
+        iniEntries: {
+          "xdebug.mode": "debug,develop",
+          "xdebug.start_with_request": "yes",
+          "xdebug.idekey": `"${ideKey}"`,
+          // Path mapping is only available starting from Xdebug 3.5,
+          // which is used by PHP 8.5+. Previous versions ignore it.
+          "xdebug.path_mapping": "yes"
+        },
+        extraFiles: resolveXdebugExtraFiles(version, xdebugOptions)
+      });
+    }
+    default:
+      throw new Error(
+        `Unknown bundled PHP extension: ${String(builtIn.name)}.`
+      );
+  }
+}
+function resolveIntlDataPath(moduleDir, dataName) {
+  const candidatePaths = [
+    // Built package layout: dist/packages/php-wasm/node/shared/icu.dat.
+    import_path2.default.join(moduleDir, "shared", dataName),
+    // Source/test layout: src/lib/extensions/intl/shared/icu.dat.
+    import_path2.default.join(moduleDir, "intl", "shared", dataName)
+  ];
+  const dataPath = candidatePaths.find(
+    (candidate) => import_fs.default.existsSync(candidate)
+  );
+  if (!dataPath) {
+    throw new Error(
+      `Could not find ${dataName}. Checked: ${candidatePaths.join(", ")}`
+    );
+  }
+  return dataPath;
+}
+function resolveXdebugExtraFiles(version, xdebugOptions) {
+  const isPHP85orHigher = import_universal8.SupportedPHPVersions.indexOf(version) <= import_universal8.SupportedPHPVersions.indexOf("8.5");
+  if (!isPHP85orHigher) {
+    return void 0;
+  }
+  const { pathMappings, pathSkippings } = xdebugOptions;
+  if (!pathMappings && !pathSkippings) {
+    return void 0;
+  }
+  const files = {};
+  if (pathMappings) {
+    files["path.map"] = pathMappings.map((map) => `${map.vfsPath} = ${map.hostPath}`).join("\n");
+  }
+  if (pathSkippings) {
+    files["skip.map"] = pathSkippings.map((path3) => `${path3} = SKIP`).join("\n");
+  }
+  return {
+    targetPath: "/.xdebug",
+    files
   };
 }
 
 // packages/php-wasm/node/src/lib/load-runtime.ts
 var import_util = require("@php-wasm/util");
 var import_os = require("os");
-var dangerousDefaultProcessIdAllocator = process.env.VITEST ? new import_universal12.ProcessIdAllocator() : void 0;
+
+// node_modules/wasm-feature-detect/dist/esm/index.js
+var jspi = () => (async () => "Suspending" in WebAssembly)();
+
+// packages/php-wasm/node/src/lib/load-runtime.ts
+var dangerousDefaultProcessIdAllocator = process.env.VITEST ? new import_universal9.ProcessIdAllocator() : void 0;
 async function loadNodeRuntime(phpVersion, options = {}) {
   const processId = options.emscriptenOptions?.processId ?? // !! Only assign a default process ID during test.
   // Otherwise, multiple workers with duplicate process IDs
   // could break file locking and lead to database corruption.
   (process.env.VITEST ? dangerousDefaultProcessIdAllocator.claim() : void 0);
+  const isLegacy = (0, import_universal9.isLegacyPHPVersion)(phpVersion);
+  const phpWasmAsyncMode = await jspi() ? "jspi" : "asyncify";
+  const requestedExtensions = [...options.extensions ?? []];
+  if (options.withIntl && !hasBuiltInExtension(requestedExtensions, "intl")) {
+    requestedExtensions.push("intl");
+  }
+  if (options.withRedis && !hasBuiltInExtension(requestedExtensions, "redis")) {
+    requestedExtensions.push("redis");
+  }
+  if (options.withMemcached && !hasBuiltInExtension(requestedExtensions, "memcached")) {
+    requestedExtensions.push("memcached");
+  }
+  if (options.withXdebug && !hasBuiltInExtension(requestedExtensions, "xdebug")) {
+    requestedExtensions.push(
+      typeof options.withXdebug === "object" ? { name: "xdebug", options: options.withXdebug } : "xdebug"
+    );
+  }
   let emscriptenOptions = {
     /**
      * Emscripten default behavior is to kill the process when
@@ -1916,19 +1903,30 @@ async function loadNodeRuntime(phpVersion, options = {}) {
     },
     bindUserSpace: (userSpaceContext) => {
       const nativeFileLockManager = (0, import_os.platform)() === "win32" ? new FileLockManagerForWindows() : new FileLockManagerForPosix();
-      const fileLockManager = options.fileLockManager ? new import_universal12.FileLockManagerComposite({
+      const fileLockManager = options.fileLockManager ? new import_universal9.FileLockManagerComposite({
         nativeLockManager: nativeFileLockManager,
         wasmLockManager: options.fileLockManager
       }) : nativeFileLockManager;
       return bindUserSpace({ fileLockManager }, userSpaceContext);
     },
     ...options.emscriptenOptions || {},
+    phpWasmAsyncMode,
     processId,
+    // For legacy PHP: pre-create php.ini via a preRun step. See
+    // createLegacyPhpIniPreRunStep for why this must run before
+    // the PHP SAPI starts. Merge with any caller-provided preRun
+    // hooks (the spread above may have set them).
+    ...isLegacy ? {
+      preRun: [
+        (0, import_universal9.createLegacyPhpIniPreRunStep)(),
+        ...options.emscriptenOptions?.preRun ?? []
+      ]
+    } : {},
     onRuntimeInitialized: (phpRuntime) => {
       if (options?.followSymlinks === true) {
         phpRuntime.FS.filesystems.NODEFS.node_ops.readlink = (node) => {
           const absoluteSourcePath = phpRuntime.FS.filesystems.NODEFS.tryFSOperation(
-            () => import_fs5.default.realpathSync(
+            () => import_fs2.default.realpathSync(
               phpRuntime.FS.filesystems.NODEFS.realPath(node)
             )
           );
@@ -1937,9 +1935,9 @@ async function loadNodeRuntime(phpVersion, options = {}) {
             `/internal/symlinks`,
             normalizedPath
           );
-          if (import_fs5.default.existsSync(absoluteSourcePath)) {
-            const sourceStat = import_fs5.default.statSync(absoluteSourcePath);
-            if (!import_universal12.FSHelpers.fileExists(
+          if (import_fs2.default.existsSync(absoluteSourcePath)) {
+            const sourceStat = import_fs2.default.statSync(absoluteSourcePath);
+            if (!import_universal9.FSHelpers.fileExists(
               phpRuntime.FS,
               symlinkMountPath
             )) {
@@ -1978,49 +1976,56 @@ async function loadNodeRuntime(phpVersion, options = {}) {
       phpRuntime.FS.root.mount.opts.root = ".";
     }
   };
-  if (options?.withXdebug) {
-    emscriptenOptions = await withXdebug(
-      phpVersion,
-      emscriptenOptions,
-      typeof options.withXdebug === "object" ? options.withXdebug : {}
+  if (isLegacy && requestedExtensions.length) {
+    throw new Error(
+      `Extensions (xdebug, intl, redis, memcached) are not available for legacy PHP ${phpVersion}.`
     );
   }
-  if (options?.withIntl === true) {
-    emscriptenOptions = await withIntl(phpVersion, emscriptenOptions);
-  }
-  if (options?.withRedis === true) {
-    emscriptenOptions = await withRedis(phpVersion, emscriptenOptions);
-  }
-  if (options?.withMemcached === true) {
-    emscriptenOptions = await withMemcached(phpVersion, emscriptenOptions);
+  if (!isLegacy) {
+    const modernVersion = phpVersion;
+    emscriptenOptions = await withPHPExtensions(
+      modernVersion,
+      phpWasmAsyncMode,
+      emscriptenOptions,
+      requestedExtensions
+    );
   }
   emscriptenOptions = await withNetworking(emscriptenOptions);
   const phpLoaderModule = await getPHPLoaderModule(phpVersion);
-  const runtimeId = await (0, import_universal12.loadPHPRuntime)(phpLoaderModule, emscriptenOptions);
+  const runtimeId = await (0, import_universal9.loadPHPRuntime)(phpLoaderModule, emscriptenOptions);
   return runtimeId;
 }
+function hasBuiltInExtension(extensions, name) {
+  return extensions.some((extension) => {
+    if (typeof extension === "string") {
+      return extension === name;
+    }
+    return !("source" in extension) && extension.name === name;
+  });
+}
 
 // packages/php-wasm/node/src/lib/use-host-filesystem.ts
 var import_node_fs = require("node:fs");
 
 // packages/php-wasm/node/src/lib/node-fs-mount.ts
-var import_universal13 = require("@php-wasm/universal");
+var import_universal10 = require("@php-wasm/universal");
 var import_util2 = require("@php-wasm/util");
-var import_fs6 = require("fs");
-var import_path2 = require("path");
+var import_fs3 = require("fs");
+var import_path3 = require("path");
 function createNodeFsMountHandler(localPath) {
   return function(php, FS, vfsMountPoint) {
     let removeVfsNode = false;
-    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));
+    const mountRoot = (0, import_fs3.realpathSync)(localPath);
+    if (!import_universal10.FSHelpers.fileExists(FS, vfsMountPoint)) {
+      const stat = (0, import_fs3.statSync)(mountRoot);
+      if (stat.isFile()) {
+        FS.mkdirTree((0, import_path3.dirname)(vfsMountPoint));
         FS.writeFile(vfsMountPoint, "");
-      } else if (lstat.isDirectory()) {
+      } else if (stat.isDirectory()) {
         FS.mkdirTree(vfsMountPoint);
       } else {
         throw new Error(
-          "Unsupported file type. PHP-wasm supports only symlinks that link to files, directories, or symlinks."
+          "Unsupported file type. PHP-wasm supports mounting only files and directories, including symlinks that resolve to files or directories."
         );
       }
       removeVfsNode = true;
@@ -2037,7 +2042,7 @@ function createNodeFsMountHandler(localPath) {
       }
       throw e;
     }
-    FS.mount(FS.filesystems["NODEFS"], { root: localPath }, vfsMountPoint);
+    FS.mount(FS.filesystems["NODEFS"], { root: mountRoot }, vfsMountPoint);
     return () => {
       FS.unmount(vfsMountPoint);
       if (removeVfsNode) {
@@ -2073,20 +2078,20 @@ function useHostFilesystem(php) {
   }
   php.chdir(process.cwd());
 }
-function statPathFollowSymlinks(path2) {
-  let stat = (0, import_node_fs.lstatSync)(path2);
+function statPathFollowSymlinks(path3) {
+  let stat = (0, import_node_fs.lstatSync)(path3);
   if (stat.isSymbolicLink()) {
-    const fs6 = require("fs");
-    let target = path2;
+    const fs3 = require("fs");
+    let target = path3;
     const seen = /* @__PURE__ */ new Set();
     while (true) {
       if (seen.has(target)) {
-        throw new Error(`Symlink loop detected: ${path2}`);
+        throw new Error(`Symlink loop detected: ${path3}`);
       }
       seen.add(target);
       const linkStat = (0, import_node_fs.lstatSync)(target);
       if (linkStat.isSymbolicLink()) {
-        target = fs6.realpathSync(target);
+        target = fs3.realpathSync(target);
         continue;
       }
       stat = linkStat;
@@ -2104,6 +2109,5 @@ function statPathFollowSymlinks(path2) {
   getPHPLoaderModule,
   loadNodeRuntime,
   useHostFilesystem,
-  withNetworking,
-  withXdebug
+  withNetworking
 });