@php-wasm/universal 0.7.19 → 0.9.2

package/lib/emscripten-types.d.ts

@@ -0,0 +1,265 @@
+/** 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.
+     *
+     * 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 {};
+}

package/lib/fs-helpers.d.ts

@@ -0,0 +1,94 @@
+import { Emscripten } from './emscripten-types';
+export interface RmDirOptions {
+    /**
+     * If true, recursively removes the directory and all its contents.
+     * Default: true.
+     */
+    recursive?: boolean;
+}
+export interface ListFilesOptions {
+    /**
+     * If true, prepend given folder path to all file names.
+     * Default: false.
+     */
+    prependPath: boolean;
+}
+export declare class FSHelpers {
+    /**
+     * 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.
+     */
+    static readFileAsText(FS: Emscripten.RootFS, 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.
+     */
+    static readFileAsBuffer(FS: Emscripten.RootFS, 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.
+     */
+    static writeFile(FS: Emscripten.RootFS, 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.
+     */
+    static unlink(FS: Emscripten.RootFS, 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.
+     */
+    static mv(FS: Emscripten.RootFS, fromPath: string, toPath: string): void;
+    /**
+     * Removes a directory from the PHP filesystem.
+     *
+     * @param path The directory path to remove.
+     * @param options Options for the removal.
+     */
+    static rmdir(FS: Emscripten.RootFS, path: string, options?: RmDirOptions): 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.
+     */
+    static listFiles(FS: Emscripten.RootFS, path: string, options?: ListFilesOptions): string[];
+    /**
+     * Checks if a directory exists in the PHP filesystem.
+     *
+     * @param  path – The path to check.
+     * @returns True if the path is a directory, false otherwise.
+     */
+    static isDir(FS: Emscripten.RootFS, path: string): boolean;
+    /**
+     * 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.
+     */
+    static fileExists(FS: Emscripten.RootFS, path: string): boolean;
+    /**
+     * 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.
+     */
+    static mkdir(FS: Emscripten.RootFS, path: string): void;
+    static copyRecursive(FS: Emscripten.FileSystemInstance, fromPath: string, toPath: string): void;
+}

package/lib/index.d.ts

@@ -1,4 +1,8 @@
-export type { IsomorphicLocalPHP, IsomorphicRemotePHP, MessageListener, PHPOutput, PHPRunOptions, UniversalPHP, ListFilesOptions, RmDirOptions, PHPEvent, PHPEventListener, HTTPMethod, PHPRequest, PHPRequestHeaders, SpawnHandler, } from './universal-php';
+export type { MessageListener, PHPOutput, PHPRunOptions, UniversalPHP, PHPEvent, PHPEventListener, HTTPMethod, PHPRequest, PHPRequestHeaders, SpawnHandler, } from './universal-php';
+export { FSHelpers } from './fs-helpers';
+export type { ListFilesOptions, RmDirOptions } from './fs-helpers';
+export { PHPWorker } from './php-worker';
+export { getPhpIniEntries, setPhpIniEntries, withPHPIniValues } from './ini';
 export { UnhandledRejectionsTarget } from './wasm-error-reporting';
 export { HttpCookieStore } from './http-cookie-store';
 export type { IteratePhpFilesOptions as IterateFilesOptions } from './iterate-files';
@@ -13,15 +17,16 @@ export { LatestSupportedPHPVersion, SupportedPHPVersions, SupportedPHPVersionsLi
 export type { SupportedPHPVersion } from './supported-php-versions';
 export { SupportedPHPExtensionsList, SupportedPHPExtensionBundles, } from './supported-php-extensions';
 export type { SupportedPHPExtension, SupportedPHPExtensionBundle, } from './supported-php-extensions';
-export { BasePHP, __private__dont__use } from './base-php';
+export { PHP, __private__dont__use } from './php';
+export type { MountHandler, UnmountFunction } from './php';
 export { loadPHPRuntime } from './load-php-runtime';
+export type * from './emscripten-types';
 export type { DataModule, EmscriptenOptions, PHPLoaderModule, PHPRuntime, PHPRuntimeId, RuntimeType, } from './load-php-runtime';
-export { rethrowFileSystemError } from './rethrow-file-system-error';
-export { isLocalPHP } from './is-local-php';
-export { isRemotePHP } from './is-remote-php';
 export type { PHPRequestHandlerConfiguration, RewriteRule, } from './php-request-handler';
 export { PHPRequestHandler, applyRewriteRules } from './php-request-handler';
 export { rotatePHPRuntime } from './rotate-php-runtime';
 export { writeFiles } from './write-files';
+export type { FileTree } from './write-files';
 export { DEFAULT_BASE_URL, ensurePathPrefix, removePathPrefix, toRelativeUrl, } from './urls';
 export { isExitCodeZero } from './is-exit-code-zero';
+export { proxyFileSystem } from './proxy-file-system';

package/lib/ini.d.ts

@@ -0,0 +1,45 @@
+import { UniversalPHP } from './universal-php';
+/**
+ * Reads the php.ini file and returns its entries.
+ *
+ * @param php The PHP instance.
+ * @param entries Optional. If provided, only the specified entries will be returned.
+ * @returns The php.ini entries.
+ */
+export declare function getPhpIniEntries(php: UniversalPHP, entries?: string[]): Promise<{
+    [key: string]: any;
+}>;
+/**
+ * Rewrites the php.ini file with the given entries.
+ *
+ * @param php The PHP instance.
+ * @param entries The entries to write to the php.ini file.
+ */
+export declare function setPhpIniEntries(php: UniversalPHP, entries: Record<string, unknown>): Promise<void>;
+/**
+ * Sets php.ini values to the given values, executes a callback,
+ * and restores the original php.ini values. This is useful for
+ * running code with temporary php.ini values, such as when
+ * disabling network-related PHP functions just to run WordPress
+ * installer.
+ *
+ * @example
+ * ```ts
+ *	await withPHPIniValues(
+ *		php,
+ *		{
+ *			disable_functions: 'fsockopen',
+ *			allow_url_fopen: '0',
+ *		},
+ *		async () => await runWpInstallationWizard(php, {
+ *			options: {},
+ *		})
+ *	);
+ *	```
+ *
+ * @param php The PHP instance.
+ * @param phpIniValues The php.ini values to set.
+ * @param callback The callback to execute.
+ * @returns The result of the callback.
+ */
+export declare function withPHPIniValues(php: UniversalPHP, phpIniValues: Record<string, string>, callback: () => Promise<any>): Promise<any>;

package/lib/php-process-manager.d.ts

@@ -1,9 +1,9 @@
-import { BasePHP } from './base-php';
+import { PHP } from './php';
 export type PHPFactoryOptions = {
     isPrimary: boolean;
 };
-export type PHPFactory<PHP extends BasePHP> = (options: PHPFactoryOptions) => Promise<PHP>;
-export interface ProcessManagerOptions<PHP extends BasePHP> {
+export type PHPFactory = (options: PHPFactoryOptions) => Promise<PHP>;
+export interface ProcessManagerOptions {
     /**
      * The maximum number of PHP instances that can exist at
      * the same time.
@@ -26,9 +26,9 @@ export interface ProcessManagerOptions<PHP extends BasePHP> {
     /**
      * A factory function used for spawning new PHP instances.
      */
-    phpFactory?: PHPFactory<PHP>;
+    phpFactory?: PHPFactory;
 }
-export interface SpawnedPHP<PHP extends BasePHP> {
+export interface SpawnedPHP {
     php: PHP;
     reap: () => void;
 }
@@ -57,7 +57,7 @@ export declare class MaxPhpInstancesError extends Error {
  * extra time to spin up a few PHP instances. This is a more resource-friendly tradeoff
  * than keeping 5 idle instances at all times.
  */
-export declare class PHPProcessManager<PHP extends BasePHP> implements AsyncDisposable {
+export declare class PHPProcessManager implements AsyncDisposable {
     private primaryPhp?;
     private primaryIdle;
     private nextInstance;
@@ -69,7 +69,7 @@ export declare class PHPProcessManager<PHP extends BasePHP> implements AsyncDisp
     private phpFactory?;
     private maxPhpInstances;
     private semaphore;
-    constructor(options?: ProcessManagerOptions<PHP>);
+    constructor(options?: ProcessManagerOptions);
     /**
      * Get the primary PHP instance.
      *
@@ -88,7 +88,7 @@ export declare class PHPProcessManager<PHP extends BasePHP> implements AsyncDisp
      * @throws {MaxPhpInstancesError} when the maximum number of PHP instances is reached
      *                                and the waiting timeout is exceeded.
      */
-    acquirePHPInstance(): Promise<SpawnedPHP<PHP>>;
+    acquirePHPInstance(): Promise<SpawnedPHP>;
     /**
      * Initiated spawning of a new PHP instance.
      * This function is synchronous on purpose – it needs to synchronously

package/lib/php-request-handler.d.ts

@@ -1,4 +1,4 @@
-import { BasePHP } from './base-php';
+import { PHP } from './php';
 import { PHPResponse } from './php-response';
 import { PHPRequest } from './universal-php';
 import { PHPFactoryOptions, PHPProcessManager } from './php-process-manager';
@@ -21,10 +21,10 @@ 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.
@@ -36,9 +36,9 @@ 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.
@@ -99,10 +99,10 @@ export type PHPRequestHandlerConfiguration<PHP extends BasePHP> = BaseConfigurat
  * // "Hi from PHP!"
  * ```
  */
-export declare class PHPRequestHandler<PHP extends BasePHP> {
+export 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
@@ -114,7 +114,7 @@ export 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

package/lib/php-worker.d.ts

@@ -0,0 +1,77 @@
+import { EmscriptenDownloadMonitor } from '../../../progress/src/index.ts';
+import { PHP } from './php';
+import { PHPRequestHandler } from './php-request-handler';
+import { PHPResponse } from './php-response';
+import { PHPRequest, PHPRunOptions, MessageListener, PHPEvent, PHPEventListener } from './universal-php';
+import { RmDirOptions, ListFilesOptions } from './fs-helpers';
+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'];
+};
+/**
+ * A PHP client that can be used to run PHP code in the browser.
+ */
+export 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, monitor?: EmscriptenDownloadMonitor);
+    __internal_setRequestHandler(requestHandler: PHPRequestHandler): void;
+    /**
+     * @internal
+     * @deprecated
+     * Do not use this method directly in the code consuming
+     * the web API. It will change or even be removed without
+     * a warning.
+     */
+    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  */
+    internalUrlToPath(internalUrl: string): string;
+    /**
+     * The onDownloadProgress event listener.
+     */
+    onDownloadProgress(callback: (progress: CustomEvent<ProgressEvent>) => void): Promise<void>;
+    /** @inheritDoc @php-wasm/universal!PHP.mv  */
+    mv(fromPath: string, toPath: string): Promise<void>;
+    /** @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/universal!/PHP.run */
+    run(request: PHPRunOptions): Promise<PHPResponse>;
+    /** @inheritDoc @php-wasm/universal!/PHP.chdir */
+    chdir(path: string): void;
+    /** @inheritDoc @php-wasm/universal!/PHP.setSapiName */
+    setSapiName(newName: string): void;
+    /** @inheritDoc @php-wasm/universal!/PHP.mkdir */
+    mkdir(path: string): void;
+    /** @inheritDoc @php-wasm/universal!/PHP.mkdirTree */
+    mkdirTree(path: string): void;
+    /** @inheritDoc @php-wasm/universal!/PHP.readFileAsText */
+    readFileAsText(path: string): string;
+    /** @inheritDoc @php-wasm/universal!/PHP.readFileAsBuffer */
+    readFileAsBuffer(path: string): Uint8Array;
+    /** @inheritDoc @php-wasm/universal!/PHP.writeFile */
+    writeFile(path: string, data: string | Uint8Array): void;
+    /** @inheritDoc @php-wasm/universal!/PHP.unlink */
+    unlink(path: string): void;
+    /** @inheritDoc @php-wasm/universal!/PHP.listFiles */
+    listFiles(path: string, options?: ListFilesOptions): string[];
+    /** @inheritDoc @php-wasm/universal!/PHP.isDir */
+    isDir(path: string): boolean;
+    /** @inheritDoc @php-wasm/universal!/PHP.fileExists */
+    fileExists(path: string): boolean;
+    /** @inheritDoc @php-wasm/universal!/PHP.onMessage */
+    onMessage(listener: MessageListener): void;
+    /** @inheritDoc @php-wasm/universal!/PHP.defineConstant */
+    defineConstant(key: string, value: string | boolean | number | null): void;
+    /** @inheritDoc @php-wasm/universal!/PHP.addEventListener */
+    addEventListener(eventType: PHPEvent['type'], listener: PHPEventListener): void;
+    /** @inheritDoc @php-wasm/universal!/PHP.removeEventListener */
+    removeEventListener(eventType: PHPEvent['type'], listener: PHPEventListener): void;
+}