@php-wasm/node 0.6.16 → 0.7.0

package/index.cjs

@@ -71823,20 +71823,50 @@ function extractPHPFunctionsFromStack(stack) {
   }
 }
 
+// packages/php-wasm/util/src/lib/sleep.ts
+var SleepFinished = Symbol("SleepFinished");
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(() => resolve(SleepFinished), ms);
+  });
+}
+
 // packages/php-wasm/util/src/lib/semaphore.ts
+var AcquireTimeoutError = class extends Error {
+  constructor() {
+    super("Acquiring lock timed out");
+  }
+};
 var Semaphore = class {
-  constructor({ concurrency }) {
+  constructor({ concurrency, timeout }) {
     this._running = 0;
     this.concurrency = concurrency;
+    this.timeout = timeout;
     this.queue = [];
   }
+  get remaining() {
+    return this.concurrency - this.running;
+  }
   get running() {
     return this._running;
   }
   async acquire() {
     while (true) {
       if (this._running >= this.concurrency) {
-        await new Promise((resolve) => this.queue.push(resolve));
+        const acquired = new Promise((resolve) => {
+          this.queue.push(resolve);
+        });
+        if (this.timeout !== void 0) {
+          await Promise.race([acquired, sleep(this.timeout)]).then(
+            (value) => {
+              if (value === SleepFinished) {
+                throw new AcquireTimeoutError();
+              }
+            }
+          );
+        } else {
+          await acquired;
+        }
       } else {
         this._running++;
         let released = false;
@@ -72135,104 +72165,6 @@ var SupportedPHPVersions = [
 ];
 var LatestSupportedPHPVersion = SupportedPHPVersions[0];
 
-// packages/php-wasm/universal/src/lib/php-browser.ts
-var PHPBrowser = class {
-  #cookies;
-  #config;
-  /**
-   * @param  server - The PHP server to browse.
-   * @param  config - The browser configuration.
-   */
-  constructor(requestHandler, config = {}) {
-    this.requestHandler = requestHandler;
-    this.#cookies = {};
-    this.#config = {
-      handleRedirects: false,
-      maxRedirects: 4,
-      ...config
-    };
-  }
-  /**
-   * Sends the request to the server.
-   *
-   * When cookies are present in the response, this method stores
-   * them and sends them with any subsequent requests.
-   *
-   * When a redirection is present in the response, this method
-   * follows it by discarding a response and sending a subsequent
-   * request.
-   *
-   * @param  request   - The request.
-   * @param  redirects - Internal. The number of redirects handled so far.
-   * @returns PHPRequestHandler response.
-   */
-  async request(request, redirects = 0) {
-    const response = await this.requestHandler.request({
-      ...request,
-      headers: {
-        ...request.headers,
-        cookie: this.serializeCookies()
-      }
-    });
-    if (response.headers["set-cookie"]) {
-      this.setCookies(response.headers["set-cookie"]);
-    }
-    if (this.#config.handleRedirects && response.headers["location"] && redirects < this.#config.maxRedirects) {
-      const redirectUrl = new URL(
-        response.headers["location"][0],
-        this.requestHandler.absoluteUrl
-      );
-      return this.request(
-        {
-          url: redirectUrl.toString(),
-          method: "GET",
-          headers: {}
-        },
-        redirects + 1
-      );
-    }
-    return response;
-  }
-  /** @inheritDoc */
-  pathToInternalUrl(path) {
-    return this.requestHandler.pathToInternalUrl(path);
-  }
-  /** @inheritDoc */
-  internalUrlToPath(internalUrl) {
-    return this.requestHandler.internalUrlToPath(internalUrl);
-  }
-  /** @inheritDoc */
-  get absoluteUrl() {
-    return this.requestHandler.absoluteUrl;
-  }
-  /** @inheritDoc */
-  get documentRoot() {
-    return this.requestHandler.documentRoot;
-  }
-  setCookies(cookies) {
-    for (const cookie of cookies) {
-      try {
-        if (!cookie.includes("=")) {
-          continue;
-        }
-        const equalsIndex = cookie.indexOf("=");
-        const name = cookie.substring(0, equalsIndex);
-        const value = cookie.substring(equalsIndex + 1).split(";")[0];
-        this.#cookies[name] = value;
-      } catch (e) {
-        console.error(e);
-      }
-    }
-  }
-  serializeCookies() {
-    const cookiesArray = [];
-    for (const name in this.#cookies) {
-      cookiesArray.push(`${name}=${this.#cookies[name]}`);
-    }
-    return cookiesArray.join("; ");
-  }
-};
-
 // packages/php-wasm/universal/src/lib/urls.ts
 var DEFAULT_BASE_URL = "http://example.com";
 function toRelativeUrl(url) {
@@ -72305,6 +72237,38 @@ function fileToUint8Array(file) {
   });
 }
 
+// packages/php-wasm/universal/src/lib/http-cookie-store.ts
+var HttpCookieStore = class {
+  constructor() {
+    this.cookies = {};
+  }
+  rememberCookiesFromResponseHeaders(headers) {
+    if (!headers?.["set-cookie"]) {
+      return;
+    }
+    for (const setCookie of headers["set-cookie"]) {
+      try {
+        if (!setCookie.includes("=")) {
+          continue;
+        }
+        const equalsIndex = setCookie.indexOf("=");
+        const name = setCookie.substring(0, equalsIndex);
+        const value = setCookie.substring(equalsIndex + 1).split(";")[0];
+        this.cookies[name] = value;
+      } catch (e) {
+        console.error(e);
+      }
+    }
+  }
+  getCookieRequestHeader() {
+    const cookiesArray = [];
+    for (const name in this.cookies) {
+      cookiesArray.push(`${name}=${this.cookies[name]}`);
+    }
+    return cookiesArray.join("; ");
+  }
+};
+
 // packages/php-wasm/universal/src/lib/php-request-handler.ts
 var PHPRequestHandler = class {
   #DOCROOT;
@@ -72315,6 +72279,7 @@ var PHPRequestHandler = class {
   #PATHNAME;
   #ABSOLUTE_URL;
   #semaphore;
+  #cookieStore;
   /**
    * @param  php    - The PHP instance.
    * @param  config - Request Handler configuration.
@@ -72327,6 +72292,7 @@ var PHPRequestHandler = class {
       rewriteRules = []
     } = config;
     this.php = php;
+    this.#cookieStore = new HttpCookieStore();
     this.#DOCROOT = documentRoot;
     const url = new URL(absoluteUrl);
     this.#HOSTNAME = url.hostname;
@@ -72345,11 +72311,23 @@ var PHPRequestHandler = class {
     ].join("");
     this.rewriteRules = rewriteRules;
   }
-  /** @inheritDoc */
+  /**
+   * Converts a path to an absolute URL based at the PHPRequestHandler
+   * root.
+   *
+   * @param  path The server path to convert to an absolute URL.
+   * @returns The absolute URL.
+   */
   pathToInternalUrl(path) {
     return `${this.absoluteUrl}${path}`;
   }
-  /** @inheritDoc */
+  /**
+   * Converts an absolute URL based at the PHPRequestHandler to a relative path
+   * without the server pathname and scope.
+   *
+   * @param  internalUrl An absolute URL based at the PHPRequestHandler root.
+   * @returns The relative path.
+   */
   internalUrlToPath(internalUrl) {
     const url = new URL(internalUrl);
     if (url.pathname.startsWith(this.#PATHNAME)) {
@@ -72360,15 +72338,67 @@ var PHPRequestHandler = class {
   get isRequestRunning() {
     return this.#semaphore.running > 0;
   }
-  /** @inheritDoc */
+  /**
+   * The absolute URL of this PHPRequestHandler instance.
+   */
   get absoluteUrl() {
     return this.#ABSOLUTE_URL;
   }
-  /** @inheritDoc */
+  /**
+   * The directory in the PHP filesystem where the server will look
+   * for the files to serve. Default: `/var/www`.
+   */
   get documentRoot() {
     return this.#DOCROOT;
   }
-  /** @inheritDoc */
+  /**
+   * Serves the request – either by serving a static file, or by
+   * dispatching it to the PHP runtime.
+   *
+   * The request() method mode behaves like a web server and only works if
+   * the PHP was initialized with a `requestHandler` option (which the online version
+   * of WordPress Playground does by default).
+   *
+   * In the request mode, you pass an object containing the request information
+   * (method, headers, body, etc.) and the path to the PHP file to run:
+   *
+   * ```ts
+   * const php = PHP.load('7.4', {
+   * 	requestHandler: {
+   * 		documentRoot: "/www"
+   * 	}
+   * })
+   * php.writeFile("/www/index.php", `<?php echo file_get_contents("php://input");`);
+   * const result = await php.request({
+   * 	method: "GET",
+   * 	headers: {
+   * 		"Content-Type": "text/plain"
+   * 	},
+   * 	body: "Hello world!",
+   * 	path: "/www/index.php"
+   * });
+   * // result.text === "Hello world!"
+   * ```
+   *
+   * The `request()` method cannot be used in conjunction with `cli()`.
+   *
+   * @example
+   * ```js
+   * const output = await php.request({
+   * 	method: 'GET',
+   * 	url: '/index.php',
+   * 	headers: {
+   * 		'X-foo': 'bar',
+   * 	},
+   * 	body: {
+   * 		foo: 'bar',
+   * 	},
+   * });
+   * console.log(output.stdout); // "Hello world!"
+   * ```
+   *
+   * @param  request - PHP Request data.
+   */
   async request(request) {
     const isAbsolute = request.url.startsWith("http://") || request.url.startsWith("https://");
     const requestedUrl = new URL(
@@ -72442,16 +72472,11 @@ var PHPRequestHandler = class {
     }
     const release = await this.#semaphore.acquire();
     try {
-      this.php.addServerGlobalEntry("REMOTE_ADDR", "127.0.0.1");
-      this.php.addServerGlobalEntry("DOCUMENT_ROOT", this.#DOCROOT);
-      this.php.addServerGlobalEntry(
-        "HTTPS",
-        this.#ABSOLUTE_URL.startsWith("https://") ? "on" : ""
-      );
       let preferredMethod = "GET";
       const headers = {
         host: this.#HOST,
-        ...normalizeHeaders(request.headers || {})
+        ...normalizeHeaders(request.headers || {}),
+        cookie: this.#cookieStore.getCookieRequestHeader()
       };
       let body = request.body;
       if (typeof body === "object" && !(body instanceof Uint8Array)) {
@@ -72473,17 +72498,26 @@ var PHPRequestHandler = class {
         );
       }
       try {
-        return await this.php.run({
+        const response = await this.php.run({
           relativeUri: ensurePathPrefix(
             toRelativeUrl(requestedUrl),
             this.#PATHNAME
           ),
           protocol: this.#PROTOCOL,
           method: request.method || preferredMethod,
+          $_SERVER: {
+            REMOTE_ADDR: "127.0.0.1",
+            DOCUMENT_ROOT: this.#DOCROOT,
+            HTTPS: this.#ABSOLUTE_URL.startsWith("https://") ? "on" : ""
+          },
           body,
           scriptPath,
           headers
         });
+        this.#cookieStore.rememberCookiesFromResponseHeaders(
+          response.headers
+        );
+        return response;
       } catch (error) {
         const executionError = error;
         if (executionError?.response) {
@@ -72561,6 +72595,38 @@ function inferMimeType(path) {
     case "txt":
     case "md":
       return "text/plain";
+    case "pdf":
+      return "application/pdf";
+    case "webp":
+      return "image/webp";
+    case "mp3":
+      return "audio/mpeg";
+    case "mp4":
+      return "video/mp4";
+    case "csv":
+      return "text/csv";
+    case "xls":
+      return "application/vnd.ms-excel";
+    case "xlsx":
+      return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+    case "doc":
+      return "application/msword";
+    case "docx":
+      return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+    case "ppt":
+      return "application/vnd.ms-powerpoint";
+    case "pptx":
+      return "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+    case "zip":
+      return "application/zip";
+    case "rar":
+      return "application/x-rar-compressed";
+    case "tar":
+      return "application/x-tar";
+    case "gz":
+      return "application/gzip";
+    case "7z":
+      return "application/x-7z-compressed";
     default:
       return "application-octet-stream";
   }
@@ -72775,7 +72841,6 @@ var BasePHP2 = class {
     this.#phpIniOverrides = [];
     this.#webSapiInitialized = false;
     this.#wasmErrorsTarget = null;
-    this.#serverEntries = {};
     this.#eventListeners = /* @__PURE__ */ new Map();
     this.#messageListeners = [];
     this.semaphore = new Semaphore({ concurrency: 1 });
@@ -72783,9 +72848,7 @@ var BasePHP2 = class {
       this.initializeRuntime(PHPRuntimeId);
     }
     if (serverOptions) {
-      this.requestHandler = new PHPBrowser(
-        new PHPRequestHandler(this, serverOptions)
-      );
+      this.requestHandler = new PHPRequestHandler(this, serverOptions);
     }
   }
   static {
@@ -72796,7 +72859,6 @@ var BasePHP2 = class {
   #sapiName;
   #webSapiInitialized;
   #wasmErrorsTarget;
-  #serverEntries;
   #eventListeners;
   #messageListeners;
   addEventListener(eventType, listener) {
@@ -72830,21 +72892,19 @@ var BasePHP2 = class {
   }
   /** @inheritDoc */
   get absoluteUrl() {
-    return this.requestHandler.requestHandler.absoluteUrl;
+    return this.requestHandler.absoluteUrl;
   }
   /** @inheritDoc */
   get documentRoot() {
-    return this.requestHandler.requestHandler.documentRoot;
+    return this.requestHandler.documentRoot;
   }
   /** @inheritDoc */
   pathToInternalUrl(path) {
-    return this.requestHandler.requestHandler.pathToInternalUrl(path);
+    return this.requestHandler.pathToInternalUrl(path);
   }
   /** @inheritDoc */
   internalUrlToPath(internalUrl) {
-    return this.requestHandler.requestHandler.internalUrlToPath(
-      internalUrl
-    );
+    return this.requestHandler.internalUrlToPath(internalUrl);
   }
   initializeRuntime(runtimeId) {
     if (this[__private__dont__use]) {
@@ -72909,11 +72969,11 @@ var BasePHP2 = class {
     this[__private__dont__use].FS.chdir(path);
   }
   /** @inheritDoc */
-  async request(request, maxRedirects) {
+  async request(request) {
     if (!this.requestHandler) {
       throw new Error("No request handler available.");
     }
-    return this.requestHandler.request(request, maxRedirects);
+    return this.requestHandler.request(request);
   }
   /** @inheritDoc */
   async run(request) {
@@ -72934,7 +72994,12 @@ var BasePHP2 = class {
       this.#setRequestMethod(request.method || "GET");
       const headers = normalizeHeaders(request.headers || {});
       const host = headers["host"] || "example.com:443";
-      this.#setRequestHostAndProtocol(host, request.protocol || "http");
+      const port = this.#inferPortFromHostAndProtocol(
+        host,
+        request.protocol || "http"
+      );
+      this.#setRequestHost(host);
+      this.#setRequestPort(port);
       this.#setRequestHeaders(headers);
       if (request.body) {
         heapBodyPointer = this.#setRequestBody(request.body);
@@ -72942,7 +73007,14 @@ var BasePHP2 = class {
       if (typeof request.code === "string") {
         this.#setPHPCode(" ?>" + request.code);
       }
-      this.#addServerGlobalEntriesInWasm();
+      const $_SERVER = this.#prepareServerEntries(
+        request.$_SERVER,
+        headers,
+        port
+      );
+      for (const key in $_SERVER) {
+        this.#setServerGlobalEntry(key, $_SERVER[key]);
+      }
       const env = request.env || {};
       for (const key in env) {
         this.#setEnv(key, env[key]);
@@ -72980,6 +73052,29 @@ var BasePHP2 = class {
       }
     }
   }
+  /**
+   * Prepares the $_SERVER entries for the PHP runtime.
+   *
+   * @param defaults Default entries to include in $_SERVER.
+   * @param headers HTTP headers to include in $_SERVER (as HTTP_ prefixed entries).
+   * @param port HTTP port, used to determine infer $_SERVER['HTTPS'] value if none
+   *             was provided.
+   * @returns Computed $_SERVER entries.
+   */
+  #prepareServerEntries(defaults, headers, port) {
+    const $_SERVER = {
+      ...defaults || {}
+    };
+    $_SERVER["HTTPS"] = $_SERVER["HTTPS"] || port === 443 ? "on" : "off";
+    for (const name in headers) {
+      let HTTP_prefix = "HTTP_";
+      if (["content-type", "content-length"].includes(name.toLowerCase())) {
+        HTTP_prefix = "";
+      }
+      $_SERVER[`${HTTP_prefix}${name.toUpperCase().replace(/-/g, "_")}`] = headers[name];
+    }
+    return $_SERVER;
+  }
   #initWebRuntime() {
     this.setPhpIniEntry("auto_prepend_file", "/internal/consts.php");
     if (!this.fileExists("/internal/consts.php")) {
@@ -73050,13 +73145,23 @@ var BasePHP2 = class {
       );
     }
   }
-  #setRequestHostAndProtocol(host, protocol) {
+  #setRequestHost(host) {
     this[__private__dont__use].ccall(
       "wasm_set_request_host",
       null,
       [STRING],
       [host]
     );
+  }
+  #setRequestPort(port) {
+    this[__private__dont__use].ccall(
+      "wasm_set_request_port",
+      null,
+      [NUMBER],
+      [port]
+    );
+  }
+  #inferPortFromHostAndProtocol(host, protocol) {
     let port;
     try {
       port = parseInt(new URL(host).port, 10);
@@ -73065,15 +73170,7 @@ var BasePHP2 = class {
     if (!port || isNaN(port) || port === 80) {
       port = protocol === "https" ? 443 : 80;
     }
-    this[__private__dont__use].ccall(
-      "wasm_set_request_port",
-      null,
-      [NUMBER],
-      [port]
-    );
-    if (protocol === "https" || !protocol && port === 443) {
-      this.addServerGlobalEntry("HTTPS", "on");
-    }
+    return port;
   }
   #setRequestMethod(method) {
     this[__private__dont__use].ccall(
@@ -73108,16 +73205,6 @@ var BasePHP2 = class {
         [parseInt(headers["content-length"], 10)]
       );
     }
-    for (const name in headers) {
-      let HTTP_prefix = "HTTP_";
-      if (["content-type", "content-length"].includes(name.toLowerCase())) {
-        HTTP_prefix = "";
-      }
-      this.addServerGlobalEntry(
-        `${HTTP_prefix}${name.toUpperCase().replace(/-/g, "_")}`,
-        headers[name]
-      );
-    }
   }
   #setRequestBody(body) {
     let size, contentLength;
@@ -73166,18 +73253,13 @@ var BasePHP2 = class {
       [path]
     );
   }
-  addServerGlobalEntry(key, value) {
-    this.#serverEntries[key] = value;
-  }
-  #addServerGlobalEntriesInWasm() {
-    for (const key in this.#serverEntries) {
-      this[__private__dont__use].ccall(
-        "wasm_add_SERVER_entry",
-        null,
-        [STRING, STRING],
-        [key, this.#serverEntries[key]]
-      );
-    }
+  #setServerGlobalEntry(key, value) {
+    this[__private__dont__use].ccall(
+      "wasm_add_SERVER_entry",
+      null,
+      [STRING, STRING],
+      [key, value]
+    );
   }
   #setEnv(name, value) {
     this[__private__dont__use].ccall(
@@ -73259,7 +73341,6 @@ var BasePHP2 = class {
       throw rethrown;
     } finally {
       this.#wasmErrorsTarget?.removeEventListener("error", errorListener);
-      this.#serverEntries = {};
     }
     const { headers, httpStatusCode } = this.#getResponseHeaders();
     return new PHPResponse(
@@ -73357,8 +73438,12 @@ var BasePHP2 = class {
    * interrupting the operations of this PHP instance.
    *
    * @param runtime
+   * @param cwd. Internal, the VFS path to recreate in the new runtime.
+   *             This arg is temporary and will be removed once BasePHP
+   *             is fully decoupled from the request handler and
+   *             accepts a constructor-level cwd argument.
    */
-  hotSwapPHPRuntime(runtime) {
+  hotSwapPHPRuntime(runtime, cwd) {
     const oldFS = this[__private__dont__use].FS;
     try {
       this.exit();
@@ -73371,9 +73456,8 @@ var BasePHP2 = class {
     if (this.#sapiName) {
       this.setSapiName(this.#sapiName);
     }
-    if (this.requestHandler) {
-      const docroot = this.documentRoot;
-      copyFS(oldFS, this[__private__dont__use].FS, docroot);
+    if (cwd) {
+      copyFS(oldFS, this[__private__dont__use].FS, cwd);
     }
   }
   exit(code = 0) {

package/index.d.ts

@@ -83,137 +83,17 @@ export type PHPEvent = PHPRequestEndEvent | PHPRequestErrorEvent | PHPRuntimeIni
  * A callback function that handles PHP events.
  */
 export type PHPEventListener = (event: PHPEvent) => void;
-/**
- * Handles HTTP requests using PHP runtime as a backend.
- *
- * @public
- * @example Use PHPRequestHandler implicitly with a new PHP instance:
- * ```js
- * import { PHP } from '@php-wasm/web';
- *
- * const php = await PHP.load( '7.4', {
- *     requestHandler: {
- *         // PHP FS path to serve the files from:
- *         documentRoot: '/www',
- *
- *         // Used to populate $_SERVER['SERVER_NAME'] etc.:
- *         absoluteUrl: 'http://127.0.0.1'
- *     }
- * } );
- *
- * php.mkdirTree('/www');
- * php.writeFile('/www/index.php', '<?php echo "Hi from PHP!"; ');
- *
- * const response = await php.request({ path: '/index.php' });
- * console.log(response.text);
- * // "Hi from PHP!"
- * ```
- *
- * @example Explicitly create a PHPRequestHandler instance and run a PHP script:
- * ```js
- * import {
- *   loadPHPRuntime,
- *   PHP,
- *   PHPRequestHandler,
- *   getPHPLoaderModule,
- * } from '@php-wasm/web';
- *
- * const runtime = await loadPHPRuntime( await getPHPLoaderModule('7.4') );
- * const php = new PHP( runtime );
- *
- * php.mkdirTree('/www');
- * php.writeFile('/www/index.php', '<?php echo "Hi from PHP!"; ');
- *
- * const server = new PHPRequestHandler(php, {
- *     // PHP FS path to serve the files from:
- *     documentRoot: '/www',
- *
- *     // Used to populate $_SERVER['SERVER_NAME'] etc.:
- *     absoluteUrl: 'http://127.0.0.1'
- * });
- *
- * const response = server.request({ path: '/index.php' });
- * console.log(response.text);
- * // "Hi from PHP!"
- * ```
- */
-export interface RequestHandler {
-	/**
-	 * Serves the request – either by serving a static file, or by
-	 * dispatching it to the PHP runtime.
-	 *
-	 * The request() method mode behaves like a web server and only works if
-	 * the PHP was initialized with a `requestHandler` option (which the online version
-	 * of WordPress Playground does by default).
-	 *
-	 * In the request mode, you pass an object containing the request information
-	 * (method, headers, body, etc.) and the path to the PHP file to run:
-	 *
-	 * ```ts
-	 * const php = PHP.load('7.4', {
-	 * 	requestHandler: {
-	 * 		documentRoot: "/www"
-	 * 	}
-	 * })
-	 * php.writeFile("/www/index.php", `<?php echo file_get_contents("php://input");`);
-	 * const result = await php.request({
-	 * 	method: "GET",
-	 * 	headers: {
-	 * 		"Content-Type": "text/plain"
-	 * 	},
-	 * 	body: "Hello world!",
-	 * 	path: "/www/index.php"
-	 * });
-	 * // result.text === "Hello world!"
-	 * ```
-	 *
-	 * The `request()` method cannot be used in conjunction with `cli()`.
-	 *
-	 * @example
-	 * ```js
-	 * const output = await php.request({
-	 * 	method: 'GET',
-	 * 	url: '/index.php',
-	 * 	headers: {
-	 * 		'X-foo': 'bar',
-	 * 	},
-	 * 	body: {
-	 * 		foo: 'bar',
-	 * 	},
-	 * });
-	 * console.log(output.stdout); // "Hello world!"
-	 * ```
-	 *
-	 * @param  request - PHP Request data.
-	 */
-	request(request: PHPRequest, maxRedirects?: number): Promise<PHPResponse>;
-	/**
-	 * Converts a path to an absolute URL based at the PHPRequestHandler
-	 * root.
-	 *
-	 * @param  path The server path to convert to an absolute URL.
-	 * @returns The absolute URL.
-	 */
+export interface IsomorphicLocalPHP {
+	/** @deprecated Use PHPRequestHandler instead. */
+	request(request: PHPRequest): Promise<PHPResponse>;
+	/** @deprecated Use PHPRequestHandler instead. */
 	pathToInternalUrl(path: string): string;
-	/**
-	 * Converts an absolute URL based at the PHPRequestHandler to a relative path
-	 * without the server pathname and scope.
-	 *
-	 * @param  internalUrl An absolute URL based at the PHPRequestHandler root.
-	 * @returns The relative path.
-	 */
+	/** @deprecated Use PHPRequestHandler instead. */
 	internalUrlToPath(internalUrl: string): string;
-	/**
-	 * The absolute URL of this PHPRequestHandler instance.
-	 */
+	/** @deprecated Use PHPRequestHandler instead. */
 	absoluteUrl: string;
-	/**
-	 * The directory in the PHP filesystem where the server will look
-	 * for the files to serve. Default: `/var/www`.
-	 */
+	/** @deprecated Use PHPRequestHandler instead. */
 	documentRoot: string;
-}
-export interface IsomorphicLocalPHP extends RequestHandler {
 	/**
 	 * Sets the SAPI name exposed by the PHP module.
 	 * @param newName - The new SAPI name.
@@ -449,14 +329,6 @@ export interface IsomorphicLocalPHP extends RequestHandler {
 	 * @param listener Callback function to handle the message.
 	 */
 	onMessage(listener: MessageListener): void;
-	/**
-	 * Registers a handler to spawns a child process when
-	 * `proc_open()`, `popen()`, `exec()`, `system()`, or `passthru()`
-	 * is called.
-	 *
-	 * @param handler Callback function to spawn a process.
-	 */
-	setSpawnHandler(handler: SpawnHandler | string): void;
 }
 export type MessageListener = (data: string) => Promise<string | Uint8Array | void> | string | void;
 export interface EventEmitter {
@@ -519,6 +391,10 @@ export interface PHPRunOptions {
 	 * Environment variables to set for this run.
 	 */
 	env?: Record<string, string>;
+	/**
+	 * $_SERVER entries to set for this run.
+	 */
+	$_SERVER?: Record<string, string>;
 	/**
 	 * The code snippet to eval instead of a php file.
 	 */
@@ -569,7 +445,7 @@ export interface PHPRequestHandlerConfiguration {
 	 */
 	rewriteRules?: RewriteRule[];
 }
-declare class PHPRequestHandler implements RequestHandler {
+declare class PHPRequestHandler {
 	#private;
 	rewriteRules: RewriteRule[];
 	/**
@@ -581,62 +457,81 @@ declare class PHPRequestHandler implements RequestHandler {
 	 * @param  config - Request Handler configuration.
 	 */
 	constructor(php: BasePHP, config?: PHPRequestHandlerConfiguration);
-	/** @inheritDoc */
+	/**
+	 * Converts a path to an absolute URL based at the PHPRequestHandler
+	 * root.
+	 *
+	 * @param  path The server path to convert to an absolute URL.
+	 * @returns The absolute URL.
+	 */
 	pathToInternalUrl(path: string): string;
-	/** @inheritDoc */
-	internalUrlToPath(internalUrl: string): string;
-	get isRequestRunning(): boolean;
-	/** @inheritDoc */
-	get absoluteUrl(): string;
-	/** @inheritDoc */
-	get documentRoot(): string;
-	/** @inheritDoc */
-	request(request: PHPRequest): Promise<PHPResponse>;
-}
-export interface PHPBrowserConfiguration {
 	/**
-	 * Should handle redirects internally?
+	 * Converts an absolute URL based at the PHPRequestHandler to a relative path
+	 * without the server pathname and scope.
+	 *
+	 * @param  internalUrl An absolute URL based at the PHPRequestHandler root.
+	 * @returns The relative path.
 	 */
-	handleRedirects?: boolean;
+	internalUrlToPath(internalUrl: string): string;
+	get isRequestRunning(): boolean;
 	/**
-	 * The maximum number of redirects to follow internally. Once
-	 * exceeded, request() will return the redirecting response.
+	 * The absolute URL of this PHPRequestHandler instance.
 	 */
-	maxRedirects?: number;
-}
-declare class PHPBrowser implements RequestHandler {
-	#private;
-	requestHandler: PHPRequestHandler;
+	get absoluteUrl(): string;
 	/**
-	 * @param  server - The PHP server to browse.
-	 * @param  config - The browser configuration.
+	 * The directory in the PHP filesystem where the server will look
+	 * for the files to serve. Default: `/var/www`.
 	 */
-	constructor(requestHandler: PHPRequestHandler, config?: PHPBrowserConfiguration);
+	get documentRoot(): string;
 	/**
-	 * Sends the request to the server.
+	 * Serves the request – either by serving a static file, or by
+	 * dispatching it to the PHP runtime.
 	 *
-	 * When cookies are present in the response, this method stores
-	 * them and sends them with any subsequent requests.
+	 * The request() method mode behaves like a web server and only works if
+	 * the PHP was initialized with a `requestHandler` option (which the online version
+	 * of WordPress Playground does by default).
 	 *
-	 * When a redirection is present in the response, this method
-	 * follows it by discarding a response and sending a subsequent
-	 * request.
+	 * In the request mode, you pass an object containing the request information
+	 * (method, headers, body, etc.) and the path to the PHP file to run:
 	 *
-	 * @param  request   - The request.
-	 * @param  redirects - Internal. The number of redirects handled so far.
-	 * @returns PHPRequestHandler response.
+	 * ```ts
+	 * const php = PHP.load('7.4', {
+	 * 	requestHandler: {
+	 * 		documentRoot: "/www"
+	 * 	}
+	 * })
+	 * php.writeFile("/www/index.php", `<?php echo file_get_contents("php://input");`);
+	 * const result = await php.request({
+	 * 	method: "GET",
+	 * 	headers: {
+	 * 		"Content-Type": "text/plain"
+	 * 	},
+	 * 	body: "Hello world!",
+	 * 	path: "/www/index.php"
+	 * });
+	 * // result.text === "Hello world!"
+	 * ```
+	 *
+	 * The `request()` method cannot be used in conjunction with `cli()`.
+	 *
+	 * @example
+	 * ```js
+	 * const output = await php.request({
+	 * 	method: 'GET',
+	 * 	url: '/index.php',
+	 * 	headers: {
+	 * 		'X-foo': 'bar',
+	 * 	},
+	 * 	body: {
+	 * 		foo: 'bar',
+	 * 	},
+	 * });
+	 * console.log(output.stdout); // "Hello world!"
+	 * ```
+	 *
+	 * @param  request - PHP Request data.
 	 */
-	request(request: PHPRequest, redirects?: number): Promise<PHPResponse>;
-	/** @inheritDoc */
-	pathToInternalUrl(path: string): string;
-	/** @inheritDoc */
-	internalUrlToPath(internalUrl: string): string;
-	/** @inheritDoc */
-	get absoluteUrl(): string;
-	/** @inheritDoc */
-	get documentRoot(): string;
-	setCookies(cookies: string[]): void;
-	serializeCookies(): string;
+	request(request: PHPRequest): Promise<PHPResponse>;
 }
 export type PHPRuntimeId = number;
 export type PHPRuntime = any;
@@ -660,16 +555,26 @@ export type EmscriptenOptions = {
 	onRuntimeInitialized?: () => void;
 	monitorRunDependencies?: (left: number) => void;
 	onMessage?: (listener: EmscriptenMessageListener) => void;
+	instantiateWasm?: (info: WebAssembly.Imports, receiveInstance: (instance: WebAssembly.Instance, module: WebAssembly.Module) => void) => void;
 } & Record<string, any>;
 export type EmscriptenMessageListener = (type: string, data: string) => void;
 export interface SemaphoreOptions {
+	/**
+	 * The maximum number of concurrent locks.
+	 */
 	concurrency: number;
+	/**
+	 * The maximum time to wait for a lock to become available.
+	 */
+	timeout?: number;
 }
 declare class Semaphore {
 	private _running;
 	private concurrency;
+	private timeout?;
 	private queue;
-	constructor({ concurrency }: SemaphoreOptions);
+	constructor({ concurrency, timeout }: SemaphoreOptions);
+	get remaining(): number;
 	get running(): number;
 	acquire(): Promise<() => void>;
 	run<T>(fn: () => T | Promise<T>): Promise<T>;
@@ -678,7 +583,7 @@ declare const __private__dont__use: unique symbol;
 declare abstract class BasePHP implements IsomorphicLocalPHP {
 	#private;
 	protected [__private__dont__use]: any;
-	requestHandler?: PHPBrowser;
+	requestHandler?: PHPRequestHandler;
 	/**
 	 * An exclusive lock that prevent multiple requests from running at
 	 * the same time.
@@ -717,10 +622,9 @@ declare abstract class BasePHP implements IsomorphicLocalPHP {
 	/** @inheritDoc */
 	chdir(path: string): void;
 	/** @inheritDoc */
-	request(request: PHPRequest, maxRedirects?: number): Promise<PHPResponse>;
+	request(request: PHPRequest): Promise<PHPResponse>;
 	/** @inheritDoc */
 	run(request: PHPRunOptions): Promise<PHPResponse>;
-	addServerGlobalEntry(key: string, value: string): void;
 	defineConstant(key: string, value: string | boolean | number | null): void;
 	/** @inheritDoc */
 	mkdir(path: string): void;
@@ -749,8 +653,12 @@ declare abstract class BasePHP implements IsomorphicLocalPHP {
 	 * interrupting the operations of this PHP instance.
 	 *
 	 * @param runtime
+	 * @param cwd. Internal, the VFS path to recreate in the new runtime.
+	 *             This arg is temporary and will be removed once BasePHP
+	 *             is fully decoupled from the request handler and
+	 *             accepts a constructor-level cwd argument.
 	 */
-	hotSwapPHPRuntime(runtime: number): void;
+	hotSwapPHPRuntime(runtime: number, cwd?: string): void;
 	exit(code?: number): void;
 }
 export declare function getPHPLoaderModule(version?: SupportedPHPVersion): Promise<PHPLoaderModule>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@php-wasm/node",
-  "version": "0.6.16",
+  "version": "0.7.0",
   "description": "PHP.wasm for Node.js",
   "repository": {
     "type": "git",
@@ -28,7 +28,7 @@
   "license": "GPL-2.0-or-later",
   "main": "index.cjs",
   "types": "index.d.ts",
-  "gitHead": "1981567e7eacecbc4a18c870267c20bf489afd8f",
+  "gitHead": "c5eba3d709f2821c4303521e8c81b962e3bcca23",
   "engines": {
     "node": ">=18.18.0",
     "npm": ">=8.11.0"
@@ -37,8 +37,8 @@
     "comlink": "^4.4.1",
     "ws": "8.13.0",
     "yargs": "17.7.2",
-    "@php-wasm/node-polyfills": "0.6.16",
-    "@php-wasm/universal": "0.6.16",
-    "@php-wasm/util": "0.6.16"
+    "@php-wasm/node-polyfills": "0.7.0",
+    "@php-wasm/universal": "0.7.0",
+    "@php-wasm/util": "0.7.0"
   }
 }