@php-wasm/node 3.1.21 → 3.1.22

package/index.js

@@ -391,7 +391,7 @@ async function withNetworking(phpModuleArgs = {}) {
 // packages/php-wasm/node/src/lib/load-runtime.ts
 import {
   loadPHPRuntime,
-  FSHelpers as FSHelpers5,
+  FSHelpers,
   FileLockManagerComposite,
   createLegacyPhpIniPreRunStep,
   isLegacyPHPVersion,
@@ -466,8 +466,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;
       }
@@ -1098,7 +1098,7 @@ function bindUserSpace({ fileLockManager }, {
 }
 
 // packages/php-wasm/node/src/lib/load-runtime.ts
-import fs5 from "fs";
+import fs2 from "fs";
 
 // packages/php-wasm/node/src/lib/file-lock-manager-for-posix.ts
 import { MAX_ADDRESSABLE_FILE_OFFSET } from "@php-wasm/universal";
@@ -1116,7 +1116,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 {
       flockSync(op.fd, opType);
@@ -1128,7 +1128,7 @@ var FileLockManagerForPosix = class {
         }
         this.wholeFileLockMap.get(op.pid).set(op.fd, {
           ...op,
-          path: path2
+          path: path3
         });
       }
       return true;
@@ -1139,7 +1139,7 @@ var FileLockManagerForPosix = class {
       return false;
     }
   }
-  lockFileByteRange(path2, op, waitForLock) {
+  lockFileByteRange(path3, op, waitForLock) {
     if (op.start === op.end) {
       op = {
         ...op,
@@ -1160,10 +1160,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)) {
@@ -1172,13 +1172,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 {
@@ -1206,11 +1206,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,
@@ -1222,7 +1222,7 @@ var FileLockManagerForPosix = class {
           );
         } catch (e) {
           logger2.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
           );
         }
@@ -1286,7 +1286,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") {
@@ -1298,7 +1298,7 @@ var FileLockManagerForWindows = class {
         }
       } else {
         logger3.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;
@@ -1366,22 +1366,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: MAX_ADDRESSABLE_FILE_OFFSET2
       };
     }
-    if (!this.rangeLockedFds.has(path2)) {
-      this.rangeLockedFds.set(path2, new FileLockIntervalTree());
+    if (!this.rangeLockedFds.has(path3)) {
+      this.rangeLockedFds.set(path3, new 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,
@@ -1466,12 +1466,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;
     }
@@ -1500,18 +1500,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) {
           logger3.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
           );
         }
@@ -1547,204 +1547,63 @@ var FileLockManagerForWindows = class {
   }
 };
 
-// packages/php-wasm/node/src/lib/extensions/xdebug/with-xdebug.ts
+// packages/php-wasm/node/src/lib/extensions/load-extensions.ts
 import { DEFAULT_IDE_KEY } from "@php-wasm/cli-util";
 import {
-  FSHelpers,
-  LatestSupportedPHPVersion as LatestSupportedPHPVersion3,
-  SupportedPHPVersions,
-  SupportedPHPVersionsList
+  withResolvedPHPExtensions,
+  resolvePHPExtension,
+  SupportedPHPVersions
 } from "@php-wasm/universal";
 import fs from "fs";
+import path2 from "path";
 
-// 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
 import { LatestSupportedPHPVersion as LatestSupportedPHPVersion2 } from "@php-wasm/universal";
-async function getXdebugExtensionModule(version = LatestSupportedPHPVersion2) {
+async function getIntlExtensionModule(version = LatestSupportedPHPVersion2) {
   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 = LatestSupportedPHPVersion3, options, xdebugOptions) {
-  const fileName = "xdebug.so";
-  const filePath = await getXdebugExtensionModule(version);
-  const extension = fs.readFileSync(filePath);
-  return {
-    ...options,
-    ENV: {
-      ...options.ENV,
-      PHP_INI_SCAN_DIR: "/internal/shared/extensions"
-    },
-    onRuntimeInitialized: (phpRuntime) => {
-      if (options.onRuntimeInitialized) {
-        options.onRuntimeInitialized(phpRuntime);
-      }
-      if (!FSHelpers.fileExists(
-        phpRuntime.FS,
-        "/internal/shared/extensions"
-      )) {
-        phpRuntime.FS.mkdirTree("/internal/shared/extensions");
-      }
-      if (!FSHelpers.fileExists(
-        phpRuntime.FS,
-        `/internal/shared/extensions/${fileName}`
-      )) {
-        phpRuntime.FS.writeFile(
-          `/internal/shared/extensions/${fileName}`,
-          new Uint8Array(extension)
-        );
-      }
-      if (!FSHelpers.fileExists(
-        phpRuntime.FS,
-        "/internal/shared/extensions/xdebug.ini"
-      )) {
-        const ideKey = xdebugOptions.ideKey || 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 = SupportedPHPVersionsList.indexOf(version) <= 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
-import { LatestSupportedPHPVersion as LatestSupportedPHPVersion5, FSHelpers as FSHelpers2 } from "@php-wasm/universal";
-import fs2 from "fs";
-import path from "path";
-
-// packages/php-wasm/node/src/lib/extensions/intl/get-intl-extension-module.ts
-import { LatestSupportedPHPVersion as LatestSupportedPHPVersion4 } from "@php-wasm/universal";
-async function getIntlExtensionModule(version = LatestSupportedPHPVersion4) {
+// packages/php-wasm/node/src/lib/extensions/memcached/get-memcached-extension-module.ts
+import { LatestSupportedPHPVersion as LatestSupportedPHPVersion3 } from "@php-wasm/universal";
+async function getMemcachedExtensionModule(version = LatestSupportedPHPVersion3) {
   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
-async function withIntl(version = LatestSupportedPHPVersion5, options) {
-  const extensionName = "intl.so";
-  const extensionPath = await getIntlExtensionModule(version);
-  const extension = fs2.readFileSync(extensionPath);
-  const dataName = "icu.dat";
-  const moduleDir = typeof __dirname !== "undefined" ? __dirname : import.meta.dirname;
-  const dataPath = path.join(moduleDir, "shared", dataName);
-  const ICUData = fs2.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 (!FSHelpers2.fileExists(
-        phpRuntime.FS,
-        "/internal/shared/extensions"
-      )) {
-        phpRuntime.FS.mkdirTree("/internal/shared/extensions");
-      }
-      if (!FSHelpers2.fileExists(
-        phpRuntime.FS,
-        `/internal/shared/extensions/${extensionName}`
-      )) {
-        phpRuntime.FS.writeFile(
-          `/internal/shared/extensions/${extensionName}`,
-          new Uint8Array(extension)
-        );
-      }
-      if (!FSHelpers2.fileExists(
-        phpRuntime.FS,
-        "/internal/shared/extensions/intl.ini"
-      )) {
-        phpRuntime.FS.writeFile(
-          "/internal/shared/extensions/intl.ini",
-          [
-            `extension=/internal/shared/extensions/${extensionName}`
-          ].join("\n")
-        );
-      }
-      if (!FSHelpers2.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
-import { LatestSupportedPHPVersion as LatestSupportedPHPVersion7, FSHelpers as FSHelpers3 } from "@php-wasm/universal";
-import fs3 from "fs";
-
 // packages/php-wasm/node/src/lib/extensions/redis/get-redis-extension-module.ts
-import { LatestSupportedPHPVersion as LatestSupportedPHPVersion6 } from "@php-wasm/universal";
-async function getRedisExtensionModule(version = LatestSupportedPHPVersion6) {
+import { LatestSupportedPHPVersion as LatestSupportedPHPVersion4 } from "@php-wasm/universal";
+async function getRedisExtensionModule(version = LatestSupportedPHPVersion4) {
   switch (version) {
     case "8.5":
       return (await import("@php-wasm/node-8-5")).getRedisExtensionPath();
@@ -1764,125 +1623,230 @@ async function getRedisExtensionModule(version = LatestSupportedPHPVersion6) {
   throw new Error(`Unsupported PHP version ${version}`);
 }
 
-// packages/php-wasm/node/src/lib/extensions/redis/with-redis.ts
-async function withRedis(version = LatestSupportedPHPVersion7, options) {
-  const extensionName = "redis.so";
-  const extensionPath = await getRedisExtensionModule(version);
-  const extension = fs3.readFileSync(extensionPath);
-  return {
-    ...options,
-    ENV: {
-      ...options.ENV,
-      PHP_INI_SCAN_DIR: "/internal/shared/extensions"
-    },
-    onRuntimeInitialized: (phpRuntime) => {
-      if (options.onRuntimeInitialized) {
-        options.onRuntimeInitialized(phpRuntime);
-      }
-      if (!FSHelpers3.fileExists(
-        phpRuntime.FS,
-        "/internal/shared/extensions"
-      )) {
-        phpRuntime.FS.mkdirTree("/internal/shared/extensions");
-      }
-      if (!FSHelpers3.fileExists(
-        phpRuntime.FS,
-        `/internal/shared/extensions/${extensionName}`
-      )) {
-        phpRuntime.FS.writeFile(
-          `/internal/shared/extensions/${extensionName}`,
-          new Uint8Array(extension)
-        );
-      }
-      if (!FSHelpers3.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
-import { LatestSupportedPHPVersion as LatestSupportedPHPVersion9, FSHelpers as FSHelpers4 } from "@php-wasm/universal";
-import fs4 from "fs";
-
-// packages/php-wasm/node/src/lib/extensions/memcached/get-memcached-extension-module.ts
-import { LatestSupportedPHPVersion as LatestSupportedPHPVersion8 } from "@php-wasm/universal";
-async function getMemcachedExtensionModule(version = LatestSupportedPHPVersion8) {
+// packages/php-wasm/node/src/lib/extensions/xdebug/get-xdebug-extension-module.ts
+import { LatestSupportedPHPVersion as LatestSupportedPHPVersion5 } from "@php-wasm/universal";
+async function getXdebugExtensionModule(version = LatestSupportedPHPVersion5) {
   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 = LatestSupportedPHPVersion9, options) {
-  const extensionName = "memcached.so";
-  const extensionPath = await getMemcachedExtensionModule(version);
-  const extension = fs4.readFileSync(extensionPath);
+// packages/php-wasm/node/src/lib/extensions/node-extension-resources.ts
+import { readFile } from "fs/promises";
+import path from "path";
+import { fileURLToPath, pathToFileURL } from "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 (!FSHelpers4.fileExists(
-        phpRuntime.FS,
-        "/internal/shared/extensions"
-      )) {
-        phpRuntime.FS.mkdirTree("/internal/shared/extensions");
-      }
-      if (!FSHelpers4.fileExists(
-        phpRuntime.FS,
-        `/internal/shared/extensions/${extensionName}`
-      )) {
-        phpRuntime.FS.writeFile(
-          `/internal/shared/extensions/${extensionName}`,
-          new Uint8Array(extension)
-        );
-      }
-      if (!FSHelpers4.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 readFile(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 pathToFileURL(path.resolve(urlOrPath));
+}
+
+// packages/php-wasm/node/src/lib/extensions/load-extensions.ts
+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 withResolvedPHPExtensions(options, resolvedExtensions);
+}
+async function resolveRuntimePHPExtension(version, asyncMode, extension) {
+  if (typeof extension === "object" && "source" in extension) {
+    return await 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(fs.readFileSync(extensionPath));
+      const dataName = "icu.dat";
+      const moduleDir = typeof __dirname !== "undefined" ? __dirname : import.meta.dirname;
+      const ICUData = fs.readFileSync(
+        resolveIntlDataPath(moduleDir, dataName)
+      );
+      return await 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 resolvePHPExtension({
+        source: {
+          format: "so",
+          name: "redis",
+          bytes: new Uint8Array(fs.readFileSync(extensionPath))
+        },
+        phpVersion: version,
+        asyncMode
+      });
+    }
+    case "memcached": {
+      const extensionPath = await getMemcachedExtensionModule(version);
+      return await resolvePHPExtension({
+        source: {
+          format: "so",
+          name: "memcached",
+          bytes: new Uint8Array(fs.readFileSync(extensionPath))
+        },
+        phpVersion: version,
+        asyncMode
+      });
+    }
+    case "xdebug": {
+      const xdebugOptions = builtIn.options ?? {};
+      const filePath = await getXdebugExtensionModule(version);
+      const ideKey = xdebugOptions.ideKey || DEFAULT_IDE_KEY;
+      return await resolvePHPExtension({
+        source: {
+          format: "so",
+          name: "xdebug",
+          bytes: new Uint8Array(fs.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.
+    path2.join(moduleDir, "shared", dataName),
+    // Source/test layout: src/lib/extensions/intl/shared/icu.dat.
+    path2.join(moduleDir, "intl", "shared", dataName)
+  ];
+  const dataPath = candidatePaths.find(
+    (candidate) => fs.existsSync(candidate)
+  );
+  if (!dataPath) {
+    throw new Error(
+      `Could not find ${dataName}. Checked: ${candidatePaths.join(", ")}`
+    );
+  }
+  return dataPath;
+}
+function resolveXdebugExtraFiles(version, xdebugOptions) {
+  const isPHP85orHigher = SupportedPHPVersions.indexOf(version) <= 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
 import { dirname, joinPaths, toPosixPath } from "@php-wasm/util";
 import { platform } from "os";
+import { jspi } from "wasm-feature-detect";
 var dangerousDefaultProcessIdAllocator = process.env.VITEST ? new ProcessIdAllocator() : void 0;
 async function loadNodeRuntime(phpVersion, options = {}) {
   const processId = options.emscriptenOptions?.processId ?? // !! Only assign a default process ID during test.
@@ -1890,6 +1854,22 @@ async function loadNodeRuntime(phpVersion, options = {}) {
   // could break file locking and lead to database corruption.
   (process.env.VITEST ? dangerousDefaultProcessIdAllocator.claim() : void 0);
   const isLegacy = 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
@@ -1908,6 +1888,7 @@ async function loadNodeRuntime(phpVersion, options = {}) {
       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
@@ -1923,7 +1904,7 @@ async function loadNodeRuntime(phpVersion, options = {}) {
       if (options?.followSymlinks === true) {
         phpRuntime.FS.filesystems.NODEFS.node_ops.readlink = (node) => {
           const absoluteSourcePath = phpRuntime.FS.filesystems.NODEFS.tryFSOperation(
-            () => fs5.realpathSync(
+            () => fs2.realpathSync(
               phpRuntime.FS.filesystems.NODEFS.realPath(node)
             )
           );
@@ -1932,9 +1913,9 @@ async function loadNodeRuntime(phpVersion, options = {}) {
             `/internal/symlinks`,
             normalizedPath
           );
-          if (fs5.existsSync(absoluteSourcePath)) {
-            const sourceStat = fs5.statSync(absoluteSourcePath);
-            if (!FSHelpers5.fileExists(
+          if (fs2.existsSync(absoluteSourcePath)) {
+            const sourceStat = fs2.statSync(absoluteSourcePath);
+            if (!FSHelpers.fileExists(
               phpRuntime.FS,
               symlinkMountPath
             )) {
@@ -1973,68 +1954,58 @@ async function loadNodeRuntime(phpVersion, options = {}) {
       phpRuntime.FS.root.mount.opts.root = ".";
     }
   };
-  if (isLegacy && (options?.withXdebug || options?.withIntl || options?.withRedis || options?.withMemcached)) {
+  if (isLegacy && requestedExtensions.length) {
     throw new Error(
       `Extensions (xdebug, intl, redis, memcached) are not available for legacy PHP ${phpVersion}.`
     );
   }
   if (!isLegacy) {
     const modernVersion = phpVersion;
-    if (options?.withXdebug) {
-      emscriptenOptions = await withXdebug(
-        modernVersion,
-        emscriptenOptions,
-        typeof options.withXdebug === "object" ? options.withXdebug : {}
-      );
-    }
-    if (options?.withIntl === true) {
-      emscriptenOptions = await withIntl(
-        modernVersion,
-        emscriptenOptions
-      );
-    }
-    if (options?.withRedis === true) {
-      emscriptenOptions = await withRedis(
-        modernVersion,
-        emscriptenOptions
-      );
-    }
-    if (options?.withMemcached === true) {
-      emscriptenOptions = await withMemcached(
-        modernVersion,
-        emscriptenOptions
-      );
-    }
+    emscriptenOptions = await withPHPExtensions(
+      modernVersion,
+      phpWasmAsyncMode,
+      emscriptenOptions,
+      requestedExtensions
+    );
   }
   emscriptenOptions = await withNetworking(emscriptenOptions);
   const phpLoaderModule = await getPHPLoaderModule(phpVersion);
   const runtimeId = await 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
-import { lstatSync as lstatSync2, readdirSync } from "node:fs";
+import { lstatSync, readdirSync } from "node:fs";
 
 // packages/php-wasm/node/src/lib/node-fs-mount.ts
 import {
-  FSHelpers as FSHelpers6
+  FSHelpers as FSHelpers2
 } from "@php-wasm/universal";
 import { isParentOf } from "@php-wasm/util";
-import { lstatSync } from "fs";
+import { realpathSync, statSync } from "fs";
 import { dirname as dirname2 } from "path";
 function createNodeFsMountHandler(localPath) {
   return function(php, FS, vfsMountPoint) {
     let removeVfsNode = false;
-    if (!FSHelpers6.fileExists(FS, vfsMountPoint)) {
-      const lstat = lstatSync(localPath);
-      if (lstat.isFile() || lstat.isSymbolicLink()) {
+    const mountRoot = realpathSync(localPath);
+    if (!FSHelpers2.fileExists(FS, vfsMountPoint)) {
+      const stat = statSync(mountRoot);
+      if (stat.isFile()) {
         FS.mkdirTree(dirname2(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;
@@ -2051,7 +2022,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) {
@@ -2087,20 +2058,20 @@ function useHostFilesystem(php) {
   }
   php.chdir(process.cwd());
 }
-function statPathFollowSymlinks(path2) {
-  let stat = lstatSync2(path2);
+function statPathFollowSymlinks(path3) {
+  let stat = 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 = lstatSync2(target);
+      const linkStat = lstatSync(target);
       if (linkStat.isSymbolicLink()) {
-        target = fs6.realpathSync(target);
+        target = fs3.realpathSync(target);
         continue;
       }
       stat = linkStat;
@@ -2117,6 +2088,5 @@ export {
   getPHPLoaderModule,
   loadNodeRuntime,
   useHostFilesystem,
-  withNetworking,
-  withXdebug
+  withNetworking
 };