karajan-code 3.4.1 → 3.4.2

package/node_modules/execa/lib/ipc/send.js

@@ -1,91 +0,0 @@
-import {promisify} from 'node:util';
-import {
-	validateIpcMethod,
-	handleEpipeError,
-	handleSerializationError,
-	disconnect,
-} from './validation.js';
-import {startSendMessage, endSendMessage} from './outgoing.js';
-import {handleSendStrict, waitForStrictResponse} from './strict.js';
-
-// 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.
-export 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`
-export 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 = promisify(anyProcess.send.bind(anyProcess));
-	PROCESS_SEND_METHODS.set(anyProcess, sendMethod);
-	return sendMethod;
-};
-
-const PROCESS_SEND_METHODS = new WeakMap();

package/node_modules/execa/lib/ipc/strict.js

@@ -1,113 +0,0 @@
-import {once} from 'node:events';
-import {createDeferred} from '../utils/deferred.js';
-import {incrementMaxListeners} from '../utils/max-listeners.js';
-import {sendMessage} from './send.js';
-import {throwOnMissingStrict, throwOnStrictDisconnect, throwOnStrictDeadlockError} from './validation.js';
-import {getIpcEmitter} from './forward.js';
-import {hasMessageListeners} from './outgoing.js';
-
-// When using the `strict` option, wrap the message with metadata during `sendMessage()`
-export 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.
-export 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
-export 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
-export 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()`
-export 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(anyProcess, isSubprocess, controller),
-		]);
-
-		if (isDeadlock) {
-			throwOnStrictDeadlockError(isSubprocess);
-		}
-
-		if (!hasListeners) {
-			throwOnMissingStrict(isSubprocess);
-		}
-	} finally {
-		controller.abort();
-		delete STRICT_RESPONSES[wrappedMessage.id];
-	}
-};
-
-const STRICT_RESPONSES = {};
-
-const throwOnDisconnect = async (anyProcess, isSubprocess, {signal}) => {
-	incrementMaxListeners(anyProcess, 1, signal);
-	await once(anyProcess, 'disconnect', {signal});
-	throwOnStrictDisconnect(isSubprocess);
-};
-
-const REQUEST_TYPE = 'execa:ipc:request';
-const RESPONSE_TYPE = 'execa:ipc:response';

package/node_modules/execa/lib/ipc/validation.js

@@ -1,111 +0,0 @@
-// Validate the IPC channel is connected before receiving/sending messages
-export 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.
-export 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
-export 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
-export 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
-export 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
-export 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
-export 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`
-export const getAbortDisconnectError = () => new Error(`\`cancelSignal\` aborted: the ${getOtherProcessName(true)} disconnected.`);
-
-// When the subprocess uses `cancelSignal` but not the current process
-export 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
-export 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'`.
-export 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.
-export const disconnect = anyProcess => {
-	if (anyProcess.connected) {
-		anyProcess.disconnect();
-	}
-};

package/node_modules/execa/lib/methods/bind.js

@@ -1,23 +0,0 @@
-import isPlainObject from 'is-plain-obj';
-import {FD_SPECIFIC_OPTIONS} from '../arguments/specific.js';
-
-// Deep merge specific options like `env`. Shallow merge the other ones.
-export const mergeOptions = (boundOptions, options) => {
-	const newOptions = Object.fromEntries(
-		Object.entries(options).map(([optionName, optionValue]) => [
-			optionName,
-			mergeOption(optionName, boundOptions[optionName], optionValue),
-		]),
-	);
-	return {...boundOptions, ...newOptions};
-};
-
-const mergeOption = (optionName, boundOptionValue, optionValue) => {
-	if (DEEP_OPTIONS.has(optionName) && isPlainObject(boundOptionValue) && isPlainObject(optionValue)) {
-		return {...boundOptionValue, ...optionValue};
-	}
-
-	return optionValue;
-};
-
-const DEEP_OPTIONS = new Set(['env', ...FD_SPECIFIC_OPTIONS]);

package/node_modules/execa/lib/methods/command.js

@@ -1,43 +0,0 @@
-// Main logic for `execaCommand()`
-export const mapCommandAsync = ({file, commandArguments}) => parseCommand(file, commandArguments);
-
-// Main logic for `execaCommandSync()`
-export const mapCommandSync = ({file, commandArguments}) => ({...parseCommand(file, commandArguments), isSync: true});
-
-// Convert `execaCommand(command)` into `execa(file, ...commandArguments)`
-const parseCommand = (command, unusedArguments) => {
-	if (unusedArguments.length > 0) {
-		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}`
-export 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 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('\\')) {
-			// Merge previous token with current one
-			tokens[tokens.length - 1] = `${previousToken.slice(0, -1)} ${token}`;
-		} else {
-			tokens.push(token);
-		}
-	}
-
-	return tokens;
-};
-
-const SPACES_REGEXP = / +/g;

package/node_modules/execa/lib/methods/create.js

@@ -1,65 +0,0 @@
-import isPlainObject from 'is-plain-obj';
-import {normalizeParameters} from './parameters.js';
-import {isTemplateString, parseTemplates} from './template.js';
-import {execaCoreSync} from './main-sync.js';
-import {execaCoreAsync} from './main-async.js';
-import {mergeOptions} from './bind.js';
-
-// Wraps every exported methods to provide the following features:
-//  - template string syntax: execa`command argument`
-//  - options binding: boundExeca = execa(options)
-//  - optional argument/options: execa(file), execa(file, args), execa(file, options), execa(file, args, options)
-// `mapArguments()` and `setBoundExeca()` allows for method-specific logic.
-export const createExeca = (mapArguments, boundOptions, deepOptions, setBoundExeca) => {
-	const createNested = (mapArguments, boundOptions, setBoundExeca) => createExeca(mapArguments, boundOptions, deepOptions, setBoundExeca);
-	const boundExeca = (...execaArguments) => callBoundExeca({
-		mapArguments,
-		deepOptions,
-		boundOptions,
-		setBoundExeca,
-		createNested,
-	}, ...execaArguments);
-
-	if (setBoundExeca !== undefined) {
-		setBoundExeca(boundExeca, createNested, boundOptions);
-	}
-
-	return boundExeca;
-};
-
-const callBoundExeca = ({mapArguments, deepOptions = {}, boundOptions = {}, setBoundExeca, createNested}, firstArgument, ...nextArguments) => {
-	if (isPlainObject(firstArgument)) {
-		return createNested(mapArguments, mergeOptions(boundOptions, firstArgument), setBoundExeca);
-	}
-
-	const {file, commandArguments, options, isSync} = parseArguments({
-		mapArguments,
-		firstArgument,
-		nextArguments,
-		deepOptions,
-		boundOptions,
-	});
-	return isSync
-		? execaCoreSync(file, commandArguments, options)
-		: execaCoreAsync(file, commandArguments, options, createNested);
-};
-
-const parseArguments = ({mapArguments, firstArgument, nextArguments, deepOptions, boundOptions}) => {
-	const callArguments = isTemplateString(firstArgument)
-		? parseTemplates(firstArgument, nextArguments)
-		: [firstArgument, ...nextArguments];
-	const [initialFile, initialArguments, initialOptions] = normalizeParameters(...callArguments);
-	const mergedOptions = mergeOptions(mergeOptions(deepOptions, boundOptions), initialOptions);
-	const {
-		file = initialFile,
-		commandArguments = initialArguments,
-		options = mergedOptions,
-		isSync = false,
-	} = mapArguments({file: initialFile, commandArguments: initialArguments, options: mergedOptions});
-	return {
-		file,
-		commandArguments,
-		options,
-		isSync,
-	};
-};

package/node_modules/execa/lib/methods/main-async.js

@@ -1,194 +0,0 @@
-import {setMaxListeners} from 'node:events';
-import {spawn} from 'node:child_process';
-import {MaxBufferError} from 'get-stream';
-import {handleCommand} from '../arguments/command.js';
-import {normalizeOptions} from '../arguments/options.js';
-import {SUBPROCESS_OPTIONS} from '../arguments/fd-options.js';
-import {concatenateShell} from '../arguments/shell.js';
-import {addIpcMethods} from '../ipc/methods.js';
-import {makeError, makeSuccessResult} from '../return/result.js';
-import {handleResult} from '../return/reject.js';
-import {handleEarlyError} from '../return/early-error.js';
-import {handleStdioAsync} from '../stdio/handle-async.js';
-import {stripNewline} from '../io/strip-newline.js';
-import {pipeOutputAsync} from '../io/output-async.js';
-import {subprocessKill} from '../terminate/kill.js';
-import {cleanupOnExit} from '../terminate/cleanup.js';
-import {pipeToSubprocess} from '../pipe/setup.js';
-import {makeAllStream} from '../resolve/all-async.js';
-import {waitForSubprocessResult} from '../resolve/wait-subprocess.js';
-import {addConvertedStreams} from '../convert/add.js';
-import {createDeferred} from '../utils/deferred.js';
-import {mergePromise} from './promise.js';
-
-// Main shared logic for all async methods: `execa()`, `$`, `execaNode()`
-export const execaCoreAsync = (rawFile, rawArguments, rawOptions, createNested) => {
-	const {file, commandArguments, command, escapedCommand, startTime, verboseInfo, options, fileDescriptors} = handleAsyncArguments(rawFile, rawArguments, rawOptions);
-	const {subprocess, promise} = spawnSubprocessAsync({
-		file,
-		commandArguments,
-		options,
-		startTime,
-		verboseInfo,
-		command,
-		escapedCommand,
-		fileDescriptors,
-	});
-	subprocess.pipe = pipeToSubprocess.bind(undefined, {
-		source: subprocess,
-		sourcePromise: promise,
-		boundOptions: {},
-		createNested,
-	});
-	mergePromise(subprocess, promise);
-	SUBPROCESS_OPTIONS.set(subprocess, {options, fileDescriptors});
-	return subprocess;
-};
-
-// Compute arguments to pass to `child_process.spawn()`
-const handleAsyncArguments = (rawFile, rawArguments, rawOptions) => {
-	const {command, escapedCommand, startTime, verboseInfo} = handleCommand(rawFile, rawArguments, rawOptions);
-	const {file, commandArguments, options: normalizedOptions} = normalizeOptions(rawFile, rawArguments, rawOptions);
-	const options = handleAsyncOptions(normalizedOptions);
-	const fileDescriptors = handleStdioAsync(options, verboseInfo);
-	return {
-		file,
-		commandArguments,
-		command,
-		escapedCommand,
-		startTime,
-		verboseInfo,
-		options,
-		fileDescriptors,
-	};
-};
-
-// Options normalization logic specific to async methods.
-// Prevent passing the `timeout` option directly to `child_process.spawn()`.
-const handleAsyncOptions = ({timeout, signal, ...options}) => {
-	if (signal !== undefined) {
-		throw new TypeError('The "signal" option has been renamed to "cancelSignal" instead.');
-	}
-
-	return {...options, timeoutDuration: timeout};
-};
-
-const spawnSubprocessAsync = ({file, commandArguments, options, startTime, verboseInfo, command, escapedCommand, fileDescriptors}) => {
-	let subprocess;
-	try {
-		subprocess = spawn(...concatenateShell(file, commandArguments, options));
-	} catch (error) {
-		return handleEarlyError({
-			error,
-			command,
-			escapedCommand,
-			fileDescriptors,
-			options,
-			startTime,
-			verboseInfo,
-		});
-	}
-
-	const controller = new AbortController();
-	setMaxListeners(Number.POSITIVE_INFINITY, controller.signal);
-
-	const originalStreams = [...subprocess.stdio];
-	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,
-		options,
-		startTime,
-		verboseInfo,
-		fileDescriptors,
-		originalStreams,
-		command,
-		escapedCommand,
-		context,
-		onInternalError,
-		controller,
-	});
-	return {subprocess, promise};
-};
-
-// 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, context, onInternalError, controller}) => {
-	const [
-		errorInfo,
-		[exitCode, signal],
-		stdioResults,
-		allResult,
-		ipcOutput,
-	] = await waitForSubprocessResult({
-		subprocess,
-		options,
-		context,
-		verboseInfo,
-		fileDescriptors,
-		originalStreams,
-		onInternalError,
-		controller,
-	});
-	controller.abort();
-	onInternalError.resolve();
-
-	const stdio = stdioResults.map((stdioResult, fdNumber) => stripNewline(stdioResult, options, fdNumber));
-	const all = stripNewline(allResult, options, 'all');
-	const result = getAsyncResult({
-		errorInfo,
-		exitCode,
-		signal,
-		stdio,
-		all,
-		ipcOutput,
-		context,
-		options,
-		command,
-		escapedCommand,
-		startTime,
-	});
-	return handleResult(result, verboseInfo, options);
-};
-
-const getAsyncResult = ({errorInfo, exitCode, signal, stdio, all, ipcOutput, context, options, command, escapedCommand, startTime}) => 'error' in errorInfo
-	? makeError({
-		error: errorInfo.error,
-		command,
-		escapedCommand,
-		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,
-	})
-	: makeSuccessResult({
-		command,
-		escapedCommand,
-		stdio,
-		all,
-		ipcOutput,
-		options,
-		startTime,
-	});