@karmaniverous/get-dotenv 4.4.3 → 4.4.5

package/dist/index.cjs

@@ -14,6 +14,7 @@ var require$$0$2 = require('path');
 var require$$0$1 = require('fs');
 var promises = require('node:timers/promises');
 var node_os = require('node:os');
+var node_v8 = require('node:v8');
 var node_stream = require('node:stream');
 var node_buffer = require('node:buffer');
 var promises$1 = require('node:stream/promises');
@@ -4463,64 +4464,6 @@ const fallbackSymbols = {...common$7, ...specialFallbackSymbols};
 const shouldUseMain = isUnicodeSupported();
 const figures = shouldUseMain ? mainSymbols : fallbackSymbols;
 
-// Write synchronously to ensure lines are properly ordered and not interleaved with `stdout`
-const verboseLog = (string, verboseId, icon, color) => {
-	const prefixedLines = addPrefix(string, verboseId, icon, color);
-	fs$v.writeFileSync(STDERR_FD, `${prefixedLines}\n`);
-};
-
-const STDERR_FD = 2;
-
-const addPrefix = (string, verboseId, icon, color) => string.includes('\n')
-	? string
-		.split('\n')
-		.map(line => addPrefixToLine(line, verboseId, icon, color))
-		.join('\n')
-	: addPrefixToLine(string, verboseId, icon, color);
-
-const addPrefixToLine = (line, verboseId, icon, color = identity$1) => [
-	gray(`[${getTimestamp()}]`),
-	gray(`[${verboseId}]`),
-	color(ICONS[icon]),
-	color(line),
-].join(' ');
-
-const identity$1 = string => string;
-
-// Prepending the timestamp allows debugging the slow paths of a subprocess
-const getTimestamp = () => {
-	const date = new Date();
-	return `${padField(date.getHours(), 2)}:${padField(date.getMinutes(), 2)}:${padField(date.getSeconds(), 2)}.${padField(date.getMilliseconds(), 3)}`;
-};
-
-const padField = (field, padding) => String(field).padStart(padding, '0');
-
-const ICONS = {
-	command: '$',
-	pipedCommand: '|',
-	output: ' ',
-	error: figures.cross,
-	warning: figures.warning,
-	success: figures.tick,
-};
-
-// When `verbose` is `short|full`, print each command
-const logCommand = (escapedCommand, {verbose, verboseId}, {piped = false}) => {
-	if (!isVerbose(verbose)) {
-		return;
-	}
-
-	const icon = piped ? 'pipedCommand' : 'command';
-	verboseLog(escapedCommand, verboseId, icon, bold);
-};
-
-// Start counting time before spawning the subprocess
-const getStartTime = () => process$3.hrtime.bigint();
-
-// Compute duration after the subprocess ended.
-// Printed by the `verbose` option.
-const getDurationMs = startTime => Number(process$3.hrtime.bigint() - startTime) / 1e6;
-
 // Compute `result.command` and `result.escapedCommand`
 const joinCommand = (filePath, rawArguments) => {
 	const fileAndArguments = [filePath, ...rawArguments];
@@ -4591,6 +4534,75 @@ const quoteString = escapedArgument => {
 
 const NO_ESCAPE_REGEXP = /^[\w./-]+$/;
 
+// Write synchronously to ensure lines are properly ordered and not interleaved with `stdout`
+const verboseLog = (string, verboseId, icon, color) => {
+	const prefixedLines = addPrefix(string, verboseId, icon, color);
+	fs$v.writeFileSync(STDERR_FD, `${prefixedLines}\n`);
+};
+
+const STDERR_FD = 2;
+
+const addPrefix = (string, verboseId, icon, color) => string.includes('\n')
+	? string
+		.split('\n')
+		.map(line => addPrefixToLine(line, verboseId, icon, color))
+		.join('\n')
+	: addPrefixToLine(string, verboseId, icon, color);
+
+const addPrefixToLine = (line, verboseId, icon, color = identity$1) => [
+	gray(`[${getTimestamp()}]`),
+	gray(`[${verboseId}]`),
+	color(ICONS[icon]),
+	color(line),
+].join(' ');
+
+const identity$1 = string => string;
+
+// Prepending the timestamp allows debugging the slow paths of a subprocess
+const getTimestamp = () => {
+	const date = new Date();
+	return `${padField(date.getHours(), 2)}:${padField(date.getMinutes(), 2)}:${padField(date.getSeconds(), 2)}.${padField(date.getMilliseconds(), 3)}`;
+};
+
+const padField = (field, padding) => String(field).padStart(padding, '0');
+
+const ICONS = {
+	command: '$',
+	pipedCommand: '|',
+	output: ' ',
+	ipc: '*',
+	error: figures.cross,
+	warning: figures.warning,
+	success: figures.tick,
+};
+
+// Serialize any type to a line string, for logging
+const serializeLogMessage = message => {
+	const messageString = typeof message === 'string' ? message : node_util.inspect(message);
+	const escapedMessage = escapeLines(messageString);
+	return escapedMessage.replaceAll('\t', ' '.repeat(TAB_SIZE));
+};
+
+// Same as `util.inspect()`
+const TAB_SIZE = 2;
+
+// When `verbose` is `short|full`, print each command
+const logCommand = (escapedCommand, {verbose, verboseId}, {piped = false}) => {
+	if (!isVerbose(verbose)) {
+		return;
+	}
+
+	const icon = piped ? 'pipedCommand' : 'command';
+	verboseLog(escapedCommand, verboseId, icon, bold);
+};
+
+// Start counting time before spawning the subprocess
+const getStartTime = () => process$3.hrtime.bigint();
+
+// Compute duration after the subprocess ended.
+// Printed by the `verbose` option.
+const getDurationMs = startTime => Number(process$3.hrtime.bigint() - startTime) / 1e6;
+
 const isStandardStream = stream => STANDARD_STREAMS.includes(stream);
 const STANDARD_STREAMS = [process$3.stdin, process$3.stdout, process$3.stderr];
 const STANDARD_STREAMS_ALIASES = ['stdin', 'stdout', 'stderr'];
@@ -4610,7 +4622,7 @@ const normalizeFdSpecificOptions = options => {
 };
 
 const normalizeFdSpecificOption = (options, optionName) => {
-	const optionBaseArray = Array.from({length: getStdioLength(options)});
+	const optionBaseArray = Array.from({length: getStdioLength(options) + 1});
 	const optionArray = normalizeFdSpecificValue(options[optionName], optionBaseArray, optionName);
 	return addDefaultValue$1(optionArray, optionName);
 };
@@ -4645,10 +4657,14 @@ const getFdNameOrder = fdName => {
 };
 
 const parseFdName = (fdName, optionName, optionArray) => {
+	if (fdName === 'ipc') {
+		return [optionArray.length - 1];
+	}
+
 	const fdNumber = parseFd(fdName);
 	if (fdNumber === undefined || fdNumber === 0) {
 		throw new TypeError(`"${optionName}.${fdName}" is invalid.
-It must be "${optionName}.stdout", "${optionName}.stderr", "${optionName}.all", or "${optionName}.fd3", "${optionName}.fd4" (and so on).`);
+It must be "${optionName}.stdout", "${optionName}.stderr", "${optionName}.all", "${optionName}.ipc", or "${optionName}.fd3", "${optionName}.fd4" (and so on).`);
 	}
 
 	if (fdNumber >= optionArray.length) {
@@ -5442,6 +5458,386 @@ setErrorName(ExecaError, ExecaError.name);
 class ExecaSyncError extends Error {}
 setErrorName(ExecaSyncError, ExecaSyncError.name);
 
+const getRealtimeSignals=()=>{
+const length=SIGRTMAX-SIGRTMIN+1;
+return Array.from({length},getRealtimeSignal)
+};
+
+const getRealtimeSignal=(value,index)=>({
+name:`SIGRT${index+1}`,
+number:SIGRTMIN+index,
+action:"terminate",
+description:"Application-specific signal (realtime)",
+standard:"posix"
+});
+
+const SIGRTMIN=34;
+const SIGRTMAX=64;
+
+const SIGNALS=[
+{
+name:"SIGHUP",
+number:1,
+action:"terminate",
+description:"Terminal closed",
+standard:"posix"
+},
+{
+name:"SIGINT",
+number:2,
+action:"terminate",
+description:"User interruption with CTRL-C",
+standard:"ansi"
+},
+{
+name:"SIGQUIT",
+number:3,
+action:"core",
+description:"User interruption with CTRL-\\",
+standard:"posix"
+},
+{
+name:"SIGILL",
+number:4,
+action:"core",
+description:"Invalid machine instruction",
+standard:"ansi"
+},
+{
+name:"SIGTRAP",
+number:5,
+action:"core",
+description:"Debugger breakpoint",
+standard:"posix"
+},
+{
+name:"SIGABRT",
+number:6,
+action:"core",
+description:"Aborted",
+standard:"ansi"
+},
+{
+name:"SIGIOT",
+number:6,
+action:"core",
+description:"Aborted",
+standard:"bsd"
+},
+{
+name:"SIGBUS",
+number:7,
+action:"core",
+description:
+"Bus error due to misaligned, non-existing address or paging error",
+standard:"bsd"
+},
+{
+name:"SIGEMT",
+number:7,
+action:"terminate",
+description:"Command should be emulated but is not implemented",
+standard:"other"
+},
+{
+name:"SIGFPE",
+number:8,
+action:"core",
+description:"Floating point arithmetic error",
+standard:"ansi"
+},
+{
+name:"SIGKILL",
+number:9,
+action:"terminate",
+description:"Forced termination",
+standard:"posix",
+forced:true
+},
+{
+name:"SIGUSR1",
+number:10,
+action:"terminate",
+description:"Application-specific signal",
+standard:"posix"
+},
+{
+name:"SIGSEGV",
+number:11,
+action:"core",
+description:"Segmentation fault",
+standard:"ansi"
+},
+{
+name:"SIGUSR2",
+number:12,
+action:"terminate",
+description:"Application-specific signal",
+standard:"posix"
+},
+{
+name:"SIGPIPE",
+number:13,
+action:"terminate",
+description:"Broken pipe or socket",
+standard:"posix"
+},
+{
+name:"SIGALRM",
+number:14,
+action:"terminate",
+description:"Timeout or timer",
+standard:"posix"
+},
+{
+name:"SIGTERM",
+number:15,
+action:"terminate",
+description:"Termination",
+standard:"ansi"
+},
+{
+name:"SIGSTKFLT",
+number:16,
+action:"terminate",
+description:"Stack is empty or overflowed",
+standard:"other"
+},
+{
+name:"SIGCHLD",
+number:17,
+action:"ignore",
+description:"Child process terminated, paused or unpaused",
+standard:"posix"
+},
+{
+name:"SIGCLD",
+number:17,
+action:"ignore",
+description:"Child process terminated, paused or unpaused",
+standard:"other"
+},
+{
+name:"SIGCONT",
+number:18,
+action:"unpause",
+description:"Unpaused",
+standard:"posix",
+forced:true
+},
+{
+name:"SIGSTOP",
+number:19,
+action:"pause",
+description:"Paused",
+standard:"posix",
+forced:true
+},
+{
+name:"SIGTSTP",
+number:20,
+action:"pause",
+description:"Paused using CTRL-Z or \"suspend\"",
+standard:"posix"
+},
+{
+name:"SIGTTIN",
+number:21,
+action:"pause",
+description:"Background process cannot read terminal input",
+standard:"posix"
+},
+{
+name:"SIGBREAK",
+number:21,
+action:"terminate",
+description:"User interruption with CTRL-BREAK",
+standard:"other"
+},
+{
+name:"SIGTTOU",
+number:22,
+action:"pause",
+description:"Background process cannot write to terminal output",
+standard:"posix"
+},
+{
+name:"SIGURG",
+number:23,
+action:"ignore",
+description:"Socket received out-of-band data",
+standard:"bsd"
+},
+{
+name:"SIGXCPU",
+number:24,
+action:"core",
+description:"Process timed out",
+standard:"bsd"
+},
+{
+name:"SIGXFSZ",
+number:25,
+action:"core",
+description:"File too big",
+standard:"bsd"
+},
+{
+name:"SIGVTALRM",
+number:26,
+action:"terminate",
+description:"Timeout or timer",
+standard:"bsd"
+},
+{
+name:"SIGPROF",
+number:27,
+action:"terminate",
+description:"Timeout or timer",
+standard:"bsd"
+},
+{
+name:"SIGWINCH",
+number:28,
+action:"ignore",
+description:"Terminal window size changed",
+standard:"bsd"
+},
+{
+name:"SIGIO",
+number:29,
+action:"terminate",
+description:"I/O is available",
+standard:"other"
+},
+{
+name:"SIGPOLL",
+number:29,
+action:"terminate",
+description:"Watched event",
+standard:"other"
+},
+{
+name:"SIGINFO",
+number:29,
+action:"ignore",
+description:"Request for process information",
+standard:"other"
+},
+{
+name:"SIGPWR",
+number:30,
+action:"terminate",
+description:"Device running out of power",
+standard:"systemv"
+},
+{
+name:"SIGSYS",
+number:31,
+action:"core",
+description:"Invalid system call",
+standard:"other"
+},
+{
+name:"SIGUNUSED",
+number:31,
+action:"terminate",
+description:"Invalid system call",
+standard:"other"
+}];
+
+const getSignals=()=>{
+const realtimeSignals=getRealtimeSignals();
+const signals=[...SIGNALS,...realtimeSignals].map(normalizeSignal$1);
+return signals
+};
+
+
+
+
+
+
+
+const normalizeSignal$1=({
+name,
+number:defaultNumber,
+description,
+action,
+forced=false,
+standard
+})=>{
+const{
+signals:{[name]:constantSignal}
+}=node_os.constants;
+const supported=constantSignal!==undefined;
+const number=supported?constantSignal:defaultNumber;
+return {name,number,description,supported,action,forced,standard}
+};
+
+const getSignalsByName=()=>{
+const signals=getSignals();
+return Object.fromEntries(signals.map(getSignalByName))
+};
+
+const getSignalByName=({
+name,
+number,
+description,
+supported,
+action,
+forced,
+standard
+})=>[name,{name,number,description,supported,action,forced,standard}];
+
+const signalsByName=getSignalsByName();
+
+
+
+
+const getSignalsByNumber=()=>{
+const signals=getSignals();
+const length=SIGRTMAX+1;
+const signalsA=Array.from({length},(value,number)=>
+getSignalByNumber(number,signals)
+);
+return Object.assign({},...signalsA)
+};
+
+const getSignalByNumber=(number,signals)=>{
+const signal=findSignalByNumber(number,signals);
+
+if(signal===undefined){
+return {}
+}
+
+const{name,description,supported,action,forced,standard}=signal;
+return {
+[number]:{
+name,
+number,
+description,
+supported,
+action,
+forced,
+standard
+}
+}
+};
+
+
+
+const findSignalByNumber=(number,signals)=>{
+const signal=signals.find(({name})=>node_os.constants.signals[name]===number);
+
+if(signal!==undefined){
+return signal
+}
+
+return signals.find((signalA)=>signalA.number===number)
+};
+
+getSignalsByNumber();
+
 // Normalize signals for comparison purpose.
 // Also validate the signal exists.
 const normalizeKillSignal = killSignal => {
@@ -5450,14 +5846,14 @@ const normalizeKillSignal = killSignal => {
 		throw new TypeError(`Invalid ${optionName}: 0 cannot be used.`);
 	}
 
-	return normalizeSignal$1(killSignal, optionName);
+	return normalizeSignal(killSignal, optionName);
 };
 
 const normalizeSignalArgument = signal => signal === 0
 	? signal
-	: normalizeSignal$1(signal, '`subprocess.kill()`\'s argument');
+	: normalizeSignal(signal, '`subprocess.kill()`\'s argument');
 
-const normalizeSignal$1 = (signalNameOrInteger, optionName) => {
+const normalizeSignal = (signalNameOrInteger, optionName) => {
 	if (Number.isInteger(signalNameOrInteger)) {
 		return normalizeSignalInteger(signalNameOrInteger, optionName);
 	}
@@ -5507,6 +5903,9 @@ const getAvailableSignalIntegers = () => [...new Set(Object.values(node_os.const
 	.sort((signalInteger, signalIntegerTwo) => signalInteger - signalIntegerTwo))]
 	.join(', ');
 
+// Human-friendly description of a signal
+const getSignalDescription = signal => signalsByName[signal].description;
+
 // Normalize the `forceKillAfterDelay` option
 const normalizeForceKillAfterDelay = forceKillAfterDelay => {
 	if (forceKillAfterDelay === false) {
@@ -5528,7 +5927,7 @@ const DEFAULT_FORCE_KILL_TIMEOUT = 1000 * 5;
 
 // Monkey-patches `subprocess.kill()` to add `forceKillAfterDelay` behavior and `.kill(error)`
 const subprocessKill = (
-	{kill, options: {forceKillAfterDelay, killSignal}, onInternalError, controller},
+	{kill, options: {forceKillAfterDelay, killSignal}, onInternalError, context, controller},
 	signalOrError,
 	errorArgument,
 ) => {
@@ -5541,6 +5940,7 @@ const subprocessKill = (
 		forceKillAfterDelay,
 		killSignal,
 		killResult,
+		context,
 		controller,
 	});
 	return killResult;
@@ -5571,20 +5971,834 @@ const emitKillError = (error, onInternalError) => {
 	}
 };
 
-const setKillTimeout = async ({kill, signal, forceKillAfterDelay, killSignal, killResult, controller}) => {
-	if (!shouldForceKill(signal, forceKillAfterDelay, killSignal, killResult)) {
+const setKillTimeout = async ({kill, signal, forceKillAfterDelay, killSignal, killResult, context, controller}) => {
+	if (signal === killSignal && killResult) {
+		killOnTimeout({
+			kill,
+			forceKillAfterDelay,
+			context,
+			controllerSignal: controller.signal,
+		});
+	}
+};
+
+// Forcefully terminate a subprocess after a timeout
+const killOnTimeout = async ({kill, forceKillAfterDelay, context, controllerSignal}) => {
+	if (forceKillAfterDelay === false) {
 		return;
 	}
 
 	try {
-		await promises.setTimeout(forceKillAfterDelay, undefined, {signal: controller.signal});
-		kill('SIGKILL');
+		await promises.setTimeout(forceKillAfterDelay, undefined, {signal: controllerSignal});
+		if (kill('SIGKILL')) {
+			context.isForcefullyTerminated ??= true;
+		}
 	} catch {}
 };
 
-const shouldForceKill = (signal, forceKillAfterDelay, killSignal, killResult) => signal === killSignal
-	&& forceKillAfterDelay !== false
-	&& killResult;
+// Combines `util.aborted()` and `events.addAbortListener()`: promise-based and cleaned up with a stop signal
+const onAbortedSignal = async (mainSignal, stopSignal) => {
+	if (!mainSignal.aborted) {
+		await require$$0.once(mainSignal, 'abort', {signal: stopSignal});
+	}
+};
+
+// Validate the `cancelSignal` option
+const validateCancelSignal = ({cancelSignal}) => {
+	if (cancelSignal !== undefined && Object.prototype.toString.call(cancelSignal) !== '[object AbortSignal]') {
+		throw new Error(`The \`cancelSignal\` option must be an AbortSignal: ${String(cancelSignal)}`);
+	}
+};
+
+// Terminate the subprocess when aborting the `cancelSignal` option and `gracefulSignal` is `false`
+const throwOnCancel = ({subprocess, cancelSignal, gracefulCancel, context, controller}) => cancelSignal === undefined || gracefulCancel
+	? []
+	: [terminateOnCancel(subprocess, cancelSignal, context, controller)];
+
+const terminateOnCancel = async (subprocess, cancelSignal, context, {signal}) => {
+	await onAbortedSignal(cancelSignal, signal);
+	context.terminationReason ??= 'cancel';
+	subprocess.kill();
+	throw cancelSignal.reason;
+};
+
+// Validate the IPC channel is connected before receiving/sending messages
+const validateIpcMethod = ({methodName, isSubprocess, ipc, isConnected}) => {
+	validateIpcOption(methodName, isSubprocess, ipc);
+	validateConnection(methodName, isSubprocess, isConnected);
+};
+
+// Better error message when forgetting to set `ipc: true` and using the IPC methods
+const validateIpcOption = (methodName, isSubprocess, ipc) => {
+	if (!ipc) {
+		throw new Error(`${getMethodName(methodName, isSubprocess)} can only be used if the \`ipc\` option is \`true\`.`);
+	}
+};
+
+// Better error message when one process does not send/receive messages once the other process has disconnected.
+// This also makes it clear that any buffered messages are lost once either process has disconnected.
+// Also when aborting `cancelSignal` after disconnecting the IPC.
+const validateConnection = (methodName, isSubprocess, isConnected) => {
+	if (!isConnected) {
+		throw new Error(`${getMethodName(methodName, isSubprocess)} cannot be used: the ${getOtherProcessName(isSubprocess)} has already exited or disconnected.`);
+	}
+};
+
+// When `getOneMessage()` could not complete due to an early disconnection
+const throwOnEarlyDisconnect = isSubprocess => {
+	throw new Error(`${getMethodName('getOneMessage', isSubprocess)} could not complete: the ${getOtherProcessName(isSubprocess)} exited or disconnected.`);
+};
+
+// When both processes use `sendMessage()` with `strict` at the same time
+const throwOnStrictDeadlockError = isSubprocess => {
+	throw new Error(`${getMethodName('sendMessage', isSubprocess)} failed: the ${getOtherProcessName(isSubprocess)} is sending a message too, instead of listening to incoming messages.
+This can be fixed by both sending a message and listening to incoming messages at the same time:
+
+const [receivedMessage] = await Promise.all([
+	${getMethodName('getOneMessage', isSubprocess)},
+	${getMethodName('sendMessage', isSubprocess, 'message, {strict: true}')},
+]);`);
+};
+
+// When the other process used `strict` but the current process had I/O error calling `sendMessage()` for the response
+const getStrictResponseError = (error, isSubprocess) => new Error(`${getMethodName('sendMessage', isSubprocess)} failed when sending an acknowledgment response to the ${getOtherProcessName(isSubprocess)}.`, {cause: error});
+
+// When using `strict` but the other process was not listening for messages
+const throwOnMissingStrict = isSubprocess => {
+	throw new Error(`${getMethodName('sendMessage', isSubprocess)} failed: the ${getOtherProcessName(isSubprocess)} is not listening to incoming messages.`);
+};
+
+// When using `strict` but the other process disconnected before receiving the message
+const throwOnStrictDisconnect = isSubprocess => {
+	throw new Error(`${getMethodName('sendMessage', isSubprocess)} failed: the ${getOtherProcessName(isSubprocess)} exited without listening to incoming messages.`);
+};
+
+// When the current process disconnects while the subprocess is listening to `cancelSignal`
+const getAbortDisconnectError = () => new Error(`\`cancelSignal\` aborted: the ${getOtherProcessName(true)} disconnected.`);
+
+// When the subprocess uses `cancelSignal` but not the current process
+const throwOnMissingParent = () => {
+	throw new Error('`getCancelSignal()` cannot be used without setting the `cancelSignal` subprocess option.');
+};
+
+// EPIPE can happen when sending a message to a subprocess that is closing but has not disconnected yet
+const handleEpipeError = ({error, methodName, isSubprocess}) => {
+	if (error.code === 'EPIPE') {
+		throw new Error(`${getMethodName(methodName, isSubprocess)} cannot be used: the ${getOtherProcessName(isSubprocess)} is disconnecting.`, {cause: error});
+	}
+};
+
+// Better error message when sending messages which cannot be serialized.
+// Works with both `serialization: 'advanced'` and `serialization: 'json'`.
+const handleSerializationError = ({error, methodName, isSubprocess, message}) => {
+	if (isSerializationError(error)) {
+		throw new Error(`${getMethodName(methodName, isSubprocess)}'s argument type is invalid: the message cannot be serialized: ${String(message)}.`, {cause: error});
+	}
+};
+
+const isSerializationError = ({code, message}) => SERIALIZATION_ERROR_CODES.has(code)
+	|| SERIALIZATION_ERROR_MESSAGES.some(serializationErrorMessage => message.includes(serializationErrorMessage));
+
+// `error.code` set by Node.js when it failed to serialize the message
+const SERIALIZATION_ERROR_CODES = new Set([
+	// Message is `undefined`
+	'ERR_MISSING_ARGS',
+	// Message is a function, a bigint, a symbol
+	'ERR_INVALID_ARG_TYPE',
+]);
+
+// `error.message` set by Node.js when it failed to serialize the message
+const SERIALIZATION_ERROR_MESSAGES = [
+	// Message is a promise or a proxy, with `serialization: 'advanced'`
+	'could not be cloned',
+	// Message has cycles, with `serialization: 'json'`
+	'circular structure',
+	// Message has cycles inside toJSON(), with `serialization: 'json'`
+	'call stack size exceeded',
+];
+
+const getMethodName = (methodName, isSubprocess, parameters = '') => methodName === 'cancelSignal'
+	? '`cancelSignal`\'s `controller.abort()`'
+	: `${getNamespaceName(isSubprocess)}${methodName}(${parameters})`;
+
+const getNamespaceName = isSubprocess => isSubprocess ? '' : 'subprocess.';
+
+const getOtherProcessName = isSubprocess => isSubprocess ? 'parent process' : 'subprocess';
+
+// When any error arises, we disconnect the IPC.
+// Otherwise, it is likely that one of the processes will stop sending/receiving messages.
+// This would leave the other process hanging.
+const disconnect = anyProcess => {
+	if (anyProcess.connected) {
+		anyProcess.disconnect();
+	}
+};
+
+const createDeferred = () => {
+	const methods = {};
+	const promise = new Promise((resolve, reject) => {
+		Object.assign(methods, {resolve, reject});
+	});
+	return Object.assign(promise, methods);
+};
+
+// Retrieve stream targeted by the `to` option
+const getToStream = (destination, to = 'stdin') => {
+	const isWritable = true;
+	const {options, fileDescriptors} = SUBPROCESS_OPTIONS.get(destination);
+	const fdNumber = getFdNumber(fileDescriptors, to, isWritable);
+	const destinationStream = destination.stdio[fdNumber];
+
+	if (destinationStream === null) {
+		throw new TypeError(getInvalidStdioOptionMessage(fdNumber, to, options, isWritable));
+	}
+
+	return destinationStream;
+};
+
+// Retrieve stream targeted by the `from` option
+const getFromStream = (source, from = 'stdout') => {
+	const isWritable = false;
+	const {options, fileDescriptors} = SUBPROCESS_OPTIONS.get(source);
+	const fdNumber = getFdNumber(fileDescriptors, from, isWritable);
+	const sourceStream = fdNumber === 'all' ? source.all : source.stdio[fdNumber];
+
+	if (sourceStream === null || sourceStream === undefined) {
+		throw new TypeError(getInvalidStdioOptionMessage(fdNumber, from, options, isWritable));
+	}
+
+	return sourceStream;
+};
+
+// Keeps track of the options passed to each Execa call
+const SUBPROCESS_OPTIONS = new WeakMap();
+
+const getFdNumber = (fileDescriptors, fdName, isWritable) => {
+	const fdNumber = parseFdNumber(fdName, isWritable);
+	validateFdNumber(fdNumber, fdName, isWritable, fileDescriptors);
+	return fdNumber;
+};
+
+const parseFdNumber = (fdName, isWritable) => {
+	const fdNumber = parseFd(fdName);
+	if (fdNumber !== undefined) {
+		return fdNumber;
+	}
+
+	const {validOptions, defaultValue} = isWritable
+		? {validOptions: '"stdin"', defaultValue: 'stdin'}
+		: {validOptions: '"stdout", "stderr", "all"', defaultValue: 'stdout'};
+	throw new TypeError(`"${getOptionName(isWritable)}" must not be "${fdName}".
+It must be ${validOptions} or "fd3", "fd4" (and so on).
+It is optional and defaults to "${defaultValue}".`);
+};
+
+const validateFdNumber = (fdNumber, fdName, isWritable, fileDescriptors) => {
+	const fileDescriptor = fileDescriptors[getUsedDescriptor(fdNumber)];
+	if (fileDescriptor === undefined) {
+		throw new TypeError(`"${getOptionName(isWritable)}" must not be ${fdName}. That file descriptor does not exist.
+Please set the "stdio" option to ensure that file descriptor exists.`);
+	}
+
+	if (fileDescriptor.direction === 'input' && !isWritable) {
+		throw new TypeError(`"${getOptionName(isWritable)}" must not be ${fdName}. It must be a readable stream, not writable.`);
+	}
+
+	if (fileDescriptor.direction !== 'input' && isWritable) {
+		throw new TypeError(`"${getOptionName(isWritable)}" must not be ${fdName}. It must be a writable stream, not readable.`);
+	}
+};
+
+const getInvalidStdioOptionMessage = (fdNumber, fdName, options, isWritable) => {
+	if (fdNumber === 'all' && !options.all) {
+		return 'The "all" option must be true to use "from: \'all\'".';
+	}
+
+	const {optionName, optionValue} = getInvalidStdioOption(fdNumber, options);
+	return `The "${optionName}: ${serializeOptionValue(optionValue)}" option is incompatible with using "${getOptionName(isWritable)}: ${serializeOptionValue(fdName)}".
+Please set this option with "pipe" instead.`;
+};
+
+const getInvalidStdioOption = (fdNumber, {stdin, stdout, stderr, stdio}) => {
+	const usedDescriptor = getUsedDescriptor(fdNumber);
+
+	if (usedDescriptor === 0 && stdin !== undefined) {
+		return {optionName: 'stdin', optionValue: stdin};
+	}
+
+	if (usedDescriptor === 1 && stdout !== undefined) {
+		return {optionName: 'stdout', optionValue: stdout};
+	}
+
+	if (usedDescriptor === 2 && stderr !== undefined) {
+		return {optionName: 'stderr', optionValue: stderr};
+	}
+
+	return {optionName: `stdio[${usedDescriptor}]`, optionValue: stdio[usedDescriptor]};
+};
+
+const getUsedDescriptor = fdNumber => fdNumber === 'all' ? 1 : fdNumber;
+
+const getOptionName = isWritable => isWritable ? 'to' : 'from';
+
+const serializeOptionValue = value => {
+	if (typeof value === 'string') {
+		return `'${value}'`;
+	}
+
+	return typeof value === 'number' ? `${value}` : 'Stream';
+};
+
+// Temporarily increase the maximum number of listeners on an eventEmitter
+const incrementMaxListeners = (eventEmitter, maxListenersIncrement, signal) => {
+	const maxListeners = eventEmitter.getMaxListeners();
+	if (maxListeners === 0 || maxListeners === Number.POSITIVE_INFINITY) {
+		return;
+	}
+
+	eventEmitter.setMaxListeners(maxListeners + maxListenersIncrement);
+	require$$0.addAbortListener(signal, () => {
+		eventEmitter.setMaxListeners(eventEmitter.getMaxListeners() - maxListenersIncrement);
+	});
+};
+
+// By default, Node.js keeps the subprocess alive while it has a `message` or `disconnect` listener.
+// We replicate the same logic for the events that we proxy.
+// This ensures the subprocess is kept alive while `getOneMessage()` and `getEachMessage()` are ongoing.
+// This is not a problem with `sendMessage()` since Node.js handles that method automatically.
+// We do not use `anyProcess.channel.ref()` since this would prevent the automatic `.channel.refCounted()` Node.js is doing.
+// We keep a reference to `anyProcess.channel` since it might be `null` while `getOneMessage()` or `getEachMessage()` is still processing debounced messages.
+// See https://github.com/nodejs/node/blob/2aaeaa863c35befa2ebaa98fb7737ec84df4d8e9/lib/internal/child_process.js#L547
+const addReference = (channel, reference) => {
+	if (reference) {
+		addReferenceCount(channel);
+	}
+};
+
+const addReferenceCount = channel => {
+	channel.refCounted();
+};
+
+const removeReference = (channel, reference) => {
+	if (reference) {
+		removeReferenceCount(channel);
+	}
+};
+
+const removeReferenceCount = channel => {
+	channel.unrefCounted();
+};
+
+// To proxy events, we setup some global listeners on the `message` and `disconnect` events.
+// Those should not keep the subprocess alive, so we remove the automatic counting that Node.js is doing.
+// See https://github.com/nodejs/node/blob/1b965270a9c273d4cf70e8808e9d28b9ada7844f/lib/child_process.js#L180
+const undoAddedReferences = (channel, isSubprocess) => {
+	if (isSubprocess) {
+		removeReferenceCount(channel);
+		removeReferenceCount(channel);
+	}
+};
+
+// Reverse it during `disconnect`
+const redoAddedReferences = (channel, isSubprocess) => {
+	if (isSubprocess) {
+		addReferenceCount(channel);
+		addReferenceCount(channel);
+	}
+};
+
+// By default, Node.js buffers `message` events.
+//  - Buffering happens when there is a `message` event is emitted but there is no handler.
+//  - As soon as a `message` event handler is set, all buffered `message` events are emitted, emptying the buffer.
+//  - This happens both in the current process and the subprocess.
+//  - See https://github.com/nodejs/node/blob/501546e8f37059cd577041e23941b640d0d4d406/lib/internal/child_process.js#L719
+// This is helpful. Notably, this allows sending messages to a subprocess that's still initializing.
+// However, it has several problems.
+//  - This works with `events.on()` but not `events.once()` since all buffered messages are emitted at once.
+//    For example, users cannot call `await getOneMessage()`/`getEachMessage()` multiple times in a row.
+//  - When a user intentionally starts listening to `message` at a specific point in time, past `message` events are replayed, which might be unexpected.
+//  - Buffering is unlimited, which might lead to an out-of-memory crash.
+//  - This does not work well with multiple consumers.
+//    For example, Execa consumes events with both `result.ipcOutput` and manual IPC calls like `getOneMessage()`.
+//    Since `result.ipcOutput` reads all incoming messages, no buffering happens for manual IPC calls.
+//  - Forgetting to setup a `message` listener, or setting it up too late, is a programming mistake.
+//    The default behavior does not allow users to realize they made that mistake.
+// To solve those problems, instead of buffering messages, we debounce them.
+// The `message` event so it is emitted at most once per macrotask.
+const onMessage = async ({anyProcess, channel, isSubprocess, ipcEmitter}, wrappedMessage) => {
+	if (handleStrictResponse(wrappedMessage) || handleAbort(wrappedMessage)) {
+		return;
+	}
+
+	if (!INCOMING_MESSAGES.has(anyProcess)) {
+		INCOMING_MESSAGES.set(anyProcess, []);
+	}
+
+	const incomingMessages = INCOMING_MESSAGES.get(anyProcess);
+	incomingMessages.push(wrappedMessage);
+
+	if (incomingMessages.length > 1) {
+		return;
+	}
+
+	while (incomingMessages.length > 0) {
+		// eslint-disable-next-line no-await-in-loop
+		await waitForOutgoingMessages(anyProcess, ipcEmitter, wrappedMessage);
+		// eslint-disable-next-line no-await-in-loop
+		await promises.scheduler.yield();
+
+		// eslint-disable-next-line no-await-in-loop
+		const message = await handleStrictRequest({
+			wrappedMessage: incomingMessages[0],
+			anyProcess,
+			channel,
+			isSubprocess,
+			ipcEmitter,
+		});
+
+		incomingMessages.shift();
+		ipcEmitter.emit('message', message);
+		ipcEmitter.emit('message:done');
+	}
+};
+
+// If the `message` event is currently debounced, the `disconnect` event must wait for it
+const onDisconnect = async ({anyProcess, channel, isSubprocess, ipcEmitter, boundOnMessage}) => {
+	abortOnDisconnect();
+
+	const incomingMessages = INCOMING_MESSAGES.get(anyProcess);
+	while (incomingMessages?.length > 0) {
+		// eslint-disable-next-line no-await-in-loop
+		await require$$0.once(ipcEmitter, 'message:done');
+	}
+
+	anyProcess.removeListener('message', boundOnMessage);
+	redoAddedReferences(channel, isSubprocess);
+	ipcEmitter.connected = false;
+	ipcEmitter.emit('disconnect');
+};
+
+const INCOMING_MESSAGES = new WeakMap();
+
+// Forward the `message` and `disconnect` events from the process and subprocess to a proxy emitter.
+// This prevents the `error` event from stopping IPC.
+// This also allows debouncing the `message` event.
+const getIpcEmitter = (anyProcess, channel, isSubprocess) => {
+	if (IPC_EMITTERS.has(anyProcess)) {
+		return IPC_EMITTERS.get(anyProcess);
+	}
+
+	// Use an `EventEmitter`, like the `process` that is being proxied
+	// eslint-disable-next-line unicorn/prefer-event-target
+	const ipcEmitter = new require$$0.EventEmitter();
+	ipcEmitter.connected = true;
+	IPC_EMITTERS.set(anyProcess, ipcEmitter);
+	forwardEvents({
+		ipcEmitter,
+		anyProcess,
+		channel,
+		isSubprocess,
+	});
+	return ipcEmitter;
+};
+
+const IPC_EMITTERS = new WeakMap();
+
+// The `message` and `disconnect` events are buffered in the subprocess until the first listener is setup.
+// However, unbuffering happens after one tick, so this give enough time for the caller to setup the listener on the proxy emitter first.
+// See https://github.com/nodejs/node/blob/2aaeaa863c35befa2ebaa98fb7737ec84df4d8e9/lib/internal/child_process.js#L721
+const forwardEvents = ({ipcEmitter, anyProcess, channel, isSubprocess}) => {
+	const boundOnMessage = onMessage.bind(undefined, {
+		anyProcess,
+		channel,
+		isSubprocess,
+		ipcEmitter,
+	});
+	anyProcess.on('message', boundOnMessage);
+	anyProcess.once('disconnect', onDisconnect.bind(undefined, {
+		anyProcess,
+		channel,
+		isSubprocess,
+		ipcEmitter,
+		boundOnMessage,
+	}));
+	undoAddedReferences(channel, isSubprocess);
+};
+
+// Check whether there might still be some `message` events to receive
+const isConnected = anyProcess => {
+	const ipcEmitter = IPC_EMITTERS.get(anyProcess);
+	return ipcEmitter === undefined
+		? anyProcess.channel !== null
+		: ipcEmitter.connected;
+};
+
+// When using the `strict` option, wrap the message with metadata during `sendMessage()`
+const handleSendStrict = ({anyProcess, channel, isSubprocess, message, strict}) => {
+	if (!strict) {
+		return message;
+	}
+
+	const ipcEmitter = getIpcEmitter(anyProcess, channel, isSubprocess);
+	const hasListeners = hasMessageListeners(anyProcess, ipcEmitter);
+	return {
+		id: count++,
+		type: REQUEST_TYPE,
+		message,
+		hasListeners,
+	};
+};
+
+let count = 0n;
+
+// Handles when both processes are calling `sendMessage()` with `strict` at the same time.
+// If neither process is listening, this would create a deadlock. We detect it and throw.
+const validateStrictDeadlock = (outgoingMessages, wrappedMessage) => {
+	if (wrappedMessage?.type !== REQUEST_TYPE || wrappedMessage.hasListeners) {
+		return;
+	}
+
+	for (const {id} of outgoingMessages) {
+		if (id !== undefined) {
+			STRICT_RESPONSES[id].resolve({isDeadlock: true, hasListeners: false});
+		}
+	}
+};
+
+// The other process then sends the acknowledgment back as a response
+const handleStrictRequest = async ({wrappedMessage, anyProcess, channel, isSubprocess, ipcEmitter}) => {
+	if (wrappedMessage?.type !== REQUEST_TYPE || !anyProcess.connected) {
+		return wrappedMessage;
+	}
+
+	const {id, message} = wrappedMessage;
+	const response = {id, type: RESPONSE_TYPE, message: hasMessageListeners(anyProcess, ipcEmitter)};
+
+	try {
+		await sendMessage({
+			anyProcess,
+			channel,
+			isSubprocess,
+			ipc: true,
+		}, response);
+	} catch (error) {
+		ipcEmitter.emit('strict:error', error);
+	}
+
+	return message;
+};
+
+// Reception of the acknowledgment response
+const handleStrictResponse = wrappedMessage => {
+	if (wrappedMessage?.type !== RESPONSE_TYPE) {
+		return false;
+	}
+
+	const {id, message: hasListeners} = wrappedMessage;
+	STRICT_RESPONSES[id]?.resolve({isDeadlock: false, hasListeners});
+	return true;
+};
+
+// Wait for the other process to receive the message from `sendMessage()`
+const waitForStrictResponse = async (wrappedMessage, anyProcess, isSubprocess) => {
+	if (wrappedMessage?.type !== REQUEST_TYPE) {
+		return;
+	}
+
+	const deferred = createDeferred();
+	STRICT_RESPONSES[wrappedMessage.id] = deferred;
+	const controller = new AbortController();
+
+	try {
+		const {isDeadlock, hasListeners} = await Promise.race([
+			deferred,
+			throwOnDisconnect$1(anyProcess, isSubprocess, controller),
+		]);
+
+		if (isDeadlock) {
+			throwOnStrictDeadlockError(isSubprocess);
+		}
+
+		if (!hasListeners) {
+			throwOnMissingStrict(isSubprocess);
+		}
+	} finally {
+		controller.abort();
+		delete STRICT_RESPONSES[wrappedMessage.id];
+	}
+};
+
+const STRICT_RESPONSES = {};
+
+const throwOnDisconnect$1 = async (anyProcess, isSubprocess, {signal}) => {
+	incrementMaxListeners(anyProcess, 1, signal);
+	await require$$0.once(anyProcess, 'disconnect', {signal});
+	throwOnStrictDisconnect(isSubprocess);
+};
+
+const REQUEST_TYPE = 'execa:ipc:request';
+const RESPONSE_TYPE = 'execa:ipc:response';
+
+// When `sendMessage()` is ongoing, any `message` being received waits before being emitted.
+// This allows calling one or multiple `await sendMessage()` followed by `await getOneMessage()`/`await getEachMessage()`.
+// Without running into a race condition when the other process sends a response too fast, before the current process set up a listener.
+const startSendMessage = (anyProcess, wrappedMessage, strict) => {
+	if (!OUTGOING_MESSAGES.has(anyProcess)) {
+		OUTGOING_MESSAGES.set(anyProcess, new Set());
+	}
+
+	const outgoingMessages = OUTGOING_MESSAGES.get(anyProcess);
+	const onMessageSent = createDeferred();
+	const id = strict ? wrappedMessage.id : undefined;
+	const outgoingMessage = {onMessageSent, id};
+	outgoingMessages.add(outgoingMessage);
+	return {outgoingMessages, outgoingMessage};
+};
+
+const endSendMessage = ({outgoingMessages, outgoingMessage}) => {
+	outgoingMessages.delete(outgoingMessage);
+	outgoingMessage.onMessageSent.resolve();
+};
+
+// Await while `sendMessage()` is ongoing, unless there is already a `message` listener
+const waitForOutgoingMessages = async (anyProcess, ipcEmitter, wrappedMessage) => {
+	while (!hasMessageListeners(anyProcess, ipcEmitter) && OUTGOING_MESSAGES.get(anyProcess)?.size > 0) {
+		const outgoingMessages = [...OUTGOING_MESSAGES.get(anyProcess)];
+		validateStrictDeadlock(outgoingMessages, wrappedMessage);
+		// eslint-disable-next-line no-await-in-loop
+		await Promise.all(outgoingMessages.map(({onMessageSent}) => onMessageSent));
+	}
+};
+
+const OUTGOING_MESSAGES = new WeakMap();
+
+// Whether any `message` listener is setup
+const hasMessageListeners = (anyProcess, ipcEmitter) => ipcEmitter.listenerCount('message') > getMinListenerCount(anyProcess);
+
+// When `buffer` is `false`, we set up a `message` listener that should be ignored.
+// That listener is only meant to intercept `strict` acknowledgement responses.
+const getMinListenerCount = anyProcess => SUBPROCESS_OPTIONS.has(anyProcess)
+	&& !SUBPROCESS_OPTIONS.get(anyProcess).options.buffer.at(-1)
+	? 1
+	: 0;
+
+// Like `[sub]process.send()` but promise-based.
+// We do not `await subprocess` during `.sendMessage()` nor `.getOneMessage()` since those methods are transient.
+// Users would still need to `await subprocess` after the method is done.
+// Also, this would prevent `unhandledRejection` event from being emitted, making it silent.
+const sendMessage = ({anyProcess, channel, isSubprocess, ipc}, message, {strict = false} = {}) => {
+	const methodName = 'sendMessage';
+	validateIpcMethod({
+		methodName,
+		isSubprocess,
+		ipc,
+		isConnected: anyProcess.connected,
+	});
+
+	return sendMessageAsync({
+		anyProcess,
+		channel,
+		methodName,
+		isSubprocess,
+		message,
+		strict,
+	});
+};
+
+const sendMessageAsync = async ({anyProcess, channel, methodName, isSubprocess, message, strict}) => {
+	const wrappedMessage = handleSendStrict({
+		anyProcess,
+		channel,
+		isSubprocess,
+		message,
+		strict,
+	});
+	const outgoingMessagesState = startSendMessage(anyProcess, wrappedMessage, strict);
+	try {
+		await sendOneMessage({
+			anyProcess,
+			methodName,
+			isSubprocess,
+			wrappedMessage,
+			message,
+		});
+	} catch (error) {
+		disconnect(anyProcess);
+		throw error;
+	} finally {
+		endSendMessage(outgoingMessagesState);
+	}
+};
+
+// Used internally by `cancelSignal`
+const sendOneMessage = async ({anyProcess, methodName, isSubprocess, wrappedMessage, message}) => {
+	const sendMethod = getSendMethod(anyProcess);
+
+	try {
+		await Promise.all([
+			waitForStrictResponse(wrappedMessage, anyProcess, isSubprocess),
+			sendMethod(wrappedMessage),
+		]);
+	} catch (error) {
+		handleEpipeError({error, methodName, isSubprocess});
+		handleSerializationError({
+			error,
+			methodName,
+			isSubprocess,
+			message,
+		});
+		throw error;
+	}
+};
+
+// [sub]process.send() promisified, memoized
+const getSendMethod = anyProcess => {
+	if (PROCESS_SEND_METHODS.has(anyProcess)) {
+		return PROCESS_SEND_METHODS.get(anyProcess);
+	}
+
+	const sendMethod = node_util.promisify(anyProcess.send.bind(anyProcess));
+	PROCESS_SEND_METHODS.set(anyProcess, sendMethod);
+	return sendMethod;
+};
+
+const PROCESS_SEND_METHODS = new WeakMap();
+
+// Send an IPC message so the subprocess performs a graceful termination
+const sendAbort = (subprocess, message) => {
+	const methodName = 'cancelSignal';
+	validateConnection(methodName, false, subprocess.connected);
+	return sendOneMessage({
+		anyProcess: subprocess,
+		methodName,
+		isSubprocess: false,
+		wrappedMessage: {type: GRACEFUL_CANCEL_TYPE, message},
+		message,
+	});
+};
+
+// When the signal is being used, start listening for incoming messages.
+// Unbuffering messages takes one microtask to complete, so this must be async.
+const getCancelSignal = async ({anyProcess, channel, isSubprocess, ipc}) => {
+	await startIpc({
+		anyProcess,
+		channel,
+		isSubprocess,
+		ipc,
+	});
+	return cancelController.signal;
+};
+
+const startIpc = async ({anyProcess, channel, isSubprocess, ipc}) => {
+	if (cancelListening) {
+		return;
+	}
+
+	cancelListening = true;
+
+	if (!ipc) {
+		throwOnMissingParent();
+		return;
+	}
+
+	if (channel === null) {
+		abortOnDisconnect();
+		return;
+	}
+
+	getIpcEmitter(anyProcess, channel, isSubprocess);
+	await promises.scheduler.yield();
+};
+
+let cancelListening = false;
+
+// Reception of IPC message to perform a graceful termination
+const handleAbort = wrappedMessage => {
+	if (wrappedMessage?.type !== GRACEFUL_CANCEL_TYPE) {
+		return false;
+	}
+
+	cancelController.abort(wrappedMessage.message);
+	return true;
+};
+
+const GRACEFUL_CANCEL_TYPE = 'execa:ipc:cancel';
+
+// When the current process disconnects early, the subprocess `cancelSignal` is aborted.
+// Otherwise, the signal would never be able to be aborted later on.
+const abortOnDisconnect = () => {
+	cancelController.abort(getAbortDisconnectError());
+};
+
+const cancelController = new AbortController();
+
+// Validate the `gracefulCancel` option
+const validateGracefulCancel = ({gracefulCancel, cancelSignal, ipc, serialization}) => {
+	if (!gracefulCancel) {
+		return;
+	}
+
+	if (cancelSignal === undefined) {
+		throw new Error('The `cancelSignal` option must be defined when setting the `gracefulCancel` option.');
+	}
+
+	if (!ipc) {
+		throw new Error('The `ipc` option cannot be false when setting the `gracefulCancel` option.');
+	}
+
+	if (serialization === 'json') {
+		throw new Error('The `serialization` option cannot be \'json\' when setting the `gracefulCancel` option.');
+	}
+};
+
+// Send abort reason to the subprocess when aborting the `cancelSignal` option and `gracefulCancel` is `true`
+const throwOnGracefulCancel = ({
+	subprocess,
+	cancelSignal,
+	gracefulCancel,
+	forceKillAfterDelay,
+	context,
+	controller,
+}) => gracefulCancel
+	? [sendOnAbort({
+		subprocess,
+		cancelSignal,
+		forceKillAfterDelay,
+		context,
+		controller,
+	})]
+	: [];
+
+const sendOnAbort = async ({subprocess, cancelSignal, forceKillAfterDelay, context, controller: {signal}}) => {
+	await onAbortedSignal(cancelSignal, signal);
+	const reason = getReason(cancelSignal);
+	await sendAbort(subprocess, reason);
+	killOnTimeout({
+		kill: subprocess.kill,
+		forceKillAfterDelay,
+		context,
+		controllerSignal: signal,
+	});
+	context.terminationReason ??= 'gracefulCancel';
+	throw cancelSignal.reason;
+};
+
+// The default `reason` is a DOMException, which is not serializable with V8
+// See https://github.com/nodejs/node/issues/53225
+const getReason = ({reason}) => {
+	if (!(reason instanceof DOMException)) {
+		return reason;
+	}
+
+	const error = new Error(reason.message);
+	Object.defineProperty(error, 'stack', {
+		value: reason.stack,
+		enumerable: false,
+		configurable: true,
+		writable: true,
+	});
+	return error;
+};
 
 // Validate `timeout` option
 const validateTimeout = ({timeout}) => {
@@ -5600,7 +6814,7 @@ const throwOnTimeout = (subprocess, timeout, context, controller) => timeout ===
 
 const killAfterTimeout = async (subprocess, timeout, context, {signal}) => {
 	await promises.setTimeout(timeout, undefined, {signal});
-	context.timedOut = true;
+	context.terminationReason ??= 'timeout';
 	subprocess.kill();
 	throw new DiscardedError();
 };
@@ -5653,6 +6867,49 @@ const handleNodeOption = (file, commandArguments, {
 	];
 };
 
+// Validate the `ipcInput` option
+const validateIpcInputOption = ({ipcInput, ipc, serialization}) => {
+	if (ipcInput === undefined) {
+		return;
+	}
+
+	if (!ipc) {
+		throw new Error('The `ipcInput` option cannot be set unless the `ipc` option is `true`.');
+	}
+
+	validateIpcInput[serialization](ipcInput);
+};
+
+const validateAdvancedInput = ipcInput => {
+	try {
+		node_v8.serialize(ipcInput);
+	} catch (error) {
+		throw new Error('The `ipcInput` option is not serializable with a structured clone.', {cause: error});
+	}
+};
+
+const validateJsonInput = ipcInput => {
+	try {
+		JSON.stringify(ipcInput);
+	} catch (error) {
+		throw new Error('The `ipcInput` option is not serializable with JSON.', {cause: error});
+	}
+};
+
+const validateIpcInput = {
+	advanced: validateAdvancedInput,
+	json: validateJsonInput,
+};
+
+// When the `ipcInput` option is set, it is sent as an initial IPC message to the subprocess
+const sendIpcInput = async (subprocess, ipcInput) => {
+	if (ipcInput === undefined) {
+		return;
+	}
+
+	await subprocess.sendMessage(ipcInput);
+};
+
 // Validate `encoding` option
 const validateEncoding = ({encoding}) => {
 	if (ENCODINGS.has(encoding)) {
@@ -5751,6 +7008,9 @@ const normalizeOptions$2 = (filePath, rawArguments, rawOptions) => {
 	const options = addDefaultOptions(fdOptions);
 	validateTimeout(options);
 	validateEncoding(options);
+	validateIpcInputOption(options);
+	validateCancelSignal(options);
+	validateGracefulCancel(options);
 	options.shell = normalizeFileUrl(options.shell);
 	options.env = getEnv(options);
 	options.killSignal = normalizeKillSignal(options.killSignal);
@@ -5777,7 +7037,9 @@ const addDefaultOptions = ({
 	windowsHide = true,
 	killSignal = 'SIGTERM',
 	forceKillAfterDelay = true,
-	ipc = false,
+	gracefulCancel = false,
+	ipcInput,
+	ipc = ipcInput !== undefined || gracefulCancel,
 	serialization = 'advanced',
 	...options
 }) => ({
@@ -5793,6 +7055,8 @@ const addDefaultOptions = ({
 	windowsHide,
 	killSignal,
 	forceKillAfterDelay,
+	gracefulCancel,
+	ipcInput,
 	ipc,
 	serialization,
 });
@@ -5813,386 +7077,6 @@ const getEnv = ({env: envOption, extendEnv, preferLocal, node, localDirectory, n
 	return env;
 };
 
-const getRealtimeSignals=()=>{
-const length=SIGRTMAX-SIGRTMIN+1;
-return Array.from({length},getRealtimeSignal)
-};
-
-const getRealtimeSignal=(value,index)=>({
-name:`SIGRT${index+1}`,
-number:SIGRTMIN+index,
-action:"terminate",
-description:"Application-specific signal (realtime)",
-standard:"posix"
-});
-
-const SIGRTMIN=34;
-const SIGRTMAX=64;
-
-const SIGNALS=[
-{
-name:"SIGHUP",
-number:1,
-action:"terminate",
-description:"Terminal closed",
-standard:"posix"
-},
-{
-name:"SIGINT",
-number:2,
-action:"terminate",
-description:"User interruption with CTRL-C",
-standard:"ansi"
-},
-{
-name:"SIGQUIT",
-number:3,
-action:"core",
-description:"User interruption with CTRL-\\",
-standard:"posix"
-},
-{
-name:"SIGILL",
-number:4,
-action:"core",
-description:"Invalid machine instruction",
-standard:"ansi"
-},
-{
-name:"SIGTRAP",
-number:5,
-action:"core",
-description:"Debugger breakpoint",
-standard:"posix"
-},
-{
-name:"SIGABRT",
-number:6,
-action:"core",
-description:"Aborted",
-standard:"ansi"
-},
-{
-name:"SIGIOT",
-number:6,
-action:"core",
-description:"Aborted",
-standard:"bsd"
-},
-{
-name:"SIGBUS",
-number:7,
-action:"core",
-description:
-"Bus error due to misaligned, non-existing address or paging error",
-standard:"bsd"
-},
-{
-name:"SIGEMT",
-number:7,
-action:"terminate",
-description:"Command should be emulated but is not implemented",
-standard:"other"
-},
-{
-name:"SIGFPE",
-number:8,
-action:"core",
-description:"Floating point arithmetic error",
-standard:"ansi"
-},
-{
-name:"SIGKILL",
-number:9,
-action:"terminate",
-description:"Forced termination",
-standard:"posix",
-forced:true
-},
-{
-name:"SIGUSR1",
-number:10,
-action:"terminate",
-description:"Application-specific signal",
-standard:"posix"
-},
-{
-name:"SIGSEGV",
-number:11,
-action:"core",
-description:"Segmentation fault",
-standard:"ansi"
-},
-{
-name:"SIGUSR2",
-number:12,
-action:"terminate",
-description:"Application-specific signal",
-standard:"posix"
-},
-{
-name:"SIGPIPE",
-number:13,
-action:"terminate",
-description:"Broken pipe or socket",
-standard:"posix"
-},
-{
-name:"SIGALRM",
-number:14,
-action:"terminate",
-description:"Timeout or timer",
-standard:"posix"
-},
-{
-name:"SIGTERM",
-number:15,
-action:"terminate",
-description:"Termination",
-standard:"ansi"
-},
-{
-name:"SIGSTKFLT",
-number:16,
-action:"terminate",
-description:"Stack is empty or overflowed",
-standard:"other"
-},
-{
-name:"SIGCHLD",
-number:17,
-action:"ignore",
-description:"Child process terminated, paused or unpaused",
-standard:"posix"
-},
-{
-name:"SIGCLD",
-number:17,
-action:"ignore",
-description:"Child process terminated, paused or unpaused",
-standard:"other"
-},
-{
-name:"SIGCONT",
-number:18,
-action:"unpause",
-description:"Unpaused",
-standard:"posix",
-forced:true
-},
-{
-name:"SIGSTOP",
-number:19,
-action:"pause",
-description:"Paused",
-standard:"posix",
-forced:true
-},
-{
-name:"SIGTSTP",
-number:20,
-action:"pause",
-description:"Paused using CTRL-Z or \"suspend\"",
-standard:"posix"
-},
-{
-name:"SIGTTIN",
-number:21,
-action:"pause",
-description:"Background process cannot read terminal input",
-standard:"posix"
-},
-{
-name:"SIGBREAK",
-number:21,
-action:"terminate",
-description:"User interruption with CTRL-BREAK",
-standard:"other"
-},
-{
-name:"SIGTTOU",
-number:22,
-action:"pause",
-description:"Background process cannot write to terminal output",
-standard:"posix"
-},
-{
-name:"SIGURG",
-number:23,
-action:"ignore",
-description:"Socket received out-of-band data",
-standard:"bsd"
-},
-{
-name:"SIGXCPU",
-number:24,
-action:"core",
-description:"Process timed out",
-standard:"bsd"
-},
-{
-name:"SIGXFSZ",
-number:25,
-action:"core",
-description:"File too big",
-standard:"bsd"
-},
-{
-name:"SIGVTALRM",
-number:26,
-action:"terminate",
-description:"Timeout or timer",
-standard:"bsd"
-},
-{
-name:"SIGPROF",
-number:27,
-action:"terminate",
-description:"Timeout or timer",
-standard:"bsd"
-},
-{
-name:"SIGWINCH",
-number:28,
-action:"ignore",
-description:"Terminal window size changed",
-standard:"bsd"
-},
-{
-name:"SIGIO",
-number:29,
-action:"terminate",
-description:"I/O is available",
-standard:"other"
-},
-{
-name:"SIGPOLL",
-number:29,
-action:"terminate",
-description:"Watched event",
-standard:"other"
-},
-{
-name:"SIGINFO",
-number:29,
-action:"ignore",
-description:"Request for process information",
-standard:"other"
-},
-{
-name:"SIGPWR",
-number:30,
-action:"terminate",
-description:"Device running out of power",
-standard:"systemv"
-},
-{
-name:"SIGSYS",
-number:31,
-action:"core",
-description:"Invalid system call",
-standard:"other"
-},
-{
-name:"SIGUNUSED",
-number:31,
-action:"terminate",
-description:"Invalid system call",
-standard:"other"
-}];
-
-const getSignals=()=>{
-const realtimeSignals=getRealtimeSignals();
-const signals=[...SIGNALS,...realtimeSignals].map(normalizeSignal);
-return signals
-};
-
-
-
-
-
-
-
-const normalizeSignal=({
-name,
-number:defaultNumber,
-description,
-action,
-forced=false,
-standard
-})=>{
-const{
-signals:{[name]:constantSignal}
-}=node_os.constants;
-const supported=constantSignal!==undefined;
-const number=supported?constantSignal:defaultNumber;
-return {name,number,description,supported,action,forced,standard}
-};
-
-const getSignalsByName=()=>{
-const signals=getSignals();
-return Object.fromEntries(signals.map(getSignalByName))
-};
-
-const getSignalByName=({
-name,
-number,
-description,
-supported,
-action,
-forced,
-standard
-})=>[name,{name,number,description,supported,action,forced,standard}];
-
-const signalsByName=getSignalsByName();
-
-
-
-
-const getSignalsByNumber=()=>{
-const signals=getSignals();
-const length=SIGRTMAX+1;
-const signalsA=Array.from({length},(value,number)=>
-getSignalByNumber(number,signals)
-);
-return Object.assign({},...signalsA)
-};
-
-const getSignalByNumber=(number,signals)=>{
-const signal=findSignalByNumber(number,signals);
-
-if(signal===undefined){
-return {}
-}
-
-const{name,description,supported,action,forced,standard}=signal;
-return {
-[number]:{
-name,
-number,
-description,
-supported,
-action,
-forced,
-standard
-}
-}
-};
-
-
-
-const findSignalByNumber=(number,signals)=>{
-const signal=signals.find(({name})=>node_os.constants.signals[name]===number);
-
-if(signal!==undefined){
-return signal
-}
-
-return signals.find((signalA)=>signalA.number===number)
-};
-
-getSignalsByNumber();
-
 function stripFinalNewline(input) {
 	if (typeof input === 'string') {
 		return stripFinalNewlineString(input);
@@ -6714,6 +7598,17 @@ const getMaxBufferUnit = (readableObjectMode, lines, encoding) => {
 	return 'characters';
 };
 
+// Check the `maxBuffer` option with `result.ipcOutput`
+const checkIpcMaxBuffer = (subprocess, ipcOutput, maxBuffer) => {
+	if (ipcOutput.length !== maxBuffer) {
+		return;
+	}
+
+	const error = new MaxBufferError();
+	error.maxBufferInfo = {fdNumber: 'ipc'};
+	throw error;
+};
+
 // Error message when `maxBuffer` is hit
 const getMaxBufferMessage = (error, maxBuffer) => {
 	const {streamName, threshold, unit} = getMaxBufferInfo(error, maxBuffer);
@@ -6727,6 +7622,11 @@ const getMaxBufferInfo = (error, maxBuffer) => {
 
 	const {maxBufferInfo: {fdNumber, unit}} = error;
 	delete error.maxBufferInfo;
+
+	if (fdNumber === 'ipc') {
+		return {streamName: 'IPC output', threshold: maxBuffer.at(-1), unit: 'messages'};
+	}
+
 	return {streamName: getStreamName(fdNumber), threshold: maxBuffer[fdNumber], unit};
 };
 
@@ -6754,6 +7654,7 @@ const getMaxBufferSync = ([, stdoutMaxBuffer]) => stdoutMaxBuffer;
 const createMessages = ({
 	stdio,
 	all,
+	ipcOutput,
 	originalError,
 	signal,
 	signalDescription,
@@ -6761,7 +7662,11 @@ const createMessages = ({
 	escapedCommand,
 	timedOut,
 	isCanceled,
+	isGracefullyCanceled,
 	isMaxBuffer,
+	isForcefullyTerminated,
+	forceKillAfterDelay,
+	killSignal,
 	maxBuffer,
 	timeout,
 	cwd,
@@ -6778,33 +7683,73 @@ const createMessages = ({
 		signalDescription,
 		exitCode,
 		isCanceled,
+		isGracefullyCanceled,
+		isForcefullyTerminated,
+		forceKillAfterDelay,
+		killSignal,
 	});
 	const originalMessage = getOriginalMessage(originalError, cwd);
 	const suffix = originalMessage === undefined ? '' : `\n${originalMessage}`;
 	const shortMessage = `${prefix}: ${escapedCommand}${suffix}`;
 	const messageStdio = all === undefined ? [stdio[2], stdio[1]] : [all];
-	const message = [shortMessage, ...messageStdio, ...stdio.slice(3)]
+	const message = [
+		shortMessage,
+		...messageStdio,
+		...stdio.slice(3),
+		ipcOutput.map(ipcMessage => serializeIpcMessage(ipcMessage)).join('\n'),
+	]
 		.map(messagePart => escapeLines(stripFinalNewline(serializeMessagePart(messagePart))))
 		.filter(Boolean)
 		.join('\n\n');
 	return {originalMessage, shortMessage, message};
 };
 
-const getErrorPrefix = ({originalError, timedOut, timeout, isMaxBuffer, maxBuffer, errorCode, signal, signalDescription, exitCode, isCanceled}) => {
+const getErrorPrefix = ({
+	originalError,
+	timedOut,
+	timeout,
+	isMaxBuffer,
+	maxBuffer,
+	errorCode,
+	signal,
+	signalDescription,
+	exitCode,
+	isCanceled,
+	isGracefullyCanceled,
+	isForcefullyTerminated,
+	forceKillAfterDelay,
+	killSignal,
+}) => {
+	const forcefulSuffix = getForcefulSuffix(isForcefullyTerminated, forceKillAfterDelay);
+
 	if (timedOut) {
-		return `Command timed out after ${timeout} milliseconds`;
+		return `Command timed out after ${timeout} milliseconds${forcefulSuffix}`;
+	}
+
+	if (isGracefullyCanceled) {
+		if (signal === undefined) {
+			return `Command was gracefully canceled with exit code ${exitCode}`;
+		}
+
+		return isForcefullyTerminated
+			? `Command was gracefully canceled${forcefulSuffix}`
+			: `Command was gracefully canceled with ${signal} (${signalDescription})`;
 	}
 
 	if (isCanceled) {
-		return 'Command was canceled';
+		return `Command was canceled${forcefulSuffix}`;
 	}
 
 	if (isMaxBuffer) {
-		return getMaxBufferMessage(originalError, maxBuffer);
+		return `${getMaxBufferMessage(originalError, maxBuffer)}${forcefulSuffix}`;
 	}
 
 	if (errorCode !== undefined) {
-		return `Command failed with ${errorCode}`;
+		return `Command failed with ${errorCode}${forcefulSuffix}`;
+	}
+
+	if (isForcefullyTerminated) {
+		return `Command was killed with ${killSignal} (${getSignalDescription(killSignal)})${forcefulSuffix}`;
 	}
 
 	if (signal !== undefined) {
@@ -6818,6 +7763,10 @@ const getErrorPrefix = ({originalError, timedOut, timeout, isMaxBuffer, maxBuffe
 	return 'Command failed';
 };
 
+const getForcefulSuffix = (isForcefullyTerminated, forceKillAfterDelay) => isForcefullyTerminated
+	? ` and was forcefully terminated after ${forceKillAfterDelay} milliseconds`
+	: '';
+
 const getOriginalMessage = (originalError, cwd) => {
 	if (originalError instanceof DiscardedError) {
 		return;
@@ -6830,6 +7779,10 @@ const getOriginalMessage = (originalError, cwd) => {
 	return escapedOriginalMessage === '' ? undefined : escapedOriginalMessage;
 };
 
+const serializeIpcMessage = ipcMessage => typeof ipcMessage === 'string'
+	? ipcMessage
+	: node_util.inspect(ipcMessage);
+
 const serializeMessagePart = messagePart => Array.isArray(messagePart)
 	? messagePart.map(messageItem => stripFinalNewline(serializeMessageItem(messageItem))).filter(Boolean).join('\n')
 	: serializeMessageItem(messagePart);
@@ -6852,6 +7805,7 @@ const makeSuccessResult = ({
 	escapedCommand,
 	stdio,
 	all,
+	ipcOutput,
 	options: {cwd},
 	startTime,
 }) => omitUndefinedProperties({
@@ -6862,13 +7816,16 @@ const makeSuccessResult = ({
 	failed: false,
 	timedOut: false,
 	isCanceled: false,
+	isGracefullyCanceled: false,
 	isTerminated: false,
 	isMaxBuffer: false,
+	isForcefullyTerminated: false,
 	exitCode: 0,
 	stdout: stdio[1],
 	stderr: stdio[2],
 	all,
 	stdio,
+	ipcOutput,
 	pipedFrom: [],
 });
 
@@ -6888,8 +7845,11 @@ const makeEarlyError = ({
 	startTime,
 	timedOut: false,
 	isCanceled: false,
+	isGracefullyCanceled: false,
 	isMaxBuffer: false,
+	isForcefullyTerminated: false,
 	stdio: Array.from({length: fileDescriptors.length}),
+	ipcOutput: [],
 	options,
 	isSync,
 });
@@ -6902,18 +7862,29 @@ const makeError = ({
 	startTime,
 	timedOut,
 	isCanceled,
+	isGracefullyCanceled,
 	isMaxBuffer,
+	isForcefullyTerminated,
 	exitCode: rawExitCode,
 	signal: rawSignal,
 	stdio,
 	all,
-	options: {timeoutDuration, timeout = timeoutDuration, cwd, maxBuffer},
+	ipcOutput,
+	options: {
+		timeoutDuration,
+		timeout = timeoutDuration,
+		forceKillAfterDelay,
+		killSignal,
+		cwd,
+		maxBuffer,
+	},
 	isSync,
 }) => {
 	const {exitCode, signal, signalDescription} = normalizeExitPayload(rawExitCode, rawSignal);
 	const {originalMessage, shortMessage, message} = createMessages({
 		stdio,
 		all,
+		ipcOutput,
 		originalError,
 		signal,
 		signalDescription,
@@ -6921,7 +7892,11 @@ const makeError = ({
 		escapedCommand,
 		timedOut,
 		isCanceled,
+		isGracefullyCanceled,
 		isMaxBuffer,
+		isForcefullyTerminated,
+		forceKillAfterDelay,
+		killSignal,
 		maxBuffer,
 		timeout,
 		cwd,
@@ -6934,12 +7909,15 @@ const makeError = ({
 		startTime,
 		timedOut,
 		isCanceled,
+		isGracefullyCanceled,
 		isMaxBuffer,
+		isForcefullyTerminated,
 		exitCode,
 		signal,
 		signalDescription,
 		stdio,
 		all,
+		ipcOutput,
 		cwd,
 		originalMessage,
 		shortMessage,
@@ -6954,12 +7932,15 @@ const getErrorProperties = ({
 	startTime,
 	timedOut,
 	isCanceled,
+	isGracefullyCanceled,
 	isMaxBuffer,
+	isForcefullyTerminated,
 	exitCode,
 	signal,
 	signalDescription,
 	stdio,
 	all,
+	ipcOutput,
 	cwd,
 	originalMessage,
 	shortMessage,
@@ -6973,8 +7954,10 @@ const getErrorProperties = ({
 	failed: true,
 	timedOut,
 	isCanceled,
+	isGracefullyCanceled,
 	isTerminated: signal !== undefined,
 	isMaxBuffer,
+	isForcefullyTerminated,
 	exitCode,
 	signal,
 	signalDescription,
@@ -6983,6 +7966,7 @@ const getErrorProperties = ({
 	stderr: stdio[2],
 	all,
 	stdio,
+	ipcOutput,
 	pipedFrom: [],
 });
 
@@ -6993,7 +7977,7 @@ const omitUndefinedProperties = result => Object.fromEntries(Object.entries(resu
 const normalizeExitPayload = (rawExitCode, rawSignal) => {
 	const exitCode = rawExitCode === null ? undefined : rawExitCode;
 	const signal = rawSignal === null ? undefined : rawSignal;
-	const signalDescription = signal === undefined ? undefined : signalsByName[rawSignal].description;
+	const signalDescription = signal === undefined ? undefined : getSignalDescription(rawSignal);
 	return {exitCode, signal, signalDescription};
 };
 
@@ -7633,11 +8617,18 @@ const getStandardStreamDirection = value => {
 // When the ambiguity remains, we default to `output` since it is the most common use case for additional file descriptors.
 const DEFAULT_DIRECTION = 'output';
 
+// The `ipc` option adds an `ipc` item to the `stdio` option
+const normalizeIpcStdioArray = (stdioArray, ipc) => ipc && !stdioArray.includes('ipc')
+	? [...stdioArray, 'ipc']
+	: stdioArray;
+
 // Add support for `stdin`/`stdout`/`stderr` as an alias for `stdio`.
 // Also normalize the `stdio` option.
 const normalizeStdioOption = ({stdio, ipc, buffer, verbose, ...options}, isSync) => {
 	const stdioArray = getStdioArray(stdio, options).map((stdioOption, fdNumber) => addDefaultValue(stdioOption, fdNumber));
-	return isSync ? normalizeStdioSync(stdioArray, buffer, verbose) : normalizeStdioAsync(stdioArray, ipc);
+	return isSync
+		? normalizeStdioSync(stdioArray, buffer, verbose)
+		: normalizeIpcStdioArray(stdioArray, ipc);
 };
 
 const getStdioArray = (stdio, options) => {
@@ -7688,118 +8679,6 @@ const normalizeStdioSync = (stdioArray, buffer, verbose) => stdioArray.map((stdi
 const isOutputPipeOnly = stdioOption => stdioOption === 'pipe'
 	|| (Array.isArray(stdioOption) && stdioOption.every(item => item === 'pipe'));
 
-// The `ipc` option adds an `ipc` item to the `stdio` option
-const normalizeStdioAsync = (stdioArray, ipc) => ipc && !stdioArray.includes('ipc')
-	? [...stdioArray, 'ipc']
-	: stdioArray;
-
-// Retrieve stream targeted by the `to` option
-const getToStream = (destination, to = 'stdin') => {
-	const isWritable = true;
-	const {options, fileDescriptors} = SUBPROCESS_OPTIONS.get(destination);
-	const fdNumber = getFdNumber(fileDescriptors, to, isWritable);
-	const destinationStream = destination.stdio[fdNumber];
-
-	if (destinationStream === null) {
-		throw new TypeError(getInvalidStdioOptionMessage(fdNumber, to, options, isWritable));
-	}
-
-	return destinationStream;
-};
-
-// Retrieve stream targeted by the `from` option
-const getFromStream = (source, from = 'stdout') => {
-	const isWritable = false;
-	const {options, fileDescriptors} = SUBPROCESS_OPTIONS.get(source);
-	const fdNumber = getFdNumber(fileDescriptors, from, isWritable);
-	const sourceStream = fdNumber === 'all' ? source.all : source.stdio[fdNumber];
-
-	if (sourceStream === null || sourceStream === undefined) {
-		throw new TypeError(getInvalidStdioOptionMessage(fdNumber, from, options, isWritable));
-	}
-
-	return sourceStream;
-};
-
-// Keeps track of the options passed to each Execa call
-const SUBPROCESS_OPTIONS = new WeakMap();
-
-const getFdNumber = (fileDescriptors, fdName, isWritable) => {
-	const fdNumber = parseFdNumber(fdName, isWritable);
-	validateFdNumber(fdNumber, fdName, isWritable, fileDescriptors);
-	return fdNumber;
-};
-
-const parseFdNumber = (fdName, isWritable) => {
-	const fdNumber = parseFd(fdName);
-	if (fdNumber !== undefined) {
-		return fdNumber;
-	}
-
-	const {validOptions, defaultValue} = isWritable
-		? {validOptions: '"stdin"', defaultValue: 'stdin'}
-		: {validOptions: '"stdout", "stderr", "all"', defaultValue: 'stdout'};
-	throw new TypeError(`"${getOptionName(isWritable)}" must not be "${fdName}".
-It must be ${validOptions} or "fd3", "fd4" (and so on).
-It is optional and defaults to "${defaultValue}".`);
-};
-
-const validateFdNumber = (fdNumber, fdName, isWritable, fileDescriptors) => {
-	const fileDescriptor = fileDescriptors[getUsedDescriptor(fdNumber)];
-	if (fileDescriptor === undefined) {
-		throw new TypeError(`"${getOptionName(isWritable)}" must not be ${fdName}. That file descriptor does not exist.
-Please set the "stdio" option to ensure that file descriptor exists.`);
-	}
-
-	if (fileDescriptor.direction === 'input' && !isWritable) {
-		throw new TypeError(`"${getOptionName(isWritable)}" must not be ${fdName}. It must be a readable stream, not writable.`);
-	}
-
-	if (fileDescriptor.direction !== 'input' && isWritable) {
-		throw new TypeError(`"${getOptionName(isWritable)}" must not be ${fdName}. It must be a writable stream, not readable.`);
-	}
-};
-
-const getInvalidStdioOptionMessage = (fdNumber, fdName, options, isWritable) => {
-	if (fdNumber === 'all' && !options.all) {
-		return 'The "all" option must be true to use "from: \'all\'".';
-	}
-
-	const {optionName, optionValue} = getInvalidStdioOption(fdNumber, options);
-	return `The "${optionName}: ${serializeOptionValue(optionValue)}" option is incompatible with using "${getOptionName(isWritable)}: ${serializeOptionValue(fdName)}".
-Please set this option with "pipe" instead.`;
-};
-
-const getInvalidStdioOption = (fdNumber, {stdin, stdout, stderr, stdio}) => {
-	const usedDescriptor = getUsedDescriptor(fdNumber);
-
-	if (usedDescriptor === 0 && stdin !== undefined) {
-		return {optionName: 'stdin', optionValue: stdin};
-	}
-
-	if (usedDescriptor === 1 && stdout !== undefined) {
-		return {optionName: 'stdout', optionValue: stdout};
-	}
-
-	if (usedDescriptor === 2 && stderr !== undefined) {
-		return {optionName: 'stderr', optionValue: stderr};
-	}
-
-	return {optionName: `stdio[${usedDescriptor}]`, optionValue: stdio[usedDescriptor]};
-};
-
-const getUsedDescriptor = fdNumber => fdNumber === 'all' ? 1 : fdNumber;
-
-const getOptionName = isWritable => isWritable ? 'to' : 'from';
-
-const serializeOptionValue = value => {
-	if (typeof value === 'string') {
-		return `'${value}'`;
-	}
-
-	return typeof value === 'number' ? `${value}` : 'Stream';
-};
-
 // When we use multiple `stdio` values for the same streams, we pass 'pipe' to `child_process.spawn()`.
 // We then emulate the piping done by core Node.js.
 // To do so, we transform the following values:
@@ -8032,7 +8911,7 @@ const getDuplicateStreamInstance = ({otherStdioItems, type, value, optionName, d
 
 const hasSameValue = ({type, value}, secondValue) => {
 	if (type === 'filePath') {
-		return value.path === secondValue.path;
+		return value.file === secondValue.file;
 	}
 
 	if (type === 'fileUrl') {
@@ -8782,7 +9661,7 @@ const fdUsesVerbose = fdNumber => fdNumber === 1 || fdNumber === 2;
 
 const PIPED_STDIO_VALUES = new Set(['pipe', 'overlapped']);
 
-// `verbose` printing logic with async methods
+// `verbose: 'full'` printing logic with async methods
 const logLines = async (linesIterable, stream, verboseInfo) => {
 	for await (const line of linesIterable) {
 		if (!isPipingStream(stream)) {
@@ -8791,7 +9670,7 @@ const logLines = async (linesIterable, stream, verboseInfo) => {
 	}
 };
 
-// `verbose` printing logic with sync methods
+// `verbose: 'full'` printing logic with sync methods
 const logLinesSync = (linesArray, verboseInfo) => {
 	for (const line of linesArray) {
 		logLine(line, verboseInfo);
@@ -8809,15 +9688,9 @@ const isPipingStream = stream => stream._readableState.pipes.length > 0;
 
 // When `verbose` is `full`, print stdout|stderr
 const logLine = (line, {verboseId}) => {
-	const lines = typeof line === 'string' ? line : node_util.inspect(line);
-	const escapedLines = escapeLines(lines);
-	const spacedLines = escapedLines.replaceAll('\t', ' '.repeat(TAB_SIZE));
-	verboseLog(spacedLines, verboseId, 'output');
+	verboseLog(serializeLogMessage(line), verboseId, 'output');
 };
 
-// Same as `util.inspect()`
-const TAB_SIZE = 2;
-
 // Apply `stdout`/`stderr` options, after spawning, in sync mode
 const transformOutputSync = ({fileDescriptors, syncResult: {output}, options, isMaxBuffer, verboseInfo}) => {
 	if (output === null) {
@@ -8959,13 +9832,19 @@ const getAllSync = ([, stdout, stderr], options) => {
 };
 
 // If `error` is emitted before `spawn`, `exit` will never be emitted.
-// However, `error` might be emitted after `spawn`, e.g. with the `cancelSignal` option.
+// However, `error` might be emitted after `spawn`.
 // In that case, `exit` will still be emitted.
 // Since the `exit` event contains the signal name, we want to make sure we are listening for it.
 // This function also takes into account the following unlikely cases:
 //  - `exit` being emitted in the same microtask as `spawn`
 //  - `error` being emitted multiple times
-const waitForExit = async subprocess => {
+const waitForExit = async (subprocess, context) => {
+	const [exitCode, signal] = await waitForExitOrError(subprocess);
+	context.isForcefullyTerminated ??= false;
+	return [exitCode, signal];
+};
+
+const waitForExitOrError = async subprocess => {
 	const [spawnPayload, exitPayload] = await Promise.allSettled([
 		require$$0.once(subprocess, 'spawn'),
 		require$$0.once(subprocess, 'exit'),
@@ -9026,7 +9905,7 @@ const getResultError = (error, exitCode, signal) => {
 	return isFailedExit(exitCode, signal) ? new DiscardedError() : undefined;
 };
 
-// Main shared logic for all sync methods: `execaSync()`, `execaCommandSync()`, `$.sync()`
+// Main shared logic for all sync methods: `execaSync()`, `$.sync()`
 const execaCoreSync = (rawFile, rawArguments, rawOptions) => {
 	const {file, commandArguments, command, escapedCommand, startTime, verboseInfo, options, fileDescriptors} = handleSyncArguments(rawFile, rawArguments, rawOptions);
 	const result = spawnSubprocessSync({
@@ -9071,7 +9950,11 @@ const handleSyncArguments = (rawFile, rawArguments, rawOptions) => {
 const normalizeSyncOptions = options => options.node && !options.ipc ? {...options, ipc: false} : options;
 
 // Options validation logic specific to sync methods
-const validateSyncOptions = ({ipc, detached, cancelSignal}) => {
+const validateSyncOptions = ({ipc, ipcInput, detached, cancelSignal}) => {
+	if (ipcInput) {
+		throwInvalidSyncOption('ipcInput');
+	}
+
 	if (ipc) {
 		throwInvalidSyncOption('ipc: true');
 	}
@@ -9155,6 +10038,7 @@ const getSyncResult = ({error, exitCode, signal, timedOut, isMaxBuffer, stdio, a
 		escapedCommand,
 		stdio,
 		all,
+		ipcOutput: [],
 		options,
 		startTime,
 	})
@@ -9164,16 +10048,208 @@ const getSyncResult = ({error, exitCode, signal, timedOut, isMaxBuffer, stdio, a
 		escapedCommand,
 		timedOut,
 		isCanceled: false,
+		isGracefullyCanceled: false,
 		isMaxBuffer,
+		isForcefullyTerminated: false,
 		exitCode,
 		signal,
 		stdio,
 		all,
+		ipcOutput: [],
 		options,
 		startTime,
 		isSync: true,
 	});
 
+// Like `[sub]process.once('message')` but promise-based
+const getOneMessage = ({anyProcess, channel, isSubprocess, ipc}, {reference = true, filter} = {}) => {
+	validateIpcMethod({
+		methodName: 'getOneMessage',
+		isSubprocess,
+		ipc,
+		isConnected: isConnected(anyProcess),
+	});
+
+	return getOneMessageAsync({
+		anyProcess,
+		channel,
+		isSubprocess,
+		filter,
+		reference,
+	});
+};
+
+const getOneMessageAsync = async ({anyProcess, channel, isSubprocess, filter, reference}) => {
+	addReference(channel, reference);
+	const ipcEmitter = getIpcEmitter(anyProcess, channel, isSubprocess);
+	const controller = new AbortController();
+	try {
+		return await Promise.race([
+			getMessage(ipcEmitter, filter, controller),
+			throwOnDisconnect(ipcEmitter, isSubprocess, controller),
+			throwOnStrictError(ipcEmitter, isSubprocess, controller),
+		]);
+	} catch (error) {
+		disconnect(anyProcess);
+		throw error;
+	} finally {
+		controller.abort();
+		removeReference(channel, reference);
+	}
+};
+
+const getMessage = async (ipcEmitter, filter, {signal}) => {
+	if (filter === undefined) {
+		const [message] = await require$$0.once(ipcEmitter, 'message', {signal});
+		return message;
+	}
+
+	for await (const [message] of require$$0.on(ipcEmitter, 'message', {signal})) {
+		if (filter(message)) {
+			return message;
+		}
+	}
+};
+
+const throwOnDisconnect = async (ipcEmitter, isSubprocess, {signal}) => {
+	await require$$0.once(ipcEmitter, 'disconnect', {signal});
+	throwOnEarlyDisconnect(isSubprocess);
+};
+
+const throwOnStrictError = async (ipcEmitter, isSubprocess, {signal}) => {
+	const [error] = await require$$0.once(ipcEmitter, 'strict:error', {signal});
+	throw getStrictResponseError(error, isSubprocess);
+};
+
+// Like `[sub]process.on('message')` but promise-based
+const getEachMessage = ({anyProcess, channel, isSubprocess, ipc}, {reference = true} = {}) => loopOnMessages({
+	anyProcess,
+	channel,
+	isSubprocess,
+	ipc,
+	shouldAwait: !isSubprocess,
+	reference,
+});
+
+// Same but used internally
+const loopOnMessages = ({anyProcess, channel, isSubprocess, ipc, shouldAwait, reference}) => {
+	validateIpcMethod({
+		methodName: 'getEachMessage',
+		isSubprocess,
+		ipc,
+		isConnected: isConnected(anyProcess),
+	});
+
+	addReference(channel, reference);
+	const ipcEmitter = getIpcEmitter(anyProcess, channel, isSubprocess);
+	const controller = new AbortController();
+	const state = {};
+	stopOnDisconnect(anyProcess, ipcEmitter, controller);
+	abortOnStrictError({
+		ipcEmitter,
+		isSubprocess,
+		controller,
+		state,
+	});
+	return iterateOnMessages({
+		anyProcess,
+		channel,
+		ipcEmitter,
+		isSubprocess,
+		shouldAwait,
+		controller,
+		state,
+		reference,
+	});
+};
+
+const stopOnDisconnect = async (anyProcess, ipcEmitter, controller) => {
+	try {
+		await require$$0.once(ipcEmitter, 'disconnect', {signal: controller.signal});
+		controller.abort();
+	} catch {}
+};
+
+const abortOnStrictError = async ({ipcEmitter, isSubprocess, controller, state}) => {
+	try {
+		const [error] = await require$$0.once(ipcEmitter, 'strict:error', {signal: controller.signal});
+		state.error = getStrictResponseError(error, isSubprocess);
+		controller.abort();
+	} catch {}
+};
+
+const iterateOnMessages = async function * ({anyProcess, channel, ipcEmitter, isSubprocess, shouldAwait, controller, state, reference}) {
+	try {
+		for await (const [message] of require$$0.on(ipcEmitter, 'message', {signal: controller.signal})) {
+			throwIfStrictError(state);
+			yield message;
+		}
+	} catch {
+		throwIfStrictError(state);
+	} finally {
+		controller.abort();
+		removeReference(channel, reference);
+
+		if (!isSubprocess) {
+			disconnect(anyProcess);
+		}
+
+		if (shouldAwait) {
+			await anyProcess;
+		}
+	}
+};
+
+const throwIfStrictError = ({error}) => {
+	if (error) {
+		throw error;
+	}
+};
+
+// Add promise-based IPC methods in current process
+const addIpcMethods = (subprocess, {ipc}) => {
+	Object.assign(subprocess, getIpcMethods(subprocess, false, ipc));
+};
+
+// Get promise-based IPC in the subprocess
+const getIpcExport = () => {
+	const anyProcess = process$3;
+	const isSubprocess = true;
+	const ipc = process$3.channel !== undefined;
+
+	return {
+		...getIpcMethods(anyProcess, isSubprocess, ipc),
+		getCancelSignal: getCancelSignal.bind(undefined, {
+			anyProcess,
+			channel: anyProcess.channel,
+			isSubprocess,
+			ipc,
+		}),
+	};
+};
+
+// Retrieve the `ipc` shared by both the current process and the subprocess
+const getIpcMethods = (anyProcess, isSubprocess, ipc) => ({
+	sendMessage: sendMessage.bind(undefined, {
+		anyProcess,
+		channel: anyProcess.channel,
+		isSubprocess,
+		ipc,
+	}),
+	getOneMessage: getOneMessage.bind(undefined, {
+		anyProcess,
+		channel: anyProcess.channel,
+		isSubprocess,
+		ipc,
+	}),
+	getEachMessage: getEachMessage.bind(undefined, {
+		anyProcess,
+		channel: anyProcess.channel,
+		isSubprocess,
+		ipc,
+	}),
+});
+
 // When the subprocess fails to spawn.
 // We ensure the returned error is always both a promise and a subprocess.
 const handleEarlyError = ({error, command, escapedCommand, fileDescriptors, options, startTime, verboseInfo}) => {
@@ -9532,19 +10608,6 @@ const PASSTHROUGH_LISTENERS_COUNT = 2;
 //  - once due to `stream.pipe(passThroughStream)`
 const PASSTHROUGH_LISTENERS_PER_STREAM = 1;
 
-// Temporarily increase the maximum number of listeners on an eventEmitter
-const incrementMaxListeners = (eventEmitter, maxListenersIncrement, signal) => {
-	const maxListeners = eventEmitter.getMaxListeners();
-	if (maxListeners === 0 || maxListeners === Number.POSITIVE_INFINITY) {
-		return;
-	}
-
-	eventEmitter.setMaxListeners(maxListeners + maxListenersIncrement);
-	require$$0.addAbortListener(signal, () => {
-		eventEmitter.setMaxListeners(eventEmitter.getMaxListeners() - maxListenersIncrement);
-	});
-};
-
 // Similar to `Stream.pipeline(source, destination)`, but does not destroy standard streams
 const pipeStreams = (source, destination) => {
 	source.pipe(destination);
@@ -10671,10 +11734,72 @@ const getAllMixed = ({all, stdout, stderr}) => all
 	&& stderr
 	&& stdout.readableObjectMode !== stderr.readableObjectMode;
 
+// When `verbose` is `'full'`, print IPC messages from the subprocess
+const shouldLogIpc = ({verbose}) => verbose.at(-1) === 'full';
+
+const logIpcOutput = (message, {verboseId}) => {
+	verboseLog(serializeLogMessage(message), verboseId, 'ipc');
+};
+
+// Iterate through IPC messages sent by the subprocess
+const waitForIpcOutput = async ({
+	subprocess,
+	buffer: bufferArray,
+	maxBuffer: maxBufferArray,
+	ipc,
+	ipcOutput,
+	verboseInfo,
+}) => {
+	if (!ipc) {
+		return ipcOutput;
+	}
+
+	const isVerbose = shouldLogIpc(verboseInfo);
+	const buffer = bufferArray.at(-1);
+	const maxBuffer = maxBufferArray.at(-1);
+
+	for await (const message of loopOnMessages({
+		anyProcess: subprocess,
+		channel: subprocess.channel,
+		isSubprocess: false,
+		ipc,
+		shouldAwait: false,
+		reference: true,
+	})) {
+		if (buffer) {
+			checkIpcMaxBuffer(subprocess, ipcOutput, maxBuffer);
+			ipcOutput.push(message);
+		}
+
+		if (isVerbose) {
+			logIpcOutput(message, verboseInfo);
+		}
+	}
+
+	return ipcOutput;
+};
+
+const getBufferedIpcOutput = async (ipcOutputPromise, ipcOutput) => {
+	await Promise.allSettled([ipcOutputPromise]);
+	return ipcOutput;
+};
+
 // Retrieve result of subprocess: exit code, signal, error, streams (stdout/stderr/all)
 const waitForSubprocessResult = async ({
 	subprocess,
-	options: {encoding, buffer, maxBuffer, lines, timeoutDuration: timeout, stripFinalNewline},
+	options: {
+		encoding,
+		buffer,
+		maxBuffer,
+		lines,
+		timeoutDuration: timeout,
+		cancelSignal,
+		gracefulCancel,
+		forceKillAfterDelay,
+		stripFinalNewline,
+		ipc,
+		ipcInput,
+	},
 	context,
 	verboseInfo,
 	fileDescriptors,
@@ -10682,7 +11807,7 @@ const waitForSubprocessResult = async ({
 	onInternalError,
 	controller,
 }) => {
-	const exitPromise = waitForExit(subprocess);
+	const exitPromise = waitForExit(subprocess, context);
 	const streamInfo = {
 		originalStreams,
 		fileDescriptors,
@@ -10711,6 +11836,15 @@ const waitForSubprocessResult = async ({
 		verboseInfo,
 		streamInfo,
 	});
+	const ipcOutput = [];
+	const ipcOutputPromise = waitForIpcOutput({
+		subprocess,
+		buffer,
+		maxBuffer,
+		ipc,
+		ipcOutput,
+		verboseInfo,
+	});
 	const originalPromises = waitForOriginalStreams(originalStreams, subprocess, streamInfo);
 	const customStreamsEndPromises = waitForCustomStreamsEnd(fileDescriptors, streamInfo);
 
@@ -10721,19 +11855,38 @@ const waitForSubprocessResult = async ({
 				waitForSuccessfulExit(exitPromise),
 				Promise.all(stdioPromises),
 				allPromise,
+				ipcOutputPromise,
+				sendIpcInput(subprocess, ipcInput),
 				...originalPromises,
 				...customStreamsEndPromises,
 			]),
 			onInternalError,
 			throwOnSubprocessError(subprocess, controller),
 			...throwOnTimeout(subprocess, timeout, context, controller),
+			...throwOnCancel({
+				subprocess,
+				cancelSignal,
+				gracefulCancel,
+				context,
+				controller,
+			}),
+			...throwOnGracefulCancel({
+				subprocess,
+				cancelSignal,
+				gracefulCancel,
+				forceKillAfterDelay,
+				context,
+				controller,
+			}),
 		]);
 	} catch (error) {
+		context.terminationReason ??= 'other';
 		return Promise.all([
 			{error},
 			exitPromise,
 			Promise.all(stdioPromises.map(stdioPromise => getBufferedData(stdioPromise))),
 			getBufferedData(allPromise),
+			getBufferedIpcOutput(ipcOutputPromise, ipcOutput),
 			Promise.allSettled(originalPromises),
 			Promise.allSettled(customStreamsEndPromises),
 		]);
@@ -10763,14 +11916,6 @@ const throwOnSubprocessError = async (subprocess, {signal}) => {
 	throw error;
 };
 
-const createDeferred = () => {
-	const methods = {};
-	const promise = new Promise((resolve, reject) => {
-		Object.assign(methods, {resolve, reject});
-	});
-	return Object.assign(promise, methods);
-};
-
 // When using multiple `.readable()`/`.writable()`/`.duplex()`, `final` and `destroy` should wait for other streams
 const initializeConcurrentStreams = () => ({
 	readableDestroy: new WeakMap(),
@@ -11137,7 +12282,7 @@ const descriptors = ['then', 'catch', 'finally'].map(property => [
 	Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property),
 ]);
 
-// Main shared logic for all async methods: `execa()`, `execaCommand()`, `$`, `execaNode()`
+// Main shared logic for all async methods: `execa()`, `$`, `execaNode()`
 const execaCoreAsync = (rawFile, rawArguments, rawOptions, createNested) => {
 	const {file, commandArguments, command, escapedCommand, startTime, verboseInfo, options, fileDescriptors} = handleAsyncArguments(rawFile, rawArguments, rawOptions);
 	const {subprocess, promise} = spawnSubprocessAsync({
@@ -11187,12 +12332,12 @@ const handleAsyncArguments = (rawFile, rawArguments, rawOptions) => {
 
 // Options normalization logic specific to async methods.
 // Prevent passing the `timeout` option directly to `child_process.spawn()`.
-const handleAsyncOptions = ({timeout, signal, cancelSignal, ...options}) => {
+const handleAsyncOptions = ({timeout, signal, ...options}) => {
 	if (signal !== undefined) {
 		throw new TypeError('The "signal" option has been renamed to "cancelSignal" instead.');
 	}
 
-	return {...options, timeoutDuration: timeout, signal: cancelSignal};
+	return {...options, timeoutDuration: timeout};
 };
 
 const spawnSubprocessAsync = ({file, commandArguments, options, startTime, verboseInfo, command, escapedCommand, fileDescriptors}) => {
@@ -11218,15 +12363,18 @@ const spawnSubprocessAsync = ({file, commandArguments, options, startTime, verbo
 	pipeOutputAsync(subprocess, fileDescriptors, controller);
 	cleanupOnExit(subprocess, options, controller);
 
+	const context = {};
 	const onInternalError = createDeferred();
 	subprocess.kill = subprocessKill.bind(undefined, {
 		kill: subprocess.kill.bind(subprocess),
 		options,
 		onInternalError,
+		context,
 		controller,
 	});
 	subprocess.all = makeAllStream(subprocess, options);
 	addConvertedStreams(subprocess, options);
+	addIpcMethods(subprocess, options);
 
 	const promise = handlePromise({
 		subprocess,
@@ -11237,6 +12385,7 @@ const spawnSubprocessAsync = ({file, commandArguments, options, startTime, verbo
 		originalStreams,
 		command,
 		escapedCommand,
+		context,
 		onInternalError,
 		controller,
 	});
@@ -11244,10 +12393,14 @@ const spawnSubprocessAsync = ({file, commandArguments, options, startTime, verbo
 };
 
 // Asynchronous logic, as opposed to the previous logic which can be run synchronously, i.e. can be returned to user right away
-const handlePromise = async ({subprocess, options, startTime, verboseInfo, fileDescriptors, originalStreams, command, escapedCommand, onInternalError, controller}) => {
-	const context = {timedOut: false};
-
-	const [errorInfo, [exitCode, signal], stdioResults, allResult] = await waitForSubprocessResult({
+const handlePromise = async ({subprocess, options, startTime, verboseInfo, fileDescriptors, originalStreams, command, escapedCommand, context, onInternalError, controller}) => {
+	const [
+		errorInfo,
+		[exitCode, signal],
+		stdioResults,
+		allResult,
+		ipcOutput,
+	] = await waitForSubprocessResult({
 		subprocess,
 		options,
 		context,
@@ -11268,6 +12421,7 @@ const handlePromise = async ({subprocess, options, startTime, verboseInfo, fileD
 		signal,
 		stdio,
 		all,
+		ipcOutput,
 		context,
 		options,
 		command,
@@ -11277,18 +12431,21 @@ const handlePromise = async ({subprocess, options, startTime, verboseInfo, fileD
 	return handleResult(result, verboseInfo, options);
 };
 
-const getAsyncResult = ({errorInfo, exitCode, signal, stdio, all, context, options, command, escapedCommand, startTime}) => 'error' in errorInfo
+const getAsyncResult = ({errorInfo, exitCode, signal, stdio, all, ipcOutput, context, options, command, escapedCommand, startTime}) => 'error' in errorInfo
 	? makeError({
 		error: errorInfo.error,
 		command,
 		escapedCommand,
-		timedOut: context.timedOut,
-		isCanceled: options.signal?.aborted === true,
+		timedOut: context.terminationReason === 'timeout',
+		isCanceled: context.terminationReason === 'cancel' || context.terminationReason === 'gracefulCancel',
+		isGracefullyCanceled: context.terminationReason === 'gracefulCancel',
 		isMaxBuffer: errorInfo.error instanceof MaxBufferError,
+		isForcefullyTerminated: context.isForcefullyTerminated,
 		exitCode,
 		signal,
 		stdio,
 		all,
+		ipcOutput,
 		options,
 		startTime,
 		isSync: false,
@@ -11298,6 +12455,7 @@ const getAsyncResult = ({errorInfo, exitCode, signal, stdio, all, context, optio
 		escapedCommand,
 		stdio,
 		all,
+		ipcOutput,
 		options,
 		startTime,
 	});
@@ -11394,8 +12552,23 @@ const parseCommand = (command, unusedArguments) => {
 		throw new TypeError(`The command and its arguments must be passed as a single string: ${command} ${unusedArguments}.`);
 	}
 
+	const [file, ...commandArguments] = parseCommandString(command);
+	return {file, commandArguments};
+};
+
+// Convert `command` string into an array of file or arguments to pass to $`${...fileOrCommandArguments}`
+const parseCommandString = command => {
+	if (typeof command !== 'string') {
+		throw new TypeError(`The command must be a string: ${String(command)}.`);
+	}
+
+	const trimmedCommand = command.trim();
+	if (trimmedCommand === '') {
+		return [];
+	}
+
 	const tokens = [];
-	for (const token of command.trim().split(SPACES_REGEXP)) {
+	for (const token of trimmedCommand.split(SPACES_REGEXP)) {
 		// Allow spaces to be escaped by a backslash if not meant as a delimiter
 		const previousToken = tokens.at(-1);
 		if (previousToken && previousToken.endsWith('\\')) {
@@ -11406,8 +12579,7 @@ const parseCommand = (command, unusedArguments) => {
 		}
 	}
 
-	const [file, ...commandArguments] = tokens;
-	return {file, commandArguments};
+	return tokens;
 };
 
 const SPACES_REGEXP = / +/g;
@@ -11442,6 +12614,8 @@ createExeca(mapCommandSync);
 createExeca(mapNode);
 createExeca(mapScriptAsync, {}, deepScriptOptions, setScriptSync);
 
+getIpcExport();
+
 var lodash = {exports: {}};
 
 /**
@@ -32272,7 +33446,7 @@ var utils$j = {};
 	 */
 
 	exports.escapeNode = (block, n = 0, type) => {
-	  let node = block.nodes[n];
+	  const node = block.nodes[n];
 	  if (!node) return;
 
 	  if ((type && node.type === type) || node.type === 'open' || node.type === 'close') {
@@ -32341,13 +33515,23 @@ var utils$j = {};
 
 	exports.flatten = (...args) => {
 	  const result = [];
+
 	  const flat = arr => {
 	    for (let i = 0; i < arr.length; i++) {
-	      let ele = arr[i];
-	      Array.isArray(ele) ? flat(ele) : ele !== void 0 && result.push(ele);
+	      const ele = arr[i];
+
+	      if (Array.isArray(ele)) {
+	        flat(ele);
+	        continue;
+	      }
+
+	      if (ele !== undefined) {
+	        result.push(ele);
+	      }
 	    }
 	    return result;
 	  };
+
 	  flat(args);
 	  return result;
 	}; 
@@ -32356,9 +33540,9 @@ var utils$j = {};
 const utils$i = utils$j;
 
 var stringify$4 = (ast, options = {}) => {
-  let stringify = (node, parent = {}) => {
-    let invalidBlock = options.escapeInvalid && utils$i.isInvalidBrace(parent);
-    let invalidNode = node.invalid === true && options.escapeInvalid === true;
+  const stringify = (node, parent = {}) => {
+    const invalidBlock = options.escapeInvalid && utils$i.isInvalidBrace(parent);
+    const invalidNode = node.invalid === true && options.escapeInvalid === true;
     let output = '';
 
     if (node.value) {
@@ -32373,7 +33557,7 @@ var stringify$4 = (ast, options = {}) => {
     }
 
     if (node.nodes) {
-      for (let child of node.nodes) {
+      for (const child of node.nodes) {
         output += stringify(child);
       }
     }
@@ -32747,7 +33931,7 @@ const toMaxLen = (input, maxLength) => {
   return negative ? ('-' + input) : input;
 };
 
-const toSequence = (parts, options) => {
+const toSequence = (parts, options, maxLen) => {
   parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
   parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
 
@@ -32757,11 +33941,11 @@ const toSequence = (parts, options) => {
   let result;
 
   if (parts.positives.length) {
-    positives = parts.positives.join('|');
+    positives = parts.positives.map(v => toMaxLen(String(v), maxLen)).join('|');
   }
 
   if (parts.negatives.length) {
-    negatives = `-(${prefix}${parts.negatives.join('|')})`;
+    negatives = `-(${prefix}${parts.negatives.map(v => toMaxLen(String(v), maxLen)).join('|')})`;
   }
 
   if (positives && negatives) {
@@ -32859,7 +34043,7 @@ const fillNumbers = (start, end, step = 1, options = {}) => {
 
   if (options.toRegex === true) {
     return step > 1
-      ? toSequence(parts, options)
+      ? toSequence(parts, options, maxLen)
       : toRegex(range, null, { wrap: false, ...options });
   }
 
@@ -32871,7 +34055,6 @@ const fillLetters = (start, end, step = 1, options = {}) => {
     return invalidRange(start, end, options);
   }
 
-
   let format = options.transform || (val => String.fromCharCode(val));
   let a = `${start}`.charCodeAt(0);
   let b = `${end}`.charCodeAt(0);
@@ -32939,30 +34122,32 @@ const fill$1 = fillRange;
 const utils$h = utils$j;
 
 const compile$1 = (ast, options = {}) => {
-  let walk = (node, parent = {}) => {
-    let invalidBlock = utils$h.isInvalidBrace(parent);
-    let invalidNode = node.invalid === true && options.escapeInvalid === true;
-    let invalid = invalidBlock === true || invalidNode === true;
-    let prefix = options.escapeInvalid === true ? '\\' : '';
+  const walk = (node, parent = {}) => {
+    const invalidBlock = utils$h.isInvalidBrace(parent);
+    const invalidNode = node.invalid === true && options.escapeInvalid === true;
+    const invalid = invalidBlock === true || invalidNode === true;
+    const prefix = options.escapeInvalid === true ? '\\' : '';
     let output = '';
 
     if (node.isOpen === true) {
       return prefix + node.value;
     }
+
     if (node.isClose === true) {
+      console.log('node.isClose', prefix, node.value);
       return prefix + node.value;
     }
 
     if (node.type === 'open') {
-      return invalid ? (prefix + node.value) : '(';
+      return invalid ? prefix + node.value : '(';
     }
 
     if (node.type === 'close') {
-      return invalid ? (prefix + node.value) : ')';
+      return invalid ? prefix + node.value : ')';
     }
 
     if (node.type === 'comma') {
-      return node.prev.type === 'comma' ? '' : (invalid ? node.value : '|');
+      return node.prev.type === 'comma' ? '' : invalid ? node.value : '|';
     }
 
     if (node.value) {
@@ -32970,8 +34155,8 @@ const compile$1 = (ast, options = {}) => {
     }
 
     if (node.nodes && node.ranges > 0) {
-      let args = utils$h.reduce(node.nodes);
-      let range = fill$1(...args, { ...options, wrap: false, toRegex: true });
+      const args = utils$h.reduce(node.nodes);
+      const range = fill$1(...args, { ...options, wrap: false, toRegex: true, strictZeros: true });
 
       if (range.length !== 0) {
         return args.length > 1 && range.length > 1 ? `(${range})` : range;
@@ -32979,10 +34164,11 @@ const compile$1 = (ast, options = {}) => {
     }
 
     if (node.nodes) {
-      for (let child of node.nodes) {
+      for (const child of node.nodes) {
         output += walk(child, node);
       }
     }
+
     return output;
   };
 
@@ -32996,7 +34182,7 @@ const stringify$2 = stringify$4;
 const utils$g = utils$j;
 
 const append = (queue = '', stash = '', enclose = false) => {
-  let result = [];
+  const result = [];
 
   queue = [].concat(queue);
   stash = [].concat(stash);
@@ -33006,15 +34192,15 @@ const append = (queue = '', stash = '', enclose = false) => {
     return enclose ? utils$g.flatten(stash).map(ele => `{${ele}}`) : stash;
   }
 
-  for (let item of queue) {
+  for (const item of queue) {
     if (Array.isArray(item)) {
-      for (let value of item) {
+      for (const value of item) {
         result.push(append(value, stash, enclose));
       }
     } else {
       for (let ele of stash) {
         if (enclose === true && typeof ele === 'string') ele = `{${ele}}`;
-        result.push(Array.isArray(ele) ? append(item, ele, enclose) : (item + ele));
+        result.push(Array.isArray(ele) ? append(item, ele, enclose) : item + ele);
       }
     }
   }
@@ -33022,9 +34208,9 @@ const append = (queue = '', stash = '', enclose = false) => {
 };
 
 const expand$1 = (ast, options = {}) => {
-  let rangeLimit = options.rangeLimit === void 0 ? 1000 : options.rangeLimit;
+  const rangeLimit = options.rangeLimit === undefined ? 1000 : options.rangeLimit;
 
-  let walk = (node, parent = {}) => {
+  const walk = (node, parent = {}) => {
     node.queue = [];
 
     let p = parent;
@@ -33046,7 +34232,7 @@ const expand$1 = (ast, options = {}) => {
     }
 
     if (node.nodes && node.ranges > 0) {
-      let args = utils$g.reduce(node.nodes);
+      const args = utils$g.reduce(node.nodes);
 
       if (utils$g.exceedsLimit(...args, options.step, rangeLimit)) {
         throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
@@ -33062,7 +34248,7 @@ const expand$1 = (ast, options = {}) => {
       return;
     }
 
-    let enclose = utils$g.encloseBrace(node);
+    const enclose = utils$g.encloseBrace(node);
     let queue = node.queue;
     let block = node;
 
@@ -33072,7 +34258,7 @@ const expand$1 = (ast, options = {}) => {
     }
 
     for (let i = 0; i < node.nodes.length; i++) {
-      let child = node.nodes[i];
+      const child = node.nodes[i];
 
       if (child.type === 'comma' && node.type === 'brace') {
         if (i === 1) queue.push('');
@@ -33104,7 +34290,7 @@ const expand$1 = (ast, options = {}) => {
 var expand_1 = expand$1;
 
 var constants$4 = {
-  MAX_LENGTH: 1024 * 64,
+  MAX_LENGTH: 10000,
 
   // Digits
   CHAR_0: '0', /* 0 */
@@ -33192,18 +34378,18 @@ const parse$3 = (input, options = {}) => {
     throw new TypeError('Expected a string');
   }
 
-  let opts = options || {};
-  let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1;
+  const opts = options || {};
+  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1;
   if (input.length > max) {
     throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
   }
 
-  let ast = { type: 'root', input, nodes: [] };
-  let stack = [ast];
+  const ast = { type: 'root', input, nodes: [] };
+  const stack = [ast];
   let block = ast;
   let prev = ast;
   let brackets = 0;
-  let length = input.length;
+  const length = input.length;
   let index = 0;
   let depth = 0;
   let value;
@@ -33268,6 +34454,7 @@ const parse$3 = (input, options = {}) => {
 
     if (value === CHAR_LEFT_SQUARE_BRACKET$1) {
       brackets++;
+
       let next;
 
       while (index < length && (next = advance())) {
@@ -33323,7 +34510,7 @@ const parse$3 = (input, options = {}) => {
      */
 
     if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
-      let open = value;
+      const open = value;
       let next;
 
       if (options.keepQuotes !== true) {
@@ -33355,8 +34542,8 @@ const parse$3 = (input, options = {}) => {
     if (value === CHAR_LEFT_CURLY_BRACE$1) {
       depth++;
 
-      let dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;
-      let brace = {
+      const dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;
+      const brace = {
         type: 'brace',
         open: true,
         close: false,
@@ -33383,7 +34570,7 @@ const parse$3 = (input, options = {}) => {
         continue;
       }
 
-      let type = 'close';
+      const type = 'close';
       block = stack.pop();
       block.close = true;
 
@@ -33401,7 +34588,7 @@ const parse$3 = (input, options = {}) => {
     if (value === CHAR_COMMA$1 && depth > 0) {
       if (block.ranges > 0) {
         block.ranges = 0;
-        let open = block.nodes.shift();
+        const open = block.nodes.shift();
         block.nodes = [open, { type: 'text', value: stringify$1(block) }];
       }
 
@@ -33415,7 +34602,7 @@ const parse$3 = (input, options = {}) => {
      */
 
     if (value === CHAR_DOT$1 && depth > 0 && block.commas === 0) {
-      let siblings = block.nodes;
+      const siblings = block.nodes;
 
       if (depth === 0 || siblings.length === 0) {
         push({ type: 'text', value });
@@ -33442,7 +34629,7 @@ const parse$3 = (input, options = {}) => {
       if (prev.type === 'range') {
         siblings.pop();
 
-        let before = siblings[siblings.length - 1];
+        const before = siblings[siblings.length - 1];
         before.value += prev.value + value;
         prev = before;
         block.ranges--;
@@ -33475,8 +34662,8 @@ const parse$3 = (input, options = {}) => {
       });
 
       // get the location of the block on parent.nodes (block's siblings)
-      let parent = stack[stack.length - 1];
-      let index = parent.nodes.indexOf(block);
+      const parent = stack[stack.length - 1];
+      const index = parent.nodes.indexOf(block);
       // replace the (invalid) block with it's nodes
       parent.nodes.splice(index, 1, ...block.nodes);
     }
@@ -33511,8 +34698,8 @@ const braces$1 = (input, options = {}) => {
   let output = [];
 
   if (Array.isArray(input)) {
-    for (let pattern of input) {
-      let result = braces$1.create(pattern, options);
+    for (const pattern of input) {
+      const result = braces$1.create(pattern, options);
       if (Array.isArray(result)) {
         output.push(...result);
       } else {
@@ -33646,7 +34833,7 @@ braces$1.create = (input, options = {}) => {
     return [input];
   }
 
- return options.expand !== true
+  return options.expand !== true
     ? braces$1.compile(input, options)
     : braces$1.expand(input, options);
 };