@php-wasm/node 1.1.2 → 1.1.4

package/jspi/php_7_2.js

@@ -8,7 +8,7 @@ import path from 'path';
 
 const dependencyFilename = path.join(__dirname, '7_2_34', 'php_7_2.wasm');
 export { dependencyFilename };
-export const dependenciesTotalSize = 17819046;
+export const dependenciesTotalSize = 17821497;
 export function init(RuntimeName, PHPLoader) {
 	// The rest of the code comes from the built php.js file and esm-suffix.js
 	// include: shell.js
@@ -5209,7 +5209,360 @@ export function init(RuntimeName, PHPLoader) {
 
 	var syscallGetVarargP = syscallGetVarargI;
 
-	function ___syscall_fcntl64(fd, cmd, varargs) {
+	var stringToUTF8 = (str, outPtr, maxBytesToWrite) =>
+		stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+
+	Module['stringToUTF8'] = stringToUTF8;
+
+	var stackAlloc = (sz) => __emscripten_stack_alloc(sz);
+
+	/** @suppress {duplicate } */ var stringToUTF8OnStack = (str) => {
+		var size = lengthBytesUTF8(str) + 1;
+		var ret = stackAlloc(size);
+		stringToUTF8(str, ret, size);
+		return ret;
+	};
+
+	var allocateUTF8OnStack = stringToUTF8OnStack;
+
+	var PHPWASM = {
+		init: function () {
+			// The /internal directory is required by the C module. It's where the
+			// stdout, stderr, and headers information are written for the JavaScript
+			// code to read later on.
+			FS.mkdir('/internal');
+			// The files from the shared directory are shared between all the
+			// PHP processes managed by PHPProcessManager.
+			FS.mkdir('/internal/shared');
+			// The files from the preload directory are preloaded using the
+			// auto_prepend_file php.ini directive.
+			FS.mkdir('/internal/shared/preload');
+			// Create stdout and stderr devices. We can't just use Emscripten's
+			// default stdout and stderr devices because they stop processing data
+			// on the first null byte. However, when dealing with binary data,
+			// null bytes are valid and common.
+			FS.registerDevice(FS.makedev(64, 0), {
+				open: () => {},
+				close: () => {},
+				read: () => 0,
+				write: (stream, buffer, offset, length, pos) => {
+					const chunk = buffer.subarray(offset, offset + length);
+					PHPWASM.onStdout(chunk);
+					return length;
+				},
+			});
+			FS.mkdev('/internal/stdout', FS.makedev(64, 0));
+			FS.registerDevice(FS.makedev(63, 0), {
+				open: () => {},
+				close: () => {},
+				read: () => 0,
+				write: (stream, buffer, offset, length, pos) => {
+					const chunk = buffer.subarray(offset, offset + length);
+					PHPWASM.onStderr(chunk);
+					return length;
+				},
+			});
+			FS.mkdev('/internal/stderr', FS.makedev(63, 0));
+			FS.registerDevice(FS.makedev(62, 0), {
+				open: () => {},
+				close: () => {},
+				read: () => 0,
+				write: (stream, buffer, offset, length, pos) => {
+					const chunk = buffer.subarray(offset, offset + length);
+					PHPWASM.onHeaders(chunk);
+					return length;
+				},
+			});
+			FS.mkdev('/internal/headers', FS.makedev(62, 0));
+			// Handle events.
+			PHPWASM.EventEmitter = ENVIRONMENT_IS_NODE
+				? require('events').EventEmitter
+				: class EventEmitter {
+						constructor() {
+							this.listeners = {};
+						}
+						emit(eventName, data) {
+							if (this.listeners[eventName]) {
+								this.listeners[eventName].forEach(
+									(callback) => {
+										callback(data);
+									}
+								);
+							}
+						}
+						once(eventName, callback) {
+							const self = this;
+							function removedCallback() {
+								callback(...arguments);
+								self.removeListener(eventName, removedCallback);
+							}
+							this.on(eventName, removedCallback);
+						}
+						removeAllListeners(eventName) {
+							if (eventName) {
+								delete this.listeners[eventName];
+							} else {
+								this.listeners = {};
+							}
+						}
+						removeListener(eventName, callback) {
+							if (this.listeners[eventName]) {
+								const idx =
+									this.listeners[eventName].indexOf(callback);
+								if (idx !== -1) {
+									this.listeners[eventName].splice(idx, 1);
+								}
+							}
+						}
+				  };
+			// Clean up the fd -> childProcess mapping when the fd is closed:
+			const originalClose = FS.close;
+			FS.close = function (stream) {
+				originalClose(stream);
+				delete PHPWASM.child_proc_by_fd[stream.fd];
+			};
+			PHPWASM.child_proc_by_fd = {};
+			PHPWASM.child_proc_by_pid = {};
+			PHPWASM.input_devices = {};
+			const originalWrite = TTY.stream_ops.write;
+			TTY.stream_ops.write = function (stream, ...rest) {
+				const retval = originalWrite(stream, ...rest);
+				// Implicit flush since PHP's fflush() doesn't seem to trigger the fsync event
+				// @TODO: Fix this at the wasm level
+				stream.tty.ops.fsync(stream.tty);
+				return retval;
+			};
+			const originalPutChar = TTY.stream_ops.put_char;
+			TTY.stream_ops.put_char = function (tty, val) {
+				/**
+				 * Buffer newlines that Emscripten normally ignores.
+				 *
+				 * Emscripten doesn't do it by default because its default
+				 * print function is console.log that implicitly adds a newline. We are overwriting
+				 * it with an environment-specific function that outputs exaclty what it was given,
+				 * e.g. in Node.js it's process.stdout.write(). Therefore, we need to mak sure
+				 * all the newlines make it to the output buffer.
+				 */ if (val === 10) tty.output.push(val);
+				return originalPutChar(tty, val);
+			};
+		},
+		onHeaders: function (chunk) {
+			if (Module['onHeaders']) {
+				Module['onHeaders'](chunk);
+				return;
+			}
+			console.log('headers', {
+				chunk,
+			});
+		},
+		onStdout: function (chunk) {
+			if (Module['onStdout']) {
+				Module['onStdout'](chunk);
+				return;
+			}
+			if (ENVIRONMENT_IS_NODE) {
+				process.stdout.write(chunk);
+			} else {
+				console.log('stdout', {
+					chunk,
+				});
+			}
+		},
+		onStderr: function (chunk) {
+			if (Module['onStderr']) {
+				Module['onStderr'](chunk);
+				return;
+			}
+			if (ENVIRONMENT_IS_NODE) {
+				process.stderr.write(chunk);
+			} else {
+				console.warn('stderr', {
+					chunk,
+				});
+			}
+		},
+		getAllWebSockets: function (sock) {
+			const webSockets = new Set();
+			if (sock.server) {
+				sock.server.clients.forEach((ws) => {
+					webSockets.add(ws);
+				});
+			}
+			for (const peer of PHPWASM.getAllPeers(sock)) {
+				webSockets.add(peer.socket);
+			}
+			return Array.from(webSockets);
+		},
+		getAllPeers: function (sock) {
+			const peers = new Set();
+			if (sock.server) {
+				sock.pending
+					.filter((pending) => pending.peers)
+					.forEach((pending) => {
+						for (const peer of Object.values(pending.peers)) {
+							peers.add(peer);
+						}
+					});
+			}
+			if (sock.peers) {
+				for (const peer of Object.values(sock.peers)) {
+					peers.add(peer);
+				}
+			}
+			return Array.from(peers);
+		},
+		awaitData: function (ws) {
+			return PHPWASM.awaitEvent(ws, 'message');
+		},
+		awaitConnection: function (ws) {
+			if (ws.OPEN === ws.readyState) {
+				return [Promise.resolve(), PHPWASM.noop];
+			}
+			return PHPWASM.awaitEvent(ws, 'open');
+		},
+		awaitClose: function (ws) {
+			if ([ws.CLOSING, ws.CLOSED].includes(ws.readyState)) {
+				return [Promise.resolve(), PHPWASM.noop];
+			}
+			return PHPWASM.awaitEvent(ws, 'close');
+		},
+		awaitError: function (ws) {
+			if ([ws.CLOSING, ws.CLOSED].includes(ws.readyState)) {
+				return [Promise.resolve(), PHPWASM.noop];
+			}
+			return PHPWASM.awaitEvent(ws, 'error');
+		},
+		awaitEvent: function (ws, event) {
+			let resolve;
+			const listener = () => {
+				resolve();
+			};
+			const promise = new Promise(function (_resolve) {
+				resolve = _resolve;
+				ws.once(event, listener);
+			});
+			const cancel = () => {
+				ws.removeListener(event, listener);
+				// Rejecting the promises bubbles up and kills the entire
+				// node process. Let's resolve them on the next tick instead
+				// to give the caller some space to unbind any handlers.
+				setTimeout(resolve);
+			};
+			return [promise, cancel];
+		},
+		noop: function () {},
+		spawnProcess: function (command, args, options) {
+			if (Module['spawnProcess']) {
+				const spawnedPromise = Module['spawnProcess'](
+					command,
+					args,
+					options
+				);
+				return Promise.resolve(spawnedPromise).then(function (spawned) {
+					if (!spawned || !spawned.on) {
+						throw new Error(
+							'spawnProcess() must return an EventEmitter but returned a different type.'
+						);
+					}
+					return spawned;
+				});
+			}
+			if (ENVIRONMENT_IS_NODE) {
+				return require('child_process').spawn(command, args, {
+					...options,
+					shell: true,
+					stdio: ['pipe', 'pipe', 'pipe'],
+					timeout: 100,
+				});
+			}
+			const e = new Error(
+				'popen(), proc_open() etc. are unsupported in the browser. Call php.setSpawnHandler() ' +
+					'and provide a callback to handle spawning processes, or disable a popen(), proc_open() ' +
+					'and similar functions via php.ini.'
+			);
+			e.code = 'SPAWN_UNSUPPORTED';
+			throw e;
+		},
+		shutdownSocket: function (socketd, how) {
+			// This implementation only supports websockets at the moment
+			const sock = getSocketFromFD(socketd);
+			const peer = Object.values(sock.peers)[0];
+			if (!peer) {
+				return -1;
+			}
+			try {
+				peer.socket.close();
+				SOCKFS.websocket_sock_ops.removePeer(sock, peer);
+				return 0;
+			} catch (e) {
+				console.log('Socket shutdown error', e);
+				return -1;
+			}
+		},
+	};
+
+	function _js_getpid() {
+		return PHPLoader.processId ?? 42;
+	}
+
+	function _js_wasm_trace(format, ...args) {
+		if (PHPLoader.trace instanceof Function) {
+			PHPLoader.trace(_js_getpid(), format, ...args);
+		}
+	}
+
+	function _fd_close(fd) {
+		_js_wasm_trace('fd_close(%d)', fd);
+		const [vfsPath, pathResolutionErrno] = locking.get_vfs_path_from_fd(fd);
+		if (pathResolutionErrno !== 0) {
+			_js_wasm_trace(
+				'fd_close(%d) get_vfs_path_from_fd error %d',
+				fd,
+				pathResolutionErrno
+			);
+			return -ERRNO_CODES.EBADF;
+		}
+		const result = _builtin_fd_close(fd);
+		if (result === 0 && locking.maybeLockedFds.has(fd)) {
+			const nativeFilePath =
+				locking.get_native_path_from_vfs_path(vfsPath);
+			return PHPLoader.fileLockManager
+				.releaseLocksForProcessFd(
+					PHPLoader.processId,
+					fd,
+					nativeFilePath
+				)
+				.then(() => {
+					_js_wasm_trace('fd_close(%d) release locks success', fd);
+				})
+				.catch((e) => {
+					_js_wasm_trace("fd_close(%d) error '%s'", fd, e);
+				})
+				.then(() => {
+					_js_wasm_trace('fd_close(%d) result %d', fd, result);
+					return result;
+				})
+				.finally(() => {
+					locking.maybeLockedFds.delete(fd);
+				});
+		} else {
+			_js_wasm_trace('fd_close(%d) result %d', fd, result);
+			return result;
+		}
+	}
+
+	function _builtin_fd_close(fd) {
+		try {
+			var stream = SYSCALLS.getStreamFromFD(fd);
+			FS.close(stream);
+			return 0;
+		} catch (e) {
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return e.errno;
+		}
+	}
+
+	function _builtin_fcntl64(fd, cmd, varargs) {
 		SYSCALLS.varargs = varargs;
 		try {
 			var stream = SYSCALLS.getStreamFromFD(fd);
@@ -5264,6 +5617,439 @@ export function init(RuntimeName, PHPLoader) {
 		}
 	}
 
+	var locking = {
+		maybeLockedFds: new Set(),
+		F_RDLCK: 0,
+		F_WRLCK: 1,
+		F_UNLCK: 2,
+		lockStateToFcntl: {
+			shared: 0,
+			exclusive: 1,
+			unlocked: 2,
+		},
+		fcntlToLockState: {
+			0: 'shared',
+			1: 'exclusive',
+			2: 'unlocked',
+		},
+		is_shared_fs_node(node) {
+			if (node?.isSharedFS) {
+				return true;
+			}
+			// Handle PROXYFS nodes which wrap other nodes.
+			if (!node?.mount?.opts?.fs?.lookupPath) {
+				return false;
+			}
+			const vfsPath = NODEFS.realPath(node);
+			const underlyingNode = node.mount.opts.fs.lookupPath(vfsPath)?.node;
+			return !!underlyingNode?.isSharedFS;
+		},
+		is_path_to_shared_fs(path) {
+			const { node } = FS.lookupPath(path);
+			return locking.is_shared_fs_node(node);
+		},
+		get_fd_access_mode(fd) {
+			const emscripten_F_GETFL = Number('3');
+			const emscripten_O_ACCMODE = Number('2097155');
+			return (
+				_builtin_fcntl64(fd, emscripten_F_GETFL) & emscripten_O_ACCMODE
+			);
+		},
+		get_vfs_path_from_fd(fd) {
+			try {
+				return [FS.readlink(`/proc/self/fd/${fd}`), 0];
+			} catch (error) {
+				return [null, ERRNO_CODES.EBADF];
+			}
+		},
+		get_native_path_from_vfs_path(vfsPath) {
+			const { node } = FS.lookupPath(vfsPath);
+			return NODEFS.realPath(node);
+		},
+		check_lock_params(fd, l_type) {
+			const emscripten_O_RDONLY = Number('0');
+			const emscripten_O_WRONLY = Number('1');
+			const accessMode = locking.get_fd_access_mode(fd);
+			if (
+				(l_type === locking.F_WRLCK &&
+					accessMode === emscripten_O_RDONLY) ||
+				(l_type === locking.F_RDLCK &&
+					accessMode === emscripten_O_WRONLY)
+			) {
+				return ERRNO_CODES.EBADF;
+			}
+			return 0;
+		},
+	};
+
+	async function ___syscall_fcntl64(fd, cmd, varargs) {
+		// Necessary to use varargs accessor
+		SYSCALLS.varargs = varargs;
+		// These constants are replaced by Emscripten during the build process
+		const emscripten_F_GETLK = Number('12');
+		const emscripten_F_SETLK = Number('13');
+		const emscripten_F_SETLKW = Number('14');
+		const emscripten_SEEK_SET = Number('0');
+		// NOTE: With the exception of l_type, these offsets are not exposed to
+		// JS by Emscripten, so we hardcode them here.
+		const emscripten_flock_l_type_offset = 0;
+		const emscripten_flock_l_whence_offset = 2;
+		const emscripten_flock_l_start_offset = 8;
+		const emscripten_flock_l_len_offset = 16;
+		const emscripten_flock_l_pid_offset = 24;
+		/**
+		 * Read the flock struct at the given address.
+		 *
+		 * @param {bigint} flockStructAddress - the address of the flock struct
+		 * @returns the flock struct
+		 */ function read_flock_struct(flockStructAddress) {
+			/*
+			 * NOTE: Since we are using HEAP<WORD_SIZE> vars like HEAP16 and HEAP64,
+			 * we need to adjust offsets to address the word size of each HEAP.
+			 *
+			 * For example, an offset of 64 bytes is the following for each HEAP:
+			 * - HEAP8: 64  (the 64th byte)
+			 * - HEAP16: 32 (the 32nd 16-bit word)
+			 * - HEAP32: 16 (the 16th 32-bit word)
+			 * - HEAP64: 8  (the 8th 64-bit word)
+			 *
+			 * We get a word offset by dividing the byte offset by the word size.
+			 */ return {
+				l_type: HEAP16[ // Shift right by 1 to divide by 2^1.
+					(flockStructAddress + emscripten_flock_l_type_offset) >> 1
+				],
+				l_whence:
+					HEAP16[ // Shift right by 1 to divide by 2^1.
+						(flockStructAddress +
+							emscripten_flock_l_whence_offset) >>
+							1
+					],
+				l_start:
+					HEAP64[ // Shift right by 3 to divide by 2^3.
+						(flockStructAddress +
+							emscripten_flock_l_start_offset) >>
+							3
+					],
+				l_len: HEAP64[ // Shift right by 3 to divide by 2^3.
+					(flockStructAddress + emscripten_flock_l_len_offset) >> 3
+				],
+				l_pid: HEAP32[ // Shift right by 2 to divide by 2^2.
+					(flockStructAddress + emscripten_flock_l_pid_offset) >> 2
+				],
+			};
+		}
+		/**
+		 * Update the flock struct at the given address with the given fields.
+		 *
+		 * @param {bigint} flockStructAddress - the address of the flock struct
+		 * @param {object} fields - the fields to update
+		 */ function update_flock_struct(flockStructAddress, fields) {
+			/*
+			 * NOTE: Since we are using HEAP<WORD_SIZE> vars like HEAP16 and HEAP64,
+			 * we need to adjust offsets to address the word size of each HEAP.
+			 *
+			 * For example, an offset of 64 bytes is the following for each HEAP:
+			 * - HEAP8: 64  (the 64th byte)
+			 * - HEAP16: 32 (the 32nd 16-bit word)
+			 * - HEAP32: 16 (the 16th 32-bit word)
+			 * - HEAP64: 8  (the 8th 64-bit word)
+			 *
+			 * We get a word offset by dividing the byte offset by the word size.
+			 */ if (fields.l_type !== undefined) {
+				HEAP16[ // Shift right by 1 to divide by 2^1.
+					(flockStructAddress + emscripten_flock_l_type_offset) >> 1
+				] = fields.l_type;
+			}
+			if (fields.l_whence !== undefined) {
+				HEAP16[ // Shift right by 1 to divide by 2^1.
+					(flockStructAddress + emscripten_flock_l_whence_offset) >> 1
+				] = fields.l_whence;
+			}
+			if (fields.l_start !== undefined) {
+				HEAP64[ // Shift right by 3 to divide by 2^3.
+					(flockStructAddress + emscripten_flock_l_start_offset) >> 3
+				] = fields.l_start;
+			}
+			if (fields.l_len !== undefined) {
+				HEAP64[ // Shift right by 3 to divide by 2^3.
+					(flockStructAddress + emscripten_flock_l_len_offset) >> 3
+				] = fields.l_len;
+			}
+			if (fields.l_pid !== undefined) {
+				HEAP32[ // Shift right by 2 to divide by 2^2.
+					(flockStructAddress + emscripten_flock_l_pid_offset) >> 2
+				] = fields.l_pid;
+			}
+		}
+		/**
+		 * Resolve the base address of the range depending on the whence and start offset.
+		 *
+		 * @param {number} fd - the file descriptor
+		 * @param {number} whence - what the start offset is relative to
+		 * @param {bigint} startOffset - the offset from the whence
+		 * @returns The resolved offset and the errno. If there is an error,
+		 *          the resolved offset is null, and the errno is non-zero.
+		 */ function get_base_address(fd, whence, startOffset) {
+			let baseAddress;
+			switch (whence) {
+				case emscripten_SEEK_SET:
+					baseAddress = 0n;
+					break;
+
+				case emscripten_SEEK_CUR:
+					baseAddress = FS.lseek(fd, 0, whence);
+					break;
+
+				case emscripten_SEEK_END:
+					baseAddress = _wasm_get_end_offset(fd);
+					break;
+
+				default:
+					return [null, ERRNO_CODES.EINVAL];
+			}
+			if (baseAddress == -1) {
+				// We cannot resolve the offset within the file.
+				// Let's treat this as a problem with the file descriptor.
+				return [null, ERRNO_CODES.EBADF];
+			}
+			const resolvedOffset = baseAddress + startOffset;
+			if (resolvedOffset < 0) {
+				// This is not a valid offset. Report args as invalid.
+				return [null, ERRNO_CODES.EINVAL];
+			}
+			return [resolvedOffset, 0];
+		}
+		const pid = PHPLoader.processId;
+		switch (cmd) {
+			case emscripten_F_GETLK: {
+				_js_wasm_trace('fcntl(%d, F_GETLK)', fd);
+				let vfsPath;
+				let errno;
+				[vfsPath, errno] = locking.get_vfs_path_from_fd(fd);
+				if (errno !== 0) {
+					_js_wasm_trace(
+						'fcntl(%d, F_GETLK) %s get_vfs_path_from_fd errno %d',
+						fd,
+						vfsPath,
+						errno
+					);
+					return -ERRNO_CODES.EBADF;
+				}
+				if (!locking.is_path_to_shared_fs(vfsPath)) {
+					_js_wasm_trace(
+						"fcntl(%d, F_GETLK) locking is not implemented for non-NodeFS path '%s'",
+						fd,
+						vfsPath
+					);
+					// If not a NodeFS path, we can't lock it.
+					// Default to succeeding as Emscripten does.
+					update_flock_struct(flockStructAddr, {
+						l_type: F_UNLCK,
+					});
+					return 0;
+				}
+				const flockStructAddr = syscallGetVarargP();
+				const flockStruct = read_flock_struct(flockStructAddr);
+				if (!(flockStruct.l_type in locking.fcntlToLockState)) {
+					return -ERRNO_CODES.EINVAL;
+				}
+				errno = locking.check_lock_params(fd, flockStruct.l_type);
+				if (errno !== 0) {
+					_js_wasm_trace(
+						'fcntl(%d, F_GETLK) %s check_lock_params errno %d',
+						fd,
+						vfsPath,
+						errno
+					);
+					return -ERRNO_CODES.EINVAL;
+				}
+				const requestedLockType =
+					locking.fcntlToLockState[flockStruct.l_type];
+				let absoluteStartOffset;
+				[absoluteStartOffset, errno] = get_base_address(
+					fd,
+					flockStruct.l_whence,
+					flockStruct.l_start
+				);
+				if (errno !== 0) {
+					_js_wasm_trace(
+						'fcntl(%d, F_GETLK) %s get_base_address errno %d',
+						fd,
+						vfsPath,
+						errno
+					);
+					return -ERRNO_CODES.EINVAL;
+				}
+				const nativeFilePath =
+					locking.get_native_path_from_vfs_path(vfsPath);
+				return PHPLoader.fileLockManager
+					.findFirstConflictingByteRangeLock(nativeFilePath, {
+						type: requestedLockType,
+						start: absoluteStartOffset,
+						end: absoluteStartOffset + flockStruct.l_len,
+						pid,
+					})
+					.then((conflictingLock) => {
+						if (conflictingLock === undefined) {
+							_js_wasm_trace(
+								'fcntl(%d, F_GETLK) %s findFirstConflictingByteRangeLock type=unlocked start=0x%x end=0x%x',
+								fd,
+								vfsPath,
+								absoluteStartOffset,
+								absoluteStartOffset + flockStruct.l_len
+							);
+							update_flock_struct(flockStructAddr, {
+								l_type: F_UNLCK,
+							});
+							return 0;
+						}
+						_js_wasm_trace(
+							'fcntl(%d, F_GETLK) %s findFirstConflictingByteRangeLock type=%s start=0x%x end=0x%x conflictingLock %d',
+							fd,
+							vfsPath,
+							conflictingLock.type,
+							conflictingLock.start,
+							conflictingLock.end,
+							conflictingLock.pid
+						);
+						const fcntlLockState =
+							locking.lockStateToFcntl[conflictingLock.type];
+						update_flock_struct(flockStructAddr, {
+							l_type: fcntlLockState,
+							l_whence: emscripten_SEEK_SET,
+							l_start: conflictingLock.start,
+							l_len: conflictingLock.end - conflictingLock.start,
+							l_pid: conflictingLock.pid,
+						});
+						return 0;
+					})
+					.catch((e) => {
+						_js_wasm_trace(
+							'fcntl(%d, F_GETLK) %s findFirstConflictingByteRangeLock error %s',
+							fd,
+							vfsPath,
+							e
+						);
+						return -ERRNO_CODES.EINVAL;
+					});
+			}
+
+			case emscripten_F_SETLK: {
+				_js_wasm_trace('fcntl(%d, F_SETLK)', fd);
+				let vfsPath;
+				let errno;
+				[vfsPath, errno] = locking.get_vfs_path_from_fd(fd);
+				if (errno !== 0) {
+					_js_wasm_trace(
+						'fcntl(%d, F_SETLK) %s get_vfs_path_from_fd errno %d',
+						fd,
+						vfsPath,
+						errno
+					);
+					return -errno;
+				}
+				if (!locking.is_path_to_shared_fs(vfsPath)) {
+					_js_wasm_trace(
+						'fcntl(%d, F_SETLK) locking is not implemented for non-NodeFS path %s',
+						fd,
+						vfsPath
+					);
+					// If not a NodeFS path, we can't lock it.
+					// Default to succeeding as Emscripten does.
+					return 0;
+				}
+				var flockStructAddr = syscallGetVarargP();
+				const flockStruct = read_flock_struct(flockStructAddr);
+				let absoluteStartOffset;
+				[absoluteStartOffset, errno] = get_base_address(
+					fd,
+					flockStruct.l_whence,
+					flockStruct.l_start
+				);
+				if (errno !== 0) {
+					_js_wasm_trace(
+						'fcntl(%d, F_SETLK) %s get_base_address errno %d',
+						fd,
+						vfsPath,
+						errno
+					);
+					return -errno;
+				}
+				if (!(flockStruct.l_type in locking.fcntlToLockState)) {
+					_js_wasm_trace(
+						'fcntl(%d, F_SETLK) %s invalid lock type %d',
+						fd,
+						vfsPath,
+						flockStruct.l_type
+					);
+					return -ERRNO_CODES.EINVAL;
+				}
+				errno = locking.check_lock_params(fd, flockStruct.l_type);
+				if (errno !== 0) {
+					_js_wasm_trace(
+						'fcntl(%d, F_SETLK) %s check_lock_params errno %d',
+						fd,
+						vfsPath,
+						errno
+					);
+					return -errno;
+				}
+				locking.maybeLockedFds.add(fd);
+				const requestedLockType =
+					locking.fcntlToLockState[flockStruct.l_type];
+				const rangeLock = {
+					type: requestedLockType,
+					start: absoluteStartOffset,
+					end: absoluteStartOffset + flockStruct.l_len,
+					pid,
+				};
+				const nativeFilePath =
+					locking.get_native_path_from_vfs_path(vfsPath);
+				_js_wasm_trace(
+					'fcntl(%d, F_SETLK) %s calling lockFileByteRange for range lock %s',
+					fd,
+					vfsPath,
+					rangeLock
+				);
+				return PHPLoader.fileLockManager
+					.lockFileByteRange(nativeFilePath, rangeLock)
+					.then((succeeded) => {
+						_js_wasm_trace(
+							'fcntl(%d, F_SETLK) %s lockFileByteRange returned %d for range lock %s',
+							fd,
+							vfsPath,
+							succeeded,
+							rangeLock
+						);
+						return succeeded ? 0 : -ERRNO_CODES.EAGAIN;
+					})
+					.catch((e) => {
+						_js_wasm_trace(
+							'fcntl(%d, F_SETLK) %s lockFileByteRange error %s for range lock %s',
+							fd,
+							vfsPath,
+							e,
+							rangeLock
+						);
+						return -ERRNO_CODES.EINVAL;
+					});
+			}
+
+			// @TODO: Implement waiting for lock
+			case emscripten_F_SETLKW: {
+				// We do not yet support the blocking form of flock().
+				// We respond with EDEADLK to indicate failure
+				// because it is a known errno for a failed F_SETLKW command.
+				return -ERRNO_CODES.EDEADLK;
+			}
+
+			default:
+				return _builtin_fcntl64(fd, cmd, varargs);
+		}
+	}
+
+	___syscall_fcntl64.isAsync = true;
+
 	function ___syscall_fdatasync(fd) {
 		try {
 			var stream = SYSCALLS.getStreamFromFD(fd);
@@ -5295,11 +6081,6 @@ export function init(RuntimeName, PHPLoader) {
 		}
 	}
 
-	var stringToUTF8 = (str, outPtr, maxBytesToWrite) =>
-		stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
-
-	Module['stringToUTF8'] = stringToUTF8;
-
 	function ___syscall_getcwd(buf, size) {
 		try {
 			if (size === 0) return -28;
@@ -6559,17 +7340,6 @@ export function init(RuntimeName, PHPLoader) {
 		return 0;
 	};
 
-	function _fd_close(fd) {
-		try {
-			var stream = SYSCALLS.getStreamFromFD(fd);
-			FS.close(stream);
-			return 0;
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return e.errno;
-		}
-	}
-
 	function _fd_fdstat_get(fd, pbuf) {
 		try {
 			var rightsBase = 0;
@@ -6806,312 +7576,125 @@ export function init(RuntimeName, PHPLoader) {
 					return -2;
 				}
 			}
-		}
-		if (addr != null) {
-			ai = allocaddrinfo(family, type, proto, node, addr, port);
-			HEAPU32[out >> 2] = ai;
-			return 0;
-		}
-		if (flags & 4) {
-			return -2;
-		}
-		// try as a hostname
-		// resolve the hostname to a temporary fake address
-		node = DNS.lookup_name(node);
-		addr = inetPton4(node);
-		if (family === 0) {
-			family = 2;
-		} else if (family === 10) {
-			addr = [0, 0, _htonl(65535), addr];
-		}
-		ai = allocaddrinfo(family, type, proto, null, addr, port);
-		HEAPU32[out >> 2] = ai;
-		return 0;
-	};
-
-	var _getnameinfo = (sa, salen, node, nodelen, serv, servlen, flags) => {
-		var info = readSockaddr(sa, salen);
-		if (info.errno) {
-			return -6;
-		}
-		var port = info.port;
-		var addr = info.addr;
-		var overflowed = false;
-		if (node && nodelen) {
-			var lookup;
-			if (flags & 1 || !(lookup = DNS.lookup_addr(addr))) {
-				if (flags & 8) {
-					return -2;
-				}
-			} else {
-				addr = lookup;
-			}
-			var numBytesWrittenExclNull = stringToUTF8(addr, node, nodelen);
-			if (numBytesWrittenExclNull + 1 >= nodelen) {
-				overflowed = true;
-			}
-		}
-		if (serv && servlen) {
-			port = '' + port;
-			var numBytesWrittenExclNull = stringToUTF8(port, serv, servlen);
-			if (numBytesWrittenExclNull + 1 >= servlen) {
-				overflowed = true;
-			}
-		}
-		if (overflowed) {
-			// Note: even when we overflow, getnameinfo() is specced to write out the truncated results.
-			return -12;
-		}
-		return 0;
-	};
-
-	var Protocols = {
-		list: [],
-		map: {},
-	};
-
-	var _setprotoent = (stayopen) => {
-		// void setprotoent(int stayopen);
-		// Allocate and populate a protoent structure given a name, protocol number and array of aliases
-		function allocprotoent(name, proto, aliases) {
-			// write name into buffer
-			var nameBuf = _malloc(name.length + 1);
-			stringToAscii(name, nameBuf);
-			// write aliases into buffer
-			var j = 0;
-			var length = aliases.length;
-			var aliasListBuf = _malloc((length + 1) * 4);
-			// Use length + 1 so we have space for the terminating NULL ptr.
-			for (var i = 0; i < length; i++, j += 4) {
-				var alias = aliases[i];
-				var aliasBuf = _malloc(alias.length + 1);
-				stringToAscii(alias, aliasBuf);
-				HEAPU32[(aliasListBuf + j) >> 2] = aliasBuf;
-			}
-			HEAPU32[(aliasListBuf + j) >> 2] = 0;
-			// Terminating NULL pointer.
-			// generate protoent
-			var pe = _malloc(12);
-			HEAPU32[pe >> 2] = nameBuf;
-			HEAPU32[(pe + 4) >> 2] = aliasListBuf;
-			HEAP32[(pe + 8) >> 2] = proto;
-			return pe;
-		}
-		// Populate the protocol 'database'. The entries are limited to tcp and udp, though it is fairly trivial
-		// to add extra entries from /etc/protocols if desired - though not sure if that'd actually be useful.
-		var list = Protocols.list;
-		var map = Protocols.map;
-		if (list.length === 0) {
-			var entry = allocprotoent('tcp', 6, ['TCP']);
-			list.push(entry);
-			map['tcp'] = map['6'] = entry;
-			entry = allocprotoent('udp', 17, ['UDP']);
-			list.push(entry);
-			map['udp'] = map['17'] = entry;
-		}
-		_setprotoent.index = 0;
-	};
-
-	var _getprotobyname = (name) => {
-		// struct protoent *getprotobyname(const char *);
-		name = UTF8ToString(name);
-		_setprotoent(true);
-		var result = Protocols.map[name];
-		return result;
-	};
-
-	var _getprotobynumber = (number) => {
-		// struct protoent *getprotobynumber(int proto);
-		_setprotoent(true);
-		var result = Protocols.map[number];
-		return result;
-	};
-
-	var stackAlloc = (sz) => __emscripten_stack_alloc(sz);
-
-	/** @suppress {duplicate } */ var stringToUTF8OnStack = (str) => {
-		var size = lengthBytesUTF8(str) + 1;
-		var ret = stackAlloc(size);
-		stringToUTF8(str, ret, size);
-		return ret;
-	};
-
-	var allocateUTF8OnStack = stringToUTF8OnStack;
-
-	var PHPWASM = {
-		init: function () {
-			// The /internal directory is required by the C module. It's where the
-			// stdout, stderr, and headers information are written for the JavaScript
-			// code to read later on.
-			FS.mkdir('/internal');
-			// The files from the shared directory are shared between all the
-			// PHP processes managed by PHPProcessManager.
-			FS.mkdir('/internal/shared');
-			// The files from the preload directory are preloaded using the
-			// auto_prepend_file php.ini directive.
-			FS.mkdir('/internal/shared/preload');
-			PHPWASM.EventEmitter = ENVIRONMENT_IS_NODE
-				? require('events').EventEmitter
-				: class EventEmitter {
-						constructor() {
-							this.listeners = {};
-						}
-						emit(eventName, data) {
-							if (this.listeners[eventName]) {
-								this.listeners[eventName].forEach(
-									(callback) => {
-										callback(data);
-									}
-								);
-							}
-						}
-						once(eventName, callback) {
-							const self = this;
-							function removedCallback() {
-								callback(...arguments);
-								self.removeListener(eventName, removedCallback);
-							}
-							this.on(eventName, removedCallback);
-						}
-						removeAllListeners(eventName) {
-							if (eventName) {
-								delete this.listeners[eventName];
-							} else {
-								this.listeners = {};
-							}
-						}
-						removeListener(eventName, callback) {
-							if (this.listeners[eventName]) {
-								const idx =
-									this.listeners[eventName].indexOf(callback);
-								if (idx !== -1) {
-									this.listeners[eventName].splice(idx, 1);
-								}
-							}
-						}
-				  };
-			PHPWASM.child_proc_by_fd = {};
-			PHPWASM.child_proc_by_pid = {};
-			PHPWASM.input_devices = {};
-		},
-		getAllWebSockets: function (sock) {
-			const webSockets = new Set();
-			if (sock.server) {
-				sock.server.clients.forEach((ws) => {
-					webSockets.add(ws);
-				});
-			}
-			for (const peer of PHPWASM.getAllPeers(sock)) {
-				webSockets.add(peer.socket);
-			}
-			return Array.from(webSockets);
-		},
-		getAllPeers: function (sock) {
-			const peers = new Set();
-			if (sock.server) {
-				sock.pending
-					.filter((pending) => pending.peers)
-					.forEach((pending) => {
-						for (const peer of Object.values(pending.peers)) {
-							peers.add(peer);
-						}
-					});
-			}
-			if (sock.peers) {
-				for (const peer of Object.values(sock.peers)) {
-					peers.add(peer);
-				}
-			}
-			return Array.from(peers);
-		},
-		awaitData: function (ws) {
-			return PHPWASM.awaitEvent(ws, 'message');
-		},
-		awaitConnection: function (ws) {
-			if (ws.OPEN === ws.readyState) {
-				return [Promise.resolve(), PHPWASM.noop];
-			}
-			return PHPWASM.awaitEvent(ws, 'open');
-		},
-		awaitClose: function (ws) {
-			if ([ws.CLOSING, ws.CLOSED].includes(ws.readyState)) {
-				return [Promise.resolve(), PHPWASM.noop];
-			}
-			return PHPWASM.awaitEvent(ws, 'close');
-		},
-		awaitError: function (ws) {
-			if ([ws.CLOSING, ws.CLOSED].includes(ws.readyState)) {
-				return [Promise.resolve(), PHPWASM.noop];
-			}
-			return PHPWASM.awaitEvent(ws, 'error');
-		},
-		awaitEvent: function (ws, event) {
-			let resolve;
-			const listener = () => {
-				resolve();
-			};
-			const promise = new Promise(function (_resolve) {
-				resolve = _resolve;
-				ws.once(event, listener);
-			});
-			const cancel = () => {
-				ws.removeListener(event, listener);
-				// Rejecting the promises bubbles up and kills the entire
-				// node process. Let's resolve them on the next tick instead
-				// to give the caller some space to unbind any handlers.
-				setTimeout(resolve);
-			};
-			return [promise, cancel];
-		},
-		noop: function () {},
-		spawnProcess: function (command, args, options) {
-			if (Module['spawnProcess']) {
-				const spawnedPromise = Module['spawnProcess'](
-					command,
-					args,
-					options
-				);
-				return Promise.resolve(spawnedPromise).then(function (spawned) {
-					if (!spawned || !spawned.on) {
-						throw new Error(
-							'spawnProcess() must return an EventEmitter but returned a different type.'
-						);
-					}
-					return spawned;
-				});
+		}
+		if (addr != null) {
+			ai = allocaddrinfo(family, type, proto, node, addr, port);
+			HEAPU32[out >> 2] = ai;
+			return 0;
+		}
+		if (flags & 4) {
+			return -2;
+		}
+		// try as a hostname
+		// resolve the hostname to a temporary fake address
+		node = DNS.lookup_name(node);
+		addr = inetPton4(node);
+		if (family === 0) {
+			family = 2;
+		} else if (family === 10) {
+			addr = [0, 0, _htonl(65535), addr];
+		}
+		ai = allocaddrinfo(family, type, proto, null, addr, port);
+		HEAPU32[out >> 2] = ai;
+		return 0;
+	};
+
+	var _getnameinfo = (sa, salen, node, nodelen, serv, servlen, flags) => {
+		var info = readSockaddr(sa, salen);
+		if (info.errno) {
+			return -6;
+		}
+		var port = info.port;
+		var addr = info.addr;
+		var overflowed = false;
+		if (node && nodelen) {
+			var lookup;
+			if (flags & 1 || !(lookup = DNS.lookup_addr(addr))) {
+				if (flags & 8) {
+					return -2;
+				}
+			} else {
+				addr = lookup;
 			}
-			if (ENVIRONMENT_IS_NODE) {
-				return require('child_process').spawn(command, args, {
-					...options,
-					shell: true,
-					stdio: ['pipe', 'pipe', 'pipe'],
-					timeout: 100,
-				});
+			var numBytesWrittenExclNull = stringToUTF8(addr, node, nodelen);
+			if (numBytesWrittenExclNull + 1 >= nodelen) {
+				overflowed = true;
 			}
-			const e = new Error(
-				'popen(), proc_open() etc. are unsupported in the browser. Call php.setSpawnHandler() ' +
-					'and provide a callback to handle spawning processes, or disable a popen(), proc_open() ' +
-					'and similar functions via php.ini.'
-			);
-			e.code = 'SPAWN_UNSUPPORTED';
-			throw e;
-		},
-		shutdownSocket: function (socketd, how) {
-			// This implementation only supports websockets at the moment
-			const sock = getSocketFromFD(socketd);
-			const peer = Object.values(sock.peers)[0];
-			if (!peer) {
-				return -1;
+		}
+		if (serv && servlen) {
+			port = '' + port;
+			var numBytesWrittenExclNull = stringToUTF8(port, serv, servlen);
+			if (numBytesWrittenExclNull + 1 >= servlen) {
+				overflowed = true;
 			}
-			try {
-				peer.socket.close();
-				SOCKFS.websocket_sock_ops.removePeer(sock, peer);
-				return 0;
-			} catch (e) {
-				console.log('Socket shutdown error', e);
-				return -1;
+		}
+		if (overflowed) {
+			// Note: even when we overflow, getnameinfo() is specced to write out the truncated results.
+			return -12;
+		}
+		return 0;
+	};
+
+	var Protocols = {
+		list: [],
+		map: {},
+	};
+
+	var _setprotoent = (stayopen) => {
+		// void setprotoent(int stayopen);
+		// Allocate and populate a protoent structure given a name, protocol number and array of aliases
+		function allocprotoent(name, proto, aliases) {
+			// write name into buffer
+			var nameBuf = _malloc(name.length + 1);
+			stringToAscii(name, nameBuf);
+			// write aliases into buffer
+			var j = 0;
+			var length = aliases.length;
+			var aliasListBuf = _malloc((length + 1) * 4);
+			// Use length + 1 so we have space for the terminating NULL ptr.
+			for (var i = 0; i < length; i++, j += 4) {
+				var alias = aliases[i];
+				var aliasBuf = _malloc(alias.length + 1);
+				stringToAscii(alias, aliasBuf);
+				HEAPU32[(aliasListBuf + j) >> 2] = aliasBuf;
 			}
-		},
+			HEAPU32[(aliasListBuf + j) >> 2] = 0;
+			// Terminating NULL pointer.
+			// generate protoent
+			var pe = _malloc(12);
+			HEAPU32[pe >> 2] = nameBuf;
+			HEAPU32[(pe + 4) >> 2] = aliasListBuf;
+			HEAP32[(pe + 8) >> 2] = proto;
+			return pe;
+		}
+		// Populate the protocol 'database'. The entries are limited to tcp and udp, though it is fairly trivial
+		// to add extra entries from /etc/protocols if desired - though not sure if that'd actually be useful.
+		var list = Protocols.list;
+		var map = Protocols.map;
+		if (list.length === 0) {
+			var entry = allocprotoent('tcp', 6, ['TCP']);
+			list.push(entry);
+			map['tcp'] = map['6'] = entry;
+			entry = allocprotoent('udp', 17, ['UDP']);
+			list.push(entry);
+			map['udp'] = map['17'] = entry;
+		}
+		_setprotoent.index = 0;
+	};
+
+	var _getprotobyname = (name) => {
+		// struct protoent *getprotobyname(const char *);
+		name = UTF8ToString(name);
+		_setprotoent(true);
+		var result = Protocols.map[name];
+		return result;
+	};
+
+	var _getprotobynumber = (number) => {
+		// struct protoent *getprotobynumber(int proto);
+		_setprotoent(true);
+		var result = Protocols.map[number];
+		return result;
 	};
 
 	function _js_create_input_device(deviceId) {
@@ -7149,6 +7732,98 @@ export function init(RuntimeName, PHPLoader) {
 		return allocateUTF8OnStack(devicePath);
 	}
 
+	async function _js_flock(fd, op) {
+		_js_wasm_trace('js_flock(%d, %d)', fd, op);
+		// Emscripten does not expose these constants to JS, so we hardcode them here.
+		// Based on
+		// https://github.com/emscripten-core/emscripten/blob/76860cc47cef67f5712a7a03a247bc1baabf7ba4/system/lib/libc/musl/include/sys/file.h#L7-L10
+		const emscripten_LOCK_SH = 1;
+		const emscripten_LOCK_EX = 2;
+		const emscripten_LOCK_NB = 4;
+		const emscripten_LOCK_UN = 8;
+		const flockToLockOpType = {
+			[emscripten_LOCK_SH]: 'shared',
+			[emscripten_LOCK_EX]: 'exclusive',
+			[emscripten_LOCK_UN]: 'unlocked',
+		};
+		let vfsPath;
+		let errno;
+		[vfsPath, errno] = locking.get_vfs_path_from_fd(fd);
+		if (errno !== 0) {
+			_js_wasm_trace(
+				'js_flock(%d, %d) get_vfs_path_from_fd errno %d',
+				fd,
+				op,
+				vfsPath,
+				errno
+			);
+			return -errno;
+		}
+		if (!locking.is_path_to_shared_fs(vfsPath)) {
+			_js_wasm_trace(
+				'flock(%d, %d) locking is not implemented for non-NodeFS path %s',
+				fd,
+				op,
+				vfsPath
+			);
+			// If not a NodeFS path, we can't lock it.
+			// Default to succeeding as Emscripten does.
+			return 0;
+		}
+		errno = locking.check_lock_params(fd, op);
+		if (errno !== 0) {
+			_js_wasm_trace(
+				'js_flock(%d, %d) check_lock_params errno %d',
+				fd,
+				op,
+				errno
+			);
+			return -errno;
+		}
+		// @TODO: Consider supporting blocking mode of flock()
+		if (op & (emscripten_LOCK_NB === 0)) {
+			_js_wasm_trace(
+				'js_flock(%d, %d) blocking mode of flock() is not implemented',
+				fd,
+				op
+			);
+			// We do not yet support the blocking form of flock().
+			// We respond with EINVAL to indicate failure
+			// because it is a known errno for a failed blocking flock().
+			return -ERRNO_CODES.EINVAL;
+		}
+		const maskedOp =
+			op & (emscripten_LOCK_SH | emscripten_LOCK_EX | emscripten_LOCK_UN);
+		const lockOpType = flockToLockOpType[maskedOp];
+		if (lockOpType === undefined) {
+			_js_wasm_trace(
+				'js_flock(%d, %d) invalid flock() operation',
+				fd,
+				op
+			);
+			return -ERRNO_CODES.EINVAL;
+		}
+		const nativeFilePath = locking.get_native_path_from_vfs_path(vfsPath);
+		const obtainedLock = await PHPLoader.fileLockManager.lockWholeFile(
+			nativeFilePath,
+			{
+				type: lockOpType,
+				pid: PHPLoader.processId,
+				fd,
+			}
+		);
+		_js_wasm_trace(
+			'js_flock(%d, %d) lockWholeFile %s returned %d',
+			fd,
+			op,
+			vfsPath,
+			obtainedLock
+		);
+		return obtainedLock ? 0 : -ERRNO_CODES.EWOULDBLOCK;
+	}
+
+	_js_flock.isAsync = true;
+
 	function _js_open_process(
 		command,
 		argsPtr,
@@ -7174,7 +7849,7 @@ export function init(RuntimeName, PHPLoader) {
 				argsArray.push(UTF8ToString(HEAPU32[charPointer >> 2]));
 			}
 		}
-		const cwdstr = cwdPtr ? UTF8ToString(cwdPtr) : null;
+		const cwdstr = cwdPtr ? UTF8ToString(cwdPtr) : FS.cwd();
 		let envObject = null;
 		if (envLength) {
 			envObject = {};
@@ -7247,6 +7922,15 @@ export function init(RuntimeName, PHPLoader) {
 				PHPWASM.child_proc_by_fd[ProcInfo.stderrParentFd] = ProcInfo;
 			PHPWASM.child_proc_by_pid[ProcInfo.pid] = ProcInfo;
 			cp.on('exit', function (code) {
+				for (const fd of [
+					// The child process exited. Let's clean up its output streams:
+					ProcInfo.stdoutChildFd,
+					ProcInfo.stderrChildFd,
+				]) {
+					if (FS.streams[fd] && !FS.isClosed(FS.streams[fd])) {
+						FS.close(FS.streams[fd]);
+					}
+				}
 				ProcInfo.exitCode = code;
 				ProcInfo.exited = true;
 				// Emit events for the wasm_poll_socket function.
@@ -7297,12 +7981,52 @@ export function init(RuntimeName, PHPLoader) {
 			 * listen to the 'exit' event.
 			 */ try {
 				await new Promise((resolve, reject) => {
-					cp.on('spawn', resolve);
-					cp.on('error', reject);
+					/**
+					 * There was no `await` between the `spawnProcess` call
+					 * and the `await` below so the process haven't had a chance
+					 * to run any of the exit-related callbacks yet.
+					 *
+					 * Good.
+					 *
+					 * Let's listen to all the lifecycle events and resolve
+					 * the promise when the process starts or immediately crashes.
+					 */ let resolved = false;
+					cp.on('spawn', () => {
+						if (resolved) return;
+						resolved = true;
+						resolve();
+					});
+					cp.on('error', (e) => {
+						if (resolved) return;
+						resolved = true;
+						reject(e);
+					});
+					cp.on('exit', function (code) {
+						if (resolved) return;
+						resolved = true;
+						if (code === 0) {
+							resolve();
+						} else {
+							reject(
+								new Error(`Process exited with code ${code}`)
+							);
+						}
+					});
+					/**
+					 * If the process haven't even started after 5 seconds, something
+					 * is wrong. Perhaps we're missing an event listener, or perhaps
+					 * the `spawnProcess` implementation failed to dispatch the relevant
+					 * event. Either way, let's crash to avoid blocking the proc_open()
+					 * call indefinitely.
+					 */ setTimeout(() => {
+						if (resolved) return;
+						resolved = true;
+						reject(new Error('Process timed out'));
+					}, 5e3);
 				});
 			} catch (e) {
 				console.error(e);
-				wakeUp(1);
+				wakeUp(ProcInfo.pid);
 				return;
 			}
 			// Now we want to pass data from the STDIN source supplied by PHP
@@ -7372,6 +8096,21 @@ export function init(RuntimeName, PHPLoader) {
 		return 0;
 	}
 
+	var _js_release_file_locks = async function js_release_file_locks() {
+		_js_wasm_trace('js_release_file_locks()');
+		const pid = PHPLoader.processId;
+		return await PHPLoader.fileLockManager
+			.releaseLocksForProcess(pid)
+			.then(() => {
+				_js_wasm_trace('js_release_file_locks succeeded');
+			})
+			.catch((e) => {
+				_js_wasm_trace('js_release_file_locks error %s', e);
+			});
+	};
+
+	_js_release_file_locks.isAsync = true;
+
 	function _js_waitpid(pid, exitCodePtr) {
 		if (!PHPWASM.child_proc_by_pid[pid]) {
 			return -1;
@@ -8008,14 +8747,7 @@ export function init(RuntimeName, PHPLoader) {
 			const POLLNVAL = 32;
 			return returnCallback((wakeUp) => {
 				const polls = [];
-				if (socketd in PHPWASM.child_proc_by_fd) {
-					const procInfo = PHPWASM.child_proc_by_fd[socketd];
-					if (procInfo.exited) {
-						wakeUp(0);
-						return;
-					}
-					polls.push(PHPWASM.awaitEvent(procInfo.stdout, 'data'));
-				} else if (FS.isSocket(FS.getStream(socketd)?.node.mode)) {
+				if (FS.isSocket(FS.getStream(socketd)?.node.mode)) {
 					const sock = getSocketFromFD(socketd);
 					if (!sock) {
 						wakeUp(0);
@@ -8049,7 +8781,12 @@ export function init(RuntimeName, PHPLoader) {
 							polls.push(PHPWASM.awaitConnection(ws));
 							lookingFor.add('POLLOUT');
 						}
-						if (events & POLLHUP) {
+						if (
+							events & POLLHUP ||
+							events & POLLIN ||
+							events & POLLOUT ||
+							events & POLLERR
+						) {
 							polls.push(PHPWASM.awaitClose(ws));
 							lookingFor.add('POLLHUP');
 						}
@@ -8058,6 +8795,13 @@ export function init(RuntimeName, PHPLoader) {
 							lookingFor.add('POLLERR');
 						}
 					}
+				} else if (socketd in PHPWASM.child_proc_by_fd) {
+					const procInfo = PHPWASM.child_proc_by_fd[socketd];
+					if (procInfo.exited) {
+						wakeUp(0);
+						return;
+					}
+					polls.push(PHPWASM.awaitEvent(procInfo.stdout, 'data'));
 				} else {
 					setTimeout(function () {
 						wakeUp(1);
@@ -8289,9 +9033,13 @@ export function init(RuntimeName, PHPLoader) {
 		/** @export */ getprotobyname: _getprotobyname,
 		/** @export */ getprotobynumber: _getprotobynumber,
 		/** @export */ js_create_input_device: _js_create_input_device,
+		/** @export */ js_flock: _js_flock,
+		/** @export */ js_getpid: _js_getpid,
 		/** @export */ js_open_process: _js_open_process,
 		/** @export */ js_process_status: _js_process_status,
+		/** @export */ js_release_file_locks: _js_release_file_locks,
 		/** @export */ js_waitpid: _js_waitpid,
+		/** @export */ js_wasm_trace: _js_wasm_trace,
 		/** @export */ proc_exit: _proc_exit,
 		/** @export */ strptime: _strptime,
 		/** @export */ wasm_close: _wasm_close,
@@ -8307,6 +9055,9 @@ export function init(RuntimeName, PHPLoader) {
 
 	var _malloc = (a0) => (_malloc = wasmExports['malloc'])(a0);
 
+	var _getpid = (Module['_getpid'] = () =>
+		(_getpid = Module['_getpid'] = wasmExports['getpid'])());
+
 	var _wasm_sleep = (Module['_wasm_sleep'] = (a0) =>
 		(_wasm_sleep = Module['_wasm_sleep'] = wasmExports['wasm_sleep'])(a0));
 
@@ -8325,6 +9076,9 @@ export function init(RuntimeName, PHPLoader) {
 
 	var _fflush = (a0) => (_fflush = wasmExports['fflush'])(a0);
 
+	var _flock = (Module['_flock'] = (a0, a1) =>
+		(_flock = Module['_flock'] = wasmExports['flock'])(a0, a1));
+
 	var _wasm_popen = (Module['_wasm_popen'] = (a0, a1) =>
 		(_wasm_popen = Module['_wasm_popen'] = wasmExports['wasm_popen'])(
 			a0,
@@ -8343,13 +9097,6 @@ export function init(RuntimeName, PHPLoader) {
 		(___wrap_select = Module['___wrap_select'] =
 			wasmExports['__wrap_select'])(a0, a1, a2, a3, a4));
 
-	var _wasm_add_cli_arg = (Module['_wasm_add_cli_arg'] = (a0) =>
-		(_wasm_add_cli_arg = Module['_wasm_add_cli_arg'] =
-			wasmExports['wasm_add_cli_arg'])(a0));
-
-	var _run_cli = (Module['_run_cli'] = () =>
-		(_run_cli = Module['_run_cli'] = wasmExports['run_cli'])());
-
 	var _wasm_set_sapi_name = (Module['_wasm_set_sapi_name'] = (a0) =>
 		(_wasm_set_sapi_name = Module['_wasm_set_sapi_name'] =
 			wasmExports['wasm_set_sapi_name'])(a0));
@@ -8358,6 +9105,13 @@ export function init(RuntimeName, PHPLoader) {
 		(_wasm_set_phpini_path = Module['_wasm_set_phpini_path'] =
 			wasmExports['wasm_set_phpini_path'])(a0));
 
+	var _wasm_add_cli_arg = (Module['_wasm_add_cli_arg'] = (a0) =>
+		(_wasm_add_cli_arg = Module['_wasm_add_cli_arg'] =
+			wasmExports['wasm_add_cli_arg'])(a0));
+
+	var _run_cli = (Module['_run_cli'] = () =>
+		(_run_cli = Module['_run_cli'] = wasmExports['run_cli'])());
+
 	var _wasm_add_SERVER_entry = (Module['_wasm_add_SERVER_entry'] = (a0, a1) =>
 		(_wasm_add_SERVER_entry = Module['_wasm_add_SERVER_entry'] =
 			wasmExports['wasm_add_SERVER_entry'])(a0, a1));
@@ -8430,6 +9184,16 @@ export function init(RuntimeName, PHPLoader) {
 	var _wasm_free = (Module['_wasm_free'] = (a0) =>
 		(_wasm_free = Module['_wasm_free'] = wasmExports['wasm_free'])(a0));
 
+	var _wasm_get_end_offset = (Module['_wasm_get_end_offset'] = (a0) =>
+		(_wasm_get_end_offset = Module['_wasm_get_end_offset'] =
+			wasmExports['wasm_get_end_offset'])(a0));
+
+	var _wasm_trace = (Module['_wasm_trace'] = (a0, a1) =>
+		(_wasm_trace = Module['_wasm_trace'] = wasmExports['wasm_trace'])(
+			a0,
+			a1
+		));
+
 	var ___funcs_on_exit = () =>
 		(___funcs_on_exit = wasmExports['__funcs_on_exit'])();
 
@@ -8583,6 +9347,32 @@ export function init(RuntimeName, PHPLoader) {
 	PHPLoader['free'] =
 		typeof _free === 'function' ? _free : PHPLoader['_wasm_free'];
 
+	if (typeof NODEFS === 'object') {
+		// We override NODEFS.createNode() to add an `isSharedFS` flag to all NODEFS
+		// nodes. This way we can tell whether file-locking is needed and possible
+		// for an FS node, even if wrapped with PROXYFS.
+		const originalCreateNode = NODEFS.createNode;
+		NODEFS.createNode = function createNodeWithSharedFlag() {
+			const node = originalCreateNode.apply(NODEFS, arguments);
+			node.isSharedFS = true;
+			return node;
+		};
+
+		var originalHashAddNode = FS.hashAddNode;
+		FS.hashAddNode = function hashAddNodeIfNotSharedFS(node) {
+			if (
+				typeof locking === 'object' &&
+				locking?.is_shared_fs_node(node)
+			) {
+				// Avoid caching shared VFS nodes so multiple instances
+				// can access the same underlying filesystem without
+				// conflicting caches.
+				return;
+			}
+			return originalHashAddNode.apply(FS, arguments);
+		};
+	}
+
 	return PHPLoader;
 
 	// Close the opening bracket from esm-prefix.js: