@php-wasm/node 1.1.3 → 1.1.4

package/jspi/php_8_1.js

@@ -8,7 +8,7 @@ import path from 'path';
 
 const dependencyFilename = path.join(__dirname, '8_1_23', 'php_8_1.wasm');
 export { dependencyFilename };
-export const dependenciesTotalSize = 17183362;
+export const dependenciesTotalSize = 17185468;
 export function init(RuntimeName, PHPLoader) {
 	// The rest of the code comes from the built php.js file and esm-suffix.js
 	// include: shell.js
@@ -5227,734 +5227,850 @@ export function init(RuntimeName, PHPLoader) {
 
 	var syscallGetVarargP = syscallGetVarargI;
 
-	function ___syscall_fcntl64(fd, cmd, varargs) {
-		SYSCALLS.varargs = varargs;
-		try {
-			var stream = SYSCALLS.getStreamFromFD(fd);
-			switch (cmd) {
-				case 0: {
-					var arg = syscallGetVarargI();
-					if (arg < 0) {
-						return -28;
-					}
-					while (FS.streams[arg]) {
-						arg++;
-					}
-					var newStream;
-					newStream = FS.dupStream(stream, arg);
-					return newStream.fd;
-				}
-
-				case 1:
-				case 2:
-					return 0;
-
-				// FD_CLOEXEC makes no sense for a single process.
-				case 3:
-					return stream.flags;
-
-				case 4: {
-					var arg = syscallGetVarargI();
-					stream.flags |= arg;
-					return 0;
-				}
-
-				case 12: {
-					var arg = syscallGetVarargP();
-					var offset = 0;
-					// We're always unlocked.
-					HEAP16[(arg + offset) >> 1] = 2;
-					return 0;
-				}
-
-				case 13:
-				case 14:
-					// Pretend that the locking is successful. These are process-level locks,
-					// and Emscripten programs are a single process. If we supported linking a
-					// filesystem between programs, we'd need to do more here.
-					// See https://github.com/emscripten-core/emscripten/issues/23697
-					return 0;
-			}
-			return -28;
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return -e.errno;
-		}
-	}
-
-	function ___syscall_fdatasync(fd) {
-		try {
-			var stream = SYSCALLS.getStreamFromFD(fd);
-			return 0;
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return -e.errno;
-		}
-	}
-
-	function ___syscall_fstat64(fd, buf) {
-		try {
-			return SYSCALLS.writeStat(buf, FS.fstat(fd));
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return -e.errno;
-		}
-	}
-
-	function ___syscall_ftruncate64(fd, length) {
-		length = bigintToI53Checked(length);
-		try {
-			if (isNaN(length)) return 61;
-			FS.ftruncate(fd, length);
-			return 0;
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return -e.errno;
-		}
-	}
-
 	var stringToUTF8 = (str, outPtr, maxBytesToWrite) =>
 		stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
 
 	Module['stringToUTF8'] = stringToUTF8;
 
-	function ___syscall_getcwd(buf, size) {
-		try {
-			if (size === 0) return -28;
-			var cwd = FS.cwd();
-			var cwdLengthInBytes = lengthBytesUTF8(cwd) + 1;
-			if (size < cwdLengthInBytes) return -68;
-			stringToUTF8(cwd, buf, size);
-			return cwdLengthInBytes;
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return -e.errno;
-		}
-	}
-
-	function ___syscall_getdents64(fd, dirp, count) {
-		try {
-			var stream = SYSCALLS.getStreamFromFD(fd);
-			stream.getdents ||= FS.readdir(stream.path);
-			var struct_size = 280;
-			var pos = 0;
-			var off = FS.llseek(stream, 0, 1);
-			var startIdx = Math.floor(off / struct_size);
-			var endIdx = Math.min(
-				stream.getdents.length,
-				startIdx + Math.floor(count / struct_size)
-			);
-			for (var idx = startIdx; idx < endIdx; idx++) {
-				var id;
-				var type;
-				var name = stream.getdents[idx];
-				if (name === '.') {
-					id = stream.node.id;
-					type = 4;
-				} else if (name === '..') {
-					var lookup = FS.lookupPath(stream.path, {
-						parent: true,
-					});
-					id = lookup.node.id;
-					type = 4;
-				} else {
-					var child;
-					try {
-						child = FS.lookupNode(stream.node, name);
-					} catch (e) {
-						// If the entry is not a directory, file, or symlink, nodefs
-						// lookupNode will raise EINVAL. Skip these and continue.
-						if (e?.errno === 28) {
-							continue;
-						}
-						throw e;
-					}
-					id = child.id;
-					type = FS.isChrdev(child.mode)
-						? 2 // DT_CHR, character device.
-						: FS.isDir(child.mode)
-						? 4 // DT_DIR, directory.
-						: FS.isLink(child.mode)
-						? 10 // DT_LNK, symbolic link.
-						: 8;
-				}
-				HEAP64[(dirp + pos) >> 3] = BigInt(id);
-				HEAP64[(dirp + pos + 8) >> 3] = BigInt((idx + 1) * struct_size);
-				HEAP16[(dirp + pos + 16) >> 1] = 280;
-				HEAP8[dirp + pos + 18] = type;
-				stringToUTF8(name, dirp + pos + 19, 256);
-				pos += struct_size;
-			}
-			FS.llseek(stream, idx * struct_size, 0);
-			return pos;
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return -e.errno;
-		}
-	}
-
-	function ___syscall_getpeername(fd, addr, addrlen, d1, d2, d3) {
-		try {
-			var sock = getSocketFromFD(fd);
-			if (!sock.daddr) {
-				return -53;
-			}
-			var errno = writeSockaddr(
-				addr,
-				sock.family,
-				DNS.lookup_name(sock.daddr),
-				sock.dport,
-				addrlen
-			);
-			return 0;
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return -e.errno;
-		}
-	}
-
-	function ___syscall_getsockname(fd, addr, addrlen, d1, d2, d3) {
-		try {
-			var sock = getSocketFromFD(fd);
-			// TODO: sock.saddr should never be undefined, see TODO in websocket_sock_ops.getname
-			var errno = writeSockaddr(
-				addr,
-				sock.family,
-				DNS.lookup_name(sock.saddr || '0.0.0.0'),
-				sock.sport,
-				addrlen
-			);
-			return 0;
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return -e.errno;
-		}
-	}
-
-	function ___syscall_getsockopt(fd, level, optname, optval, optlen, d1) {
-		try {
-			var sock = getSocketFromFD(fd);
-			// Minimal getsockopt aimed at resolving https://github.com/emscripten-core/emscripten/issues/2211
-			// so only supports SOL_SOCKET with SO_ERROR.
-			if (level === 1) {
-				if (optname === 4) {
-					HEAP32[optval >> 2] = sock.error;
-					HEAP32[optlen >> 2] = 4;
-					sock.error = null;
-					// Clear the error (The SO_ERROR option obtains and then clears this field).
-					return 0;
-				}
-			}
-			return -50;
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return -e.errno;
-		}
-	}
+	var stackAlloc = (sz) => __emscripten_stack_alloc(sz);
 
-	function ___syscall_ioctl(fd, op, varargs) {
-		SYSCALLS.varargs = varargs;
-		try {
-			var stream = SYSCALLS.getStreamFromFD(fd);
-			switch (op) {
-				case 21509: {
-					if (!stream.tty) return -59;
-					return 0;
-				}
+	/** @suppress {duplicate } */ var stringToUTF8OnStack = (str) => {
+		var size = lengthBytesUTF8(str) + 1;
+		var ret = stackAlloc(size);
+		stringToUTF8(str, ret, size);
+		return ret;
+	};
 
-				case 21505: {
-					if (!stream.tty) return -59;
-					if (stream.tty.ops.ioctl_tcgets) {
-						var termios = stream.tty.ops.ioctl_tcgets(stream);
-						var argp = syscallGetVarargP();
-						HEAP32[argp >> 2] = termios.c_iflag || 0;
-						HEAP32[(argp + 4) >> 2] = termios.c_oflag || 0;
-						HEAP32[(argp + 8) >> 2] = termios.c_cflag || 0;
-						HEAP32[(argp + 12) >> 2] = termios.c_lflag || 0;
-						for (var i = 0; i < 32; i++) {
-							HEAP8[argp + i + 17] = termios.c_cc[i] || 0;
-						}
-						return 0;
-					}
-					return 0;
-				}
+	var allocateUTF8OnStack = stringToUTF8OnStack;
 
-				case 21510:
-				case 21511:
-				case 21512: {
-					if (!stream.tty) return -59;
-					return 0;
-				}
-
-				case 21506:
-				case 21507:
-				case 21508: {
-					if (!stream.tty) return -59;
-					if (stream.tty.ops.ioctl_tcsets) {
-						var argp = syscallGetVarargP();
-						var c_iflag = HEAP32[argp >> 2];
-						var c_oflag = HEAP32[(argp + 4) >> 2];
-						var c_cflag = HEAP32[(argp + 8) >> 2];
-						var c_lflag = HEAP32[(argp + 12) >> 2];
-						var c_cc = [];
-						for (var i = 0; i < 32; i++) {
-							c_cc.push(HEAP8[argp + i + 17]);
+	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 = {};
 						}
-						return stream.tty.ops.ioctl_tcsets(stream.tty, op, {
-							c_iflag,
-							c_oflag,
-							c_cflag,
-							c_lflag,
-							c_cc,
-						});
-					}
-					return 0;
-				}
-
-				case 21519: {
-					if (!stream.tty) return -59;
-					var argp = syscallGetVarargP();
-					HEAP32[argp >> 2] = 0;
-					return 0;
-				}
-
-				case 21520: {
-					if (!stream.tty) return -59;
-					return -28;
-				}
-
-				case 21531: {
-					var argp = syscallGetVarargP();
-					return FS.ioctl(stream, op, argp);
-				}
-
-				case 21523: {
-					// TODO: in theory we should write to the winsize struct that gets
-					// passed in, but for now musl doesn't read anything on it
-					if (!stream.tty) return -59;
-					if (stream.tty.ops.ioctl_tiocgwinsz) {
-						var winsize = stream.tty.ops.ioctl_tiocgwinsz(
-							stream.tty
-						);
-						var argp = syscallGetVarargP();
-						HEAP16[argp >> 1] = winsize[0];
-						HEAP16[(argp + 2) >> 1] = winsize[1];
-					}
-					return 0;
-				}
-
-				case 21524: {
-					// TODO: technically, this ioctl call should change the window size.
-					// but, since emscripten doesn't have any concept of a terminal window
-					// yet, we'll just silently throw it away as we do TIOCGWINSZ
-					if (!stream.tty) return -59;
-					return 0;
-				}
-
-				case 21515: {
-					if (!stream.tty) return -59;
-					return 0;
+						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);
 				}
-
-				default:
-					return -28;
 			}
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return -e.errno;
-		}
-	}
-
-	function ___syscall_listen(fd, backlog) {
-		try {
-			var sock = getSocketFromFD(fd);
-			sock.sock_ops.listen(sock, backlog);
-			return 0;
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return -e.errno;
-		}
-	}
-
-	function ___syscall_lstat64(path, buf) {
-		try {
-			path = SYSCALLS.getStr(path);
-			return SYSCALLS.writeStat(buf, FS.lstat(path));
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return -e.errno;
-		}
-	}
-
-	function ___syscall_mkdirat(dirfd, path, mode) {
-		try {
-			path = SYSCALLS.getStr(path);
-			path = SYSCALLS.calculateAt(dirfd, path);
-			FS.mkdir(path, mode, 0);
-			return 0;
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return -e.errno;
-		}
-	}
-
-	function ___syscall_newfstatat(dirfd, path, buf, flags) {
-		try {
-			path = SYSCALLS.getStr(path);
-			var nofollow = flags & 256;
-			var allowEmpty = flags & 4096;
-			flags = flags & ~6400;
-			path = SYSCALLS.calculateAt(dirfd, path, allowEmpty);
-			return SYSCALLS.writeStat(
-				buf,
-				nofollow ? FS.lstat(path) : FS.stat(path)
-			);
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return -e.errno;
-		}
-	}
-
-	function ___syscall_openat(dirfd, path, flags, varargs) {
-		SYSCALLS.varargs = varargs;
-		try {
-			path = SYSCALLS.getStr(path);
-			path = SYSCALLS.calculateAt(dirfd, path);
-			var mode = varargs ? syscallGetVarargI() : 0;
-			return FS.open(path, flags, mode).fd;
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return -e.errno;
-		}
-	}
-
-	var PIPEFS = {
-		BUCKET_BUFFER_SIZE: 8192,
-		mount(mount) {
-			// Do not pollute the real root directory or its child nodes with pipes
-			// Looks like it is OK to create another pseudo-root node not linked to the FS.root hierarchy this way
-			return FS.createNode(null, '/', 16384 | 511, 0);
+			return Array.from(peers);
 		},
-		createPipe() {
-			var pipe = {
-				buckets: [],
-				// refcnt 2 because pipe has a read end and a write end. We need to be
-				// able to read from the read end after write end is closed.
-				refcnt: 2,
-				timestamp: new Date(),
+		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();
 			};
-			pipe.buckets.push({
-				buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE),
-				offset: 0,
-				roffset: 0,
-			});
-			var rName = PIPEFS.nextname();
-			var wName = PIPEFS.nextname();
-			var rNode = FS.createNode(PIPEFS.root, rName, 4096, 0);
-			var wNode = FS.createNode(PIPEFS.root, wName, 4096, 0);
-			rNode.pipe = pipe;
-			wNode.pipe = pipe;
-			var readableStream = FS.createStream({
-				path: rName,
-				node: rNode,
-				flags: 0,
-				seekable: false,
-				stream_ops: PIPEFS.stream_ops,
-			});
-			rNode.stream = readableStream;
-			var writableStream = FS.createStream({
-				path: wName,
-				node: wNode,
-				flags: 1,
-				seekable: false,
-				stream_ops: PIPEFS.stream_ops,
-			});
-			wNode.stream = writableStream;
-			return {
-				readable_fd: readableStream.fd,
-				writable_fd: writableStream.fd,
+			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];
 		},
-		stream_ops: {
-			getattr(stream) {
-				var node = stream.node;
-				var timestamp = node.pipe.timestamp;
-				return {
-					dev: 14,
-					ino: node.id,
-					mode: 4480,
-					nlink: 1,
-					uid: 0,
-					gid: 0,
-					rdev: 0,
-					size: 0,
-					atime: timestamp,
-					mtime: timestamp,
-					ctime: timestamp,
-					blksize: 4096,
-					blocks: 0,
-				};
-			},
-			poll(stream) {
-				var pipe = stream.node.pipe;
-				if ((stream.flags & 2097155) === 1) {
-					return 256 | 4;
-				}
-				for (var bucket of pipe.buckets) {
-					if (bucket.offset - bucket.roffset > 0) {
-						return 64 | 1;
-					}
-				}
-				return 0;
-			},
-			dup(stream) {
-				stream.node.pipe.refcnt++;
-			},
-			ioctl(stream, request, varargs) {
-				return 28;
-			},
-			fsync(stream) {
-				return 28;
-			},
-			read(stream, buffer, offset, length, position) {
-				var pipe = stream.node.pipe;
-				var currentLength = 0;
-				for (var bucket of pipe.buckets) {
-					currentLength += bucket.offset - bucket.roffset;
-				}
-				var data = buffer.subarray(offset, offset + length);
-				if (length <= 0) {
-					return 0;
-				}
-				if (currentLength == 0) {
-					// Behave as if the read end is always non-blocking
-					throw new FS.ErrnoError(6);
-				}
-				var toRead = Math.min(currentLength, length);
-				var totalRead = toRead;
-				var toRemove = 0;
-				for (var bucket of pipe.buckets) {
-					var bucketSize = bucket.offset - bucket.roffset;
-					if (toRead <= bucketSize) {
-						var tmpSlice = bucket.buffer.subarray(
-							bucket.roffset,
-							bucket.offset
-						);
-						if (toRead < bucketSize) {
-							tmpSlice = tmpSlice.subarray(0, toRead);
-							bucket.roffset += toRead;
-						} else {
-							toRemove++;
-						}
-						data.set(tmpSlice);
-						break;
-					} else {
-						var tmpSlice = bucket.buffer.subarray(
-							bucket.roffset,
-							bucket.offset
+		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.'
 						);
-						data.set(tmpSlice);
-						data = data.subarray(tmpSlice.byteLength);
-						toRead -= tmpSlice.byteLength;
-						toRemove++;
 					}
-				}
-				if (toRemove && toRemove == pipe.buckets.length) {
-					// Do not generate excessive garbage in use cases such as
-					// write several bytes, read everything, write several bytes, read everything...
-					toRemove--;
-					pipe.buckets[toRemove].offset = 0;
-					pipe.buckets[toRemove].roffset = 0;
-				}
-				pipe.buckets.splice(0, toRemove);
-				return totalRead;
-			},
-			write(stream, buffer, offset, length, position) {
-				var pipe = stream.node.pipe;
-				var data = buffer.subarray(offset, offset + length);
-				var dataLen = data.byteLength;
-				if (dataLen <= 0) {
-					return 0;
-				}
-				var currBucket = null;
-				if (pipe.buckets.length == 0) {
-					currBucket = {
-						buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE),
-						offset: 0,
-						roffset: 0,
-					};
-					pipe.buckets.push(currBucket);
-				} else {
-					currBucket = pipe.buckets[pipe.buckets.length - 1];
-				}
-				assert(currBucket.offset <= PIPEFS.BUCKET_BUFFER_SIZE);
-				var freeBytesInCurrBuffer =
-					PIPEFS.BUCKET_BUFFER_SIZE - currBucket.offset;
-				if (freeBytesInCurrBuffer >= dataLen) {
-					currBucket.buffer.set(data, currBucket.offset);
-					currBucket.offset += dataLen;
-					return dataLen;
-				} else if (freeBytesInCurrBuffer > 0) {
-					currBucket.buffer.set(
-						data.subarray(0, freeBytesInCurrBuffer),
-						currBucket.offset
-					);
-					currBucket.offset += freeBytesInCurrBuffer;
-					data = data.subarray(
-						freeBytesInCurrBuffer,
-						data.byteLength
-					);
-				}
-				var numBuckets =
-					(data.byteLength / PIPEFS.BUCKET_BUFFER_SIZE) | 0;
-				var remElements = data.byteLength % PIPEFS.BUCKET_BUFFER_SIZE;
-				for (var i = 0; i < numBuckets; i++) {
-					var newBucket = {
-						buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE),
-						offset: PIPEFS.BUCKET_BUFFER_SIZE,
-						roffset: 0,
-					};
-					pipe.buckets.push(newBucket);
-					newBucket.buffer.set(
-						data.subarray(0, PIPEFS.BUCKET_BUFFER_SIZE)
-					);
-					data = data.subarray(
-						PIPEFS.BUCKET_BUFFER_SIZE,
-						data.byteLength
-					);
-				}
-				if (remElements > 0) {
-					var newBucket = {
-						buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE),
-						offset: data.byteLength,
-						roffset: 0,
-					};
-					pipe.buckets.push(newBucket);
-					newBucket.buffer.set(data);
-				}
-				return dataLen;
-			},
-			close(stream) {
-				var pipe = stream.node.pipe;
-				pipe.refcnt--;
-				if (pipe.refcnt === 0) {
-					pipe.buckets = null;
-				}
-			},
+					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;
 		},
-		nextname() {
-			if (!PIPEFS.nextname.current) {
-				PIPEFS.nextname.current = 0;
+		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;
 			}
-			return 'pipe[' + PIPEFS.nextname.current++ + ']';
 		},
 	};
 
-	function ___syscall_pipe(fdPtr) {
-		try {
-			if (fdPtr == 0) {
-				throw new FS.ErrnoError(21);
-			}
-			var res = PIPEFS.createPipe();
-			HEAP32[fdPtr >> 2] = res.readable_fd;
-			HEAP32[(fdPtr + 4) >> 2] = res.writable_fd;
-			return 0;
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return -e.errno;
-		}
+	function _js_getpid() {
+		return PHPLoader.processId ?? 42;
 	}
 
-	function ___syscall_poll(fds, nfds, timeout) {
-		try {
-			var nonzero = 0;
-			for (var i = 0; i < nfds; i++) {
-				var pollfd = fds + 8 * i;
-				var fd = HEAP32[pollfd >> 2];
-				var events = HEAP16[(pollfd + 4) >> 1];
-				var mask = 32;
-				var stream = FS.getStream(fd);
-				if (stream) {
-					mask = SYSCALLS.DEFAULT_POLLMASK;
-					if (stream.stream_ops?.poll) {
-						mask = stream.stream_ops.poll(stream, -1);
-					}
-				}
-				mask &= events | 8 | 16;
-				if (mask) nonzero++;
-				HEAP16[(pollfd + 6) >> 1] = mask;
-			}
-			return nonzero;
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return -e.errno;
+	function _js_wasm_trace(format, ...args) {
+		if (PHPLoader.trace instanceof Function) {
+			PHPLoader.trace(_js_getpid(), format, ...args);
 		}
 	}
 
-	function ___syscall_readlinkat(dirfd, path, buf, bufsize) {
+	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 {
-			path = SYSCALLS.getStr(path);
-			path = SYSCALLS.calculateAt(dirfd, path);
-			if (bufsize <= 0) return -28;
-			var ret = FS.readlink(path);
-			var len = Math.min(bufsize, lengthBytesUTF8(ret));
-			var endChar = HEAP8[buf + len];
-			stringToUTF8(ret, buf, bufsize + 1);
-			// readlink is one of the rare functions that write out a C string, but does never append a null to the output buffer(!)
-			// stringToUTF8() always appends a null byte, so restore the character under the null byte after the write.
-			HEAP8[buf + len] = endChar;
-			return len;
+			var stream = SYSCALLS.getStreamFromFD(fd);
+			FS.close(stream);
+			return 0;
 		} catch (e) {
 			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return -e.errno;
+			return e.errno;
 		}
 	}
 
-	function ___syscall_recvfrom(fd, buf, len, flags, addr, addrlen) {
+	function _builtin_fcntl64(fd, cmd, varargs) {
+		SYSCALLS.varargs = varargs;
 		try {
-			var sock = getSocketFromFD(fd);
-			var msg = sock.sock_ops.recvmsg(
-				sock,
-				len,
-				typeof flags !== 'undefined' ? flags : 0
-			);
-			if (!msg) return 0;
-			// socket is closed
-			if (addr) {
-				var errno = writeSockaddr(
-					addr,
-					sock.family,
-					DNS.lookup_name(msg.addr),
-					msg.port,
-					addrlen
-				);
+			var stream = SYSCALLS.getStreamFromFD(fd);
+			switch (cmd) {
+				case 0: {
+					var arg = syscallGetVarargI();
+					if (arg < 0) {
+						return -28;
+					}
+					while (FS.streams[arg]) {
+						arg++;
+					}
+					var newStream;
+					newStream = FS.dupStream(stream, arg);
+					return newStream.fd;
+				}
+
+				case 1:
+				case 2:
+					return 0;
+
+				// FD_CLOEXEC makes no sense for a single process.
+				case 3:
+					return stream.flags;
+
+				case 4: {
+					var arg = syscallGetVarargI();
+					stream.flags |= arg;
+					return 0;
+				}
+
+				case 12: {
+					var arg = syscallGetVarargP();
+					var offset = 0;
+					// We're always unlocked.
+					HEAP16[(arg + offset) >> 1] = 2;
+					return 0;
+				}
+
+				case 13:
+				case 14:
+					// Pretend that the locking is successful. These are process-level locks,
+					// and Emscripten programs are a single process. If we supported linking a
+					// filesystem between programs, we'd need to do more here.
+					// See https://github.com/emscripten-core/emscripten/issues/23697
+					return 0;
 			}
-			HEAPU8.set(msg.buffer, buf);
-			return msg.buffer.byteLength;
+			return -28;
 		} catch (e) {
 			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
 			return -e.errno;
 		}
 	}
 
-	function ___syscall_renameat(olddirfd, oldpath, newdirfd, newpath) {
-		try {
-			oldpath = SYSCALLS.getStr(oldpath);
-			newpath = SYSCALLS.getStr(newpath);
-			oldpath = SYSCALLS.calculateAt(olddirfd, oldpath);
-			newpath = SYSCALLS.calculateAt(newdirfd, newpath);
-			FS.rename(oldpath, newpath);
+	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;
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return -e.errno;
+		},
+	};
+
+	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);
 		}
 	}
 
-	function ___syscall_rmdir(path) {
+	___syscall_fcntl64.isAsync = true;
+
+	function ___syscall_fdatasync(fd) {
 		try {
-			path = SYSCALLS.getStr(path);
-			FS.rmdir(path);
+			var stream = SYSCALLS.getStreamFromFD(fd);
 			return 0;
 		} catch (e) {
 			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
@@ -5962,65 +6078,115 @@ export function init(RuntimeName, PHPLoader) {
 		}
 	}
 
-	function ___syscall_sendto(fd, message, length, flags, addr, addr_len) {
+	function ___syscall_fstat64(fd, buf) {
 		try {
-			var sock = getSocketFromFD(fd);
-			if (!addr) {
-				// send, no address provided
-				return FS.write(sock.stream, HEAP8, message, length);
-			}
-			var dest = getSocketAddress(addr, addr_len);
-			// sendto an address
-			return sock.sock_ops.sendmsg(
-				sock,
-				HEAP8,
-				message,
-				length,
-				dest.addr,
-				dest.port
-			);
+			return SYSCALLS.writeStat(buf, FS.fstat(fd));
 		} catch (e) {
 			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
 			return -e.errno;
 		}
 	}
 
-	function ___syscall_socket(domain, type, protocol) {
+	function ___syscall_ftruncate64(fd, length) {
+		length = bigintToI53Checked(length);
 		try {
-			var sock = SOCKFS.createSocket(domain, type, protocol);
-			return sock.stream.fd;
+			if (isNaN(length)) return 61;
+			FS.ftruncate(fd, length);
+			return 0;
 		} catch (e) {
 			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
 			return -e.errno;
 		}
 	}
 
-	function ___syscall_stat64(path, buf) {
+	function ___syscall_getcwd(buf, size) {
 		try {
-			path = SYSCALLS.getStr(path);
-			return SYSCALLS.writeStat(buf, FS.stat(path));
+			if (size === 0) return -28;
+			var cwd = FS.cwd();
+			var cwdLengthInBytes = lengthBytesUTF8(cwd) + 1;
+			if (size < cwdLengthInBytes) return -68;
+			stringToUTF8(cwd, buf, size);
+			return cwdLengthInBytes;
 		} catch (e) {
 			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
 			return -e.errno;
 		}
 	}
 
-	function ___syscall_statfs64(path, size, buf) {
+	function ___syscall_getdents64(fd, dirp, count) {
 		try {
-			SYSCALLS.writeStatFs(buf, FS.statfs(SYSCALLS.getStr(path)));
-			return 0;
+			var stream = SYSCALLS.getStreamFromFD(fd);
+			stream.getdents ||= FS.readdir(stream.path);
+			var struct_size = 280;
+			var pos = 0;
+			var off = FS.llseek(stream, 0, 1);
+			var startIdx = Math.floor(off / struct_size);
+			var endIdx = Math.min(
+				stream.getdents.length,
+				startIdx + Math.floor(count / struct_size)
+			);
+			for (var idx = startIdx; idx < endIdx; idx++) {
+				var id;
+				var type;
+				var name = stream.getdents[idx];
+				if (name === '.') {
+					id = stream.node.id;
+					type = 4;
+				} else if (name === '..') {
+					var lookup = FS.lookupPath(stream.path, {
+						parent: true,
+					});
+					id = lookup.node.id;
+					type = 4;
+				} else {
+					var child;
+					try {
+						child = FS.lookupNode(stream.node, name);
+					} catch (e) {
+						// If the entry is not a directory, file, or symlink, nodefs
+						// lookupNode will raise EINVAL. Skip these and continue.
+						if (e?.errno === 28) {
+							continue;
+						}
+						throw e;
+					}
+					id = child.id;
+					type = FS.isChrdev(child.mode)
+						? 2 // DT_CHR, character device.
+						: FS.isDir(child.mode)
+						? 4 // DT_DIR, directory.
+						: FS.isLink(child.mode)
+						? 10 // DT_LNK, symbolic link.
+						: 8;
+				}
+				HEAP64[(dirp + pos) >> 3] = BigInt(id);
+				HEAP64[(dirp + pos + 8) >> 3] = BigInt((idx + 1) * struct_size);
+				HEAP16[(dirp + pos + 16) >> 1] = 280;
+				HEAP8[dirp + pos + 18] = type;
+				stringToUTF8(name, dirp + pos + 19, 256);
+				pos += struct_size;
+			}
+			FS.llseek(stream, idx * struct_size, 0);
+			return pos;
 		} catch (e) {
 			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
 			return -e.errno;
 		}
 	}
 
-	function ___syscall_symlinkat(target, dirfd, linkpath) {
+	function ___syscall_getpeername(fd, addr, addrlen, d1, d2, d3) {
 		try {
-			target = SYSCALLS.getStr(target);
-			linkpath = SYSCALLS.getStr(linkpath);
-			linkpath = SYSCALLS.calculateAt(dirfd, linkpath);
-			FS.symlink(target, linkpath);
+			var sock = getSocketFromFD(fd);
+			if (!sock.daddr) {
+				return -53;
+			}
+			var errno = writeSockaddr(
+				addr,
+				sock.family,
+				DNS.lookup_name(sock.daddr),
+				sock.dport,
+				addrlen
+			);
 			return 0;
 		} catch (e) {
 			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
@@ -6028,17 +6194,17 @@ export function init(RuntimeName, PHPLoader) {
 		}
 	}
 
-	function ___syscall_unlinkat(dirfd, path, flags) {
+	function ___syscall_getsockname(fd, addr, addrlen, d1, d2, d3) {
 		try {
-			path = SYSCALLS.getStr(path);
-			path = SYSCALLS.calculateAt(dirfd, path);
-			if (flags === 0) {
-				FS.unlink(path);
-			} else if (flags === 512) {
-				FS.rmdir(path);
-			} else {
-				abort('Invalid flags passed to unlinkat');
-			}
+			var sock = getSocketFromFD(fd);
+			// TODO: sock.saddr should never be undefined, see TODO in websocket_sock_ops.getname
+			var errno = writeSockaddr(
+				addr,
+				sock.family,
+				DNS.lookup_name(sock.saddr || '0.0.0.0'),
+				sock.sport,
+				addrlen
+			);
 			return 0;
 		} catch (e) {
 			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
@@ -6046,1218 +6212,1535 @@ export function init(RuntimeName, PHPLoader) {
 		}
 	}
 
-	var readI53FromI64 = (ptr) =>
-		HEAPU32[ptr >> 2] + HEAP32[(ptr + 4) >> 2] * 4294967296;
-
-	function ___syscall_utimensat(dirfd, path, times, flags) {
+	function ___syscall_getsockopt(fd, level, optname, optval, optlen, d1) {
 		try {
-			path = SYSCALLS.getStr(path);
-			path = SYSCALLS.calculateAt(dirfd, path, true);
-			var now = Date.now(),
-				atime,
-				mtime;
-			if (!times) {
-				atime = now;
-				mtime = now;
-			} else {
-				var seconds = readI53FromI64(times);
-				var nanoseconds = HEAP32[(times + 8) >> 2];
-				if (nanoseconds == 1073741823) {
-					atime = now;
-				} else if (nanoseconds == 1073741822) {
-					atime = null;
-				} else {
-					atime = seconds * 1e3 + nanoseconds / (1e3 * 1e3);
-				}
-				times += 16;
-				seconds = readI53FromI64(times);
-				nanoseconds = HEAP32[(times + 8) >> 2];
-				if (nanoseconds == 1073741823) {
-					mtime = now;
-				} else if (nanoseconds == 1073741822) {
-					mtime = null;
-				} else {
-					mtime = seconds * 1e3 + nanoseconds / (1e3 * 1e3);
+			var sock = getSocketFromFD(fd);
+			// Minimal getsockopt aimed at resolving https://github.com/emscripten-core/emscripten/issues/2211
+			// so only supports SOL_SOCKET with SO_ERROR.
+			if (level === 1) {
+				if (optname === 4) {
+					HEAP32[optval >> 2] = sock.error;
+					HEAP32[optlen >> 2] = 4;
+					sock.error = null;
+					// Clear the error (The SO_ERROR option obtains and then clears this field).
+					return 0;
 				}
 			}
-			// null here means UTIME_OMIT was passed. If both were set to UTIME_OMIT then
-			// we can skip the call completely.
-			if ((mtime ?? atime) !== null) {
-				FS.utime(path, atime, mtime);
-			}
-			return 0;
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return -e.errno;
-		}
-	}
-
-	var __abort_js = () => abort('');
-
-	var __emscripten_lookup_name = (name) => {
-		// uint32_t _emscripten_lookup_name(const char *name);
-		var nameString = UTF8ToString(name);
-		return inetPton4(DNS.lookup_name(nameString));
-	};
-
-	var runtimeKeepaliveCounter = 0;
-
-	var __emscripten_runtime_keepalive_clear = () => {
-		noExitRuntime = false;
-		runtimeKeepaliveCounter = 0;
-	};
-
-	function __gmtime_js(time, tmPtr) {
-		time = bigintToI53Checked(time);
-		var date = new Date(time * 1e3);
-		HEAP32[tmPtr >> 2] = date.getUTCSeconds();
-		HEAP32[(tmPtr + 4) >> 2] = date.getUTCMinutes();
-		HEAP32[(tmPtr + 8) >> 2] = date.getUTCHours();
-		HEAP32[(tmPtr + 12) >> 2] = date.getUTCDate();
-		HEAP32[(tmPtr + 16) >> 2] = date.getUTCMonth();
-		HEAP32[(tmPtr + 20) >> 2] = date.getUTCFullYear() - 1900;
-		HEAP32[(tmPtr + 24) >> 2] = date.getUTCDay();
-		var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0);
-		var yday = ((date.getTime() - start) / (1e3 * 60 * 60 * 24)) | 0;
-		HEAP32[(tmPtr + 28) >> 2] = yday;
-	}
-
-	var isLeapYear = (year) =>
-		year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
-
-	var MONTH_DAYS_LEAP_CUMULATIVE = [
-		0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335,
-	];
-
-	var MONTH_DAYS_REGULAR_CUMULATIVE = [
-		0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334,
-	];
-
-	var ydayFromDate = (date) => {
-		var leap = isLeapYear(date.getFullYear());
-		var monthDaysCumulative = leap
-			? MONTH_DAYS_LEAP_CUMULATIVE
-			: MONTH_DAYS_REGULAR_CUMULATIVE;
-		var yday = monthDaysCumulative[date.getMonth()] + date.getDate() - 1;
-		// -1 since it's days since Jan 1
-		return yday;
-	};
-
-	function __localtime_js(time, tmPtr) {
-		time = bigintToI53Checked(time);
-		var date = new Date(time * 1e3);
-		HEAP32[tmPtr >> 2] = date.getSeconds();
-		HEAP32[(tmPtr + 4) >> 2] = date.getMinutes();
-		HEAP32[(tmPtr + 8) >> 2] = date.getHours();
-		HEAP32[(tmPtr + 12) >> 2] = date.getDate();
-		HEAP32[(tmPtr + 16) >> 2] = date.getMonth();
-		HEAP32[(tmPtr + 20) >> 2] = date.getFullYear() - 1900;
-		HEAP32[(tmPtr + 24) >> 2] = date.getDay();
-		var yday = ydayFromDate(date) | 0;
-		HEAP32[(tmPtr + 28) >> 2] = yday;
-		HEAP32[(tmPtr + 36) >> 2] = -(date.getTimezoneOffset() * 60);
-		// Attention: DST is in December in South, and some regions don't have DST at all.
-		var start = new Date(date.getFullYear(), 0, 1);
-		var summerOffset = new Date(
-			date.getFullYear(),
-			6,
-			1
-		).getTimezoneOffset();
-		var winterOffset = start.getTimezoneOffset();
-		var dst =
-			(summerOffset != winterOffset &&
-				date.getTimezoneOffset() ==
-					Math.min(winterOffset, summerOffset)) | 0;
-		HEAP32[(tmPtr + 32) >> 2] = dst;
-	}
-
-	var __mktime_js = function (tmPtr) {
-		var ret = (() => {
-			var date = new Date(
-				HEAP32[(tmPtr + 20) >> 2] + 1900,
-				HEAP32[(tmPtr + 16) >> 2],
-				HEAP32[(tmPtr + 12) >> 2],
-				HEAP32[(tmPtr + 8) >> 2],
-				HEAP32[(tmPtr + 4) >> 2],
-				HEAP32[tmPtr >> 2],
-				0
-			);
-			// There's an ambiguous hour when the time goes back; the tm_isdst field is
-			// used to disambiguate it.  Date() basically guesses, so we fix it up if it
-			// guessed wrong, or fill in tm_isdst with the guess if it's -1.
-			var dst = HEAP32[(tmPtr + 32) >> 2];
-			var guessedOffset = date.getTimezoneOffset();
-			var start = new Date(date.getFullYear(), 0, 1);
-			var summerOffset = new Date(
-				date.getFullYear(),
-				6,
-				1
-			).getTimezoneOffset();
-			var winterOffset = start.getTimezoneOffset();
-			var dstOffset = Math.min(winterOffset, summerOffset);
-			// DST is in December in South
-			if (dst < 0) {
-				// Attention: some regions don't have DST at all.
-				HEAP32[(tmPtr + 32) >> 2] = Number(
-					summerOffset != winterOffset && dstOffset == guessedOffset
-				);
-			} else if (dst > 0 != (dstOffset == guessedOffset)) {
-				var nonDstOffset = Math.max(winterOffset, summerOffset);
-				var trueOffset = dst > 0 ? dstOffset : nonDstOffset;
-				// Don't try setMinutes(date.getMinutes() + ...) -- it's messed up.
-				date.setTime(
-					date.getTime() + (trueOffset - guessedOffset) * 6e4
-				);
-			}
-			HEAP32[(tmPtr + 24) >> 2] = date.getDay();
-			var yday = ydayFromDate(date) | 0;
-			HEAP32[(tmPtr + 28) >> 2] = yday;
-			// To match expected behavior, update fields from date
-			HEAP32[tmPtr >> 2] = date.getSeconds();
-			HEAP32[(tmPtr + 4) >> 2] = date.getMinutes();
-			HEAP32[(tmPtr + 8) >> 2] = date.getHours();
-			HEAP32[(tmPtr + 12) >> 2] = date.getDate();
-			HEAP32[(tmPtr + 16) >> 2] = date.getMonth();
-			HEAP32[(tmPtr + 20) >> 2] = date.getYear();
-			var timeMs = date.getTime();
-			if (isNaN(timeMs)) {
-				return -1;
-			}
-			// Return time in microseconds
-			return timeMs / 1e3;
-		})();
-		return BigInt(ret);
-	};
-
-	function __mmap_js(len, prot, flags, fd, offset, allocated, addr) {
-		offset = bigintToI53Checked(offset);
-		try {
-			if (isNaN(offset)) return 61;
-			var stream = SYSCALLS.getStreamFromFD(fd);
-			var res = FS.mmap(stream, len, offset, prot, flags);
-			var ptr = res.ptr;
-			HEAP32[allocated >> 2] = res.allocated;
-			HEAPU32[addr >> 2] = ptr;
-			return 0;
+			return -50;
 		} catch (e) {
 			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
 			return -e.errno;
 		}
 	}
 
-	function __munmap_js(addr, len, prot, flags, fd, offset) {
-		offset = bigintToI53Checked(offset);
+	function ___syscall_ioctl(fd, op, varargs) {
+		SYSCALLS.varargs = varargs;
 		try {
 			var stream = SYSCALLS.getStreamFromFD(fd);
-			if (prot & 2) {
-				SYSCALLS.doMsync(addr, stream, len, flags, offset);
-			}
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return -e.errno;
-		}
-	}
+			switch (op) {
+				case 21509: {
+					if (!stream.tty) return -59;
+					return 0;
+				}
 
-	var timers = {};
+				case 21505: {
+					if (!stream.tty) return -59;
+					if (stream.tty.ops.ioctl_tcgets) {
+						var termios = stream.tty.ops.ioctl_tcgets(stream);
+						var argp = syscallGetVarargP();
+						HEAP32[argp >> 2] = termios.c_iflag || 0;
+						HEAP32[(argp + 4) >> 2] = termios.c_oflag || 0;
+						HEAP32[(argp + 8) >> 2] = termios.c_cflag || 0;
+						HEAP32[(argp + 12) >> 2] = termios.c_lflag || 0;
+						for (var i = 0; i < 32; i++) {
+							HEAP8[argp + i + 17] = termios.c_cc[i] || 0;
+						}
+						return 0;
+					}
+					return 0;
+				}
 
-	var handleException = (e) => {
-		// Certain exception types we do not treat as errors since they are used for
-		// internal control flow.
-		// 1. ExitStatus, which is thrown by exit()
-		// 2. "unwind", which is thrown by emscripten_unwind_to_js_event_loop() and others
-		//    that wish to return to JS event loop.
-		if (e instanceof ExitStatus || e == 'unwind') {
-			return EXITSTATUS;
-		}
-		quit_(1, e);
-	};
+				case 21510:
+				case 21511:
+				case 21512: {
+					if (!stream.tty) return -59;
+					return 0;
+				}
 
-	var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
+				case 21506:
+				case 21507:
+				case 21508: {
+					if (!stream.tty) return -59;
+					if (stream.tty.ops.ioctl_tcsets) {
+						var argp = syscallGetVarargP();
+						var c_iflag = HEAP32[argp >> 2];
+						var c_oflag = HEAP32[(argp + 4) >> 2];
+						var c_cflag = HEAP32[(argp + 8) >> 2];
+						var c_lflag = HEAP32[(argp + 12) >> 2];
+						var c_cc = [];
+						for (var i = 0; i < 32; i++) {
+							c_cc.push(HEAP8[argp + i + 17]);
+						}
+						return stream.tty.ops.ioctl_tcsets(stream.tty, op, {
+							c_iflag,
+							c_oflag,
+							c_cflag,
+							c_lflag,
+							c_cc,
+						});
+					}
+					return 0;
+				}
 
-	var _proc_exit = (code) => {
-		EXITSTATUS = code;
-		if (!keepRuntimeAlive()) {
-			Module['onExit']?.(code);
-			ABORT = true;
-		}
-		quit_(code, new ExitStatus(code));
-	};
+				case 21519: {
+					if (!stream.tty) return -59;
+					var argp = syscallGetVarargP();
+					HEAP32[argp >> 2] = 0;
+					return 0;
+				}
 
-	/** @suppress {duplicate } */ /** @param {boolean|number=} implicit */ var exitJS =
-		(status, implicit) => {
-			EXITSTATUS = status;
-			if (!keepRuntimeAlive()) {
-				exitRuntime();
-			}
-			_proc_exit(status);
-		};
+				case 21520: {
+					if (!stream.tty) return -59;
+					return -28;
+				}
 
-	var _exit = exitJS;
+				case 21531: {
+					var argp = syscallGetVarargP();
+					return FS.ioctl(stream, op, argp);
+				}
 
-	Module['_exit'] = _exit;
+				case 21523: {
+					// TODO: in theory we should write to the winsize struct that gets
+					// passed in, but for now musl doesn't read anything on it
+					if (!stream.tty) return -59;
+					if (stream.tty.ops.ioctl_tiocgwinsz) {
+						var winsize = stream.tty.ops.ioctl_tiocgwinsz(
+							stream.tty
+						);
+						var argp = syscallGetVarargP();
+						HEAP16[argp >> 1] = winsize[0];
+						HEAP16[(argp + 2) >> 1] = winsize[1];
+					}
+					return 0;
+				}
 
-	var maybeExit = () => {
-		if (runtimeExited) {
-			return;
-		}
-		if (!keepRuntimeAlive()) {
-			try {
-				_exit(EXITSTATUS);
-			} catch (e) {
-				handleException(e);
+				case 21524: {
+					// TODO: technically, this ioctl call should change the window size.
+					// but, since emscripten doesn't have any concept of a terminal window
+					// yet, we'll just silently throw it away as we do TIOCGWINSZ
+					if (!stream.tty) return -59;
+					return 0;
+				}
+
+				case 21515: {
+					if (!stream.tty) return -59;
+					return 0;
+				}
+
+				default:
+					return -28;
 			}
+		} catch (e) {
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return -e.errno;
 		}
-	};
+	}
 
-	var callUserCallback = (func) => {
-		if (runtimeExited || ABORT) {
-			return;
-		}
+	function ___syscall_listen(fd, backlog) {
 		try {
-			func();
-			maybeExit();
+			var sock = getSocketFromFD(fd);
+			sock.sock_ops.listen(sock, backlog);
+			return 0;
 		} catch (e) {
-			handleException(e);
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return -e.errno;
 		}
-	};
+	}
 
-	var _emscripten_get_now = () => performance.now();
+	function ___syscall_lstat64(path, buf) {
+		try {
+			path = SYSCALLS.getStr(path);
+			return SYSCALLS.writeStat(buf, FS.lstat(path));
+		} catch (e) {
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return -e.errno;
+		}
+	}
 
-	var __setitimer_js = (which, timeout_ms) => {
-		// First, clear any existing timer.
-		if (timers[which]) {
-			clearTimeout(timers[which].id);
-			delete timers[which];
+	function ___syscall_mkdirat(dirfd, path, mode) {
+		try {
+			path = SYSCALLS.getStr(path);
+			path = SYSCALLS.calculateAt(dirfd, path);
+			FS.mkdir(path, mode, 0);
+			return 0;
+		} catch (e) {
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return -e.errno;
 		}
-		// A timeout of zero simply cancels the current timeout so we have nothing
-		// more to do.
-		if (!timeout_ms) return 0;
-		var id = setTimeout(() => {
-			delete timers[which];
-			callUserCallback(() =>
-				__emscripten_timeout(which, _emscripten_get_now())
-			);
-		}, timeout_ms);
-		timers[which] = {
-			id,
-			timeout_ms,
-		};
-		return 0;
-	};
+	}
 
-	var __tzset_js = (timezone, daylight, std_name, dst_name) => {
-		// TODO: Use (malleable) environment variables instead of system settings.
-		var currentYear = new Date().getFullYear();
-		var winter = new Date(currentYear, 0, 1);
-		var summer = new Date(currentYear, 6, 1);
-		var winterOffset = winter.getTimezoneOffset();
-		var summerOffset = summer.getTimezoneOffset();
-		// Local standard timezone offset. Local standard time is not adjusted for
-		// daylight savings.  This code uses the fact that getTimezoneOffset returns
-		// a greater value during Standard Time versus Daylight Saving Time (DST).
-		// Thus it determines the expected output during Standard Time, and it
-		// compares whether the output of the given date the same (Standard) or less
-		// (DST).
-		var stdTimezoneOffset = Math.max(winterOffset, summerOffset);
-		// timezone is specified as seconds west of UTC ("The external variable
-		// `timezone` shall be set to the difference, in seconds, between
-		// Coordinated Universal Time (UTC) and local standard time."), the same
-		// as returned by stdTimezoneOffset.
-		// See http://pubs.opengroup.org/onlinepubs/009695399/functions/tzset.html
-		HEAPU32[timezone >> 2] = stdTimezoneOffset * 60;
-		HEAP32[daylight >> 2] = Number(winterOffset != summerOffset);
-		var extractZone = (timezoneOffset) => {
-			// Why inverse sign?
-			// Read here https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset
-			var sign = timezoneOffset >= 0 ? '-' : '+';
-			var absOffset = Math.abs(timezoneOffset);
-			var hours = String(Math.floor(absOffset / 60)).padStart(2, '0');
-			var minutes = String(absOffset % 60).padStart(2, '0');
-			return `UTC${sign}${hours}${minutes}`;
-		};
-		var winterName = extractZone(winterOffset);
-		var summerName = extractZone(summerOffset);
-		if (summerOffset < winterOffset) {
-			// Northern hemisphere
-			stringToUTF8(winterName, std_name, 17);
-			stringToUTF8(summerName, dst_name, 17);
-		} else {
-			stringToUTF8(winterName, dst_name, 17);
-			stringToUTF8(summerName, std_name, 17);
+	function ___syscall_newfstatat(dirfd, path, buf, flags) {
+		try {
+			path = SYSCALLS.getStr(path);
+			var nofollow = flags & 256;
+			var allowEmpty = flags & 4096;
+			flags = flags & ~6400;
+			path = SYSCALLS.calculateAt(dirfd, path, allowEmpty);
+			return SYSCALLS.writeStat(
+				buf,
+				nofollow ? FS.lstat(path) : FS.stat(path)
+			);
+		} catch (e) {
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return -e.errno;
 		}
-	};
-
-	var _emscripten_date_now = () => Date.now();
-
-	var nowIsMonotonic = 1;
-
-	var checkWasiClock = (clock_id) => clock_id >= 0 && clock_id <= 3;
+	}
 
-	function _clock_time_get(clk_id, ignored_precision, ptime) {
-		ignored_precision = bigintToI53Checked(ignored_precision);
-		if (!checkWasiClock(clk_id)) {
-			return 28;
+	function ___syscall_openat(dirfd, path, flags, varargs) {
+		SYSCALLS.varargs = varargs;
+		try {
+			path = SYSCALLS.getStr(path);
+			path = SYSCALLS.calculateAt(dirfd, path);
+			var mode = varargs ? syscallGetVarargI() : 0;
+			return FS.open(path, flags, mode).fd;
+		} catch (e) {
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return -e.errno;
 		}
-		var now;
-		// all wasi clocks but realtime are monotonic
-		if (clk_id === 0) {
-			now = _emscripten_date_now();
-		} else if (nowIsMonotonic) {
-			now = _emscripten_get_now();
-		} else {
-			return 52;
+	}
+
+	var PIPEFS = {
+		BUCKET_BUFFER_SIZE: 8192,
+		mount(mount) {
+			// Do not pollute the real root directory or its child nodes with pipes
+			// Looks like it is OK to create another pseudo-root node not linked to the FS.root hierarchy this way
+			return FS.createNode(null, '/', 16384 | 511, 0);
+		},
+		createPipe() {
+			var pipe = {
+				buckets: [],
+				// refcnt 2 because pipe has a read end and a write end. We need to be
+				// able to read from the read end after write end is closed.
+				refcnt: 2,
+				timestamp: new Date(),
+			};
+			pipe.buckets.push({
+				buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE),
+				offset: 0,
+				roffset: 0,
+			});
+			var rName = PIPEFS.nextname();
+			var wName = PIPEFS.nextname();
+			var rNode = FS.createNode(PIPEFS.root, rName, 4096, 0);
+			var wNode = FS.createNode(PIPEFS.root, wName, 4096, 0);
+			rNode.pipe = pipe;
+			wNode.pipe = pipe;
+			var readableStream = FS.createStream({
+				path: rName,
+				node: rNode,
+				flags: 0,
+				seekable: false,
+				stream_ops: PIPEFS.stream_ops,
+			});
+			rNode.stream = readableStream;
+			var writableStream = FS.createStream({
+				path: wName,
+				node: wNode,
+				flags: 1,
+				seekable: false,
+				stream_ops: PIPEFS.stream_ops,
+			});
+			wNode.stream = writableStream;
+			return {
+				readable_fd: readableStream.fd,
+				writable_fd: writableStream.fd,
+			};
+		},
+		stream_ops: {
+			getattr(stream) {
+				var node = stream.node;
+				var timestamp = node.pipe.timestamp;
+				return {
+					dev: 14,
+					ino: node.id,
+					mode: 4480,
+					nlink: 1,
+					uid: 0,
+					gid: 0,
+					rdev: 0,
+					size: 0,
+					atime: timestamp,
+					mtime: timestamp,
+					ctime: timestamp,
+					blksize: 4096,
+					blocks: 0,
+				};
+			},
+			poll(stream) {
+				var pipe = stream.node.pipe;
+				if ((stream.flags & 2097155) === 1) {
+					return 256 | 4;
+				}
+				for (var bucket of pipe.buckets) {
+					if (bucket.offset - bucket.roffset > 0) {
+						return 64 | 1;
+					}
+				}
+				return 0;
+			},
+			dup(stream) {
+				stream.node.pipe.refcnt++;
+			},
+			ioctl(stream, request, varargs) {
+				return 28;
+			},
+			fsync(stream) {
+				return 28;
+			},
+			read(stream, buffer, offset, length, position) {
+				var pipe = stream.node.pipe;
+				var currentLength = 0;
+				for (var bucket of pipe.buckets) {
+					currentLength += bucket.offset - bucket.roffset;
+				}
+				var data = buffer.subarray(offset, offset + length);
+				if (length <= 0) {
+					return 0;
+				}
+				if (currentLength == 0) {
+					// Behave as if the read end is always non-blocking
+					throw new FS.ErrnoError(6);
+				}
+				var toRead = Math.min(currentLength, length);
+				var totalRead = toRead;
+				var toRemove = 0;
+				for (var bucket of pipe.buckets) {
+					var bucketSize = bucket.offset - bucket.roffset;
+					if (toRead <= bucketSize) {
+						var tmpSlice = bucket.buffer.subarray(
+							bucket.roffset,
+							bucket.offset
+						);
+						if (toRead < bucketSize) {
+							tmpSlice = tmpSlice.subarray(0, toRead);
+							bucket.roffset += toRead;
+						} else {
+							toRemove++;
+						}
+						data.set(tmpSlice);
+						break;
+					} else {
+						var tmpSlice = bucket.buffer.subarray(
+							bucket.roffset,
+							bucket.offset
+						);
+						data.set(tmpSlice);
+						data = data.subarray(tmpSlice.byteLength);
+						toRead -= tmpSlice.byteLength;
+						toRemove++;
+					}
+				}
+				if (toRemove && toRemove == pipe.buckets.length) {
+					// Do not generate excessive garbage in use cases such as
+					// write several bytes, read everything, write several bytes, read everything...
+					toRemove--;
+					pipe.buckets[toRemove].offset = 0;
+					pipe.buckets[toRemove].roffset = 0;
+				}
+				pipe.buckets.splice(0, toRemove);
+				return totalRead;
+			},
+			write(stream, buffer, offset, length, position) {
+				var pipe = stream.node.pipe;
+				var data = buffer.subarray(offset, offset + length);
+				var dataLen = data.byteLength;
+				if (dataLen <= 0) {
+					return 0;
+				}
+				var currBucket = null;
+				if (pipe.buckets.length == 0) {
+					currBucket = {
+						buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE),
+						offset: 0,
+						roffset: 0,
+					};
+					pipe.buckets.push(currBucket);
+				} else {
+					currBucket = pipe.buckets[pipe.buckets.length - 1];
+				}
+				assert(currBucket.offset <= PIPEFS.BUCKET_BUFFER_SIZE);
+				var freeBytesInCurrBuffer =
+					PIPEFS.BUCKET_BUFFER_SIZE - currBucket.offset;
+				if (freeBytesInCurrBuffer >= dataLen) {
+					currBucket.buffer.set(data, currBucket.offset);
+					currBucket.offset += dataLen;
+					return dataLen;
+				} else if (freeBytesInCurrBuffer > 0) {
+					currBucket.buffer.set(
+						data.subarray(0, freeBytesInCurrBuffer),
+						currBucket.offset
+					);
+					currBucket.offset += freeBytesInCurrBuffer;
+					data = data.subarray(
+						freeBytesInCurrBuffer,
+						data.byteLength
+					);
+				}
+				var numBuckets =
+					(data.byteLength / PIPEFS.BUCKET_BUFFER_SIZE) | 0;
+				var remElements = data.byteLength % PIPEFS.BUCKET_BUFFER_SIZE;
+				for (var i = 0; i < numBuckets; i++) {
+					var newBucket = {
+						buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE),
+						offset: PIPEFS.BUCKET_BUFFER_SIZE,
+						roffset: 0,
+					};
+					pipe.buckets.push(newBucket);
+					newBucket.buffer.set(
+						data.subarray(0, PIPEFS.BUCKET_BUFFER_SIZE)
+					);
+					data = data.subarray(
+						PIPEFS.BUCKET_BUFFER_SIZE,
+						data.byteLength
+					);
+				}
+				if (remElements > 0) {
+					var newBucket = {
+						buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE),
+						offset: data.byteLength,
+						roffset: 0,
+					};
+					pipe.buckets.push(newBucket);
+					newBucket.buffer.set(data);
+				}
+				return dataLen;
+			},
+			close(stream) {
+				var pipe = stream.node.pipe;
+				pipe.refcnt--;
+				if (pipe.refcnt === 0) {
+					pipe.buckets = null;
+				}
+			},
+		},
+		nextname() {
+			if (!PIPEFS.nextname.current) {
+				PIPEFS.nextname.current = 0;
+			}
+			return 'pipe[' + PIPEFS.nextname.current++ + ']';
+		},
+	};
+
+	function ___syscall_pipe(fdPtr) {
+		try {
+			if (fdPtr == 0) {
+				throw new FS.ErrnoError(21);
+			}
+			var res = PIPEFS.createPipe();
+			HEAP32[fdPtr >> 2] = res.readable_fd;
+			HEAP32[(fdPtr + 4) >> 2] = res.writable_fd;
+			return 0;
+		} catch (e) {
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return -e.errno;
 		}
-		// "now" is in ms, and wasi times are in ns.
-		var nsec = Math.round(now * 1e3 * 1e3);
-		HEAP64[ptime >> 3] = BigInt(nsec);
-		return 0;
 	}
 
-	var getHeapMax = () =>
-		// Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
-		// full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
-		// for any code that deals with heap sizes, which would require special
-		// casing all heap size related code to treat 0 specially.
-		2147483648;
-
-	var _emscripten_get_heap_max = () => getHeapMax();
-
-	var growMemory = (size) => {
-		var b = wasmMemory.buffer;
-		var pages = ((size - b.byteLength + 65535) / 65536) | 0;
+	function ___syscall_poll(fds, nfds, timeout) {
 		try {
-			// round size grow request up to wasm page size (fixed 64KB per spec)
-			wasmMemory.grow(pages);
-			// .grow() takes a delta compared to the previous size
-			updateMemoryViews();
-			return 1;
-		} catch (e) {}
-	};
+			var nonzero = 0;
+			for (var i = 0; i < nfds; i++) {
+				var pollfd = fds + 8 * i;
+				var fd = HEAP32[pollfd >> 2];
+				var events = HEAP16[(pollfd + 4) >> 1];
+				var mask = 32;
+				var stream = FS.getStream(fd);
+				if (stream) {
+					mask = SYSCALLS.DEFAULT_POLLMASK;
+					if (stream.stream_ops?.poll) {
+						mask = stream.stream_ops.poll(stream, -1);
+					}
+				}
+				mask &= events | 8 | 16;
+				if (mask) nonzero++;
+				HEAP16[(pollfd + 6) >> 1] = mask;
+			}
+			return nonzero;
+		} catch (e) {
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return -e.errno;
+		}
+	}
 
-	var _emscripten_resize_heap = (requestedSize) => {
-		var oldSize = HEAPU8.length;
-		// With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned.
-		requestedSize >>>= 0;
-		// With multithreaded builds, races can happen (another thread might increase the size
-		// in between), so return a failure, and let the caller retry.
-		// Memory resize rules:
-		// 1.  Always increase heap size to at least the requested size, rounded up
-		//     to next page multiple.
-		// 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap
-		//     geometrically: increase the heap size according to
-		//     MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most
-		//     overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB).
-		// 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap
-		//     linearly: increase the heap size by at least
-		//     MEMORY_GROWTH_LINEAR_STEP bytes.
-		// 3.  Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by
-		//     MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest
-		// 4.  If we were unable to allocate as much memory, it may be due to
-		//     over-eager decision to excessively reserve due to (3) above.
-		//     Hence if an allocation fails, cut down on the amount of excess
-		//     growth, in an attempt to succeed to perform a smaller allocation.
-		// A limit is set for how much we can grow. We should not exceed that
-		// (the wasm binary specifies it, so if we tried, we'd fail anyhow).
-		var maxHeapSize = getHeapMax();
-		if (requestedSize > maxHeapSize) {
-			return false;
+	function ___syscall_readlinkat(dirfd, path, buf, bufsize) {
+		try {
+			path = SYSCALLS.getStr(path);
+			path = SYSCALLS.calculateAt(dirfd, path);
+			if (bufsize <= 0) return -28;
+			var ret = FS.readlink(path);
+			var len = Math.min(bufsize, lengthBytesUTF8(ret));
+			var endChar = HEAP8[buf + len];
+			stringToUTF8(ret, buf, bufsize + 1);
+			// readlink is one of the rare functions that write out a C string, but does never append a null to the output buffer(!)
+			// stringToUTF8() always appends a null byte, so restore the character under the null byte after the write.
+			HEAP8[buf + len] = endChar;
+			return len;
+		} catch (e) {
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return -e.errno;
 		}
-		// Loop through potential heap size increases. If we attempt a too eager
-		// reservation that fails, cut down on the attempted size and reserve a
-		// smaller bump instead. (max 3 times, chosen somewhat arbitrarily)
-		for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
-			var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
-			// ensure geometric growth
-			// but limit overreserving (default to capping at +96MB overgrowth at most)
-			overGrownHeapSize = Math.min(
-				overGrownHeapSize,
-				requestedSize + 100663296
-			);
-			var newSize = Math.min(
-				maxHeapSize,
-				alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536)
+	}
+
+	function ___syscall_recvfrom(fd, buf, len, flags, addr, addrlen) {
+		try {
+			var sock = getSocketFromFD(fd);
+			var msg = sock.sock_ops.recvmsg(
+				sock,
+				len,
+				typeof flags !== 'undefined' ? flags : 0
 			);
-			var replacement = growMemory(newSize);
-			if (replacement) {
-				return true;
+			if (!msg) return 0;
+			// socket is closed
+			if (addr) {
+				var errno = writeSockaddr(
+					addr,
+					sock.family,
+					DNS.lookup_name(msg.addr),
+					msg.port,
+					addrlen
+				);
 			}
+			HEAPU8.set(msg.buffer, buf);
+			return msg.buffer.byteLength;
+		} catch (e) {
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return -e.errno;
 		}
-		return false;
-	};
-
-	var runtimeKeepalivePush = () => {
-		runtimeKeepaliveCounter += 1;
-	};
-
-	var runtimeKeepalivePop = () => {
-		runtimeKeepaliveCounter -= 1;
-	};
-
-	/** @param {number=} timeout */ var safeSetTimeout = (func, timeout) => {
-		runtimeKeepalivePush();
-		return setTimeout(() => {
-			runtimeKeepalivePop();
-			callUserCallback(func);
-		}, timeout);
-	};
-
-	var _emscripten_sleep = (ms) =>
-		Asyncify.handleSleep((wakeUp) => safeSetTimeout(wakeUp, ms));
-
-	Module['_emscripten_sleep'] = _emscripten_sleep;
-
-	_emscripten_sleep.isAsync = true;
+	}
 
-	var ENV = PHPLoader.ENV || {};
+	function ___syscall_renameat(olddirfd, oldpath, newdirfd, newpath) {
+		try {
+			oldpath = SYSCALLS.getStr(oldpath);
+			newpath = SYSCALLS.getStr(newpath);
+			oldpath = SYSCALLS.calculateAt(olddirfd, oldpath);
+			newpath = SYSCALLS.calculateAt(newdirfd, newpath);
+			FS.rename(oldpath, newpath);
+			return 0;
+		} catch (e) {
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return -e.errno;
+		}
+	}
 
-	var getExecutableName = () => thisProgram || './this.program';
+	function ___syscall_rmdir(path) {
+		try {
+			path = SYSCALLS.getStr(path);
+			FS.rmdir(path);
+			return 0;
+		} catch (e) {
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return -e.errno;
+		}
+	}
 
-	var getEnvStrings = () => {
-		if (!getEnvStrings.strings) {
-			// Default values.
-			// Browser language detection #8751
-			var lang =
-				(
-					(typeof navigator == 'object' &&
-						navigator.languages &&
-						navigator.languages[0]) ||
-					'C'
-				).replace('-', '_') + '.UTF-8';
-			var env = {
-				USER: 'web_user',
-				LOGNAME: 'web_user',
-				PATH: '/',
-				PWD: '/',
-				HOME: '/home/web_user',
-				LANG: lang,
-				_: getExecutableName(),
-			};
-			// Apply the user-provided values, if any.
-			for (var x in ENV) {
-				// x is a key in ENV; if ENV[x] is undefined, that means it was
-				// explicitly set to be so. We allow user code to do that to
-				// force variables with default values to remain unset.
-				if (ENV[x] === undefined) delete env[x];
-				else env[x] = ENV[x];
-			}
-			var strings = [];
-			for (var x in env) {
-				strings.push(`${x}=${env[x]}`);
+	function ___syscall_sendto(fd, message, length, flags, addr, addr_len) {
+		try {
+			var sock = getSocketFromFD(fd);
+			if (!addr) {
+				// send, no address provided
+				return FS.write(sock.stream, HEAP8, message, length);
 			}
-			getEnvStrings.strings = strings;
+			var dest = getSocketAddress(addr, addr_len);
+			// sendto an address
+			return sock.sock_ops.sendmsg(
+				sock,
+				HEAP8,
+				message,
+				length,
+				dest.addr,
+				dest.port
+			);
+		} catch (e) {
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return -e.errno;
+		}
+	}
+
+	function ___syscall_socket(domain, type, protocol) {
+		try {
+			var sock = SOCKFS.createSocket(domain, type, protocol);
+			return sock.stream.fd;
+		} catch (e) {
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return -e.errno;
 		}
-		return getEnvStrings.strings;
-	};
+	}
 
-	var stringToAscii = (str, buffer) => {
-		for (var i = 0; i < str.length; ++i) {
-			HEAP8[buffer++] = str.charCodeAt(i);
+	function ___syscall_stat64(path, buf) {
+		try {
+			path = SYSCALLS.getStr(path);
+			return SYSCALLS.writeStat(buf, FS.stat(path));
+		} catch (e) {
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return -e.errno;
 		}
-		// Null-terminate the string
-		HEAP8[buffer] = 0;
-	};
+	}
 
-	var _environ_get = (__environ, environ_buf) => {
-		var bufSize = 0;
-		getEnvStrings().forEach((string, i) => {
-			var ptr = environ_buf + bufSize;
-			HEAPU32[(__environ + i * 4) >> 2] = ptr;
-			stringToAscii(string, ptr);
-			bufSize += string.length + 1;
-		});
-		return 0;
-	};
+	function ___syscall_statfs64(path, size, buf) {
+		try {
+			SYSCALLS.writeStatFs(buf, FS.statfs(SYSCALLS.getStr(path)));
+			return 0;
+		} catch (e) {
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return -e.errno;
+		}
+	}
 
-	var _environ_sizes_get = (penviron_count, penviron_buf_size) => {
-		var strings = getEnvStrings();
-		HEAPU32[penviron_count >> 2] = strings.length;
-		var bufSize = 0;
-		strings.forEach((string) => (bufSize += string.length + 1));
-		HEAPU32[penviron_buf_size >> 2] = bufSize;
-		return 0;
-	};
+	function ___syscall_symlinkat(target, dirfd, linkpath) {
+		try {
+			target = SYSCALLS.getStr(target);
+			linkpath = SYSCALLS.getStr(linkpath);
+			linkpath = SYSCALLS.calculateAt(dirfd, linkpath);
+			FS.symlink(target, linkpath);
+			return 0;
+		} catch (e) {
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return -e.errno;
+		}
+	}
 
-	function _fd_close(fd) {
+	function ___syscall_unlinkat(dirfd, path, flags) {
 		try {
-			var stream = SYSCALLS.getStreamFromFD(fd);
-			FS.close(stream);
+			path = SYSCALLS.getStr(path);
+			path = SYSCALLS.calculateAt(dirfd, path);
+			if (flags === 0) {
+				FS.unlink(path);
+			} else if (flags === 512) {
+				FS.rmdir(path);
+			} else {
+				abort('Invalid flags passed to unlinkat');
+			}
 			return 0;
 		} catch (e) {
 			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return e.errno;
+			return -e.errno;
 		}
 	}
 
-	function _fd_fdstat_get(fd, pbuf) {
+	var readI53FromI64 = (ptr) =>
+		HEAPU32[ptr >> 2] + HEAP32[(ptr + 4) >> 2] * 4294967296;
+
+	function ___syscall_utimensat(dirfd, path, times, flags) {
 		try {
-			var rightsBase = 0;
-			var rightsInheriting = 0;
-			var flags = 0;
-			{
-				var stream = SYSCALLS.getStreamFromFD(fd);
-				// All character devices are terminals (other things a Linux system would
-				// assume is a character device, like the mouse, we have special APIs for).
-				var type = stream.tty
-					? 2
-					: FS.isDir(stream.mode)
-					? 3
-					: FS.isLink(stream.mode)
-					? 7
-					: 4;
+			path = SYSCALLS.getStr(path);
+			path = SYSCALLS.calculateAt(dirfd, path, true);
+			var now = Date.now(),
+				atime,
+				mtime;
+			if (!times) {
+				atime = now;
+				mtime = now;
+			} else {
+				var seconds = readI53FromI64(times);
+				var nanoseconds = HEAP32[(times + 8) >> 2];
+				if (nanoseconds == 1073741823) {
+					atime = now;
+				} else if (nanoseconds == 1073741822) {
+					atime = null;
+				} else {
+					atime = seconds * 1e3 + nanoseconds / (1e3 * 1e3);
+				}
+				times += 16;
+				seconds = readI53FromI64(times);
+				nanoseconds = HEAP32[(times + 8) >> 2];
+				if (nanoseconds == 1073741823) {
+					mtime = now;
+				} else if (nanoseconds == 1073741822) {
+					mtime = null;
+				} else {
+					mtime = seconds * 1e3 + nanoseconds / (1e3 * 1e3);
+				}
+			}
+			// null here means UTIME_OMIT was passed. If both were set to UTIME_OMIT then
+			// we can skip the call completely.
+			if ((mtime ?? atime) !== null) {
+				FS.utime(path, atime, mtime);
 			}
-			HEAP8[pbuf] = type;
-			HEAP16[(pbuf + 2) >> 1] = flags;
-			HEAP64[(pbuf + 8) >> 3] = BigInt(rightsBase);
-			HEAP64[(pbuf + 16) >> 3] = BigInt(rightsInheriting);
 			return 0;
 		} catch (e) {
 			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return e.errno;
+			return -e.errno;
 		}
 	}
 
-	/** @param {number=} offset */ var doReadv = (
-		stream,
-		iov,
-		iovcnt,
-		offset
-	) => {
-		var ret = 0;
-		for (var i = 0; i < iovcnt; i++) {
-			var ptr = HEAPU32[iov >> 2];
-			var len = HEAPU32[(iov + 4) >> 2];
-			iov += 8;
-			var curr = FS.read(stream, HEAP8, ptr, len, offset);
-			if (curr < 0) return -1;
-			ret += curr;
-			if (curr < len) break;
-			// nothing more to read
-			if (typeof offset != 'undefined') {
-				offset += curr;
+	var __abort_js = () => abort('');
+
+	var __emscripten_lookup_name = (name) => {
+		// uint32_t _emscripten_lookup_name(const char *name);
+		var nameString = UTF8ToString(name);
+		return inetPton4(DNS.lookup_name(nameString));
+	};
+
+	var runtimeKeepaliveCounter = 0;
+
+	var __emscripten_runtime_keepalive_clear = () => {
+		noExitRuntime = false;
+		runtimeKeepaliveCounter = 0;
+	};
+
+	function __gmtime_js(time, tmPtr) {
+		time = bigintToI53Checked(time);
+		var date = new Date(time * 1e3);
+		HEAP32[tmPtr >> 2] = date.getUTCSeconds();
+		HEAP32[(tmPtr + 4) >> 2] = date.getUTCMinutes();
+		HEAP32[(tmPtr + 8) >> 2] = date.getUTCHours();
+		HEAP32[(tmPtr + 12) >> 2] = date.getUTCDate();
+		HEAP32[(tmPtr + 16) >> 2] = date.getUTCMonth();
+		HEAP32[(tmPtr + 20) >> 2] = date.getUTCFullYear() - 1900;
+		HEAP32[(tmPtr + 24) >> 2] = date.getUTCDay();
+		var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0);
+		var yday = ((date.getTime() - start) / (1e3 * 60 * 60 * 24)) | 0;
+		HEAP32[(tmPtr + 28) >> 2] = yday;
+	}
+
+	var isLeapYear = (year) =>
+		year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+
+	var MONTH_DAYS_LEAP_CUMULATIVE = [
+		0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335,
+	];
+
+	var MONTH_DAYS_REGULAR_CUMULATIVE = [
+		0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334,
+	];
+
+	var ydayFromDate = (date) => {
+		var leap = isLeapYear(date.getFullYear());
+		var monthDaysCumulative = leap
+			? MONTH_DAYS_LEAP_CUMULATIVE
+			: MONTH_DAYS_REGULAR_CUMULATIVE;
+		var yday = monthDaysCumulative[date.getMonth()] + date.getDate() - 1;
+		// -1 since it's days since Jan 1
+		return yday;
+	};
+
+	function __localtime_js(time, tmPtr) {
+		time = bigintToI53Checked(time);
+		var date = new Date(time * 1e3);
+		HEAP32[tmPtr >> 2] = date.getSeconds();
+		HEAP32[(tmPtr + 4) >> 2] = date.getMinutes();
+		HEAP32[(tmPtr + 8) >> 2] = date.getHours();
+		HEAP32[(tmPtr + 12) >> 2] = date.getDate();
+		HEAP32[(tmPtr + 16) >> 2] = date.getMonth();
+		HEAP32[(tmPtr + 20) >> 2] = date.getFullYear() - 1900;
+		HEAP32[(tmPtr + 24) >> 2] = date.getDay();
+		var yday = ydayFromDate(date) | 0;
+		HEAP32[(tmPtr + 28) >> 2] = yday;
+		HEAP32[(tmPtr + 36) >> 2] = -(date.getTimezoneOffset() * 60);
+		// Attention: DST is in December in South, and some regions don't have DST at all.
+		var start = new Date(date.getFullYear(), 0, 1);
+		var summerOffset = new Date(
+			date.getFullYear(),
+			6,
+			1
+		).getTimezoneOffset();
+		var winterOffset = start.getTimezoneOffset();
+		var dst =
+			(summerOffset != winterOffset &&
+				date.getTimezoneOffset() ==
+					Math.min(winterOffset, summerOffset)) | 0;
+		HEAP32[(tmPtr + 32) >> 2] = dst;
+	}
+
+	var __mktime_js = function (tmPtr) {
+		var ret = (() => {
+			var date = new Date(
+				HEAP32[(tmPtr + 20) >> 2] + 1900,
+				HEAP32[(tmPtr + 16) >> 2],
+				HEAP32[(tmPtr + 12) >> 2],
+				HEAP32[(tmPtr + 8) >> 2],
+				HEAP32[(tmPtr + 4) >> 2],
+				HEAP32[tmPtr >> 2],
+				0
+			);
+			// There's an ambiguous hour when the time goes back; the tm_isdst field is
+			// used to disambiguate it.  Date() basically guesses, so we fix it up if it
+			// guessed wrong, or fill in tm_isdst with the guess if it's -1.
+			var dst = HEAP32[(tmPtr + 32) >> 2];
+			var guessedOffset = date.getTimezoneOffset();
+			var start = new Date(date.getFullYear(), 0, 1);
+			var summerOffset = new Date(
+				date.getFullYear(),
+				6,
+				1
+			).getTimezoneOffset();
+			var winterOffset = start.getTimezoneOffset();
+			var dstOffset = Math.min(winterOffset, summerOffset);
+			// DST is in December in South
+			if (dst < 0) {
+				// Attention: some regions don't have DST at all.
+				HEAP32[(tmPtr + 32) >> 2] = Number(
+					summerOffset != winterOffset && dstOffset == guessedOffset
+				);
+			} else if (dst > 0 != (dstOffset == guessedOffset)) {
+				var nonDstOffset = Math.max(winterOffset, summerOffset);
+				var trueOffset = dst > 0 ? dstOffset : nonDstOffset;
+				// Don't try setMinutes(date.getMinutes() + ...) -- it's messed up.
+				date.setTime(
+					date.getTime() + (trueOffset - guessedOffset) * 6e4
+				);
 			}
-		}
-		return ret;
+			HEAP32[(tmPtr + 24) >> 2] = date.getDay();
+			var yday = ydayFromDate(date) | 0;
+			HEAP32[(tmPtr + 28) >> 2] = yday;
+			// To match expected behavior, update fields from date
+			HEAP32[tmPtr >> 2] = date.getSeconds();
+			HEAP32[(tmPtr + 4) >> 2] = date.getMinutes();
+			HEAP32[(tmPtr + 8) >> 2] = date.getHours();
+			HEAP32[(tmPtr + 12) >> 2] = date.getDate();
+			HEAP32[(tmPtr + 16) >> 2] = date.getMonth();
+			HEAP32[(tmPtr + 20) >> 2] = date.getYear();
+			var timeMs = date.getTime();
+			if (isNaN(timeMs)) {
+				return -1;
+			}
+			// Return time in microseconds
+			return timeMs / 1e3;
+		})();
+		return BigInt(ret);
 	};
 
-	function _fd_read(fd, iov, iovcnt, pnum) {
+	function __mmap_js(len, prot, flags, fd, offset, allocated, addr) {
+		offset = bigintToI53Checked(offset);
 		try {
+			if (isNaN(offset)) return 61;
 			var stream = SYSCALLS.getStreamFromFD(fd);
-			var num = doReadv(stream, iov, iovcnt);
-			HEAPU32[pnum >> 2] = num;
+			var res = FS.mmap(stream, len, offset, prot, flags);
+			var ptr = res.ptr;
+			HEAP32[allocated >> 2] = res.allocated;
+			HEAPU32[addr >> 2] = ptr;
 			return 0;
 		} catch (e) {
 			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return e.errno;
+			return -e.errno;
 		}
 	}
 
-	function _fd_seek(fd, offset, whence, newOffset) {
+	function __munmap_js(addr, len, prot, flags, fd, offset) {
 		offset = bigintToI53Checked(offset);
 		try {
-			if (isNaN(offset)) return 61;
 			var stream = SYSCALLS.getStreamFromFD(fd);
-			FS.llseek(stream, offset, whence);
-			HEAP64[newOffset >> 3] = BigInt(stream.position);
-			if (stream.getdents && offset === 0 && whence === 0)
-				stream.getdents = null;
-			// reset readdir state
-			return 0;
+			if (prot & 2) {
+				SYSCALLS.doMsync(addr, stream, len, flags, offset);
+			}
 		} catch (e) {
 			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return e.errno;
+			return -e.errno;
 		}
 	}
 
-	var _fd_sync = function (fd) {
-		try {
-			var stream = SYSCALLS.getStreamFromFD(fd);
-			return Asyncify.handleSleep((wakeUp) => {
-				var mount = stream.node.mount;
-				if (!mount.type.syncfs) {
-					// We write directly to the file system, so there's nothing to do here.
-					wakeUp(0);
-					return;
-				}
-				mount.type.syncfs(mount, false, (err) => {
-					if (err) {
-						wakeUp(29);
-						return;
-					}
-					wakeUp(0);
-				});
-			});
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return e.errno;
+	var timers = {};
+
+	var handleException = (e) => {
+		// Certain exception types we do not treat as errors since they are used for
+		// internal control flow.
+		// 1. ExitStatus, which is thrown by exit()
+		// 2. "unwind", which is thrown by emscripten_unwind_to_js_event_loop() and others
+		//    that wish to return to JS event loop.
+		if (e instanceof ExitStatus || e == 'unwind') {
+			return EXITSTATUS;
 		}
+		quit_(1, e);
 	};
 
-	_fd_sync.isAsync = true;
+	var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
 
-	/** @param {number=} offset */ var doWritev = (
-		stream,
-		iov,
-		iovcnt,
-		offset
-	) => {
-		var ret = 0;
-		for (var i = 0; i < iovcnt; i++) {
-			var ptr = HEAPU32[iov >> 2];
-			var len = HEAPU32[(iov + 4) >> 2];
-			iov += 8;
-			var curr = FS.write(stream, HEAP8, ptr, len, offset);
-			if (curr < 0) return -1;
-			ret += curr;
-			if (curr < len) {
-				// No more space to write.
-				break;
-			}
-			if (typeof offset != 'undefined') {
-				offset += curr;
-			}
+	var _proc_exit = (code) => {
+		EXITSTATUS = code;
+		if (!keepRuntimeAlive()) {
+			Module['onExit']?.(code);
+			ABORT = true;
 		}
-		return ret;
+		quit_(code, new ExitStatus(code));
 	};
 
-	function _fd_write(fd, iov, iovcnt, pnum) {
-		try {
-			var stream = SYSCALLS.getStreamFromFD(fd);
-			var num = doWritev(stream, iov, iovcnt);
-			HEAPU32[pnum >> 2] = num;
-			return 0;
-		} catch (e) {
-			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
-			return e.errno;
-		}
-	}
-
-	var _getaddrinfo = (node, service, hint, out) => {
-		var addr = 0;
-		var port = 0;
-		var flags = 0;
-		var family = 0;
-		var type = 0;
-		var proto = 0;
-		var ai;
-		function allocaddrinfo(family, type, proto, canon, addr, port) {
-			var sa, salen, ai;
-			var errno;
-			salen = family === 10 ? 28 : 16;
-			addr = family === 10 ? inetNtop6(addr) : inetNtop4(addr);
-			sa = _malloc(salen);
-			errno = writeSockaddr(sa, family, addr, port);
-			assert(!errno);
-			ai = _malloc(32);
-			HEAP32[(ai + 4) >> 2] = family;
-			HEAP32[(ai + 8) >> 2] = type;
-			HEAP32[(ai + 12) >> 2] = proto;
-			HEAPU32[(ai + 24) >> 2] = canon;
-			HEAPU32[(ai + 20) >> 2] = sa;
-			if (family === 10) {
-				HEAP32[(ai + 16) >> 2] = 28;
-			} else {
-				HEAP32[(ai + 16) >> 2] = 16;
-			}
-			HEAP32[(ai + 28) >> 2] = 0;
-			return ai;
-		}
-		if (hint) {
-			flags = HEAP32[hint >> 2];
-			family = HEAP32[(hint + 4) >> 2];
-			type = HEAP32[(hint + 8) >> 2];
-			proto = HEAP32[(hint + 12) >> 2];
-		}
-		if (type && !proto) {
-			proto = type === 2 ? 17 : 6;
-		}
-		if (!type && proto) {
-			type = proto === 17 ? 2 : 1;
-		}
-		// If type or proto are set to zero in hints we should really be returning multiple addrinfo values, but for
-		// now default to a TCP STREAM socket so we can at least return a sensible addrinfo given NULL hints.
-		if (proto === 0) {
-			proto = 6;
-		}
-		if (type === 0) {
-			type = 1;
-		}
-		if (!node && !service) {
-			return -2;
-		}
-		if (flags & ~(1 | 2 | 4 | 1024 | 8 | 16 | 32)) {
-			return -1;
-		}
-		if (hint !== 0 && HEAP32[hint >> 2] & 2 && !node) {
-			return -1;
-		}
-		if (flags & 32) {
-			// TODO
-			return -2;
-		}
-		if (type !== 0 && type !== 1 && type !== 2) {
-			return -7;
-		}
-		if (family !== 0 && family !== 2 && family !== 10) {
-			return -6;
-		}
-		if (service) {
-			service = UTF8ToString(service);
-			port = parseInt(service, 10);
-			if (isNaN(port)) {
-				if (flags & 1024) {
-					return -2;
-				}
-				// TODO support resolving well-known service names from:
-				// http://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.txt
-				return -8;
-			}
-		}
-		if (!node) {
-			if (family === 0) {
-				family = 2;
-			}
-			if ((flags & 1) === 0) {
-				if (family === 2) {
-					addr = _htonl(2130706433);
-				} else {
-					addr = [0, 0, 0, _htonl(1)];
-				}
-			}
-			ai = allocaddrinfo(family, type, proto, null, addr, port);
-			HEAPU32[out >> 2] = ai;
-			return 0;
-		}
-		// try as a numeric address
-		node = UTF8ToString(node);
-		addr = inetPton4(node);
-		if (addr !== null) {
-			// incoming node is a valid ipv4 address
-			if (family === 0 || family === 2) {
-				family = 2;
-			} else if (family === 10 && flags & 8) {
-				addr = [0, 0, _htonl(65535), addr];
-				family = 10;
-			} else {
-				return -2;
-			}
-		} else {
-			addr = inetPton6(node);
-			if (addr !== null) {
-				// incoming node is a valid ipv6 address
-				if (family === 0 || family === 10) {
-					family = 10;
-				} else {
-					return -2;
-				}
+	/** @suppress {duplicate } */ /** @param {boolean|number=} implicit */ var exitJS =
+		(status, implicit) => {
+			EXITSTATUS = status;
+			if (!keepRuntimeAlive()) {
+				exitRuntime();
 			}
+			_proc_exit(status);
+		};
+
+	var _exit = exitJS;
+
+	Module['_exit'] = _exit;
+
+	var maybeExit = () => {
+		if (runtimeExited) {
+			return;
 		}
-		if (addr != null) {
-			ai = allocaddrinfo(family, type, proto, node, addr, port);
-			HEAPU32[out >> 2] = ai;
-			return 0;
+		if (!keepRuntimeAlive()) {
+			try {
+				_exit(EXITSTATUS);
+			} catch (e) {
+				handleException(e);
+			}
 		}
-		if (flags & 4) {
-			return -2;
+	};
+
+	var callUserCallback = (func) => {
+		if (runtimeExited || ABORT) {
+			return;
 		}
-		// 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];
+		try {
+			func();
+			maybeExit();
+		} catch (e) {
+			handleException(e);
 		}
-		ai = allocaddrinfo(family, type, proto, null, addr, port);
-		HEAPU32[out >> 2] = ai;
-		return 0;
 	};
 
-	var _getcontext = () => abort('missing function: ${name}');
+	var _emscripten_get_now = () => performance.now();
 
-	var _getnameinfo = (sa, salen, node, nodelen, serv, servlen, flags) => {
-		var info = readSockaddr(sa, salen);
-		if (info.errno) {
-			return -6;
+	var __setitimer_js = (which, timeout_ms) => {
+		// First, clear any existing timer.
+		if (timers[which]) {
+			clearTimeout(timers[which].id);
+			delete timers[which];
 		}
-		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;
-			}
+		// A timeout of zero simply cancels the current timeout so we have nothing
+		// more to do.
+		if (!timeout_ms) return 0;
+		var id = setTimeout(() => {
+			delete timers[which];
+			callUserCallback(() =>
+				__emscripten_timeout(which, _emscripten_get_now())
+			);
+		}, timeout_ms);
+		timers[which] = {
+			id,
+			timeout_ms,
+		};
+		return 0;
+	};
+
+	var __tzset_js = (timezone, daylight, std_name, dst_name) => {
+		// TODO: Use (malleable) environment variables instead of system settings.
+		var currentYear = new Date().getFullYear();
+		var winter = new Date(currentYear, 0, 1);
+		var summer = new Date(currentYear, 6, 1);
+		var winterOffset = winter.getTimezoneOffset();
+		var summerOffset = summer.getTimezoneOffset();
+		// Local standard timezone offset. Local standard time is not adjusted for
+		// daylight savings.  This code uses the fact that getTimezoneOffset returns
+		// a greater value during Standard Time versus Daylight Saving Time (DST).
+		// Thus it determines the expected output during Standard Time, and it
+		// compares whether the output of the given date the same (Standard) or less
+		// (DST).
+		var stdTimezoneOffset = Math.max(winterOffset, summerOffset);
+		// timezone is specified as seconds west of UTC ("The external variable
+		// `timezone` shall be set to the difference, in seconds, between
+		// Coordinated Universal Time (UTC) and local standard time."), the same
+		// as returned by stdTimezoneOffset.
+		// See http://pubs.opengroup.org/onlinepubs/009695399/functions/tzset.html
+		HEAPU32[timezone >> 2] = stdTimezoneOffset * 60;
+		HEAP32[daylight >> 2] = Number(winterOffset != summerOffset);
+		var extractZone = (timezoneOffset) => {
+			// Why inverse sign?
+			// Read here https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset
+			var sign = timezoneOffset >= 0 ? '-' : '+';
+			var absOffset = Math.abs(timezoneOffset);
+			var hours = String(Math.floor(absOffset / 60)).padStart(2, '0');
+			var minutes = String(absOffset % 60).padStart(2, '0');
+			return `UTC${sign}${hours}${minutes}`;
+		};
+		var winterName = extractZone(winterOffset);
+		var summerName = extractZone(summerOffset);
+		if (summerOffset < winterOffset) {
+			// Northern hemisphere
+			stringToUTF8(winterName, std_name, 17);
+			stringToUTF8(summerName, dst_name, 17);
+		} else {
+			stringToUTF8(winterName, dst_name, 17);
+			stringToUTF8(summerName, std_name, 17);
 		}
-		if (serv && servlen) {
-			port = '' + port;
-			var numBytesWrittenExclNull = stringToUTF8(port, serv, servlen);
-			if (numBytesWrittenExclNull + 1 >= servlen) {
-				overflowed = true;
-			}
+	};
+
+	var _emscripten_date_now = () => Date.now();
+
+	var nowIsMonotonic = 1;
+
+	var checkWasiClock = (clock_id) => clock_id >= 0 && clock_id <= 3;
+
+	function _clock_time_get(clk_id, ignored_precision, ptime) {
+		ignored_precision = bigintToI53Checked(ignored_precision);
+		if (!checkWasiClock(clk_id)) {
+			return 28;
 		}
-		if (overflowed) {
-			// Note: even when we overflow, getnameinfo() is specced to write out the truncated results.
-			return -12;
+		var now;
+		// all wasi clocks but realtime are monotonic
+		if (clk_id === 0) {
+			now = _emscripten_date_now();
+		} else if (nowIsMonotonic) {
+			now = _emscripten_get_now();
+		} else {
+			return 52;
 		}
+		// "now" is in ms, and wasi times are in ns.
+		var nsec = Math.round(now * 1e3 * 1e3);
+		HEAP64[ptime >> 3] = BigInt(nsec);
 		return 0;
-	};
+	}
 
-	var Protocols = {
-		list: [],
-		map: {},
+	var getHeapMax = () =>
+		// Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
+		// full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
+		// for any code that deals with heap sizes, which would require special
+		// casing all heap size related code to treat 0 specially.
+		2147483648;
+
+	var _emscripten_get_heap_max = () => getHeapMax();
+
+	var growMemory = (size) => {
+		var b = wasmMemory.buffer;
+		var pages = ((size - b.byteLength + 65535) / 65536) | 0;
+		try {
+			// round size grow request up to wasm page size (fixed 64KB per spec)
+			wasmMemory.grow(pages);
+			// .grow() takes a delta compared to the previous size
+			updateMemoryViews();
+			return 1;
+		} catch (e) {}
 	};
 
-	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;
+	var _emscripten_resize_heap = (requestedSize) => {
+		var oldSize = HEAPU8.length;
+		// With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned.
+		requestedSize >>>= 0;
+		// With multithreaded builds, races can happen (another thread might increase the size
+		// in between), so return a failure, and let the caller retry.
+		// Memory resize rules:
+		// 1.  Always increase heap size to at least the requested size, rounded up
+		//     to next page multiple.
+		// 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap
+		//     geometrically: increase the heap size according to
+		//     MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most
+		//     overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB).
+		// 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap
+		//     linearly: increase the heap size by at least
+		//     MEMORY_GROWTH_LINEAR_STEP bytes.
+		// 3.  Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by
+		//     MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest
+		// 4.  If we were unable to allocate as much memory, it may be due to
+		//     over-eager decision to excessively reserve due to (3) above.
+		//     Hence if an allocation fails, cut down on the amount of excess
+		//     growth, in an attempt to succeed to perform a smaller allocation.
+		// A limit is set for how much we can grow. We should not exceed that
+		// (the wasm binary specifies it, so if we tried, we'd fail anyhow).
+		var maxHeapSize = getHeapMax();
+		if (requestedSize > maxHeapSize) {
+			return false;
 		}
-		// 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;
+		// Loop through potential heap size increases. If we attempt a too eager
+		// reservation that fails, cut down on the attempted size and reserve a
+		// smaller bump instead. (max 3 times, chosen somewhat arbitrarily)
+		for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+			var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
+			// ensure geometric growth
+			// but limit overreserving (default to capping at +96MB overgrowth at most)
+			overGrownHeapSize = Math.min(
+				overGrownHeapSize,
+				requestedSize + 100663296
+			);
+			var newSize = Math.min(
+				maxHeapSize,
+				alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536)
+			);
+			var replacement = growMemory(newSize);
+			if (replacement) {
+				return true;
+			}
 		}
-		_setprotoent.index = 0;
+		return false;
 	};
 
-	var _getprotobyname = (name) => {
-		// struct protoent *getprotobyname(const char *);
-		name = UTF8ToString(name);
-		_setprotoent(true);
-		var result = Protocols.map[name];
-		return result;
+	var runtimeKeepalivePush = () => {
+		runtimeKeepaliveCounter += 1;
 	};
 
-	var _getprotobynumber = (number) => {
-		// struct protoent *getprotobynumber(int proto);
-		_setprotoent(true);
-		var result = Protocols.map[number];
-		return result;
+	var runtimeKeepalivePop = () => {
+		runtimeKeepaliveCounter -= 1;
 	};
 
-	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;
+	/** @param {number=} timeout */ var safeSetTimeout = (func, timeout) => {
+		runtimeKeepalivePush();
+		return setTimeout(() => {
+			runtimeKeepalivePop();
+			callUserCallback(func);
+		}, timeout);
 	};
 
-	var allocateUTF8OnStack = stringToUTF8OnStack;
+	var _emscripten_sleep = (ms) =>
+		Asyncify.handleSleep((wakeUp) => safeSetTimeout(wakeUp, ms));
 
-	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);
+	Module['_emscripten_sleep'] = _emscripten_sleep;
+
+	_emscripten_sleep.isAsync = true;
+
+	var ENV = PHPLoader.ENV || {};
+
+	var getExecutableName = () => thisProgram || './this.program';
+
+	var getEnvStrings = () => {
+		if (!getEnvStrings.strings) {
+			// Default values.
+			// Browser language detection #8751
+			var lang =
+				(
+					(typeof navigator == 'object' &&
+						navigator.languages &&
+						navigator.languages[0]) ||
+					'C'
+				).replace('-', '_') + '.UTF-8';
+			var env = {
+				USER: 'web_user',
+				LOGNAME: 'web_user',
+				PATH: '/',
+				PWD: '/',
+				HOME: '/home/web_user',
+				LANG: lang,
+				_: getExecutableName(),
 			};
-		},
-		onHeaders: function (chunk) {
-			if (Module['onHeaders']) {
-				Module['onHeaders'](chunk);
-				return;
-			}
-			console.log('headers', {
-				chunk,
-			});
-		},
-		onStdout: function (chunk) {
-			if (Module['onStdout']) {
-				Module['onStdout'](chunk);
-				return;
+			// Apply the user-provided values, if any.
+			for (var x in ENV) {
+				// x is a key in ENV; if ENV[x] is undefined, that means it was
+				// explicitly set to be so. We allow user code to do that to
+				// force variables with default values to remain unset.
+				if (ENV[x] === undefined) delete env[x];
+				else env[x] = ENV[x];
 			}
-			if (ENVIRONMENT_IS_NODE) {
-				process.stdout.write(chunk);
-			} else {
-				console.log('stdout', {
-					chunk,
-				});
+			var strings = [];
+			for (var x in env) {
+				strings.push(`${x}=${env[x]}`);
 			}
-		},
-		onStderr: function (chunk) {
-			if (Module['onStderr']) {
-				Module['onStderr'](chunk);
-				return;
+			getEnvStrings.strings = strings;
+		}
+		return getEnvStrings.strings;
+	};
+
+	var stringToAscii = (str, buffer) => {
+		for (var i = 0; i < str.length; ++i) {
+			HEAP8[buffer++] = str.charCodeAt(i);
+		}
+		// Null-terminate the string
+		HEAP8[buffer] = 0;
+	};
+
+	var _environ_get = (__environ, environ_buf) => {
+		var bufSize = 0;
+		getEnvStrings().forEach((string, i) => {
+			var ptr = environ_buf + bufSize;
+			HEAPU32[(__environ + i * 4) >> 2] = ptr;
+			stringToAscii(string, ptr);
+			bufSize += string.length + 1;
+		});
+		return 0;
+	};
+
+	var _environ_sizes_get = (penviron_count, penviron_buf_size) => {
+		var strings = getEnvStrings();
+		HEAPU32[penviron_count >> 2] = strings.length;
+		var bufSize = 0;
+		strings.forEach((string) => (bufSize += string.length + 1));
+		HEAPU32[penviron_buf_size >> 2] = bufSize;
+		return 0;
+	};
+
+	function _fd_fdstat_get(fd, pbuf) {
+		try {
+			var rightsBase = 0;
+			var rightsInheriting = 0;
+			var flags = 0;
+			{
+				var stream = SYSCALLS.getStreamFromFD(fd);
+				// All character devices are terminals (other things a Linux system would
+				// assume is a character device, like the mouse, we have special APIs for).
+				var type = stream.tty
+					? 2
+					: FS.isDir(stream.mode)
+					? 3
+					: FS.isLink(stream.mode)
+					? 7
+					: 4;
 			}
-			if (ENVIRONMENT_IS_NODE) {
-				process.stderr.write(chunk);
-			} else {
-				console.warn('stderr', {
-					chunk,
-				});
+			HEAP8[pbuf] = type;
+			HEAP16[(pbuf + 2) >> 1] = flags;
+			HEAP64[(pbuf + 8) >> 3] = BigInt(rightsBase);
+			HEAP64[(pbuf + 16) >> 3] = BigInt(rightsInheriting);
+			return 0;
+		} catch (e) {
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return e.errno;
+		}
+	}
+
+	/** @param {number=} offset */ var doReadv = (
+		stream,
+		iov,
+		iovcnt,
+		offset
+	) => {
+		var ret = 0;
+		for (var i = 0; i < iovcnt; i++) {
+			var ptr = HEAPU32[iov >> 2];
+			var len = HEAPU32[(iov + 4) >> 2];
+			iov += 8;
+			var curr = FS.read(stream, HEAP8, ptr, len, offset);
+			if (curr < 0) return -1;
+			ret += curr;
+			if (curr < len) break;
+			// nothing more to read
+			if (typeof offset != 'undefined') {
+				offset += curr;
 			}
-		},
-		getAllWebSockets: function (sock) {
-			const webSockets = new Set();
-			if (sock.server) {
-				sock.server.clients.forEach((ws) => {
-					webSockets.add(ws);
+		}
+		return ret;
+	};
+
+	function _fd_read(fd, iov, iovcnt, pnum) {
+		try {
+			var stream = SYSCALLS.getStreamFromFD(fd);
+			var num = doReadv(stream, iov, iovcnt);
+			HEAPU32[pnum >> 2] = num;
+			return 0;
+		} catch (e) {
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return e.errno;
+		}
+	}
+
+	function _fd_seek(fd, offset, whence, newOffset) {
+		offset = bigintToI53Checked(offset);
+		try {
+			if (isNaN(offset)) return 61;
+			var stream = SYSCALLS.getStreamFromFD(fd);
+			FS.llseek(stream, offset, whence);
+			HEAP64[newOffset >> 3] = BigInt(stream.position);
+			if (stream.getdents && offset === 0 && whence === 0)
+				stream.getdents = null;
+			// reset readdir state
+			return 0;
+		} catch (e) {
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return e.errno;
+		}
+	}
+
+	var _fd_sync = function (fd) {
+		try {
+			var stream = SYSCALLS.getStreamFromFD(fd);
+			return Asyncify.handleSleep((wakeUp) => {
+				var mount = stream.node.mount;
+				if (!mount.type.syncfs) {
+					// We write directly to the file system, so there's nothing to do here.
+					wakeUp(0);
+					return;
+				}
+				mount.type.syncfs(mount, false, (err) => {
+					if (err) {
+						wakeUp(29);
+						return;
+					}
+					wakeUp(0);
 				});
+			});
+		} catch (e) {
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return e.errno;
+		}
+	};
+
+	_fd_sync.isAsync = true;
+
+	/** @param {number=} offset */ var doWritev = (
+		stream,
+		iov,
+		iovcnt,
+		offset
+	) => {
+		var ret = 0;
+		for (var i = 0; i < iovcnt; i++) {
+			var ptr = HEAPU32[iov >> 2];
+			var len = HEAPU32[(iov + 4) >> 2];
+			iov += 8;
+			var curr = FS.write(stream, HEAP8, ptr, len, offset);
+			if (curr < 0) return -1;
+			ret += curr;
+			if (curr < len) {
+				// No more space to write.
+				break;
 			}
-			for (const peer of PHPWASM.getAllPeers(sock)) {
-				webSockets.add(peer.socket);
+			if (typeof offset != 'undefined') {
+				offset += curr;
 			}
-			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);
-						}
-					});
+		}
+		return ret;
+	};
+
+	function _fd_write(fd, iov, iovcnt, pnum) {
+		try {
+			var stream = SYSCALLS.getStreamFromFD(fd);
+			var num = doWritev(stream, iov, iovcnt);
+			HEAPU32[pnum >> 2] = num;
+			return 0;
+		} catch (e) {
+			if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+			return e.errno;
+		}
+	}
+
+	var _getaddrinfo = (node, service, hint, out) => {
+		var addr = 0;
+		var port = 0;
+		var flags = 0;
+		var family = 0;
+		var type = 0;
+		var proto = 0;
+		var ai;
+		function allocaddrinfo(family, type, proto, canon, addr, port) {
+			var sa, salen, ai;
+			var errno;
+			salen = family === 10 ? 28 : 16;
+			addr = family === 10 ? inetNtop6(addr) : inetNtop4(addr);
+			sa = _malloc(salen);
+			errno = writeSockaddr(sa, family, addr, port);
+			assert(!errno);
+			ai = _malloc(32);
+			HEAP32[(ai + 4) >> 2] = family;
+			HEAP32[(ai + 8) >> 2] = type;
+			HEAP32[(ai + 12) >> 2] = proto;
+			HEAPU32[(ai + 24) >> 2] = canon;
+			HEAPU32[(ai + 20) >> 2] = sa;
+			if (family === 10) {
+				HEAP32[(ai + 16) >> 2] = 28;
+			} else {
+				HEAP32[(ai + 16) >> 2] = 16;
 			}
-			if (sock.peers) {
-				for (const peer of Object.values(sock.peers)) {
-					peers.add(peer);
+			HEAP32[(ai + 28) >> 2] = 0;
+			return ai;
+		}
+		if (hint) {
+			flags = HEAP32[hint >> 2];
+			family = HEAP32[(hint + 4) >> 2];
+			type = HEAP32[(hint + 8) >> 2];
+			proto = HEAP32[(hint + 12) >> 2];
+		}
+		if (type && !proto) {
+			proto = type === 2 ? 17 : 6;
+		}
+		if (!type && proto) {
+			type = proto === 17 ? 2 : 1;
+		}
+		// If type or proto are set to zero in hints we should really be returning multiple addrinfo values, but for
+		// now default to a TCP STREAM socket so we can at least return a sensible addrinfo given NULL hints.
+		if (proto === 0) {
+			proto = 6;
+		}
+		if (type === 0) {
+			type = 1;
+		}
+		if (!node && !service) {
+			return -2;
+		}
+		if (flags & ~(1 | 2 | 4 | 1024 | 8 | 16 | 32)) {
+			return -1;
+		}
+		if (hint !== 0 && HEAP32[hint >> 2] & 2 && !node) {
+			return -1;
+		}
+		if (flags & 32) {
+			// TODO
+			return -2;
+		}
+		if (type !== 0 && type !== 1 && type !== 2) {
+			return -7;
+		}
+		if (family !== 0 && family !== 2 && family !== 10) {
+			return -6;
+		}
+		if (service) {
+			service = UTF8ToString(service);
+			port = parseInt(service, 10);
+			if (isNaN(port)) {
+				if (flags & 1024) {
+					return -2;
 				}
+				// TODO support resolving well-known service names from:
+				// http://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.txt
+				return -8;
 			}
-			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];
+		}
+		if (!node) {
+			if (family === 0) {
+				family = 2;
+			}
+			if ((flags & 1) === 0) {
+				if (family === 2) {
+					addr = _htonl(2130706433);
+				} else {
+					addr = [0, 0, 0, _htonl(1)];
+				}
 			}
-			return PHPWASM.awaitEvent(ws, 'open');
-		},
-		awaitClose: function (ws) {
-			if ([ws.CLOSING, ws.CLOSED].includes(ws.readyState)) {
-				return [Promise.resolve(), PHPWASM.noop];
+			ai = allocaddrinfo(family, type, proto, null, addr, port);
+			HEAPU32[out >> 2] = ai;
+			return 0;
+		}
+		// try as a numeric address
+		node = UTF8ToString(node);
+		addr = inetPton4(node);
+		if (addr !== null) {
+			// incoming node is a valid ipv4 address
+			if (family === 0 || family === 2) {
+				family = 2;
+			} else if (family === 10 && flags & 8) {
+				addr = [0, 0, _htonl(65535), addr];
+				family = 10;
+			} else {
+				return -2;
 			}
-			return PHPWASM.awaitEvent(ws, 'close');
-		},
-		awaitError: function (ws) {
-			if ([ws.CLOSING, ws.CLOSED].includes(ws.readyState)) {
-				return [Promise.resolve(), PHPWASM.noop];
+		} else {
+			addr = inetPton6(node);
+			if (addr !== null) {
+				// incoming node is a valid ipv6 address
+				if (family === 0 || family === 10) {
+					family = 10;
+				} else {
+					return -2;
+				}
 			}
-			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 _getcontext = () => abort('missing function: ${name}');
+
+	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) {
@@ -7295,6 +7778,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,
@@ -7567,6 +8142,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;
@@ -8499,9 +9089,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 */ makecontext: _makecontext,
 		/** @export */ proc_exit: _proc_exit,
 		/** @export */ strptime: _strptime,
@@ -8529,6 +9123,12 @@ 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 _getpid = (Module['_getpid'] = () =>
+		(_getpid = Module['_getpid'] = wasmExports['getpid'])());
+
 	var _wasm_popen = (Module['_wasm_popen'] = (a0, a1) =>
 		(_wasm_popen = Module['_wasm_popen'] = wasmExports['wasm_popen'])(
 			a0,
@@ -8643,6 +9243,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'])();
 
@@ -8790,6 +9400,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: