@php-wasm/web 0.7.20 → 0.9.10

package/index.d.ts

@@ -23,6 +23,11 @@ export declare function exposeAPI<Methods, PipedAPI>(apiMethods?: Methods, piped
 	(e: Error) => void,
 	PublicAPI<Methods, PipedAPI>
 ];
+declare class EmscriptenDownloadMonitor extends EventTarget {
+	#private;
+	expectAssets(assets: Record<string, number>): void;
+	monitorFetch(fetchPromise: Promise<Response>): Promise<Response>;
+}
 export interface PHPResponseData {
 	/**
 	 * Response headers.
@@ -71,405 +76,410 @@ declare class PHPResponse implements PHPResponseData {
 	 */
 	get text(): string;
 }
-/**
- * Represents an event related to the PHP request.
- */
-export interface PHPRequestEndEvent {
-	type: "request.end";
-}
-/**
- * Represents an error event related to the PHP request.
- */
-export interface PHPRequestErrorEvent {
-	type: "request.error";
-	error: Error;
-	source?: "request" | "php-wasm";
-}
-/**
- * Represents a PHP runtime initialization event.
- */
-export interface PHPRuntimeInitializedEvent {
-	type: "runtime.initialized";
-}
-/**
- * Represents a PHP runtime destruction event.
- */
-export interface PHPRuntimeBeforeDestroyEvent {
-	type: "runtime.beforedestroy";
-}
-/**
- * Represents an event related to the PHP instance.
- * This is intentionally not an extension of CustomEvent
- * to make it isomorphic between different JavaScript runtimes.
- */
-export type PHPEvent = PHPRequestEndEvent | PHPRequestErrorEvent | PHPRuntimeInitializedEvent | PHPRuntimeBeforeDestroyEvent;
-/**
- * A callback function that handles PHP events.
- */
-export type PHPEventListener = (event: PHPEvent) => void;
-export interface IsomorphicLocalPHP {
-	/** @deprecated Use PHPRequestHandler instead. */
-	request(request: PHPRequest): Promise<PHPResponse>;
-	/** @deprecated Use PHPRequestHandler instead. */
-	pathToInternalUrl(path: string): string;
-	/** @deprecated Use PHPRequestHandler instead. */
-	internalUrlToPath(internalUrl: string): string;
-	/** @deprecated Use PHPRequestHandler instead. */
-	absoluteUrl: string;
-	/** @deprecated Use PHPRequestHandler instead. */
-	documentRoot: string;
-	/**
-	 * Sets the SAPI name exposed by the PHP module.
-	 * @param newName - The new SAPI name.
-	 */
-	setSapiName(newName: string): void;
-	/**
-	 * Defines a constant in the PHP runtime.
-	 * @param key - The name of the constant.
-	 * @param value - The value of the constant.
-	 */
-	defineConstant(key: string, value: boolean | string | number | null): void;
-	/**
-	 * Adds an event listener for a PHP event.
-	 * @param eventType - The type of event to listen for.
-	 * @param listener - The listener function to be called when the event is triggered.
-	 */
-	addEventListener(eventType: PHPEvent["type"], listener: PHPEventListener): void;
-	/**
-	 * Removes an event listener for a PHP event.
-	 * @param eventType - The type of event to remove the listener from.
-	 * @param listener - The listener function to be removed.
-	 */
-	removeEventListener(eventType: PHPEvent["type"], listener: PHPEventListener): void;
-	/**
-	 * Recursively creates a directory with the given path in the PHP filesystem.
-	 * For example, if the path is `/root/php/data`, and `/root` already exists,
-	 * it will create the directories `/root/php` and `/root/php/data`.
-	 *
-	 * @param  path - The directory path to create.
-	 */
-	mkdir(path: string): void;
-	/**
-	 * @deprecated Use mkdir instead.
-	 */
-	mkdirTree(path: string): void;
-	/**
-	 * Reads a file from the PHP filesystem and returns it as a string.
-	 *
-	 * @throws {@link @php-wasm/universal:ErrnoError} – If the file doesn't exist.
-	 * @param  path - The file path to read.
-	 * @returns The file contents.
-	 */
-	readFileAsText(path: string): string;
-	/**
-	 * Reads a file from the PHP filesystem and returns it as an array buffer.
-	 *
-	 * @throws {@link @php-wasm/universal:ErrnoError} – If the file doesn't exist.
-	 * @param  path - The file path to read.
-	 * @returns The file contents.
-	 */
-	readFileAsBuffer(path: string): Uint8Array;
-	/**
-	 * Overwrites data in a file in the PHP filesystem.
-	 * Creates a new file if one doesn't exist yet.
-	 *
-	 * @param  path - The file path to write to.
-	 * @param  data - The data to write to the file.
-	 */
-	writeFile(path: string, data: string | Uint8Array): void;
-	/**
-	 * Removes a file from the PHP filesystem.
-	 *
-	 * @throws {@link @php-wasm/universal:ErrnoError} – If the file doesn't exist.
-	 * @param  path - The file path to remove.
-	 */
-	unlink(path: string): void;
-	/**
-	 * Moves a file or directory in the PHP filesystem to a
-	 * new location.
-	 *
-	 * @param oldPath The path to rename.
-	 * @param newPath The new path.
-	 */
-	mv(oldPath: string, newPath: string): void;
-	/**
-	 * Removes a directory from the PHP filesystem.
-	 *
-	 * @param path The directory path to remove.
-	 * @param options Options for the removal.
-	 */
-	rmdir(path: string, options?: RmDirOptions): void;
+export type PHPRuntimeId = number;
+export type PHPRuntime = any;
+export type PHPLoaderModule = {
+	dependencyFilename: string;
+	dependenciesTotalSize: number;
+	init: (jsRuntime: string, options: EmscriptenOptions) => PHPRuntime;
+};
+export type EmscriptenOptions = {
+	onAbort?: (message: string) => void;
 	/**
-	 * Lists the files and directories in the given directory.
-	 *
-	 * @param  path - The directory path to list.
-	 * @param  options - Options for the listing.
-	 * @returns The list of files and directories in the given directory.
+	 * Set to true for debugging tricky WebAssembly errors.
 	 */
-	listFiles(path: string, options?: ListFilesOptions): string[];
-	/**
-	 * Checks if a directory exists in the PHP filesystem.
+	debug?: boolean;
+	ENV?: Record<string, string>;
+	locateFile?: (path: string) => string;
+	noInitialRun?: boolean;
+	print?: (message: string) => void;
+	printErr?: (message: string) => void;
+	quit?: (status: number, toThrow: any) => void;
+	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;
+/** Other WebAssembly declarations, for compatibility with older versions of Typescript */
+export declare namespace Emscripten {
+	export interface RootFS extends Emscripten.FileSystemInstance {
+		filesystems: Record<string, Emscripten.FileSystemType>;
+	}
+	export interface FileSystemType {
+		mount(mount: FS.Mount): FS.FSNode;
+		syncfs(mount: FS.Mount, populate: () => unknown, done: (err?: number | null) => unknown): void;
+	}
+	export type EnvironmentType = "WEB" | "NODE" | "SHELL" | "WORKER";
+	export type JSType = "number" | "string" | "array" | "boolean";
+	export type TypeCompatibleWithC = number | string | any[] | boolean;
+	export type CIntType = "i8" | "i16" | "i32" | "i64";
+	export type CFloatType = "float" | "double";
+	export type CPointerType = "i8*" | "i16*" | "i32*" | "i64*" | "float*" | "double*" | "*";
+	export type CType = CIntType | CFloatType | CPointerType;
+	export interface CCallOpts {
+		async?: boolean | undefined;
+	}
+	type NamespaceToInstance<T> = {
+		[K in keyof T]: T[K] extends (...args: any[]) => any ? T[K] : never;
+	};
+	export type FileSystemInstance = NamespaceToInstance<typeof FS> & {
+		mkdirTree(path: string): void;
+		lookupPath(path: string, opts?: any): FS.Lookup;
+	};
+	export interface EmscriptenModule {
+		print(str: string): void;
+		printErr(str: string): void;
+		arguments: string[];
+		environment: Emscripten.EnvironmentType;
+		preInit: Array<{
+			(): void;
+		}>;
+		preRun: Array<{
+			(): void;
+		}>;
+		postRun: Array<{
+			(): void;
+		}>;
+		onAbort: {
+			(what: any): void;
+		};
+		onRuntimeInitialized: {
+			(): void;
+		};
+		preinitializedWebGLContext: WebGLRenderingContext;
+		noInitialRun: boolean;
+		noExitRuntime: boolean;
+		logReadFiles: boolean;
+		filePackagePrefixURL: string;
+		wasmBinary: ArrayBuffer;
+		destroy(object: object): void;
+		getPreloadedPackage(remotePackageName: string, remotePackageSize: number): ArrayBuffer;
+		instantiateWasm(imports: WebAssembly.Imports, successCallback: (module: WebAssembly.Instance) => void): WebAssembly.Exports | undefined;
+		locateFile(url: string, scriptDirectory: string): string;
+		onCustomMessage(event: MessageEvent): void;
+		HEAP: Int32Array;
+		IHEAP: Int32Array;
+		FHEAP: Float64Array;
+		HEAP8: Int8Array;
+		HEAP16: Int16Array;
+		HEAP32: Int32Array;
+		HEAPU8: Uint8Array;
+		HEAPU16: Uint16Array;
+		HEAPU32: Uint32Array;
+		HEAPF32: Float32Array;
+		HEAPF64: Float64Array;
+		HEAP64: BigInt64Array;
+		HEAPU64: BigUint64Array;
+		TOTAL_STACK: number;
+		TOTAL_MEMORY: number;
+		FAST_MEMORY: number;
+		addOnPreRun(cb: () => any): void;
+		addOnInit(cb: () => any): void;
+		addOnPreMain(cb: () => any): void;
+		addOnExit(cb: () => any): void;
+		addOnPostRun(cb: () => any): void;
+		preloadedImages: any;
+		preloadedAudios: any;
+		_malloc(size: number): number;
+		_free(ptr: number): void;
+	}
+	/**
+	 * A factory function is generated when setting the `MODULARIZE` build option
+	 * to `1` in your Emscripten build. It return a Promise that resolves to an
+	 * initialized, ready-to-call `EmscriptenModule` instance.
 	 *
-	 * @param  path – The path to check.
-	 * @returns True if the path is a directory, false otherwise.
-	 */
-	isDir(path: string): boolean;
+	 * By default, the factory function will be named `Module`. It's recommended to
+	 * use the `EXPORT_ES6` option, in which the factory function will be the
+	 * default export. If used without `EXPORT_ES6`, the factory function will be a
+	 * global variable. You can rename the variable using the `EXPORT_NAME` build
+	 * option. It's left to you to export any global variables as needed in your
+	 * application's types.
+	 * @param moduleOverrides Default properties for the initialized module.
+	 */
+	export type EmscriptenModuleFactory<T extends EmscriptenModule = EmscriptenModule> = (moduleOverrides?: Partial<T>) => Promise<T>;
+	export namespace FS {
+		interface Lookup {
+			path: string;
+			node: FSNode;
+		}
+		interface Analyze {
+			isRoot: boolean;
+			exists: boolean;
+			error: Error;
+			name: string;
+			path: Lookup["path"];
+			object: Lookup["node"];
+			parentExists: boolean;
+			parentPath: Lookup["path"];
+			parentObject: Lookup["node"];
+		}
+		interface Mount {
+			type: Emscripten.FileSystemType;
+			opts: object;
+			mountpoint: string;
+			mounts: Mount[];
+			root: FSNode;
+		}
+		class FSStream {
+			constructor();
+			object: FSNode;
+			readonly isRead: boolean;
+			readonly isWrite: boolean;
+			readonly isAppend: boolean;
+			flags: number;
+			position: number;
+		}
+		class FSNode {
+			parent: FSNode;
+			mount: Mount;
+			mounted?: Mount;
+			id: number;
+			name: string;
+			mode: number;
+			rdev: number;
+			readMode: number;
+			writeMode: number;
+			constructor(parent: FSNode, name: string, mode: number, rdev: number);
+			read: boolean;
+			write: boolean;
+			readonly isFolder: boolean;
+			readonly isDevice: boolean;
+		}
+		interface ErrnoError extends Error {
+			name: "ErronoError";
+			errno: number;
+			code: string;
+		}
+		function lookupPath(path: string, opts: any): Lookup;
+		function getPath(node: FSNode): string;
+		function analyzePath(path: string, dontResolveLastLink?: boolean): Analyze;
+		function isFile(mode: number): boolean;
+		function isDir(mode: number): boolean;
+		function isLink(mode: number): boolean;
+		function isChrdev(mode: number): boolean;
+		function isBlkdev(mode: number): boolean;
+		function isFIFO(mode: number): boolean;
+		function isSocket(mode: number): boolean;
+		function major(dev: number): number;
+		function minor(dev: number): number;
+		function makedev(ma: number, mi: number): number;
+		function registerDevice(dev: number, ops: any): void;
+		function syncfs(populate: boolean, callback: (e: any) => any): void;
+		function syncfs(callback: (e: any) => any, populate?: boolean): void;
+		function mount(type: Emscripten.FileSystemType, opts: any, mountpoint: string): any;
+		function unmount(mountpoint: string): void;
+		function mkdir(path: string, mode?: number): any;
+		function mkdev(path: string, mode?: number, dev?: number): any;
+		function symlink(oldpath: string, newpath: string): any;
+		function rename(old_path: string, new_path: string): void;
+		function rmdir(path: string): void;
+		function readdir(path: string): any;
+		function unlink(path: string): void;
+		function readlink(path: string): string;
+		function stat(path: string, dontFollow?: boolean): any;
+		function lstat(path: string): any;
+		function chmod(path: string, mode: number, dontFollow?: boolean): void;
+		function lchmod(path: string, mode: number): void;
+		function fchmod(fd: number, mode: number): void;
+		function chown(path: string, uid: number, gid: number, dontFollow?: boolean): void;
+		function lchown(path: string, uid: number, gid: number): void;
+		function fchown(fd: number, uid: number, gid: number): void;
+		function truncate(path: string, len: number): void;
+		function ftruncate(fd: number, len: number): void;
+		function utime(path: string, atime: number, mtime: number): void;
+		function open(path: string, flags: string, mode?: number, fd_start?: number, fd_end?: number): FSStream;
+		function close(stream: FSStream): void;
+		function llseek(stream: FSStream, offset: number, whence: number): any;
+		function read(stream: FSStream, buffer: ArrayBufferView, offset: number, length: number, position?: number): number;
+		function write(stream: FSStream, buffer: ArrayBufferView, offset: number, length: number, position?: number, canOwn?: boolean): number;
+		function allocate(stream: FSStream, offset: number, length: number): void;
+		function mmap(stream: FSStream, buffer: ArrayBufferView, offset: number, length: number, position: number, prot: number, flags: number): any;
+		function ioctl(stream: FSStream, cmd: any, arg: any): any;
+		function readFile(path: string, opts: {
+			encoding: "binary";
+			flags?: string | undefined;
+		}): Uint8Array;
+		function readFile(path: string, opts: {
+			encoding: "utf8";
+			flags?: string | undefined;
+		}): string;
+		function readFile(path: string, opts?: {
+			flags?: string | undefined;
+		}): Uint8Array;
+		function writeFile(path: string, data: string | ArrayBufferView, opts?: {
+			flags?: string | undefined;
+		}): void;
+		function cwd(): string;
+		function chdir(path: string): void;
+		function init(input: null | (() => number | null), output: null | ((c: number) => any), error: null | ((c: number) => any)): void;
+		function createLazyFile(parent: string | FSNode, name: string, url: string, canRead: boolean, canWrite: boolean): FSNode;
+		function createPreloadedFile(parent: string | FSNode, name: string, url: string, canRead: boolean, canWrite: boolean, onload?: () => void, onerror?: () => void, dontCreateFile?: boolean, canOwn?: boolean): void;
+		function createDataFile(parent: string | FSNode, name: string, data: ArrayBufferView, canRead: boolean, canWrite: boolean, canOwn: boolean): FSNode;
+	}
+	export const MEMFS: Emscripten.FileSystemType;
+	export const NODEFS: Emscripten.FileSystemType;
+	export const IDBFS: Emscripten.FileSystemType;
+	type StringToType<R> = R extends Emscripten.JSType ? {
+		number: number;
+		string: string;
+		array: number[] | string[] | boolean[] | Uint8Array | Int8Array;
+		boolean: boolean;
+		null: null;
+	}[R] : never;
+	type ArgsToType<T extends Array<Emscripten.JSType | null>> = Extract<{
+		[P in keyof T]: StringToType<T[P]>;
+	}, any[]>;
+	type ReturnToType<R extends Emscripten.JSType | null> = R extends null ? null : StringToType<Exclude<R, null>>;
+	export function cwrap<I extends Array<Emscripten.JSType | null> | [
+	], R extends Emscripten.JSType | null>(ident: string, returnType: R, argTypes: I, opts?: Emscripten.CCallOpts): (...arg: ArgsToType<I>) => ReturnToType<R>;
+	export function ccall<I extends Array<Emscripten.JSType | null> | [
+	], R extends Emscripten.JSType | null>(ident: string, returnType: R, argTypes: I, args: ArgsToType<I>, opts?: Emscripten.CCallOpts): ReturnToType<R>;
+	export function setValue(ptr: number, value: any, type: Emscripten.CType, noSafe?: boolean): void;
+	export function getValue(ptr: number, type: Emscripten.CType, noSafe?: boolean): number;
+	export function allocate(slab: number[] | ArrayBufferView | number, types: Emscripten.CType | Emscripten.CType[], allocator: number, ptr?: number): number;
+	export function stackAlloc(size: number): number;
+	export function stackSave(): number;
+	export function stackRestore(ptr: number): void;
+	export function UTF8ToString(ptr: number, maxBytesToRead?: number): string;
+	export function stringToUTF8(str: string, outPtr: number, maxBytesToRead?: number): void;
+	export function lengthBytesUTF8(str: string): number;
+	export function allocateUTF8(str: string): number;
+	export function allocateUTF8OnStack(str: string): number;
+	export function UTF16ToString(ptr: number): string;
+	export function stringToUTF16(str: string, outPtr: number, maxBytesToRead?: number): void;
+	export function lengthBytesUTF16(str: string): number;
+	export function UTF32ToString(ptr: number): string;
+	export function stringToUTF32(str: string, outPtr: number, maxBytesToRead?: number): void;
+	export function lengthBytesUTF32(str: string): number;
+	export function intArrayFromString(stringy: string, dontAddNull?: boolean, length?: number): number[];
+	export function intArrayToString(array: number[]): string;
+	export function writeStringToMemory(str: string, buffer: number, dontAddNull: boolean): void;
+	export function writeArrayToMemory(array: number[], buffer: number): void;
+	export function writeAsciiToMemory(str: string, buffer: number, dontAddNull: boolean): void;
+	export function addRunDependency(id: any): void;
+	export function removeRunDependency(id: any): void;
+	export function addFunction(func: (...args: any[]) => any, signature?: string): number;
+	export function removeFunction(funcPtr: number): void;
+	export const ALLOC_NORMAL: number;
+	export const ALLOC_STACK: number;
+	export const ALLOC_STATIC: number;
+	export const ALLOC_DYNAMIC: number;
+	export const ALLOC_NONE: number;
+	export {};
+}
+export interface RmDirOptions {
 	/**
-	 * Checks if a file (or a directory) exists in the PHP filesystem.
-	 *
-	 * @param  path - The file path to check.
-	 * @returns True if the file exists, false otherwise.
+	 * If true, recursively removes the directory and all its contents.
+	 * Default: true.
 	 */
-	fileExists(path: string): boolean;
+	recursive?: boolean;
+}
+export interface ListFilesOptions {
 	/**
-	 * Changes the current working directory in the PHP filesystem.
-	 * This is the directory that will be used as the base for relative paths.
-	 * For example, if the current working directory is `/root/php`, and the
-	 * path is `data`, the absolute path will be `/root/php/data`.
-	 *
-	 * @param  path - The new working directory.
+	 * If true, prepend given folder path to all file names.
+	 * Default: false.
 	 */
-	chdir(path: string): void;
+	prependPath: boolean;
+}
+export interface SemaphoreOptions {
 	/**
-	 * Runs PHP code.
-	 *
-	 * This low-level method directly interacts with the WebAssembly
-	 * PHP interpreter.
-	 *
-	 * Every time you call run(), it prepares the PHP
-	 * environment and:
-	 *
-	 * * Resets the internal PHP state
-	 * * Populates superglobals ($_SERVER, $_GET, etc.)
-	 * * Handles file uploads
-	 * * Populates input streams (stdin, argv, etc.)
-	 * * Sets the current working directory
-	 *
-	 * You can use run() in two primary modes:
-	 *
-	 * ### Code snippet mode
-	 *
-	 * In this mode, you pass a string containing PHP code to run.
-	 *
-	 * ```ts
-	 * const result = await php.run({
-	 * 	code: `<?php echo "Hello world!";`
-	 * });
-	 * // result.text === "Hello world!"
-	 * ```
-	 *
-	 * In this mode, information like __DIR__ or __FILE__ isn't very
-	 * useful because the code is not associated with any file.
-	 *
-	 * Under the hood, the PHP snippet is passed to the `zend_eval_string`
-	 * C function.
-	 *
-	 * ### File mode
-	 *
-	 * In the file mode, you pass a scriptPath and PHP executes a file
-	 * found at a that path:
-	 *
-	 * ```ts
-	 * php.writeFile(
-	 * 	"/www/index.php",
-	 * 	`<?php echo "Hello world!";"`
-	 * );
-	 * const result = await php.run({
-	 * 	scriptPath: "/www/index.php"
-	 * });
-	 * // result.text === "Hello world!"
-	 * ```
-	 *
-	 * In this mode, you can rely on path-related information like __DIR__
-	 * or __FILE__.
-	 *
-	 * Under the hood, the PHP file is executed with the `php_execute_script`
-	 * C function.
-	 *
-	 * The `run()` method cannot be used in conjunction with `cli()`.
-	 *
-	 * @example
-	 * ```js
-	 * const result = await php.run(`<?php
-	 *  $fp = fopen('php://stderr', 'w');
-	 *  fwrite($fp, "Hello, world!");
-	 * `);
-	 * // result.errors === "Hello, world!"
-	 * ```
-	 *
-	 * @param  options - PHP runtime options.
+	 * The maximum number of concurrent locks.
 	 */
-	run(options: PHPRunOptions): Promise<PHPResponse>;
+	concurrency: number;
 	/**
-	 * Listens to message sent by the PHP code.
-	 *
-	 * To dispatch messages, call:
-	 *
-	 *     post_message_to_js(string $data)
-	 *
-	 *     Arguments:
-	 *         $data (string) – Data to pass to JavaScript.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * const php = await PHP.load('8.0');
-	 *
-	 * php.onMessage(
-	 *     // The data is always passed as a string
-	 *     function (data: string) {
-	 *         // Let's decode and log the data:
-	 *         console.log(JSON.parse(data));
-	 *     }
-	 * );
-	 *
-	 * // Now that we have a listener in place, let's
-	 * // dispatch a message:
-	 * await php.run({
-	 *     code: `<?php
-	 *         post_message_to_js(
-	 *             json_encode([
-	 *                 'post_id' => '15',
-	 *                 'post_title' => 'This is a blog post!'
-	 *             ])
-	 *         ));
-	 *     `,
-	 * });
-	 * ```
-	 *
-	 * @param listener Callback function to handle the message.
+	 * The maximum time to wait for a lock to become available.
 	 */
-	onMessage(listener: MessageListener): void;
+	timeout?: number;
 }
-export type MessageListener = (data: string) => Promise<string | Uint8Array | void> | string | void;
-export interface EventEmitter {
-	on(event: string, listener: (...args: any[]) => void): this;
-	emit(event: string, ...args: any[]): boolean;
+declare class Semaphore {
+	private _running;
+	private concurrency;
+	private timeout?;
+	private queue;
+	constructor({ concurrency, timeout }: SemaphoreOptions);
+	get remaining(): number;
+	get running(): number;
+	acquire(): Promise<() => void>;
+	run<T>(fn: () => T | Promise<T>): Promise<T>;
 }
-export type ChildProcess = EventEmitter & {
-	stdout: EventEmitter;
-	stderr: EventEmitter;
+export type PHPFactoryOptions = {
+	isPrimary: boolean;
 };
-export type SpawnHandler = (command: string, args: string[]) => ChildProcess;
-export type HTTPMethod = "GET" | "POST" | "HEAD" | "OPTIONS" | "PATCH" | "PUT" | "DELETE";
-export type PHPRequestHeaders = Record<string, string>;
-export interface PHPRequest {
+export type PHPFactory = (options: PHPFactoryOptions) => Promise<PHP>;
+export interface ProcessManagerOptions {
 	/**
-	 * Request method. Default: `GET`.
+	 * The maximum number of PHP instances that can exist at
+	 * the same time.
 	 */
-	method?: HTTPMethod;
+	maxPhpInstances?: number;
 	/**
-	 * Request path or absolute URL.
+	 * The number of milliseconds to wait for a PHP instance when
+	 * we have reached the maximum number of PHP instances and
+	 * cannot spawn a new one. If the timeout is reached, we assume
+	 * all the PHP instances are deadlocked and a throw MaxPhpInstancesError.
+	 *
+	 * Default: 5000
 	 */
-	url: string;
+	timeout?: number;
 	/**
-	 * Request headers.
+	 * The primary PHP instance that's never killed. This instance
+	 * contains the reference filesystem used by all other PHP instances.
 	 */
-	headers?: PHPRequestHeaders;
+	primaryPhp?: PHP;
 	/**
-	 * Request body.
-	 * If an object is given, the request will be encoded as multipart
-	 * and sent with a `multipart/form-data` header.
+	 * A factory function used for spawning new PHP instances.
 	 */
-	body?: string | Uint8Array | Record<string, string | Uint8Array | File>;
+	phpFactory?: PHPFactory;
 }
-export interface PHPRunOptions {
-	/**
-	 * Request path following the domain:port part.
-	 */
-	relativeUri?: string;
-	/**
-	 * Path of the .php file to execute.
-	 */
-	scriptPath?: string;
-	/**
-	 * Request protocol.
-	 */
-	protocol?: string;
-	/**
-	 * Request method. Default: `GET`.
-	 */
-	method?: HTTPMethod;
-	/**
-	 * Request headers.
-	 */
-	headers?: PHPRequestHeaders;
-	/**
-	 * Request body.
-	 */
-	body?: string | Uint8Array;
-	/**
-	 * 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.
-	 */
-	code?: string;
+export interface SpawnedPHP {
+	php: PHP;
+	reap: () => void;
 }
-export interface RmDirOptions {
+declare class PHPProcessManager implements AsyncDisposable {
+	private primaryPhp?;
+	private primaryIdle;
+	private nextInstance;
 	/**
-	 * If true, recursively removes the directory and all its contents.
-	 * Default: true.
+	 * All spawned PHP instances, including the primary PHP instance.
+	 * Used for bookkeeping and reaping all instances on dispose.
 	 */
-	recursive?: boolean;
-}
-export interface ListFilesOptions {
+	private allInstances;
+	private phpFactory?;
+	private maxPhpInstances;
+	private semaphore;
+	constructor(options?: ProcessManagerOptions);
 	/**
-	 * If true, prepend given folder path to all file names.
-	 * Default: false.
+	 * Get the primary PHP instance.
+	 *
+	 * If the primary PHP instance is not set, it will be spawned
+	 * using the provided phpFactory.
+	 *
+	 * @throws {Error} when called twice before the first call is resolved.
 	 */
-	prependPath: boolean;
-}
-export type PHPRuntimeId = number;
-export type PHPRuntime = any;
-export type PHPLoaderModule = {
-	dependencyFilename: string;
-	dependenciesTotalSize: number;
-	init: (jsRuntime: string, options: EmscriptenOptions) => PHPRuntime;
-};
-export type EmscriptenOptions = {
-	onAbort?: (message: string) => void;
+	getPrimaryPhp(): Promise<PHP>;
 	/**
-	 * Set to true for debugging tricky WebAssembly errors.
+	 * Get a PHP instance.
+	 *
+	 * It could be either the primary PHP instance, an idle disposable PHP instance,
+	 * or a newly spawned PHP instance – depending on the resource availability.
+	 *
+	 * @throws {MaxPhpInstancesError} when the maximum number of PHP instances is reached
+	 *                                and the waiting timeout is exceeded.
 	 */
-	debug?: boolean;
-	ENV?: Record<string, string>;
-	locateFile?: (path: string) => string;
-	noInitialRun?: boolean;
-	print?: (message: string) => void;
-	printErr?: (message: string) => void;
-	quit?: (status: number, toThrow: any) => void;
-	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 {
+	acquirePHPInstance(): Promise<SpawnedPHP>;
 	/**
-	 * The maximum number of concurrent locks.
+	 * Initiated spawning of a new PHP instance.
+	 * This function is synchronous on purpose – it needs to synchronously
+	 * add the spawn promise to the allInstances array without waiting
+	 * for PHP to spawn.
 	 */
-	concurrency: number;
+	private spawn;
 	/**
-	 * The maximum time to wait for a lock to become available.
+	 * Actually acquires the lock and spawns a new PHP instance.
 	 */
-	timeout?: number;
-}
-declare class Semaphore {
-	private _running;
-	private concurrency;
-	private timeout?;
-	private queue;
-	constructor({ concurrency, timeout }: SemaphoreOptions);
-	get remaining(): number;
-	get running(): number;
-	acquire(): Promise<() => void>;
-	run<T>(fn: () => T | Promise<T>): Promise<T>;
+	private doSpawn;
+	[Symbol.asyncDispose](): Promise<void>;
 }
 export type RewriteRule = {
 	match: RegExp;
@@ -490,10 +500,10 @@ export interface BaseConfiguration {
 	 */
 	rewriteRules?: RewriteRule[];
 }
-export type PHPRequestHandlerFactoryArgs<PHP extends BasePHP> = PHPFactoryOptions & {
-	requestHandler: PHPRequestHandler<PHP>;
+export type PHPRequestHandlerFactoryArgs = PHPFactoryOptions & {
+	requestHandler: PHPRequestHandler;
 };
-export type PHPRequestHandlerConfiguration<PHP extends BasePHP> = BaseConfiguration & ({
+export type PHPRequestHandlerConfiguration = BaseConfiguration & ({
 	/**
 	 * PHPProcessManager is required because the request handler needs
 	 * to make a decision for each request.
@@ -505,19 +515,19 @@ export type PHPRequestHandlerConfiguration<PHP extends BasePHP> = BaseConfigurat
 	 * Dynamic PHP requests, however, require grabbing an available PHP
 	 * interpreter, and that's where the PHPProcessManager comes in.
 	 */
-	processManager: PHPProcessManager<PHP>;
+	processManager: PHPProcessManager;
 } | {
-	phpFactory: (requestHandler: PHPRequestHandlerFactoryArgs<PHP>) => Promise<PHP>;
+	phpFactory: (requestHandler: PHPRequestHandlerFactoryArgs) => Promise<PHP>;
 	/**
 	 * The maximum number of PHP instances that can exist at
 	 * the same time.
 	 */
 	maxPhpInstances?: number;
 });
-declare class PHPRequestHandler<PHP extends BasePHP> {
+declare class PHPRequestHandler {
 	#private;
 	rewriteRules: RewriteRule[];
-	processManager: PHPProcessManager<PHP>;
+	processManager: PHPProcessManager;
 	/**
 	 * The request handler needs to decide whether to serve a static asset or
 	 * run the PHP interpreter. For static assets it should just reuse the primary
@@ -529,7 +539,7 @@ declare class PHPRequestHandler<PHP extends BasePHP> {
 	 * @param  php    - The PHP instance.
 	 * @param  config - Request Handler configuration.
 	 */
-	constructor(config: PHPRequestHandlerConfiguration<PHP>);
+	constructor(config: PHPRequestHandlerConfiguration);
 	getPrimaryPhp(): Promise<PHP>;
 	/**
 	 * Converts a path to an absolute URL based at the PHPRequestHandler
@@ -607,10 +617,12 @@ declare class PHPRequestHandler<PHP extends BasePHP> {
 	request(request: PHPRequest): Promise<PHPResponse>;
 }
 declare const __private__dont__use: unique symbol;
-declare abstract class BasePHP implements IsomorphicLocalPHP, Disposable {
+export type UnmountFunction = (() => Promise<any>) | (() => any);
+export type MountHandler = (php: PHP, FS: Emscripten.RootFS, vfsMountPoint: string) => UnmountFunction | Promise<UnmountFunction>;
+declare class PHP implements Disposable {
 	#private;
 	protected [__private__dont__use]: any;
-	requestHandler?: PHPRequestHandler<any>;
+	requestHandler?: PHPRequestHandler;
 	/**
 	 * An exclusive lock that prevent multiple requests from running at
 	 * the same time.
@@ -624,197 +636,290 @@ declare abstract class BasePHP implements IsomorphicLocalPHP, Disposable {
 	 * @param  requestHandlerOptions - Optional. Options for the PHPRequestHandler. If undefined, no request handler will be initialized.
 	 */
 	constructor(PHPRuntimeId?: PHPRuntimeId);
+	/**
+	 * Adds an event listener for a PHP event.
+	 * @param eventType - The type of event to listen for.
+	 * @param listener - The listener function to be called when the event is triggered.
+	 */
 	addEventListener(eventType: PHPEvent["type"], listener: PHPEventListener): void;
+	/**
+	 * Removes an event listener for a PHP event.
+	 * @param eventType - The type of event to remove the listener from.
+	 * @param listener - The listener function to be removed.
+	 */
 	removeEventListener(eventType: PHPEvent["type"], listener: PHPEventListener): void;
 	dispatchEvent<Event extends PHPEvent>(event: Event): void;
-	/** @inheritDoc */
-	onMessage(listener: MessageListener): Promise<void>;
-	/** @inheritDoc */
+	/**
+	 * Listens to message sent by the PHP code.
+	 *
+	 * To dispatch messages, call:
+	 *
+	 *     post_message_to_js(string $data)
+	 *
+	 *     Arguments:
+	 *         $data (string) – Data to pass to JavaScript.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * const php = await PHP.load('8.0');
+	 *
+	 * php.onMessage(
+	 *     // The data is always passed as a string
+	 *     function (data: string) {
+	 *         // Let's decode and log the data:
+	 *         console.log(JSON.parse(data));
+	 *     }
+	 * );
+	 *
+	 * // Now that we have a listener in place, let's
+	 * // dispatch a message:
+	 * await php.run({
+	 *     code: `<?php
+	 *         post_message_to_js(
+	 *             json_encode([
+	 *                 'post_id' => '15',
+	 *                 'post_title' => 'This is a blog post!'
+	 *             ])
+	 *         ));
+	 *     `,
+	 * });
+	 * ```
+	 *
+	 * @param listener Callback function to handle the message.
+	 */
+	onMessage(listener: MessageListener): void;
 	setSpawnHandler(handler: SpawnHandler | string): Promise<void>;
-	/** @inheritDoc */
+	/** @deprecated Use PHPRequestHandler instead. */
 	get absoluteUrl(): string;
-	/** @inheritDoc */
+	/** @deprecated Use PHPRequestHandler instead. */
 	get documentRoot(): string;
-	/** @inheritDoc */
+	/** @deprecated Use PHPRequestHandler instead. */
 	pathToInternalUrl(path: string): string;
-	/** @inheritDoc */
+	/** @deprecated Use PHPRequestHandler instead. */
 	internalUrlToPath(internalUrl: string): string;
 	initializeRuntime(runtimeId: PHPRuntimeId): void;
 	/** @inheritDoc */
 	setSapiName(newName: string): Promise<void>;
-	/** @inheritDoc */
+	/**
+	 * Changes the current working directory in the PHP filesystem.
+	 * This is the directory that will be used as the base for relative paths.
+	 * For example, if the current working directory is `/root/php`, and the
+	 * path is `data`, the absolute path will be `/root/php/data`.
+	 *
+	 * @param  path - The new working directory.
+	 */
 	chdir(path: string): void;
 	/**
 	 * Do not use. Use new PHPRequestHandler() instead.
 	 * @deprecated
 	 */
 	request(request: PHPRequest): Promise<PHPResponse>;
-	/** @inheritDoc */
+	/**
+	 * Runs PHP code.
+	 *
+	 * This low-level method directly interacts with the WebAssembly
+	 * PHP interpreter.
+	 *
+	 * Every time you call run(), it prepares the PHP
+	 * environment and:
+	 *
+	 * * Resets the internal PHP state
+	 * * Populates superglobals ($_SERVER, $_GET, etc.)
+	 * * Handles file uploads
+	 * * Populates input streams (stdin, argv, etc.)
+	 * * Sets the current working directory
+	 *
+	 * You can use run() in two primary modes:
+	 *
+	 * ### Code snippet mode
+	 *
+	 * In this mode, you pass a string containing PHP code to run.
+	 *
+	 * ```ts
+	 * const result = await php.run({
+	 * 	code: `<?php echo "Hello world!";`
+	 * });
+	 * // result.text === "Hello world!"
+	 * ```
+	 *
+	 * In this mode, information like __DIR__ or __FILE__ isn't very
+	 * useful because the code is not associated with any file.
+	 *
+	 * Under the hood, the PHP snippet is passed to the `zend_eval_string`
+	 * C function.
+	 *
+	 * ### File mode
+	 *
+	 * In the file mode, you pass a scriptPath and PHP executes a file
+	 * found at a that path:
+	 *
+	 * ```ts
+	 * php.writeFile(
+	 * 	"/www/index.php",
+	 * 	`<?php echo "Hello world!";"`
+	 * );
+	 * const result = await php.run({
+	 * 	scriptPath: "/www/index.php"
+	 * });
+	 * // result.text === "Hello world!"
+	 * ```
+	 *
+	 * In this mode, you can rely on path-related information like __DIR__
+	 * or __FILE__.
+	 *
+	 * Under the hood, the PHP file is executed with the `php_execute_script`
+	 * C function.
+	 *
+	 * The `run()` method cannot be used in conjunction with `cli()`.
+	 *
+	 * @example
+	 * ```js
+	 * const result = await php.run(`<?php
+	 *  $fp = fopen('php://stderr', 'w');
+	 *  fwrite($fp, "Hello, world!");
+	 * `);
+	 * // result.errors === "Hello, world!"
+	 * ```
+	 *
+	 * @param  options - PHP runtime options.
+	 */
 	run(request: PHPRunOptions): Promise<PHPResponse>;
+	/**
+	 * Defines a constant in the PHP runtime.
+	 * @param key - The name of the constant.
+	 * @param value - The value of the constant.
+	 */
 	defineConstant(key: string, value: string | boolean | number | null): void;
-	/** @inheritDoc */
-	mkdir(path: string): void;
-	/** @inheritDoc */
-	mkdirTree(path: string): void;
-	/** @inheritDoc */
-	readFileAsText(path: string): string;
-	/** @inheritDoc */
-	readFileAsBuffer(path: string): Uint8Array;
-	/** @inheritDoc */
-	writeFile(path: string, data: string | Uint8Array): void;
-	/** @inheritDoc */
-	unlink(path: string): void;
-	/** @inheritDoc */
-	mv(fromPath: string, toPath: string): void;
-	/** @inheritDoc */
-	rmdir(path: string, options?: RmDirOptions): void;
-	/** @inheritDoc */
-	listFiles(path: string, options?: ListFilesOptions): string[];
-	/** @inheritDoc */
-	isDir(path: string): boolean;
-	/** @inheritDoc */
-	fileExists(path: string): boolean;
 	/**
-	 * Hot-swaps the PHP runtime for a new one without
-	 * interrupting the operations of this PHP instance.
+	 * Recursively creates a directory with the given path in the PHP filesystem.
+	 * For example, if the path is `/root/php/data`, and `/root` already exists,
+	 * it will create the directories `/root/php` and `/root/php/data`.
 	 *
-	 * @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.
+	 * @param  path - The directory path to create.
 	 */
-	hotSwapPHPRuntime(runtime: number, cwd?: string): void;
-	exit(code?: number): void;
-	[Symbol.dispose](): void;
-}
-export type PHPFactoryOptions = {
-	isPrimary: boolean;
-};
-export type PHPFactory<PHP extends BasePHP> = (options: PHPFactoryOptions) => Promise<PHP>;
-export interface ProcessManagerOptions<PHP extends BasePHP> {
+	mkdir(path: string): void;
 	/**
-	 * The maximum number of PHP instances that can exist at
-	 * the same time.
+	 * @deprecated Use mkdir instead.
+	 */
+	mkdirTree(path: string): void;
+	/**
+	 * Reads a file from the PHP filesystem and returns it as a string.
+	 *
+	 * @throws {@link @php-wasm/universal:ErrnoError} – If the file doesn't exist.
+	 * @param  path - The file path to read.
+	 * @returns The file contents.
 	 */
-	maxPhpInstances?: number;
+	readFileAsText(path: string): string;
 	/**
-	 * The number of milliseconds to wait for a PHP instance when
-	 * we have reached the maximum number of PHP instances and
-	 * cannot spawn a new one. If the timeout is reached, we assume
-	 * all the PHP instances are deadlocked and a throw MaxPhpInstancesError.
+	 * Reads a file from the PHP filesystem and returns it as an array buffer.
 	 *
-	 * Default: 5000
+	 * @throws {@link @php-wasm/universal:ErrnoError} – If the file doesn't exist.
+	 * @param  path - The file path to read.
+	 * @returns The file contents.
 	 */
-	timeout?: number;
+	readFileAsBuffer(path: string): Uint8Array;
 	/**
-	 * The primary PHP instance that's never killed. This instance
-	 * contains the reference filesystem used by all other PHP instances.
+	 * Overwrites data in a file in the PHP filesystem.
+	 * Creates a new file if one doesn't exist yet.
+	 *
+	 * @param  path - The file path to write to.
+	 * @param  data - The data to write to the file.
 	 */
-	primaryPhp?: PHP;
+	writeFile(path: string, data: string | Uint8Array): void;
 	/**
-	 * A factory function used for spawning new PHP instances.
+	 * Removes a file from the PHP filesystem.
+	 *
+	 * @throws {@link @php-wasm/universal:ErrnoError} – If the file doesn't exist.
+	 * @param  path - The file path to remove.
 	 */
-	phpFactory?: PHPFactory<PHP>;
-}
-export interface SpawnedPHP<PHP extends BasePHP> {
-	php: PHP;
-	reap: () => void;
-}
-declare class PHPProcessManager<PHP extends BasePHP> implements AsyncDisposable {
-	private primaryPhp?;
-	private primaryIdle;
-	private nextInstance;
+	unlink(path: string): void;
 	/**
-	 * All spawned PHP instances, including the primary PHP instance.
-	 * Used for bookkeeping and reaping all instances on dispose.
+	 * Moves a file or directory in the PHP filesystem to a
+	 * new location.
+	 *
+	 * @param oldPath The path to rename.
+	 * @param newPath The new path.
 	 */
-	private allInstances;
-	private phpFactory?;
-	private maxPhpInstances;
-	private semaphore;
-	constructor(options?: ProcessManagerOptions<PHP>);
+	mv(fromPath: string, toPath: string): void;
 	/**
-	 * Get the primary PHP instance.
+	 * Removes a directory from the PHP filesystem.
 	 *
-	 * If the primary PHP instance is not set, it will be spawned
-	 * using the provided phpFactory.
+	 * @param path The directory path to remove.
+	 * @param options Options for the removal.
+	 */
+	rmdir(path: string, options?: RmDirOptions): void;
+	/**
+	 * Lists the files and directories in the given directory.
 	 *
-	 * @throws {Error} when called twice before the first call is resolved.
+	 * @param  path - The directory path to list.
+	 * @param  options - Options for the listing.
+	 * @returns The list of files and directories in the given directory.
 	 */
-	getPrimaryPhp(): Promise<PHP>;
+	listFiles(path: string, options?: ListFilesOptions): string[];
 	/**
-	 * Get a PHP instance.
+	 * Checks if a directory exists in the PHP filesystem.
 	 *
-	 * It could be either the primary PHP instance, an idle disposable PHP instance,
-	 * or a newly spawned PHP instance – depending on the resource availability.
+	 * @param  path – The path to check.
+	 * @returns True if the path is a directory, false otherwise.
+	 */
+	isDir(path: string): boolean;
+	/**
+	 * Checks if a file (or a directory) exists in the PHP filesystem.
 	 *
-	 * @throws {MaxPhpInstancesError} when the maximum number of PHP instances is reached
-	 *                                and the waiting timeout is exceeded.
+	 * @param  path - The file path to check.
+	 * @returns True if the file exists, false otherwise.
 	 */
-	acquirePHPInstance(): Promise<SpawnedPHP<PHP>>;
+	fileExists(path: string): boolean;
 	/**
-	 * Initiated spawning of a new PHP instance.
-	 * This function is synchronous on purpose – it needs to synchronously
-	 * add the spawn promise to the allInstances array without waiting
-	 * for PHP to spawn.
+	 * Hot-swaps the PHP runtime for a new one without
+	 * 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.
 	 */
-	private spawn;
+	hotSwapPHPRuntime(runtime: number, cwd?: string): void;
 	/**
-	 * Actually acquires the lock and spawns a new PHP instance.
+	 * Mounts a filesystem to a given path in the PHP filesystem.
+	 *
+	 * @param  virtualFSPath - Where to mount it in the PHP virtual filesystem.
+	 * @param  mountHandler - The mount handler to use.
+	 * @return Unmount function to unmount the filesystem.
 	 */
-	private doSpawn;
-	[Symbol.asyncDispose](): Promise<void>;
-}
-declare const SupportedPHPVersions: readonly [
-	"8.3",
-	"8.2",
-	"8.1",
-	"8.0",
-	"7.4",
-	"7.3",
-	"7.2",
-	"7.1",
-	"7.0"
-];
-export type SupportedPHPVersion = (typeof SupportedPHPVersions)[number];
-export interface PHPWebLoaderOptions {
-	emscriptenOptions?: EmscriptenOptions;
-	onPhpLoaderModuleLoaded?: (module: PHPLoaderModule) => void;
-	/** @deprecated To be replaced with `extensions` in the future */
-	loadAllExtensions?: boolean;
-}
-export declare class WebPHP extends BasePHP {
+	mount(virtualFSPath: string, mountHandler: MountHandler): Promise<UnmountFunction>;
 	/**
-	 * Creates a new PHP instance.
+	 * Starts a PHP CLI session with given arguments.
 	 *
-	 * Dynamically imports the PHP module, initializes the runtime,
-	 * and sets up networking. It's a shorthand for the lower-level
-	 * functions like `getPHPLoaderModule`, `loadPHPRuntime`, and
-	 * `PHP.initializeRuntime`
+	 * This method can only be used when PHP was compiled with the CLI SAPI
+	 * and it cannot be used in conjunction with `run()`.
 	 *
-	 * @param phpVersion The PHP Version to load
-	 * @param options The options to use when loading PHP
-	 * @returns A new PHP instance
+	 * Once this method finishes running, the PHP instance is no
+	 * longer usable and should be discarded. This is because PHP
+	 * internally cleans up all the resources and calls exit().
+	 *
+	 * @param  argv - The arguments to pass to the CLI.
+	 * @returns The exit code of the CLI session.
 	 */
-	static load(phpVersion: SupportedPHPVersion, options?: PHPWebLoaderOptions): Promise<WebPHP>;
-	static loadRuntime(phpVersion: SupportedPHPVersion, options?: PHPWebLoaderOptions): Promise<number>;
-}
-declare class EmscriptenDownloadMonitor extends EventTarget {
-	#private;
-	expectAssets(assets: Record<string, number>): void;
-	monitorFetch(fetchPromise: Promise<Response>): Promise<Response>;
+	cli(argv: string[]): Promise<number>;
+	setSkipShebang(shouldSkip: boolean): void;
+	exit(code?: number): void;
+	[Symbol.dispose](): void;
 }
-/**
- * A PHP client that can be used to run PHP code in the browser.
- */
-export declare class WebPHPEndpoint implements Omit<IsomorphicLocalPHP, "setSapiName"> {
+export type LimitedPHPApi = Pick<PHP, "request" | "defineConstant" | "addEventListener" | "removeEventListener" | "mkdir" | "mkdirTree" | "readFileAsText" | "readFileAsBuffer" | "writeFile" | "unlink" | "mv" | "rmdir" | "listFiles" | "isDir" | "fileExists" | "chdir" | "run" | "onMessage"> & {
+	documentRoot: PHP["documentRoot"];
+	absoluteUrl: PHP["absoluteUrl"];
+};
+declare class PHPWorker implements LimitedPHPApi {
 	/** @inheritDoc @php-wasm/universal!RequestHandler.absoluteUrl  */
 	absoluteUrl: string;
 	/** @inheritDoc @php-wasm/universal!RequestHandler.documentRoot  */
 	documentRoot: string;
 	/** @inheritDoc */
-	constructor(requestHandler: PHPRequestHandler<WebPHP>, monitor?: EmscriptenDownloadMonitor);
+	constructor(requestHandler?: PHPRequestHandler, monitor?: EmscriptenDownloadMonitor);
+	__internal_setRequestHandler(requestHandler: PHPRequestHandler): void;
 	/**
 	 * @internal
 	 * @deprecated
@@ -822,8 +927,8 @@ export declare class WebPHPEndpoint implements Omit<IsomorphicLocalPHP, "setSapi
 	 * the web API. It will change or even be removed without
 	 * a warning.
 	 */
-	protected __internal_getPHP(): WebPHP | undefined;
-	setPrimaryPHP(php: WebPHP): Promise<void>;
+	protected __internal_getPHP(): PHP | undefined;
+	setPrimaryPHP(php: PHP): Promise<void>;
 	/** @inheritDoc @php-wasm/universal!PHPRequestHandler.pathToInternalUrl  */
 	pathToInternalUrl(path: string): string;
 	/** @inheritDoc @php-wasm/universal!PHPRequestHandler.internalUrlToPath  */
@@ -832,45 +937,170 @@ export declare class WebPHPEndpoint implements Omit<IsomorphicLocalPHP, "setSapi
 	 * The onDownloadProgress event listener.
 	 */
 	onDownloadProgress(callback: (progress: CustomEvent<ProgressEvent>) => void): Promise<void>;
-	/** @inheritDoc @php-wasm/universal!IsomorphicLocalPHP.mv  */
+	/** @inheritDoc @php-wasm/universal!PHP.mv  */
 	mv(fromPath: string, toPath: string): Promise<void>;
-	/** @inheritDoc @php-wasm/universal!IsomorphicLocalPHP.rmdir  */
+	/** @inheritDoc @php-wasm/universal!PHP.rmdir  */
 	rmdir(path: string, options?: RmDirOptions): Promise<void>;
 	/** @inheritDoc @php-wasm/universal!PHPRequestHandler.request */
 	request(request: PHPRequest): Promise<PHPResponse>;
-	/** @inheritDoc @php-wasm/web!WebPHP.run */
+	/** @inheritDoc @php-wasm/universal!/PHP.run */
 	run(request: PHPRunOptions): Promise<PHPResponse>;
-	/** @inheritDoc @php-wasm/web!WebPHP.chdir */
+	/** @inheritDoc @php-wasm/universal!/PHP.chdir */
 	chdir(path: string): void;
-	/** @inheritDoc @php-wasm/web!WebPHP.setSapiName */
+	/** @inheritDoc @php-wasm/universal!/PHP.setSapiName */
 	setSapiName(newName: string): void;
-	/** @inheritDoc @php-wasm/web!WebPHP.mkdir */
+	/** @inheritDoc @php-wasm/universal!/PHP.mkdir */
 	mkdir(path: string): void;
-	/** @inheritDoc @php-wasm/web!WebPHP.mkdirTree */
+	/** @inheritDoc @php-wasm/universal!/PHP.mkdirTree */
 	mkdirTree(path: string): void;
-	/** @inheritDoc @php-wasm/web!WebPHP.readFileAsText */
+	/** @inheritDoc @php-wasm/universal!/PHP.readFileAsText */
 	readFileAsText(path: string): string;
-	/** @inheritDoc @php-wasm/web!WebPHP.readFileAsBuffer */
+	/** @inheritDoc @php-wasm/universal!/PHP.readFileAsBuffer */
 	readFileAsBuffer(path: string): Uint8Array;
-	/** @inheritDoc @php-wasm/web!WebPHP.writeFile */
+	/** @inheritDoc @php-wasm/universal!/PHP.writeFile */
 	writeFile(path: string, data: string | Uint8Array): void;
-	/** @inheritDoc @php-wasm/web!WebPHP.unlink */
+	/** @inheritDoc @php-wasm/universal!/PHP.unlink */
 	unlink(path: string): void;
-	/** @inheritDoc @php-wasm/web!WebPHP.listFiles */
+	/** @inheritDoc @php-wasm/universal!/PHP.listFiles */
 	listFiles(path: string, options?: ListFilesOptions): string[];
-	/** @inheritDoc @php-wasm/web!WebPHP.isDir */
+	/** @inheritDoc @php-wasm/universal!/PHP.isDir */
 	isDir(path: string): boolean;
-	/** @inheritDoc @php-wasm/web!WebPHP.fileExists */
+	/** @inheritDoc @php-wasm/universal!/PHP.fileExists */
 	fileExists(path: string): boolean;
-	/** @inheritDoc @php-wasm/web!WebPHP.onMessage */
+	/** @inheritDoc @php-wasm/universal!/PHP.onMessage */
 	onMessage(listener: MessageListener): void;
-	/** @inheritDoc @php-wasm/web!WebPHP.defineConstant */
+	/** @inheritDoc @php-wasm/universal!/PHP.defineConstant */
 	defineConstant(key: string, value: string | boolean | number | null): void;
-	/** @inheritDoc @php-wasm/web!WebPHP.addEventListener */
+	/** @inheritDoc @php-wasm/universal!/PHP.addEventListener */
 	addEventListener(eventType: PHPEvent["type"], listener: PHPEventListener): void;
-	/** @inheritDoc @php-wasm/web!WebPHP.removeEventListener */
+	/** @inheritDoc @php-wasm/universal!/PHP.removeEventListener */
 	removeEventListener(eventType: PHPEvent["type"], listener: PHPEventListener): void;
 }
+/**
+ * Represents an event related to the PHP request.
+ */
+export interface PHPRequestEndEvent {
+	type: "request.end";
+}
+/**
+ * Represents an error event related to the PHP request.
+ */
+export interface PHPRequestErrorEvent {
+	type: "request.error";
+	error: Error;
+	source?: "request" | "php-wasm";
+}
+/**
+ * Represents a PHP runtime initialization event.
+ */
+export interface PHPRuntimeInitializedEvent {
+	type: "runtime.initialized";
+}
+/**
+ * Represents a PHP runtime destruction event.
+ */
+export interface PHPRuntimeBeforeDestroyEvent {
+	type: "runtime.beforedestroy";
+}
+/**
+ * Represents an event related to the PHP instance.
+ * This is intentionally not an extension of CustomEvent
+ * to make it isomorphic between different JavaScript runtimes.
+ */
+export type PHPEvent = PHPRequestEndEvent | PHPRequestErrorEvent | PHPRuntimeInitializedEvent | PHPRuntimeBeforeDestroyEvent;
+/**
+ * A callback function that handles PHP events.
+ */
+export type PHPEventListener = (event: PHPEvent) => void;
+export type MessageListener = (data: string) => Promise<string | Uint8Array | void> | string | void;
+export interface EventEmitter {
+	on(event: string, listener: (...args: any[]) => void): this;
+	emit(event: string, ...args: any[]): boolean;
+}
+export type ChildProcess = EventEmitter & {
+	stdout: EventEmitter;
+	stderr: EventEmitter;
+};
+export type SpawnHandler = (command: string, args: string[]) => ChildProcess;
+export type HTTPMethod = "GET" | "POST" | "HEAD" | "OPTIONS" | "PATCH" | "PUT" | "DELETE";
+export type PHPRequestHeaders = Record<string, string>;
+export interface PHPRequest {
+	/**
+	 * Request method. Default: `GET`.
+	 */
+	method?: HTTPMethod;
+	/**
+	 * Request path or absolute URL.
+	 */
+	url: string;
+	/**
+	 * Request headers.
+	 */
+	headers?: PHPRequestHeaders;
+	/**
+	 * Request body.
+	 * If an object is given, the request will be encoded as multipart
+	 * and sent with a `multipart/form-data` header.
+	 */
+	body?: string | Uint8Array | Record<string, string | Uint8Array | File>;
+}
+export interface PHPRunOptions {
+	/**
+	 * Request path following the domain:port part.
+	 */
+	relativeUri?: string;
+	/**
+	 * Path of the .php file to execute.
+	 */
+	scriptPath?: string;
+	/**
+	 * Request protocol.
+	 */
+	protocol?: string;
+	/**
+	 * Request method. Default: `GET`.
+	 */
+	method?: HTTPMethod;
+	/**
+	 * Request headers.
+	 */
+	headers?: PHPRequestHeaders;
+	/**
+	 * Request body.
+	 */
+	body?: string | Uint8Array;
+	/**
+	 * 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.
+	 */
+	code?: string;
+}
+declare const SupportedPHPVersions: readonly [
+	"8.3",
+	"8.2",
+	"8.1",
+	"8.0",
+	"7.4",
+	"7.3",
+	"7.2",
+	"7.1",
+	"7.0"
+];
+export type SupportedPHPVersion = (typeof SupportedPHPVersions)[number];
+interface LoaderOptions {
+	emscriptenOptions?: EmscriptenOptions;
+	onPhpLoaderModuleLoaded?: (module: PHPLoaderModule) => void;
+	/** @deprecated To be replaced with `extensions` in the future */
+	loadAllExtensions?: boolean;
+}
+export declare function loadWebRuntime(phpVersion: SupportedPHPVersion, options?: LoaderOptions): Promise<number>;
 /**
  * Loads the PHP loader module for the given PHP version.
  *
@@ -889,7 +1119,21 @@ export declare function getPHPLoaderModule(version?: SupportedPHPVersion, varian
  *                                 mismatched with the actual version, the service worker
  *                                 will be re-registered.
  */
-export declare function registerServiceWorker<Client extends Remote<WebPHPEndpoint>>(phpApi: Client, scope: string, scriptUrl: string): Promise<void>;
+export declare function registerServiceWorker<Client extends Remote<PHPWorker>>(phpApi: Client, scope: string, scriptUrl: string): Promise<void>;
+/**
+ * Setup a postMessage relay between the parent window and a nested iframe.
+ *
+ * When we're running a Playground instance inside an iframe, sometimes that
+ * iframe will contain another iframe and so on. The parent application, however,
+ * needs to be able to communicate with the innermost iframe. This function relays
+ * the communication both ways. Call it in in every iframe layer between the topmost
+ * window and the innermost iframe.
+ *
+ * @param nestedFrame The nested iframe element
+ * @param expectedOrigin The origin that the nested iframe is expected to be on. If not
+ *                       provided, any origin is allowed.
+ */
+export declare function setupPostMessageRelay(nestedFrame: HTMLIFrameElement, expectedOrigin?: string): void;
 /**
  * Spawns a new Worker Thread.
  *
@@ -898,5 +1142,19 @@ export declare function registerServiceWorker<Client extends Remote<WebPHPEndpoi
  * @returns The spawned Worker Thread.
  */
 export declare function spawnPHPWorkerThread(workerUrl: string, startupOptions?: Record<string, string | string[]>): Promise<Worker>;
+export interface MountOptions {
+	initialSync: {
+		direction?: "opfs-to-memfs" | "memfs-to-opfs";
+		onProgress?: SyncProgressCallback;
+	};
+}
+export type SyncProgress = {
+	/** The number of files that have been synced. */
+	files: number;
+	/** The number of all files that need to be synced. */
+	total: number;
+};
+export type SyncProgressCallback = (progress: SyncProgress) => void;
+export declare function createDirectoryHandleMountHandler(handle: FileSystemDirectoryHandle, options?: MountOptions): MountHandler;
 
 export {};