wxt 0.18.6 → 0.18.8

package/dist/{execa-QQUOQNS3.js → execa-ATHZH2Y4.js}

@@ -3,7 +3,7 @@ import {
   __commonJS,
   __require,
   __toESM
-} from "./chunk-73I7FAJU.js";
+} from "./chunk-SGKCDMVR.js";
 
 // ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js
 var require_windows = __commonJS({
@@ -515,7 +515,7 @@ function isPlainObject(value) {
   return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
 }
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/arguments/file-url.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/arguments/file-url.js
 import { fileURLToPath } from "node:url";
 var safeNormalizeFileUrl = (file, name) => {
   const fileString = normalizeFileUrl(file);
@@ -526,7 +526,7 @@ var safeNormalizeFileUrl = (file, name) => {
 };
 var normalizeFileUrl = (file) => file instanceof URL ? fileURLToPath(file) : file;
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/methods/parameters.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/methods/parameters.js
 var normalizeParameters = (rawFile, rawArguments = [], rawOptions = {}) => {
   const filePath = safeNormalizeFileUrl(rawFile, "First argument");
   const [commandArguments, options] = isPlainObject(rawArguments) ? [[], rawArguments] : [rawArguments, rawOptions];
@@ -547,10 +547,10 @@ var normalizeParameters = (rawFile, rawArguments = [], rawOptions = {}) => {
   return [filePath, normalizedArguments, options];
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/methods/template.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/methods/template.js
 import { ChildProcess } from "node:child_process";
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/utils/uint-array.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/utils/uint-array.js
 import { StringDecoder } from "node:string_decoder";
 var { toString: objectToString } = Object.prototype;
 var isArrayBuffer = (value) => objectToString.call(value) === "[object ArrayBuffer]";
@@ -597,7 +597,7 @@ var getJoinLength = (uint8Arrays) => {
   return joinLength;
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/methods/template.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/methods/template.js
 var isTemplateString = (templates) => Array.isArray(templates) && Array.isArray(templates.raw);
 var parseTemplates = (templates, expressions) => {
   let tokens = [];
@@ -694,7 +694,7 @@ var getSubprocessResult = ({ stdout }) => {
   throw new TypeError(`Unexpected "${typeof stdout}" stdout in template expression`);
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/methods/main-sync.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/methods/main-sync.js
 import { spawnSync } from "node:child_process";
 
 // ../../node_modules/.pnpm/yoctocolors@2.0.2/node_modules/yoctocolors/index.js
@@ -765,7 +765,7 @@ var bgMagentaBright = format(105, 49);
 var bgCyanBright = format(106, 49);
 var bgWhiteBright = format(107, 49);
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/verbose/info.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/verbose/info.js
 import { debuglog } from "node:util";
 var verboseDefault = debuglog("execa").enabled ? "full" : "none";
 var getVerboseInfo = (verbose) => {
@@ -791,8 +791,9 @@ var validateVerbose = (verbose) => {
 };
 var VERBOSE_VALUES = /* @__PURE__ */ new Set(["none", "short", "full"]);
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/verbose/log.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/verbose/log.js
 import { writeFileSync } from "node:fs";
+import { inspect } from "node:util";
 
 // ../../node_modules/.pnpm/is-unicode-supported@2.0.0/node_modules/is-unicode-supported/index.js
 import process2 from "node:process";
@@ -1079,7 +1080,45 @@ var figures = shouldUseMain ? mainSymbols : fallbackSymbols;
 var figures_default = figures;
 var replacements = Object.entries(specialMainSymbols);
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/verbose/log.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/arguments/escape.js
+import { platform } from "node:process";
+import { stripVTControlCharacters } from "node:util";
+var joinCommand = (filePath, rawArguments) => {
+  const fileAndArguments = [filePath, ...rawArguments];
+  const command = fileAndArguments.join(" ");
+  const escapedCommand = fileAndArguments.map((fileAndArgument) => quoteString(escapeControlCharacters(fileAndArgument))).join(" ");
+  return { command, escapedCommand };
+};
+var escapeLines = (lines) => stripVTControlCharacters(lines).split("\n").map((line) => escapeControlCharacters(line)).join("\n");
+var escapeControlCharacters = (line) => line.replaceAll(SPECIAL_CHAR_REGEXP, (character) => escapeControlCharacter(character));
+var escapeControlCharacter = (character) => {
+  const commonEscape = COMMON_ESCAPES[character];
+  if (commonEscape !== void 0) {
+    return commonEscape;
+  }
+  const codepoint = character.codePointAt(0);
+  const codepointHex = codepoint.toString(16);
+  return codepoint <= ASTRAL_START ? `\\u${codepointHex.padStart(4, "0")}` : `\\U${codepointHex}`;
+};
+var SPECIAL_CHAR_REGEXP = /\p{Separator}|\p{Other}/gu;
+var COMMON_ESCAPES = {
+  " ": " ",
+  "\b": "\\b",
+  "\f": "\\f",
+  "\n": "\\n",
+  "\r": "\\r",
+  "	": "\\t"
+};
+var ASTRAL_START = 65535;
+var quoteString = (escapedArgument) => {
+  if (NO_ESCAPE_REGEXP.test(escapedArgument)) {
+    return escapedArgument;
+  }
+  return platform === "win32" ? `"${escapedArgument.replaceAll('"', '""')}"` : `'${escapedArgument.replaceAll("'", "'\\''")}'`;
+};
+var NO_ESCAPE_REGEXP = /^[\w./-]+$/;
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/verbose/log.js
 var verboseLog = (string, verboseId, icon, color) => {
   const prefixedLines = addPrefix(string, verboseId, icon, color);
   writeFileSync(STDERR_FD, `${prefixedLines}
@@ -1103,12 +1142,19 @@ var ICONS = {
   command: "$",
   pipedCommand: "|",
   output: " ",
+  ipc: "*",
   error: figures_default.cross,
   warning: figures_default.warning,
   success: figures_default.tick
 };
+var serializeLogMessage = (message) => {
+  const messageString = typeof message === "string" ? message : inspect(message);
+  const escapedMessage = escapeLines(messageString);
+  return escapedMessage.replaceAll("	", " ".repeat(TAB_SIZE));
+};
+var TAB_SIZE = 2;
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/verbose/start.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/verbose/start.js
 var logCommand = (escapedCommand, { verbose, verboseId }, { piped = false }) => {
   if (!isVerbose(verbose)) {
     return;
@@ -1117,57 +1163,19 @@ var logCommand = (escapedCommand, { verbose, verboseId }, { piped = false }) =>
   verboseLog(escapedCommand, verboseId, icon, bold);
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/return/duration.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/return/duration.js
 import { hrtime } from "node:process";
 var getStartTime = () => hrtime.bigint();
 var getDurationMs = (startTime) => Number(hrtime.bigint() - startTime) / 1e6;
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/arguments/escape.js
-import { platform } from "node:process";
-import { stripVTControlCharacters } from "node:util";
-var joinCommand = (filePath, rawArguments) => {
-  const fileAndArguments = [filePath, ...rawArguments];
-  const command = fileAndArguments.join(" ");
-  const escapedCommand = fileAndArguments.map((fileAndArgument) => quoteString(escapeControlCharacters(fileAndArgument))).join(" ");
-  return { command, escapedCommand };
-};
-var escapeLines = (lines) => stripVTControlCharacters(lines).split("\n").map((line) => escapeControlCharacters(line)).join("\n");
-var escapeControlCharacters = (line) => line.replaceAll(SPECIAL_CHAR_REGEXP, (character) => escapeControlCharacter(character));
-var escapeControlCharacter = (character) => {
-  const commonEscape = COMMON_ESCAPES[character];
-  if (commonEscape !== void 0) {
-    return commonEscape;
-  }
-  const codepoint = character.codePointAt(0);
-  const codepointHex = codepoint.toString(16);
-  return codepoint <= ASTRAL_START ? `\\u${codepointHex.padStart(4, "0")}` : `\\U${codepointHex}`;
-};
-var SPECIAL_CHAR_REGEXP = /\p{Separator}|\p{Other}/gu;
-var COMMON_ESCAPES = {
-  " ": " ",
-  "\b": "\\b",
-  "\f": "\\f",
-  "\n": "\\n",
-  "\r": "\\r",
-  "	": "\\t"
-};
-var ASTRAL_START = 65535;
-var quoteString = (escapedArgument) => {
-  if (NO_ESCAPE_REGEXP.test(escapedArgument)) {
-    return escapedArgument;
-  }
-  return platform === "win32" ? `"${escapedArgument.replaceAll('"', '""')}"` : `'${escapedArgument.replaceAll("'", "'\\''")}'`;
-};
-var NO_ESCAPE_REGEXP = /^[\w./-]+$/;
-
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/utils/standard-stream.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/utils/standard-stream.js
 import process3 from "node:process";
 var isStandardStream = (stream) => STANDARD_STREAMS.includes(stream);
 var STANDARD_STREAMS = [process3.stdin, process3.stdout, process3.stderr];
 var STANDARD_STREAMS_ALIASES = ["stdin", "stdout", "stderr"];
 var getStreamName = (fdNumber) => STANDARD_STREAMS_ALIASES[fdNumber] ?? `stdio[${fdNumber}]`;
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/arguments/specific.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/arguments/specific.js
 var normalizeFdSpecificOptions = (options) => {
   const optionsCopy = { ...options };
   for (const optionName of FD_SPECIFIC_OPTIONS) {
@@ -1176,7 +1184,7 @@ var normalizeFdSpecificOptions = (options) => {
   return optionsCopy;
 };
 var 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(optionArray, optionName);
 };
@@ -1198,10 +1206,13 @@ var getFdNameOrder = (fdName) => {
   return fdName === "all" ? 2 : 1;
 };
 var parseFdName = (fdName, optionName, optionArray) => {
+  if (fdName === "ipc") {
+    return [optionArray.length - 1];
+  }
   const fdNumber = parseFd(fdName);
   if (fdNumber === void 0 || 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) {
     throw new TypeError(`"${optionName}.${fdName}" is invalid: that file descriptor does not exist.
@@ -1232,7 +1243,7 @@ var DEFAULT_OPTIONS = {
 };
 var FD_SPECIFIC_OPTIONS = ["lines", "buffer", "maxBuffer", "verbose", "stripFinalNewline"];
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/arguments/command.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/arguments/command.js
 var handleCommand = (filePath, rawArguments, rawOptions) => {
   const startTime = getStartTime();
   const { command, escapedCommand } = joinCommand(filePath, rawArguments);
@@ -1246,7 +1257,7 @@ var handleCommand = (filePath, rawArguments, rawOptions) => {
   };
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/arguments/options.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/arguments/options.js
 var import_cross_spawn = __toESM(require_cross_spawn(), 1);
 import { basename as basename2 } from "node:path";
 import process6 from "node:process";
@@ -1307,10 +1318,10 @@ var npmRunPathEnv = ({ env = process4.env, ...options } = {}) => {
   return env;
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/terminate/kill.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/terminate/kill.js
 import { setTimeout } from "node:timers/promises";
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/return/final-error.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/return/final-error.js
 var getFinalError = (originalError, message, isSync) => {
   const ErrorClass = isSync ? ExecaSyncError : ExecaError;
   const options = originalError instanceof DiscardedError ? {} : { cause: originalError };
@@ -1342,323 +1353,29 @@ var ExecaSyncError = class extends Error {
 };
 setErrorName(ExecaSyncError, ExecaSyncError.name);
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/terminate/signal.js
-import { constants } from "node:os";
-var normalizeKillSignal = (killSignal) => {
-  const optionName = "option `killSignal`";
-  if (killSignal === 0) {
-    throw new TypeError(`Invalid ${optionName}: 0 cannot be used.`);
-  }
-  return normalizeSignal(killSignal, optionName);
-};
-var normalizeSignalArgument = (signal) => signal === 0 ? signal : normalizeSignal(signal, "`subprocess.kill()`'s argument");
-var normalizeSignal = (signalNameOrInteger, optionName) => {
-  if (Number.isInteger(signalNameOrInteger)) {
-    return normalizeSignalInteger(signalNameOrInteger, optionName);
-  }
-  if (typeof signalNameOrInteger === "string") {
-    return normalizeSignalName(signalNameOrInteger, optionName);
-  }
-  throw new TypeError(`Invalid ${optionName} ${String(signalNameOrInteger)}: it must be a string or an integer.
-${getAvailableSignals()}`);
-};
-var normalizeSignalInteger = (signalInteger, optionName) => {
-  if (signalsIntegerToName.has(signalInteger)) {
-    return signalsIntegerToName.get(signalInteger);
-  }
-  throw new TypeError(`Invalid ${optionName} ${signalInteger}: this signal integer does not exist.
-${getAvailableSignals()}`);
-};
-var getSignalsIntegerToName = () => new Map(Object.entries(constants.signals).reverse().map(([signalName, signalInteger]) => [signalInteger, signalName]));
-var signalsIntegerToName = getSignalsIntegerToName();
-var normalizeSignalName = (signalName, optionName) => {
-  if (signalName in constants.signals) {
-    return signalName;
-  }
-  if (signalName.toUpperCase() in constants.signals) {
-    throw new TypeError(`Invalid ${optionName} '${signalName}': please rename it to '${signalName.toUpperCase()}'.`);
-  }
-  throw new TypeError(`Invalid ${optionName} '${signalName}': this signal name does not exist.
-${getAvailableSignals()}`);
-};
-var getAvailableSignals = () => `Available signal names: ${getAvailableSignalNames()}.
-Available signal numbers: ${getAvailableSignalIntegers()}.`;
-var getAvailableSignalNames = () => Object.keys(constants.signals).sort().map((signalName) => `'${signalName}'`).join(", ");
-var getAvailableSignalIntegers = () => [...new Set(Object.values(constants.signals).sort((signalInteger, signalIntegerTwo) => signalInteger - signalIntegerTwo))].join(", ");
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/terminate/signal.js
+import { constants as constants3 } from "node:os";
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/terminate/kill.js
-var normalizeForceKillAfterDelay = (forceKillAfterDelay) => {
-  if (forceKillAfterDelay === false) {
-    return forceKillAfterDelay;
-  }
-  if (forceKillAfterDelay === true) {
-    return DEFAULT_FORCE_KILL_TIMEOUT;
-  }
-  if (!Number.isFinite(forceKillAfterDelay) || forceKillAfterDelay < 0) {
-    throw new TypeError(`Expected the \`forceKillAfterDelay\` option to be a non-negative integer, got \`${forceKillAfterDelay}\` (${typeof forceKillAfterDelay})`);
-  }
-  return forceKillAfterDelay;
-};
-var DEFAULT_FORCE_KILL_TIMEOUT = 1e3 * 5;
-var subprocessKill = ({ kill, options: { forceKillAfterDelay, killSignal }, onInternalError, controller }, signalOrError, errorArgument) => {
-  const { signal, error } = parseKillArguments(signalOrError, errorArgument, killSignal);
-  emitKillError(error, onInternalError);
-  const killResult = kill(signal);
-  setKillTimeout({
-    kill,
-    signal,
-    forceKillAfterDelay,
-    killSignal,
-    killResult,
-    controller
-  });
-  return killResult;
-};
-var parseKillArguments = (signalOrError, errorArgument, killSignal) => {
-  const [signal = killSignal, error] = isErrorInstance(signalOrError) ? [void 0, signalOrError] : [signalOrError, errorArgument];
-  if (typeof signal !== "string" && !Number.isInteger(signal)) {
-    throw new TypeError(`The first argument must be an error instance or a signal name string/integer: ${String(signal)}`);
-  }
-  if (error !== void 0 && !isErrorInstance(error)) {
-    throw new TypeError(`The second argument is optional. If specified, it must be an error instance: ${error}`);
-  }
-  return { signal: normalizeSignalArgument(signal), error };
-};
-var emitKillError = (error, onInternalError) => {
-  if (error !== void 0) {
-    onInternalError.reject(error);
-  }
-};
-var setKillTimeout = async ({ kill, signal, forceKillAfterDelay, killSignal, killResult, controller }) => {
-  if (!shouldForceKill(signal, forceKillAfterDelay, killSignal, killResult)) {
-    return;
-  }
-  try {
-    await setTimeout(forceKillAfterDelay, void 0, { signal: controller.signal });
-    kill("SIGKILL");
-  } catch {
-  }
-};
-var shouldForceKill = (signal, forceKillAfterDelay, killSignal, killResult) => signal === killSignal && forceKillAfterDelay !== false && killResult;
+// ../../node_modules/.pnpm/human-signals@7.0.0/node_modules/human-signals/build/src/main.js
+import { constants as constants2 } from "node:os";
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/terminate/timeout.js
-import { setTimeout as setTimeout2 } from "node:timers/promises";
-var validateTimeout = ({ timeout }) => {
-  if (timeout !== void 0 && (!Number.isFinite(timeout) || timeout < 0)) {
-    throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
-  }
-};
-var throwOnTimeout = (subprocess, timeout, context, controller) => timeout === 0 || timeout === void 0 ? [] : [killAfterTimeout(subprocess, timeout, context, controller)];
-var killAfterTimeout = async (subprocess, timeout, context, { signal }) => {
-  await setTimeout2(timeout, void 0, { signal });
-  context.timedOut = true;
-  subprocess.kill();
-  throw new DiscardedError();
+// ../../node_modules/.pnpm/human-signals@7.0.0/node_modules/human-signals/build/src/realtime.js
+var getRealtimeSignals = () => {
+  const length = SIGRTMAX - SIGRTMIN + 1;
+  return Array.from({ length }, getRealtimeSignal);
 };
+var getRealtimeSignal = (value, index) => ({
+  name: `SIGRT${index + 1}`,
+  number: SIGRTMIN + index,
+  action: "terminate",
+  description: "Application-specific signal (realtime)",
+  standard: "posix"
+});
+var SIGRTMIN = 34;
+var SIGRTMAX = 64;
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/methods/node.js
-import { execPath, execArgv } from "node:process";
-import { basename, resolve } from "node:path";
-var mapNode = ({ options }) => {
-  if (options.node === false) {
-    throw new TypeError('The "node" option cannot be false with `execaNode()`.');
-  }
-  return { options: { ...options, node: true } };
-};
-var handleNodeOption = (file, commandArguments, {
-  node: shouldHandleNode = false,
-  nodePath = execPath,
-  nodeOptions = execArgv.filter((nodeOption) => !nodeOption.startsWith("--inspect")),
-  cwd,
-  execPath: formerNodePath,
-  ...options
-}) => {
-  if (formerNodePath !== void 0) {
-    throw new TypeError('The "execPath" option has been removed. Please use the "nodePath" option instead.');
-  }
-  const normalizedNodePath = safeNormalizeFileUrl(nodePath, 'The "nodePath" option');
-  const resolvedNodePath = resolve(cwd, normalizedNodePath);
-  const newOptions = {
-    ...options,
-    nodePath: resolvedNodePath,
-    node: shouldHandleNode,
-    cwd
-  };
-  if (!shouldHandleNode) {
-    return [file, commandArguments, newOptions];
-  }
-  if (basename(file, ".exe") === "node") {
-    throw new TypeError('When the "node" option is true, the first argument does not need to be "node".');
-  }
-  return [
-    resolvedNodePath,
-    [...nodeOptions, file, ...commandArguments],
-    { ipc: true, ...newOptions, shell: false }
-  ];
-};
-
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/arguments/encoding-option.js
-var validateEncoding = ({ encoding }) => {
-  if (ENCODINGS.has(encoding)) {
-    return;
-  }
-  const correctEncoding = getCorrectEncoding(encoding);
-  if (correctEncoding !== void 0) {
-    throw new TypeError(`Invalid option \`encoding: ${serializeEncoding(encoding)}\`.
-Please rename it to ${serializeEncoding(correctEncoding)}.`);
-  }
-  const correctEncodings = [...ENCODINGS].map((correctEncoding2) => serializeEncoding(correctEncoding2)).join(", ");
-  throw new TypeError(`Invalid option \`encoding: ${serializeEncoding(encoding)}\`.
-Please rename it to one of: ${correctEncodings}.`);
-};
-var TEXT_ENCODINGS = /* @__PURE__ */ new Set(["utf8", "utf16le"]);
-var BINARY_ENCODINGS = /* @__PURE__ */ new Set(["buffer", "hex", "base64", "base64url", "latin1", "ascii"]);
-var ENCODINGS = /* @__PURE__ */ new Set([...TEXT_ENCODINGS, ...BINARY_ENCODINGS]);
-var getCorrectEncoding = (encoding) => {
-  if (encoding === null) {
-    return "buffer";
-  }
-  if (typeof encoding !== "string") {
-    return;
-  }
-  const lowerEncoding = encoding.toLowerCase();
-  if (lowerEncoding in ENCODING_ALIASES) {
-    return ENCODING_ALIASES[lowerEncoding];
-  }
-  if (ENCODINGS.has(lowerEncoding)) {
-    return lowerEncoding;
-  }
-};
-var ENCODING_ALIASES = {
-  // eslint-disable-next-line unicorn/text-encoding-identifier-case
-  "utf-8": "utf8",
-  "utf-16le": "utf16le",
-  "ucs-2": "utf16le",
-  ucs2: "utf16le",
-  binary: "latin1"
-};
-var serializeEncoding = (encoding) => typeof encoding === "string" ? `"${encoding}"` : String(encoding);
-
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/arguments/cwd.js
-import { statSync } from "node:fs";
-import { resolve as resolve2 } from "node:path";
-import process5 from "node:process";
-var normalizeCwd = (cwd = getDefaultCwd()) => {
-  const cwdString = safeNormalizeFileUrl(cwd, 'The "cwd" option');
-  return resolve2(cwdString);
-};
-var getDefaultCwd = () => {
-  try {
-    return process5.cwd();
-  } catch (error) {
-    error.message = `The current directory does not exist.
-${error.message}`;
-    throw error;
-  }
-};
-var fixCwdError = (originalMessage, cwd) => {
-  if (cwd === getDefaultCwd()) {
-    return originalMessage;
-  }
-  let cwdStat;
-  try {
-    cwdStat = statSync(cwd);
-  } catch (error) {
-    return `The "cwd" option is invalid: ${cwd}.
-${error.message}
-${originalMessage}`;
-  }
-  if (!cwdStat.isDirectory()) {
-    return `The "cwd" option is not a directory: ${cwd}.
-${originalMessage}`;
-  }
-  return originalMessage;
-};
-
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/arguments/options.js
-var normalizeOptions = (filePath, rawArguments, rawOptions) => {
-  rawOptions.cwd = normalizeCwd(rawOptions.cwd);
-  const [processedFile, processedArguments, processedOptions] = handleNodeOption(filePath, rawArguments, rawOptions);
-  const { command: file, args: commandArguments, options: initialOptions } = import_cross_spawn.default._parse(processedFile, processedArguments, processedOptions);
-  const fdOptions = normalizeFdSpecificOptions(initialOptions);
-  const options = addDefaultOptions(fdOptions);
-  validateTimeout(options);
-  validateEncoding(options);
-  options.shell = normalizeFileUrl(options.shell);
-  options.env = getEnv(options);
-  options.killSignal = normalizeKillSignal(options.killSignal);
-  options.forceKillAfterDelay = normalizeForceKillAfterDelay(options.forceKillAfterDelay);
-  options.lines = options.lines.map((lines, fdNumber) => lines && !BINARY_ENCODINGS.has(options.encoding) && options.buffer[fdNumber]);
-  if (process6.platform === "win32" && basename2(file, ".exe") === "cmd") {
-    commandArguments.unshift("/q");
-  }
-  return { file, commandArguments, options };
-};
-var addDefaultOptions = ({
-  extendEnv = true,
-  preferLocal = false,
-  cwd,
-  localDir: localDirectory = cwd,
-  encoding = "utf8",
-  reject = true,
-  cleanup = true,
-  all = false,
-  windowsHide = true,
-  killSignal = "SIGTERM",
-  forceKillAfterDelay = true,
-  ipc = false,
-  serialization = "advanced",
-  ...options
-}) => ({
-  ...options,
-  extendEnv,
-  preferLocal,
-  cwd,
-  localDirectory,
-  encoding,
-  reject,
-  cleanup,
-  all,
-  windowsHide,
-  killSignal,
-  forceKillAfterDelay,
-  ipc,
-  serialization
-});
-var getEnv = ({ env: envOption, extendEnv, preferLocal, node, localDirectory, nodePath }) => {
-  const env = extendEnv ? { ...process6.env, ...envOption } : envOption;
-  if (preferLocal || node) {
-    return npmRunPathEnv({
-      env,
-      cwd: localDirectory,
-      execPath: nodePath,
-      preferLocal,
-      addExecPath: node
-    });
-  }
-  return env;
-};
-
-// ../../node_modules/.pnpm/human-signals@7.0.0/node_modules/human-signals/build/src/main.js
-import { constants as constants3 } from "node:os";
-
-// ../../node_modules/.pnpm/human-signals@7.0.0/node_modules/human-signals/build/src/realtime.js
-var getRealtimeSignals = () => {
-  const length = SIGRTMAX - SIGRTMIN + 1;
-  return Array.from({ length }, getRealtimeSignal);
-};
-var getRealtimeSignal = (value, index) => ({
-  name: `SIGRT${index + 1}`,
-  number: SIGRTMIN + index,
-  action: "terminate",
-  description: "Application-specific signal (realtime)",
-  standard: "posix"
-});
-var SIGRTMIN = 34;
-var SIGRTMAX = 64;
-
-// ../../node_modules/.pnpm/human-signals@7.0.0/node_modules/human-signals/build/src/signals.js
-import { constants as constants2 } from "node:os";
+// ../../node_modules/.pnpm/human-signals@7.0.0/node_modules/human-signals/build/src/signals.js
+import { constants } from "node:os";
 
 // ../../node_modules/.pnpm/human-signals@7.0.0/node_modules/human-signals/build/src/core.js
 var SIGNALS = [
@@ -1936,10 +1653,10 @@ var SIGNALS = [
 // ../../node_modules/.pnpm/human-signals@7.0.0/node_modules/human-signals/build/src/signals.js
 var getSignals = () => {
   const realtimeSignals = getRealtimeSignals();
-  const signals2 = [...SIGNALS, ...realtimeSignals].map(normalizeSignal2);
+  const signals2 = [...SIGNALS, ...realtimeSignals].map(normalizeSignal);
   return signals2;
 };
-var normalizeSignal2 = ({
+var normalizeSignal = ({
   name,
   number: defaultNumber,
   description,
@@ -1949,7 +1666,7 @@ var normalizeSignal2 = ({
 }) => {
   const {
     signals: { [name]: constantSignal }
-  } = constants2;
+  } = constants;
   const supported = constantSignal !== void 0;
   const number = supported ? constantSignal : defaultNumber;
   return { name, number, description, supported, action, forced, standard };
@@ -1998,13 +1715,977 @@ var getSignalByNumber = (number, signals2) => {
   };
 };
 var findSignalByNumber = (number, signals2) => {
-  const signal = signals2.find(({ name }) => constants3.signals[name] === number);
+  const signal = signals2.find(({ name }) => constants2.signals[name] === number);
   if (signal !== void 0) {
     return signal;
   }
-  return signals2.find((signalA) => signalA.number === number);
+  return signals2.find((signalA) => signalA.number === number);
+};
+var signalsByNumber = getSignalsByNumber();
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/terminate/signal.js
+var normalizeKillSignal = (killSignal) => {
+  const optionName = "option `killSignal`";
+  if (killSignal === 0) {
+    throw new TypeError(`Invalid ${optionName}: 0 cannot be used.`);
+  }
+  return normalizeSignal2(killSignal, optionName);
+};
+var normalizeSignalArgument = (signal) => signal === 0 ? signal : normalizeSignal2(signal, "`subprocess.kill()`'s argument");
+var normalizeSignal2 = (signalNameOrInteger, optionName) => {
+  if (Number.isInteger(signalNameOrInteger)) {
+    return normalizeSignalInteger(signalNameOrInteger, optionName);
+  }
+  if (typeof signalNameOrInteger === "string") {
+    return normalizeSignalName(signalNameOrInteger, optionName);
+  }
+  throw new TypeError(`Invalid ${optionName} ${String(signalNameOrInteger)}: it must be a string or an integer.
+${getAvailableSignals()}`);
+};
+var normalizeSignalInteger = (signalInteger, optionName) => {
+  if (signalsIntegerToName.has(signalInteger)) {
+    return signalsIntegerToName.get(signalInteger);
+  }
+  throw new TypeError(`Invalid ${optionName} ${signalInteger}: this signal integer does not exist.
+${getAvailableSignals()}`);
+};
+var getSignalsIntegerToName = () => new Map(Object.entries(constants3.signals).reverse().map(([signalName, signalInteger]) => [signalInteger, signalName]));
+var signalsIntegerToName = getSignalsIntegerToName();
+var normalizeSignalName = (signalName, optionName) => {
+  if (signalName in constants3.signals) {
+    return signalName;
+  }
+  if (signalName.toUpperCase() in constants3.signals) {
+    throw new TypeError(`Invalid ${optionName} '${signalName}': please rename it to '${signalName.toUpperCase()}'.`);
+  }
+  throw new TypeError(`Invalid ${optionName} '${signalName}': this signal name does not exist.
+${getAvailableSignals()}`);
+};
+var getAvailableSignals = () => `Available signal names: ${getAvailableSignalNames()}.
+Available signal numbers: ${getAvailableSignalIntegers()}.`;
+var getAvailableSignalNames = () => Object.keys(constants3.signals).sort().map((signalName) => `'${signalName}'`).join(", ");
+var getAvailableSignalIntegers = () => [...new Set(Object.values(constants3.signals).sort((signalInteger, signalIntegerTwo) => signalInteger - signalIntegerTwo))].join(", ");
+var getSignalDescription = (signal) => signalsByName[signal].description;
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/terminate/kill.js
+var normalizeForceKillAfterDelay = (forceKillAfterDelay) => {
+  if (forceKillAfterDelay === false) {
+    return forceKillAfterDelay;
+  }
+  if (forceKillAfterDelay === true) {
+    return DEFAULT_FORCE_KILL_TIMEOUT;
+  }
+  if (!Number.isFinite(forceKillAfterDelay) || forceKillAfterDelay < 0) {
+    throw new TypeError(`Expected the \`forceKillAfterDelay\` option to be a non-negative integer, got \`${forceKillAfterDelay}\` (${typeof forceKillAfterDelay})`);
+  }
+  return forceKillAfterDelay;
+};
+var DEFAULT_FORCE_KILL_TIMEOUT = 1e3 * 5;
+var subprocessKill = ({ kill, options: { forceKillAfterDelay, killSignal }, onInternalError, context, controller }, signalOrError, errorArgument) => {
+  const { signal, error } = parseKillArguments(signalOrError, errorArgument, killSignal);
+  emitKillError(error, onInternalError);
+  const killResult = kill(signal);
+  setKillTimeout({
+    kill,
+    signal,
+    forceKillAfterDelay,
+    killSignal,
+    killResult,
+    context,
+    controller
+  });
+  return killResult;
+};
+var parseKillArguments = (signalOrError, errorArgument, killSignal) => {
+  const [signal = killSignal, error] = isErrorInstance(signalOrError) ? [void 0, signalOrError] : [signalOrError, errorArgument];
+  if (typeof signal !== "string" && !Number.isInteger(signal)) {
+    throw new TypeError(`The first argument must be an error instance or a signal name string/integer: ${String(signal)}`);
+  }
+  if (error !== void 0 && !isErrorInstance(error)) {
+    throw new TypeError(`The second argument is optional. If specified, it must be an error instance: ${error}`);
+  }
+  return { signal: normalizeSignalArgument(signal), error };
+};
+var emitKillError = (error, onInternalError) => {
+  if (error !== void 0) {
+    onInternalError.reject(error);
+  }
+};
+var setKillTimeout = async ({ kill, signal, forceKillAfterDelay, killSignal, killResult, context, controller }) => {
+  if (signal === killSignal && killResult) {
+    killOnTimeout({
+      kill,
+      forceKillAfterDelay,
+      context,
+      controllerSignal: controller.signal
+    });
+  }
+};
+var killOnTimeout = async ({ kill, forceKillAfterDelay, context, controllerSignal }) => {
+  if (forceKillAfterDelay === false) {
+    return;
+  }
+  try {
+    await setTimeout(forceKillAfterDelay, void 0, { signal: controllerSignal });
+    if (kill("SIGKILL")) {
+      context.isForcefullyTerminated ??= true;
+    }
+  } catch {
+  }
+};
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/utils/abort-signal.js
+import { once } from "node:events";
+var onAbortedSignal = async (mainSignal, stopSignal) => {
+  if (!mainSignal.aborted) {
+    await once(mainSignal, "abort", { signal: stopSignal });
+  }
+};
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/terminate/cancel.js
+var validateCancelSignal = ({ cancelSignal }) => {
+  if (cancelSignal !== void 0 && Object.prototype.toString.call(cancelSignal) !== "[object AbortSignal]") {
+    throw new Error(`The \`cancelSignal\` option must be an AbortSignal: ${String(cancelSignal)}`);
+  }
+};
+var throwOnCancel = ({ subprocess, cancelSignal, gracefulCancel, context, controller }) => cancelSignal === void 0 || gracefulCancel ? [] : [terminateOnCancel(subprocess, cancelSignal, context, controller)];
+var terminateOnCancel = async (subprocess, cancelSignal, context, { signal }) => {
+  await onAbortedSignal(cancelSignal, signal);
+  context.terminationReason ??= "cancel";
+  subprocess.kill();
+  throw cancelSignal.reason;
+};
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/ipc/graceful.js
+import { scheduler as scheduler2 } from "node:timers/promises";
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/ipc/send.js
+import { promisify } from "node:util";
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/ipc/validation.js
+var validateIpcMethod = ({ methodName, isSubprocess, ipc, isConnected: isConnected2 }) => {
+  validateIpcOption(methodName, isSubprocess, ipc);
+  validateConnection(methodName, isSubprocess, isConnected2);
+};
+var validateIpcOption = (methodName, isSubprocess, ipc) => {
+  if (!ipc) {
+    throw new Error(`${getMethodName(methodName, isSubprocess)} can only be used if the \`ipc\` option is \`true\`.`);
+  }
+};
+var validateConnection = (methodName, isSubprocess, isConnected2) => {
+  if (!isConnected2) {
+    throw new Error(`${getMethodName(methodName, isSubprocess)} cannot be used: the ${getOtherProcessName(isSubprocess)} has already exited or disconnected.`);
+  }
+};
+var throwOnEarlyDisconnect = (isSubprocess) => {
+  throw new Error(`${getMethodName("getOneMessage", isSubprocess)} could not complete: the ${getOtherProcessName(isSubprocess)} exited or disconnected.`);
+};
+var 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}")},
+]);`);
+};
+var getStrictResponseError = (error, isSubprocess) => new Error(`${getMethodName("sendMessage", isSubprocess)} failed when sending an acknowledgment response to the ${getOtherProcessName(isSubprocess)}.`, { cause: error });
+var throwOnMissingStrict = (isSubprocess) => {
+  throw new Error(`${getMethodName("sendMessage", isSubprocess)} failed: the ${getOtherProcessName(isSubprocess)} is not listening to incoming messages.`);
+};
+var throwOnStrictDisconnect = (isSubprocess) => {
+  throw new Error(`${getMethodName("sendMessage", isSubprocess)} failed: the ${getOtherProcessName(isSubprocess)} exited without listening to incoming messages.`);
+};
+var getAbortDisconnectError = () => new Error(`\`cancelSignal\` aborted: the ${getOtherProcessName(true)} disconnected.`);
+var throwOnMissingParent = () => {
+  throw new Error("`getCancelSignal()` cannot be used without setting the `cancelSignal` subprocess option.");
+};
+var handleEpipeError = ({ error, methodName, isSubprocess }) => {
+  if (error.code === "EPIPE") {
+    throw new Error(`${getMethodName(methodName, isSubprocess)} cannot be used: the ${getOtherProcessName(isSubprocess)} is disconnecting.`, { cause: error });
+  }
+};
+var 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 });
+  }
+};
+var isSerializationError = ({ code, message }) => SERIALIZATION_ERROR_CODES.has(code) || SERIALIZATION_ERROR_MESSAGES.some((serializationErrorMessage) => message.includes(serializationErrorMessage));
+var SERIALIZATION_ERROR_CODES = /* @__PURE__ */ new Set([
+  // Message is `undefined`
+  "ERR_MISSING_ARGS",
+  // Message is a function, a bigint, a symbol
+  "ERR_INVALID_ARG_TYPE"
+]);
+var 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"
+];
+var getMethodName = (methodName, isSubprocess, parameters = "") => methodName === "cancelSignal" ? "`cancelSignal`'s `controller.abort()`" : `${getNamespaceName(isSubprocess)}${methodName}(${parameters})`;
+var getNamespaceName = (isSubprocess) => isSubprocess ? "" : "subprocess.";
+var getOtherProcessName = (isSubprocess) => isSubprocess ? "parent process" : "subprocess";
+var disconnect = (anyProcess) => {
+  if (anyProcess.connected) {
+    anyProcess.disconnect();
+  }
+};
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/utils/deferred.js
+var createDeferred = () => {
+  const methods = {};
+  const promise = new Promise((resolve3, reject) => {
+    Object.assign(methods, { resolve: resolve3, reject });
+  });
+  return Object.assign(promise, methods);
+};
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/arguments/fd-options.js
+var 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;
+};
+var 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 === void 0) {
+    throw new TypeError(getInvalidStdioOptionMessage(fdNumber, from, options, isWritable));
+  }
+  return sourceStream;
+};
+var SUBPROCESS_OPTIONS = /* @__PURE__ */ new WeakMap();
+var getFdNumber = (fileDescriptors, fdName, isWritable) => {
+  const fdNumber = parseFdNumber(fdName, isWritable);
+  validateFdNumber(fdNumber, fdName, isWritable, fileDescriptors);
+  return fdNumber;
+};
+var parseFdNumber = (fdName, isWritable) => {
+  const fdNumber = parseFd(fdName);
+  if (fdNumber !== void 0) {
+    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}".`);
+};
+var validateFdNumber = (fdNumber, fdName, isWritable, fileDescriptors) => {
+  const fileDescriptor = fileDescriptors[getUsedDescriptor(fdNumber)];
+  if (fileDescriptor === void 0) {
+    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.`);
+  }
+};
+var 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.`;
+};
+var getInvalidStdioOption = (fdNumber, { stdin, stdout, stderr, stdio }) => {
+  const usedDescriptor = getUsedDescriptor(fdNumber);
+  if (usedDescriptor === 0 && stdin !== void 0) {
+    return { optionName: "stdin", optionValue: stdin };
+  }
+  if (usedDescriptor === 1 && stdout !== void 0) {
+    return { optionName: "stdout", optionValue: stdout };
+  }
+  if (usedDescriptor === 2 && stderr !== void 0) {
+    return { optionName: "stderr", optionValue: stderr };
+  }
+  return { optionName: `stdio[${usedDescriptor}]`, optionValue: stdio[usedDescriptor] };
+};
+var getUsedDescriptor = (fdNumber) => fdNumber === "all" ? 1 : fdNumber;
+var getOptionName = (isWritable) => isWritable ? "to" : "from";
+var serializeOptionValue = (value) => {
+  if (typeof value === "string") {
+    return `'${value}'`;
+  }
+  return typeof value === "number" ? `${value}` : "Stream";
+};
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/ipc/strict.js
+import { once as once3 } from "node:events";
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/utils/max-listeners.js
+import { addAbortListener } from "node:events";
+var incrementMaxListeners = (eventEmitter, maxListenersIncrement, signal) => {
+  const maxListeners = eventEmitter.getMaxListeners();
+  if (maxListeners === 0 || maxListeners === Number.POSITIVE_INFINITY) {
+    return;
+  }
+  eventEmitter.setMaxListeners(maxListeners + maxListenersIncrement);
+  addAbortListener(signal, () => {
+    eventEmitter.setMaxListeners(eventEmitter.getMaxListeners() - maxListenersIncrement);
+  });
+};
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/ipc/forward.js
+import { EventEmitter } from "node:events";
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/ipc/incoming.js
+import { once as once2 } from "node:events";
+import { scheduler } from "node:timers/promises";
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/ipc/reference.js
+var addReference = (channel, reference) => {
+  if (reference) {
+    addReferenceCount(channel);
+  }
+};
+var addReferenceCount = (channel) => {
+  channel.refCounted();
+};
+var removeReference = (channel, reference) => {
+  if (reference) {
+    removeReferenceCount(channel);
+  }
+};
+var removeReferenceCount = (channel) => {
+  channel.unrefCounted();
+};
+var undoAddedReferences = (channel, isSubprocess) => {
+  if (isSubprocess) {
+    removeReferenceCount(channel);
+    removeReferenceCount(channel);
+  }
+};
+var redoAddedReferences = (channel, isSubprocess) => {
+  if (isSubprocess) {
+    addReferenceCount(channel);
+    addReferenceCount(channel);
+  }
+};
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/ipc/incoming.js
+var 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) {
+    await waitForOutgoingMessages(anyProcess, ipcEmitter, wrappedMessage);
+    await scheduler.yield();
+    const message = await handleStrictRequest({
+      wrappedMessage: incomingMessages[0],
+      anyProcess,
+      channel,
+      isSubprocess,
+      ipcEmitter
+    });
+    incomingMessages.shift();
+    ipcEmitter.emit("message", message);
+    ipcEmitter.emit("message:done");
+  }
+};
+var onDisconnect = async ({ anyProcess, channel, isSubprocess, ipcEmitter, boundOnMessage }) => {
+  abortOnDisconnect();
+  const incomingMessages = INCOMING_MESSAGES.get(anyProcess);
+  while (incomingMessages?.length > 0) {
+    await once2(ipcEmitter, "message:done");
+  }
+  anyProcess.removeListener("message", boundOnMessage);
+  redoAddedReferences(channel, isSubprocess);
+  ipcEmitter.connected = false;
+  ipcEmitter.emit("disconnect");
+};
+var INCOMING_MESSAGES = /* @__PURE__ */ new WeakMap();
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/ipc/forward.js
+var getIpcEmitter = (anyProcess, channel, isSubprocess) => {
+  if (IPC_EMITTERS.has(anyProcess)) {
+    return IPC_EMITTERS.get(anyProcess);
+  }
+  const ipcEmitter = new EventEmitter();
+  ipcEmitter.connected = true;
+  IPC_EMITTERS.set(anyProcess, ipcEmitter);
+  forwardEvents({
+    ipcEmitter,
+    anyProcess,
+    channel,
+    isSubprocess
+  });
+  return ipcEmitter;
+};
+var IPC_EMITTERS = /* @__PURE__ */ new WeakMap();
+var forwardEvents = ({ ipcEmitter, anyProcess, channel, isSubprocess }) => {
+  const boundOnMessage = onMessage.bind(void 0, {
+    anyProcess,
+    channel,
+    isSubprocess,
+    ipcEmitter
+  });
+  anyProcess.on("message", boundOnMessage);
+  anyProcess.once("disconnect", onDisconnect.bind(void 0, {
+    anyProcess,
+    channel,
+    isSubprocess,
+    ipcEmitter,
+    boundOnMessage
+  }));
+  undoAddedReferences(channel, isSubprocess);
+};
+var isConnected = (anyProcess) => {
+  const ipcEmitter = IPC_EMITTERS.get(anyProcess);
+  return ipcEmitter === void 0 ? anyProcess.channel !== null : ipcEmitter.connected;
+};
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/ipc/strict.js
+var 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
+  };
+};
+var count = 0n;
+var validateStrictDeadlock = (outgoingMessages, wrappedMessage) => {
+  if (wrappedMessage?.type !== REQUEST_TYPE || wrappedMessage.hasListeners) {
+    return;
+  }
+  for (const { id } of outgoingMessages) {
+    if (id !== void 0) {
+      STRICT_RESPONSES[id].resolve({ isDeadlock: true, hasListeners: false });
+    }
+  }
+};
+var 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;
+};
+var handleStrictResponse = (wrappedMessage) => {
+  if (wrappedMessage?.type !== RESPONSE_TYPE) {
+    return false;
+  }
+  const { id, message: hasListeners } = wrappedMessage;
+  STRICT_RESPONSES[id]?.resolve({ isDeadlock: false, hasListeners });
+  return true;
+};
+var 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];
+  }
+};
+var STRICT_RESPONSES = {};
+var throwOnDisconnect = async (anyProcess, isSubprocess, { signal }) => {
+  incrementMaxListeners(anyProcess, 1, signal);
+  await once3(anyProcess, "disconnect", { signal });
+  throwOnStrictDisconnect(isSubprocess);
+};
+var REQUEST_TYPE = "execa:ipc:request";
+var RESPONSE_TYPE = "execa:ipc:response";
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/ipc/outgoing.js
+var startSendMessage = (anyProcess, wrappedMessage, strict) => {
+  if (!OUTGOING_MESSAGES.has(anyProcess)) {
+    OUTGOING_MESSAGES.set(anyProcess, /* @__PURE__ */ new Set());
+  }
+  const outgoingMessages = OUTGOING_MESSAGES.get(anyProcess);
+  const onMessageSent = createDeferred();
+  const id = strict ? wrappedMessage.id : void 0;
+  const outgoingMessage = { onMessageSent, id };
+  outgoingMessages.add(outgoingMessage);
+  return { outgoingMessages, outgoingMessage };
+};
+var endSendMessage = ({ outgoingMessages, outgoingMessage }) => {
+  outgoingMessages.delete(outgoingMessage);
+  outgoingMessage.onMessageSent.resolve();
+};
+var waitForOutgoingMessages = async (anyProcess, ipcEmitter, wrappedMessage) => {
+  while (!hasMessageListeners(anyProcess, ipcEmitter) && OUTGOING_MESSAGES.get(anyProcess)?.size > 0) {
+    const outgoingMessages = [...OUTGOING_MESSAGES.get(anyProcess)];
+    validateStrictDeadlock(outgoingMessages, wrappedMessage);
+    await Promise.all(outgoingMessages.map(({ onMessageSent }) => onMessageSent));
+  }
+};
+var OUTGOING_MESSAGES = /* @__PURE__ */ new WeakMap();
+var hasMessageListeners = (anyProcess, ipcEmitter) => ipcEmitter.listenerCount("message") > getMinListenerCount(anyProcess);
+var getMinListenerCount = (anyProcess) => SUBPROCESS_OPTIONS.has(anyProcess) && !SUBPROCESS_OPTIONS.get(anyProcess).options.buffer.at(-1) ? 1 : 0;
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/ipc/send.js
+var 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
+  });
+};
+var 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);
+  }
+};
+var 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;
+  }
+};
+var 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;
+};
+var PROCESS_SEND_METHODS = /* @__PURE__ */ new WeakMap();
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/ipc/graceful.js
+var 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
+  });
+};
+var getCancelSignal = async ({ anyProcess, channel, isSubprocess, ipc }) => {
+  await startIpc({
+    anyProcess,
+    channel,
+    isSubprocess,
+    ipc
+  });
+  return cancelController.signal;
+};
+var 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 scheduler2.yield();
+};
+var cancelListening = false;
+var handleAbort = (wrappedMessage) => {
+  if (wrappedMessage?.type !== GRACEFUL_CANCEL_TYPE) {
+    return false;
+  }
+  cancelController.abort(wrappedMessage.message);
+  return true;
+};
+var GRACEFUL_CANCEL_TYPE = "execa:ipc:cancel";
+var abortOnDisconnect = () => {
+  cancelController.abort(getAbortDisconnectError());
+};
+var cancelController = new AbortController();
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/terminate/graceful.js
+var validateGracefulCancel = ({ gracefulCancel, cancelSignal, ipc, serialization }) => {
+  if (!gracefulCancel) {
+    return;
+  }
+  if (cancelSignal === void 0) {
+    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.");
+  }
+};
+var throwOnGracefulCancel = ({
+  subprocess,
+  cancelSignal,
+  gracefulCancel,
+  forceKillAfterDelay,
+  context,
+  controller
+}) => gracefulCancel ? [sendOnAbort({
+  subprocess,
+  cancelSignal,
+  forceKillAfterDelay,
+  context,
+  controller
+})] : [];
+var 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;
+};
+var 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;
+};
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/terminate/timeout.js
+import { setTimeout as setTimeout2 } from "node:timers/promises";
+var validateTimeout = ({ timeout }) => {
+  if (timeout !== void 0 && (!Number.isFinite(timeout) || timeout < 0)) {
+    throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
+  }
+};
+var throwOnTimeout = (subprocess, timeout, context, controller) => timeout === 0 || timeout === void 0 ? [] : [killAfterTimeout(subprocess, timeout, context, controller)];
+var killAfterTimeout = async (subprocess, timeout, context, { signal }) => {
+  await setTimeout2(timeout, void 0, { signal });
+  context.terminationReason ??= "timeout";
+  subprocess.kill();
+  throw new DiscardedError();
+};
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/methods/node.js
+import { execPath, execArgv } from "node:process";
+import { basename, resolve } from "node:path";
+var mapNode = ({ options }) => {
+  if (options.node === false) {
+    throw new TypeError('The "node" option cannot be false with `execaNode()`.');
+  }
+  return { options: { ...options, node: true } };
+};
+var handleNodeOption = (file, commandArguments, {
+  node: shouldHandleNode = false,
+  nodePath = execPath,
+  nodeOptions = execArgv.filter((nodeOption) => !nodeOption.startsWith("--inspect")),
+  cwd,
+  execPath: formerNodePath,
+  ...options
+}) => {
+  if (formerNodePath !== void 0) {
+    throw new TypeError('The "execPath" option has been removed. Please use the "nodePath" option instead.');
+  }
+  const normalizedNodePath = safeNormalizeFileUrl(nodePath, 'The "nodePath" option');
+  const resolvedNodePath = resolve(cwd, normalizedNodePath);
+  const newOptions = {
+    ...options,
+    nodePath: resolvedNodePath,
+    node: shouldHandleNode,
+    cwd
+  };
+  if (!shouldHandleNode) {
+    return [file, commandArguments, newOptions];
+  }
+  if (basename(file, ".exe") === "node") {
+    throw new TypeError('When the "node" option is true, the first argument does not need to be "node".');
+  }
+  return [
+    resolvedNodePath,
+    [...nodeOptions, file, ...commandArguments],
+    { ipc: true, ...newOptions, shell: false }
+  ];
+};
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/ipc/ipc-input.js
+import { serialize } from "node:v8";
+var validateIpcInputOption = ({ ipcInput, ipc, serialization }) => {
+  if (ipcInput === void 0) {
+    return;
+  }
+  if (!ipc) {
+    throw new Error("The `ipcInput` option cannot be set unless the `ipc` option is `true`.");
+  }
+  validateIpcInput[serialization](ipcInput);
+};
+var validateAdvancedInput = (ipcInput) => {
+  try {
+    serialize(ipcInput);
+  } catch (error) {
+    throw new Error("The `ipcInput` option is not serializable with a structured clone.", { cause: error });
+  }
+};
+var validateJsonInput = (ipcInput) => {
+  try {
+    JSON.stringify(ipcInput);
+  } catch (error) {
+    throw new Error("The `ipcInput` option is not serializable with JSON.", { cause: error });
+  }
+};
+var validateIpcInput = {
+  advanced: validateAdvancedInput,
+  json: validateJsonInput
+};
+var sendIpcInput = async (subprocess, ipcInput) => {
+  if (ipcInput === void 0) {
+    return;
+  }
+  await subprocess.sendMessage(ipcInput);
+};
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/arguments/encoding-option.js
+var validateEncoding = ({ encoding }) => {
+  if (ENCODINGS.has(encoding)) {
+    return;
+  }
+  const correctEncoding = getCorrectEncoding(encoding);
+  if (correctEncoding !== void 0) {
+    throw new TypeError(`Invalid option \`encoding: ${serializeEncoding(encoding)}\`.
+Please rename it to ${serializeEncoding(correctEncoding)}.`);
+  }
+  const correctEncodings = [...ENCODINGS].map((correctEncoding2) => serializeEncoding(correctEncoding2)).join(", ");
+  throw new TypeError(`Invalid option \`encoding: ${serializeEncoding(encoding)}\`.
+Please rename it to one of: ${correctEncodings}.`);
+};
+var TEXT_ENCODINGS = /* @__PURE__ */ new Set(["utf8", "utf16le"]);
+var BINARY_ENCODINGS = /* @__PURE__ */ new Set(["buffer", "hex", "base64", "base64url", "latin1", "ascii"]);
+var ENCODINGS = /* @__PURE__ */ new Set([...TEXT_ENCODINGS, ...BINARY_ENCODINGS]);
+var getCorrectEncoding = (encoding) => {
+  if (encoding === null) {
+    return "buffer";
+  }
+  if (typeof encoding !== "string") {
+    return;
+  }
+  const lowerEncoding = encoding.toLowerCase();
+  if (lowerEncoding in ENCODING_ALIASES) {
+    return ENCODING_ALIASES[lowerEncoding];
+  }
+  if (ENCODINGS.has(lowerEncoding)) {
+    return lowerEncoding;
+  }
+};
+var ENCODING_ALIASES = {
+  // eslint-disable-next-line unicorn/text-encoding-identifier-case
+  "utf-8": "utf8",
+  "utf-16le": "utf16le",
+  "ucs-2": "utf16le",
+  ucs2: "utf16le",
+  binary: "latin1"
+};
+var serializeEncoding = (encoding) => typeof encoding === "string" ? `"${encoding}"` : String(encoding);
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/arguments/cwd.js
+import { statSync } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+import process5 from "node:process";
+var normalizeCwd = (cwd = getDefaultCwd()) => {
+  const cwdString = safeNormalizeFileUrl(cwd, 'The "cwd" option');
+  return resolve2(cwdString);
+};
+var getDefaultCwd = () => {
+  try {
+    return process5.cwd();
+  } catch (error) {
+    error.message = `The current directory does not exist.
+${error.message}`;
+    throw error;
+  }
+};
+var fixCwdError = (originalMessage, cwd) => {
+  if (cwd === getDefaultCwd()) {
+    return originalMessage;
+  }
+  let cwdStat;
+  try {
+    cwdStat = statSync(cwd);
+  } catch (error) {
+    return `The "cwd" option is invalid: ${cwd}.
+${error.message}
+${originalMessage}`;
+  }
+  if (!cwdStat.isDirectory()) {
+    return `The "cwd" option is not a directory: ${cwd}.
+${originalMessage}`;
+  }
+  return originalMessage;
+};
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/arguments/options.js
+var normalizeOptions = (filePath, rawArguments, rawOptions) => {
+  rawOptions.cwd = normalizeCwd(rawOptions.cwd);
+  const [processedFile, processedArguments, processedOptions] = handleNodeOption(filePath, rawArguments, rawOptions);
+  const { command: file, args: commandArguments, options: initialOptions } = import_cross_spawn.default._parse(processedFile, processedArguments, processedOptions);
+  const fdOptions = normalizeFdSpecificOptions(initialOptions);
+  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);
+  options.forceKillAfterDelay = normalizeForceKillAfterDelay(options.forceKillAfterDelay);
+  options.lines = options.lines.map((lines, fdNumber) => lines && !BINARY_ENCODINGS.has(options.encoding) && options.buffer[fdNumber]);
+  if (process6.platform === "win32" && basename2(file, ".exe") === "cmd") {
+    commandArguments.unshift("/q");
+  }
+  return { file, commandArguments, options };
+};
+var addDefaultOptions = ({
+  extendEnv = true,
+  preferLocal = false,
+  cwd,
+  localDir: localDirectory = cwd,
+  encoding = "utf8",
+  reject = true,
+  cleanup = true,
+  all = false,
+  windowsHide = true,
+  killSignal = "SIGTERM",
+  forceKillAfterDelay = true,
+  gracefulCancel = false,
+  ipcInput,
+  ipc = ipcInput !== void 0 || gracefulCancel,
+  serialization = "advanced",
+  ...options
+}) => ({
+  ...options,
+  extendEnv,
+  preferLocal,
+  cwd,
+  localDirectory,
+  encoding,
+  reject,
+  cleanup,
+  all,
+  windowsHide,
+  killSignal,
+  forceKillAfterDelay,
+  gracefulCancel,
+  ipcInput,
+  ipc,
+  serialization
+});
+var getEnv = ({ env: envOption, extendEnv, preferLocal, node, localDirectory, nodePath }) => {
+  const env = extendEnv ? { ...process6.env, ...envOption } : envOption;
+  if (preferLocal || node) {
+    return npmRunPathEnv({
+      env,
+      cwd: localDirectory,
+      execPath: nodePath,
+      preferLocal,
+      addExecPath: node
+    });
+  }
+  return env;
 };
-var signalsByNumber = getSignalsByNumber();
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/return/message.js
+import { inspect as inspect2 } from "node:util";
 
 // ../../node_modules/.pnpm/strip-final-newline@4.0.0/node_modules/strip-final-newline/index.js
 function stripFinalNewline(input) {
@@ -2393,7 +3074,7 @@ var stringMethods = {
 // ../../node_modules/.pnpm/get-stream@9.0.1/node_modules/get-stream/source/index.js
 Object.assign(nodeImports, { on, finished });
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/io/max-buffer.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/io/max-buffer.js
 var handleMaxBuffer = ({ error, stream, readableObjectMode, lines, encoding, fdNumber }) => {
   if (!(error instanceof MaxBufferError)) {
     throw error;
@@ -2418,6 +3099,14 @@ var getMaxBufferUnit = (readableObjectMode, lines, encoding) => {
   }
   return "characters";
 };
+var checkIpcMaxBuffer = (subprocess, ipcOutput, maxBuffer) => {
+  if (ipcOutput.length !== maxBuffer) {
+    return;
+  }
+  const error = new MaxBufferError();
+  error.maxBufferInfo = { fdNumber: "ipc" };
+  throw error;
+};
 var getMaxBufferMessage = (error, maxBuffer) => {
   const { streamName, threshold, unit } = getMaxBufferInfo(error, maxBuffer);
   return `Command's ${streamName} was larger than ${threshold} ${unit}`;
@@ -2428,6 +3117,9 @@ var 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 };
 };
 var isMaxBufferSync = (resultError, output, maxBuffer) => resultError?.code === "ENOBUFS" && output !== null && output.some((result) => result !== null && result.length > getMaxBufferSync(maxBuffer));
@@ -2440,10 +3132,11 @@ var truncateMaxBufferSync = (result, isMaxBuffer, maxBuffer) => {
 };
 var getMaxBufferSync = ([, stdoutMaxBuffer]) => stdoutMaxBuffer;
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/return/message.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/return/message.js
 var createMessages = ({
   stdio,
   all,
+  ipcOutput,
   originalError,
   signal,
   signalDescription,
@@ -2451,7 +3144,11 @@ var createMessages = ({
   escapedCommand,
   timedOut,
   isCanceled,
+  isGracefullyCanceled,
   isMaxBuffer,
+  isForcefullyTerminated,
+  forceKillAfterDelay,
+  killSignal,
   maxBuffer,
   timeout,
   cwd
@@ -2467,28 +3164,62 @@ var createMessages = ({
     signal,
     signalDescription,
     exitCode,
-    isCanceled
+    isCanceled,
+    isGracefullyCanceled,
+    isForcefullyTerminated,
+    forceKillAfterDelay,
+    killSignal
   });
   const originalMessage = getOriginalMessage(originalError, cwd);
   const suffix = originalMessage === void 0 ? "" : `
 ${originalMessage}`;
   const shortMessage = `${prefix}: ${escapedCommand}${suffix}`;
   const messageStdio = all === void 0 ? [stdio[2], stdio[1]] : [all];
-  const message = [shortMessage, ...messageStdio, ...stdio.slice(3)].map((messagePart) => escapeLines(stripFinalNewline(serializeMessagePart(messagePart)))).filter(Boolean).join("\n\n");
+  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 };
 };
-var getErrorPrefix = ({ originalError, timedOut, timeout, isMaxBuffer, maxBuffer, errorCode, signal, signalDescription, exitCode, isCanceled }) => {
+var 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 === void 0) {
+      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 !== void 0) {
-    return `Command failed with ${errorCode}`;
+    return `Command failed with ${errorCode}${forcefulSuffix}`;
+  }
+  if (isForcefullyTerminated) {
+    return `Command was killed with ${killSignal} (${getSignalDescription(killSignal)})${forcefulSuffix}`;
   }
   if (signal !== void 0) {
     return `Command was killed with ${signal} (${signalDescription})`;
@@ -2498,6 +3229,7 @@ var getErrorPrefix = ({ originalError, timedOut, timeout, isMaxBuffer, maxBuffer
   }
   return "Command failed";
 };
+var getForcefulSuffix = (isForcefullyTerminated, forceKillAfterDelay) => isForcefullyTerminated ? ` and was forcefully terminated after ${forceKillAfterDelay} milliseconds` : "";
 var getOriginalMessage = (originalError, cwd) => {
   if (originalError instanceof DiscardedError) {
     return;
@@ -2506,6 +3238,7 @@ var getOriginalMessage = (originalError, cwd) => {
   const escapedOriginalMessage = escapeLines(fixCwdError(originalMessage, cwd));
   return escapedOriginalMessage === "" ? void 0 : escapedOriginalMessage;
 };
+var serializeIpcMessage = (ipcMessage) => typeof ipcMessage === "string" ? ipcMessage : inspect2(ipcMessage);
 var serializeMessagePart = (messagePart) => Array.isArray(messagePart) ? messagePart.map((messageItem) => stripFinalNewline(serializeMessageItem(messageItem))).filter(Boolean).join("\n") : serializeMessageItem(messagePart);
 var serializeMessageItem = (messageItem) => {
   if (typeof messageItem === "string") {
@@ -2517,12 +3250,13 @@ var serializeMessageItem = (messageItem) => {
   return "";
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/return/result.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/return/result.js
 var makeSuccessResult = ({
   command,
   escapedCommand,
   stdio,
   all,
+  ipcOutput,
   options: { cwd },
   startTime
 }) => omitUndefinedProperties({
@@ -2533,13 +3267,16 @@ var 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: []
 });
 var makeEarlyError = ({
@@ -2557,8 +3294,11 @@ var makeEarlyError = ({
   startTime,
   timedOut: false,
   isCanceled: false,
+  isGracefullyCanceled: false,
   isMaxBuffer: false,
+  isForcefullyTerminated: false,
   stdio: Array.from({ length: fileDescriptors.length }),
+  ipcOutput: [],
   options,
   isSync
 });
@@ -2569,18 +3309,29 @@ var 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,
@@ -2588,7 +3339,11 @@ var makeError = ({
     escapedCommand,
     timedOut,
     isCanceled,
+    isGracefullyCanceled,
     isMaxBuffer,
+    isForcefullyTerminated,
+    forceKillAfterDelay,
+    killSignal,
     maxBuffer,
     timeout,
     cwd
@@ -2601,12 +3356,15 @@ var makeError = ({
     startTime,
     timedOut,
     isCanceled,
+    isGracefullyCanceled,
     isMaxBuffer,
+    isForcefullyTerminated,
     exitCode,
     signal,
     signalDescription,
     stdio,
     all,
+    ipcOutput,
     cwd,
     originalMessage,
     shortMessage
@@ -2620,12 +3378,15 @@ var getErrorProperties = ({
   startTime,
   timedOut,
   isCanceled,
+  isGracefullyCanceled,
   isMaxBuffer,
+  isForcefullyTerminated,
   exitCode,
   signal,
   signalDescription,
   stdio,
   all,
+  ipcOutput,
   cwd,
   originalMessage,
   shortMessage
@@ -2639,8 +3400,10 @@ var getErrorProperties = ({
   failed: true,
   timedOut,
   isCanceled,
+  isGracefullyCanceled,
   isTerminated: signal !== void 0,
   isMaxBuffer,
+  isForcefullyTerminated,
   exitCode,
   signal,
   signalDescription,
@@ -2649,13 +3412,14 @@ var getErrorProperties = ({
   stderr: stdio[2],
   all,
   stdio,
+  ipcOutput,
   pipedFrom: []
 });
 var omitUndefinedProperties = (result) => Object.fromEntries(Object.entries(result).filter(([, value]) => value !== void 0));
 var normalizeExitPayload = (rawExitCode, rawSignal) => {
   const exitCode = rawExitCode === null ? void 0 : rawExitCode;
   const signal = rawSignal === null ? void 0 : rawSignal;
-  const signalDescription = signal === void 0 ? void 0 : signalsByName[rawSignal].description;
+  const signalDescription = signal === void 0 ? void 0 : getSignalDescription(rawSignal);
   return { exitCode, signal, signalDescription };
 };
 
@@ -2700,7 +3464,7 @@ function parseMilliseconds(milliseconds) {
 
 // ../../node_modules/.pnpm/pretty-ms@9.0.0/node_modules/pretty-ms/index.js
 var isZero = (value) => value === 0 || value === 0n;
-var pluralize = (word, count) => count === 1 || count === 1n ? word : `${word}s`;
+var pluralize = (word, count2) => count2 === 1 || count2 === 1n ? word : `${word}s`;
 var SECOND_ROUNDING_EPSILON = 1e-7;
 var ONE_DAY_IN_MILLISECONDS = 24n * 60n * 60n * 1000n;
 function prettyMilliseconds(milliseconds, options) {
@@ -2785,7 +3549,7 @@ function prettyMilliseconds(milliseconds, options) {
   return result.join(separator);
 }
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/verbose/error.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/verbose/error.js
 var logError = ({ message, failed, reject, verboseId, icon }) => {
   if (!failed) {
     return;
@@ -2794,7 +3558,7 @@ var logError = ({ message, failed, reject, verboseId, icon }) => {
   verboseLog(message, verboseId, icon, color);
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/verbose/complete.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/verbose/complete.js
 var logFinalResult = ({ shortMessage, failed, durationMs }, reject, verboseInfo) => {
   logResult({
     message: shortMessage,
@@ -2838,7 +3602,7 @@ var getIcon = (failed, reject) => {
   return reject ? "error" : "warning";
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/return/reject.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/return/reject.js
 var handleResult = (result, verboseInfo, { reject }) => {
   logFinalResult(result, reject, verboseInfo);
   if (result.failed && reject) {
@@ -2847,10 +3611,10 @@ var handleResult = (result, verboseInfo, { reject }) => {
   return result;
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/stdio/handle-sync.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/stdio/handle-sync.js
 import { readFileSync as readFileSync2 } from "node:fs";
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/stdio/type.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/stdio/type.js
 var getStdioItemType = (value, optionName) => {
   if (isAsyncGenerator(value)) {
     return "asyncGenerator";
@@ -2975,7 +3739,7 @@ var TYPE_TO_MESSAGE = {
   uint8Array: "a Uint8Array"
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/transform/object-mode.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/transform/object-mode.js
 var getTransformObjectModes = (objectMode, index, newTransforms, direction) => direction === "output" ? getOutputObjectModes(objectMode, index, newTransforms) : getInputObjectModes(objectMode, index, newTransforms);
 var getOutputObjectModes = (objectMode, index, newTransforms) => {
   const writableObjectMode = index !== 0 && newTransforms[index - 1].value.readableObjectMode;
@@ -2995,7 +3759,7 @@ var getFdObjectMode = (stdioItems, direction) => {
   return direction === "input" ? lastTransform.value.writableObjectMode : lastTransform.value.readableObjectMode;
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/transform/normalize.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/transform/normalize.js
 var normalizeTransforms = (stdioItems, optionName, direction, options) => [
   ...stdioItems.filter(({ type }) => !TRANSFORM_TYPES.has(type)),
   ...getTransforms(stdioItems, optionName, direction, options)
@@ -3089,7 +3853,7 @@ var normalizeGenerator = ({ stdioItem, stdioItem: { value }, index, newTransform
 };
 var sortTransforms = (newTransforms, direction) => direction === "input" ? newTransforms.reverse() : newTransforms;
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/stdio/direction.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/stdio/direction.js
 import process7 from "node:process";
 var getStreamDirection = (stdioItems, fdNumber, optionName) => {
   const directions = stdioItems.map((stdioItem) => getStdioItemDirection(stdioItem, fdNumber));
@@ -3139,10 +3903,13 @@ var getStandardStreamDirection = (value) => {
 };
 var DEFAULT_DIRECTION = "output";
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/stdio/stdio-option.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/ipc/array.js
+var normalizeIpcStdioArray = (stdioArray, ipc) => ipc && !stdioArray.includes("ipc") ? [...stdioArray, "ipc"] : stdioArray;
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/stdio/stdio-option.js
 var normalizeStdioOption = ({ stdio, ipc, buffer, verbose, ...options }, isSync) => {
   const stdioArray = getStdioArray(stdio, options).map((stdioOption, fdNumber) => addDefaultValue2(stdioOption, fdNumber));
-  return isSync ? normalizeStdioSync(stdioArray, buffer, verbose) : normalizeStdioAsync(stdioArray, ipc);
+  return isSync ? normalizeStdioSync(stdioArray, buffer, verbose) : normalizeIpcStdioArray(stdioArray, ipc);
 };
 var getStdioArray = (stdio, options) => {
   if (stdio === void 0) {
@@ -3172,93 +3939,10 @@ var addDefaultValue2 = (stdioOption, fdNumber) => {
 };
 var normalizeStdioSync = (stdioArray, buffer, verbose) => stdioArray.map((stdioOption, fdNumber) => !buffer[fdNumber] && fdNumber !== 0 && verbose[fdNumber] !== "full" && isOutputPipeOnly(stdioOption) ? "ignore" : stdioOption);
 var isOutputPipeOnly = (stdioOption) => stdioOption === "pipe" || Array.isArray(stdioOption) && stdioOption.every((item) => item === "pipe");
-var normalizeStdioAsync = (stdioArray, ipc) => ipc && !stdioArray.includes("ipc") ? [...stdioArray, "ipc"] : stdioArray;
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/stdio/native.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/stdio/native.js
 import { readFileSync } from "node:fs";
 import tty2 from "node:tty";
-
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/arguments/fd-options.js
-var 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;
-};
-var 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 === void 0) {
-    throw new TypeError(getInvalidStdioOptionMessage(fdNumber, from, options, isWritable));
-  }
-  return sourceStream;
-};
-var SUBPROCESS_OPTIONS = /* @__PURE__ */ new WeakMap();
-var getFdNumber = (fileDescriptors, fdName, isWritable) => {
-  const fdNumber = parseFdNumber(fdName, isWritable);
-  validateFdNumber(fdNumber, fdName, isWritable, fileDescriptors);
-  return fdNumber;
-};
-var parseFdNumber = (fdName, isWritable) => {
-  const fdNumber = parseFd(fdName);
-  if (fdNumber !== void 0) {
-    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}".`);
-};
-var validateFdNumber = (fdNumber, fdName, isWritable, fileDescriptors) => {
-  const fileDescriptor = fileDescriptors[getUsedDescriptor(fdNumber)];
-  if (fileDescriptor === void 0) {
-    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.`);
-  }
-};
-var 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.`;
-};
-var getInvalidStdioOption = (fdNumber, { stdin, stdout, stderr, stdio }) => {
-  const usedDescriptor = getUsedDescriptor(fdNumber);
-  if (usedDescriptor === 0 && stdin !== void 0) {
-    return { optionName: "stdin", optionValue: stdin };
-  }
-  if (usedDescriptor === 1 && stdout !== void 0) {
-    return { optionName: "stdout", optionValue: stdout };
-  }
-  if (usedDescriptor === 2 && stderr !== void 0) {
-    return { optionName: "stderr", optionValue: stderr };
-  }
-  return { optionName: `stdio[${usedDescriptor}]`, optionValue: stdio[usedDescriptor] };
-};
-var getUsedDescriptor = (fdNumber) => fdNumber === "all" ? 1 : fdNumber;
-var getOptionName = (isWritable) => isWritable ? "to" : "from";
-var serializeOptionValue = (value) => {
-  if (typeof value === "string") {
-    return `'${value}'`;
-  }
-  return typeof value === "number" ? `${value}` : "Stream";
-};
-
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/stdio/native.js
 var handleNativeStream = ({ stdioItem, stdioItem: { type }, isStdioArray, fdNumber, direction, isSync }) => {
   if (!isStdioArray || type !== "native") {
     return stdioItem;
@@ -3325,7 +4009,7 @@ var getStandardStream = (fdNumber, value, optionName) => {
   return standardStream;
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/stdio/input-option.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/stdio/input-option.js
 var handleInputOptions = ({ input, inputFile }, fdNumber) => fdNumber === 0 ? [
   ...handleInputOption(input),
   ...handleInputFileOption(inputFile)
@@ -3361,7 +4045,7 @@ var getInputFileType = (inputFile) => {
   throw new Error("The `inputFile` option must be a file path string or a file URL.");
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/stdio/duplicate.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/stdio/duplicate.js
 var filterDuplicates = (stdioItems) => stdioItems.filter((stdioItemOne, indexOne) => stdioItems.every((stdioItemTwo, indexTwo) => stdioItemOne.value !== stdioItemTwo.value || indexOne >= indexTwo || stdioItemOne.type === "generator" || stdioItemOne.type === "asyncGenerator"));
 var getDuplicateStream = ({ stdioItem: { type, value, optionName }, direction, fileDescriptors, isSync }) => {
   const otherStdioItems = getOtherStdioItems(fileDescriptors, type);
@@ -3419,7 +4103,7 @@ var getDuplicateStreamInstance = ({ otherStdioItems, type, value, optionName, di
 };
 var hasSameValue = ({ type, value }, secondValue) => {
   if (type === "filePath") {
-    return value.path === secondValue.path;
+    return value.file === secondValue.file;
   }
   if (type === "fileUrl") {
     return value.href === secondValue.href;
@@ -3436,7 +4120,7 @@ var throwOnDuplicateStream = (stdioItem, optionName, type) => {
   }
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/stdio/handle.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/stdio/handle.js
 var handleStdio = (addProperties3, options, verboseInfo, isSync) => {
   const stdio = normalizeStdioOption(options, isSync);
   const initialFileDescriptors = stdio.map((stdioOption, fdNumber) => getFileDescriptor({
@@ -3596,7 +4280,7 @@ var forwardStdio = (stdioItems) => {
   return type === "native" ? value : "pipe";
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/stdio/handle-sync.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/stdio/handle-sync.js
 var handleStdioSync = (options, verboseInfo) => handleStdio(addPropertiesSync, options, verboseInfo, true);
 var forbiddenIfSync = ({ type, optionName }) => {
   throwInvalidSyncValue(optionName, TYPE_TO_MESSAGE[type]);
@@ -3642,14 +4326,14 @@ var addPropertiesSync = {
   }
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/io/strip-newline.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/io/strip-newline.js
 var stripNewline = (value, { stripFinalNewline: stripFinalNewline2 }, fdNumber) => getStripFinalNewline(stripFinalNewline2, fdNumber) && value !== void 0 && !Array.isArray(value) ? stripFinalNewline(value) : value;
 var getStripFinalNewline = (stripFinalNewline2, fdNumber) => fdNumber === "all" ? stripFinalNewline2[1] || stripFinalNewline2[2] : stripFinalNewline2[fdNumber];
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/transform/generator.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/transform/generator.js
 import { Transform, getDefaultHighWaterMark } from "node:stream";
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/transform/split.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/transform/split.js
 var getSplitLinesGenerator = (binary, preserveNewlines, skipped, state) => binary || skipped ? void 0 : initializeSplitLines(preserveNewlines, state);
 var splitLinesSync = (chunk, preserveNewlines, objectMode) => objectMode ? chunk.flatMap((item) => splitLinesItemSync(item, preserveNewlines)) : splitLinesItemSync(chunk, preserveNewlines);
 var splitLinesItemSync = (chunk, preserveNewlines) => {
@@ -3729,7 +4413,7 @@ var linesUint8ArrayInfo = {
   concatBytes: concatUint8Array
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/transform/validate.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/transform/validate.js
 import { Buffer as Buffer2 } from "node:buffer";
 var getValidateTransformInput = (writableObjectMode, optionName) => writableObjectMode ? void 0 : validateStringTransformInput.bind(void 0, optionName);
 var validateStringTransformInput = function* (optionName, chunk) {
@@ -3758,7 +4442,7 @@ Instead, \`yield\` should either be called with a value, or not be called at all
   }
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/transform/encoding-transform.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/transform/encoding-transform.js
 import { Buffer as Buffer3 } from "node:buffer";
 import { StringDecoder as StringDecoder2 } from "node:string_decoder";
 var getEncodingTransformGenerator = (binary, encoding, skipped) => {
@@ -3793,7 +4477,7 @@ var encodingStringFinal = function* (stringDecoder) {
   }
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/transform/run-async.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/transform/run-async.js
 import { callbackify } from "node:util";
 var pushChunks = callbackify(async (getChunks, state, getChunksArguments, transformStream) => {
   state.currentIterable = getChunks(...getChunksArguments);
@@ -3841,7 +4525,7 @@ var identityGenerator = function* (chunk) {
   yield chunk;
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/transform/run-sync.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/transform/run-sync.js
 var pushChunksSync = (getChunksSync, getChunksArguments, transformStream, done) => {
   try {
     for (const chunk of getChunksSync(...getChunksArguments)) {
@@ -3883,7 +4567,7 @@ var identityGenerator2 = function* (chunk) {
   yield chunk;
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/transform/generator.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/transform/generator.js
 var generatorToStream = ({
   value,
   value: { transform, final, writableObjectMode, readableObjectMode },
@@ -3937,7 +4621,7 @@ var addInternalGenerators = ({ transform, final, binary, writableObjectMode, rea
   ].filter(Boolean);
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/io/input-sync.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/io/input-sync.js
 var addInputOptionsSync = (fileDescriptors, options) => {
   for (const fdNumber of getInputFdNumbers(fileDescriptors)) {
     addInputOptionSync(fileDescriptors, fdNumber, options);
@@ -3970,11 +4654,10 @@ var validateSerializable = (newContents) => {
   }
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/io/output-sync.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/io/output-sync.js
 import { writeFileSync as writeFileSync2, appendFileSync } from "node:fs";
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/verbose/output.js
-import { inspect } from "node:util";
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/verbose/output.js
 var shouldLogOutput = ({ stdioItems, encoding, verboseInfo: { verbose }, fdNumber }) => fdNumber !== "all" && verbose[fdNumber] === "full" && !BINARY_ENCODINGS.has(encoding) && fdUsesVerbose(fdNumber) && (stdioItems.some(({ type, value }) => type === "native" && PIPED_STDIO_VALUES.has(value)) || stdioItems.every(({ type }) => TRANSFORM_TYPES.has(type)));
 var fdUsesVerbose = (fdNumber) => fdNumber === 1 || fdNumber === 2;
 var PIPED_STDIO_VALUES = /* @__PURE__ */ new Set(["pipe", "overlapped"]);
@@ -3992,14 +4675,10 @@ var logLinesSync = (linesArray, verboseInfo) => {
 };
 var isPipingStream = (stream) => stream._readableState.pipes.length > 0;
 var logLine = (line, { verboseId }) => {
-  const lines = typeof line === "string" ? line : inspect(line);
-  const escapedLines = escapeLines(lines);
-  const spacedLines = escapedLines.replaceAll("	", " ".repeat(TAB_SIZE));
-  verboseLog(spacedLines, verboseId, "output");
+  verboseLog(serializeLogMessage(line), verboseId, "output");
 };
-var TAB_SIZE = 2;
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/io/output-sync.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/io/output-sync.js
 var transformOutputSync = ({ fileDescriptors, syncResult: { output }, options, isMaxBuffer, verboseInfo }) => {
   if (output === null) {
     return { output: Array.from({ length: 3 }) };
@@ -4086,7 +4765,7 @@ var writeToFiles = (serializedResult, stdioItems, outputFiles) => {
   }
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/resolve/all-sync.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/resolve/all-sync.js
 var getAllSync = ([, stdout, stderr], options) => {
   if (!options.all) {
     return;
@@ -4109,12 +4788,17 @@ var getAllSync = ([, stdout, stderr], options) => {
   return `${stdout}${stderr}`;
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/resolve/exit-async.js
-import { once } from "node:events";
-var waitForExit = async (subprocess) => {
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/resolve/exit-async.js
+import { once as once4 } from "node:events";
+var waitForExit = async (subprocess, context) => {
+  const [exitCode, signal] = await waitForExitOrError(subprocess);
+  context.isForcefullyTerminated ??= false;
+  return [exitCode, signal];
+};
+var waitForExitOrError = async (subprocess) => {
   const [spawnPayload, exitPayload] = await Promise.allSettled([
-    once(subprocess, "spawn"),
-    once(subprocess, "exit")
+    once4(subprocess, "spawn"),
+    once4(subprocess, "exit")
   ]);
   if (spawnPayload.status === "rejected") {
     return [];
@@ -4123,7 +4807,7 @@ var waitForExit = async (subprocess) => {
 };
 var waitForSubprocessExit = async (subprocess) => {
   try {
-    return await once(subprocess, "exit");
+    return await once4(subprocess, "exit");
   } catch {
     return waitForSubprocessExit(subprocess);
   }
@@ -4138,7 +4822,7 @@ var waitForSuccessfulExit = async (exitPromise) => {
 var isSubprocessErrorExit = (exitCode, signal) => exitCode === void 0 && signal === void 0;
 var isFailedExit = (exitCode, signal) => exitCode !== 0 || signal !== null;
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/resolve/exit-sync.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/resolve/exit-sync.js
 var getExitResultSync = ({ error, status: exitCode, signal, output }, { maxBuffer }) => {
   const resultError = getResultError(error, exitCode, signal);
   const timedOut = resultError?.code === "ETIMEDOUT";
@@ -4158,7 +4842,7 @@ var getResultError = (error, exitCode, signal) => {
   return isFailedExit(exitCode, signal) ? new DiscardedError() : void 0;
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/methods/main-sync.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/methods/main-sync.js
 var execaCoreSync = (rawFile, rawArguments, rawOptions) => {
   const { file, commandArguments, command, escapedCommand, startTime, verboseInfo, options, fileDescriptors } = handleSyncArguments(rawFile, rawArguments, rawOptions);
   const result = spawnSubprocessSync({
@@ -4196,7 +4880,10 @@ var handleSyncArguments = (rawFile, rawArguments, rawOptions) => {
   }
 };
 var normalizeSyncOptions = (options) => options.node && !options.ipc ? { ...options, ipc: false } : options;
-var validateSyncOptions = ({ ipc, detached, cancelSignal }) => {
+var validateSyncOptions = ({ ipc, ipcInput, detached, cancelSignal }) => {
+  if (ipcInput) {
+    throwInvalidSyncOption("ipcInput");
+  }
   if (ipc) {
     throwInvalidSyncOption("ipc: true");
   }
@@ -4270,6 +4957,7 @@ var getSyncResult = ({ error, exitCode, signal, timedOut, isMaxBuffer, stdio, al
   escapedCommand,
   stdio,
   all,
+  ipcOutput: [],
   options,
   startTime
 }) : makeError({
@@ -4278,21 +4966,200 @@ var getSyncResult = ({ error, exitCode, signal, timedOut, isMaxBuffer, stdio, al
   escapedCommand,
   timedOut,
   isCanceled: false,
+  isGracefullyCanceled: false,
   isMaxBuffer,
+  isForcefullyTerminated: false,
   exitCode,
   signal,
   stdio,
   all,
+  ipcOutput: [],
   options,
   startTime,
   isSync: true
 });
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/methods/main-async.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/methods/main-async.js
 import { setMaxListeners } from "node:events";
 import { spawn } from "node:child_process";
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/return/early-error.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/ipc/methods.js
+import process8 from "node:process";
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/ipc/get-one.js
+import { once as once5, on as on2 } from "node:events";
+var getOneMessage = ({ anyProcess, channel, isSubprocess, ipc }, { reference = true, filter } = {}) => {
+  validateIpcMethod({
+    methodName: "getOneMessage",
+    isSubprocess,
+    ipc,
+    isConnected: isConnected(anyProcess)
+  });
+  return getOneMessageAsync({
+    anyProcess,
+    channel,
+    isSubprocess,
+    filter,
+    reference
+  });
+};
+var 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),
+      throwOnDisconnect2(ipcEmitter, isSubprocess, controller),
+      throwOnStrictError(ipcEmitter, isSubprocess, controller)
+    ]);
+  } catch (error) {
+    disconnect(anyProcess);
+    throw error;
+  } finally {
+    controller.abort();
+    removeReference(channel, reference);
+  }
+};
+var getMessage = async (ipcEmitter, filter, { signal }) => {
+  if (filter === void 0) {
+    const [message] = await once5(ipcEmitter, "message", { signal });
+    return message;
+  }
+  for await (const [message] of on2(ipcEmitter, "message", { signal })) {
+    if (filter(message)) {
+      return message;
+    }
+  }
+};
+var throwOnDisconnect2 = async (ipcEmitter, isSubprocess, { signal }) => {
+  await once5(ipcEmitter, "disconnect", { signal });
+  throwOnEarlyDisconnect(isSubprocess);
+};
+var throwOnStrictError = async (ipcEmitter, isSubprocess, { signal }) => {
+  const [error] = await once5(ipcEmitter, "strict:error", { signal });
+  throw getStrictResponseError(error, isSubprocess);
+};
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/ipc/get-each.js
+import { once as once6, on as on3 } from "node:events";
+var getEachMessage = ({ anyProcess, channel, isSubprocess, ipc }, { reference = true } = {}) => loopOnMessages({
+  anyProcess,
+  channel,
+  isSubprocess,
+  ipc,
+  shouldAwait: !isSubprocess,
+  reference
+});
+var 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
+  });
+};
+var stopOnDisconnect = async (anyProcess, ipcEmitter, controller) => {
+  try {
+    await once6(ipcEmitter, "disconnect", { signal: controller.signal });
+    controller.abort();
+  } catch {
+  }
+};
+var abortOnStrictError = async ({ ipcEmitter, isSubprocess, controller, state }) => {
+  try {
+    const [error] = await once6(ipcEmitter, "strict:error", { signal: controller.signal });
+    state.error = getStrictResponseError(error, isSubprocess);
+    controller.abort();
+  } catch {
+  }
+};
+var iterateOnMessages = async function* ({ anyProcess, channel, ipcEmitter, isSubprocess, shouldAwait, controller, state, reference }) {
+  try {
+    for await (const [message] of on3(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;
+    }
+  }
+};
+var throwIfStrictError = ({ error }) => {
+  if (error) {
+    throw error;
+  }
+};
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/ipc/methods.js
+var addIpcMethods = (subprocess, { ipc }) => {
+  Object.assign(subprocess, getIpcMethods(subprocess, false, ipc));
+};
+var getIpcExport = () => {
+  const anyProcess = process8;
+  const isSubprocess = true;
+  const ipc = process8.channel !== void 0;
+  return {
+    ...getIpcMethods(anyProcess, isSubprocess, ipc),
+    getCancelSignal: getCancelSignal.bind(void 0, {
+      anyProcess,
+      channel: anyProcess.channel,
+      isSubprocess,
+      ipc
+    })
+  };
+};
+var getIpcMethods = (anyProcess, isSubprocess, ipc) => ({
+  sendMessage: sendMessage.bind(void 0, {
+    anyProcess,
+    channel: anyProcess.channel,
+    isSubprocess,
+    ipc
+  }),
+  getOneMessage: getOneMessage.bind(void 0, {
+    anyProcess,
+    channel: anyProcess.channel,
+    isSubprocess,
+    ipc
+  }),
+  getEachMessage: getEachMessage.bind(void 0, {
+    anyProcess,
+    channel: anyProcess.channel,
+    isSubprocess,
+    ipc
+  })
+});
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/return/early-error.js
 import { ChildProcess as ChildProcess2 } from "node:child_process";
 import {
   PassThrough,
@@ -4346,7 +5213,7 @@ var duplex = () => new Duplex({ read() {
 } });
 var handleDummyPromise = async (error, verboseInfo, options) => handleResult(error, verboseInfo, options);
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/stdio/handle-async.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/stdio/handle-async.js
 import { createReadStream, createWriteStream } from "node:fs";
 import { Buffer as Buffer4 } from "node:buffer";
 import { Readable as Readable2, Writable as Writable2, Duplex as Duplex2 } from "node:stream";
@@ -4392,7 +5259,7 @@ var addPropertiesAsync = {
 };
 
 // ../../node_modules/.pnpm/@sindresorhus+merge-streams@4.0.0/node_modules/@sindresorhus/merge-streams/index.js
-import { on as on2, once as once2 } from "node:events";
+import { on as on4, once as once7 } from "node:events";
 import { PassThrough as PassThroughStream, getDefaultHighWaterMark as getDefaultHighWaterMark2 } from "node:stream";
 import { finished as finished2 } from "node:stream/promises";
 function mergeStreams(streams) {
@@ -4484,7 +5351,7 @@ var onMergedStreamEnd = async (passThroughStream, { signal }) => {
   }
 };
 var onInputStreamsUnpipe = async (passThroughStream, streams, unpipeEvent, { signal }) => {
-  for await (const [unpipedStream] of on2(passThroughStream, "unpipe", { signal })) {
+  for await (const [unpipedStream] of on4(passThroughStream, "unpipe", { signal })) {
     if (streams.has(unpipedStream)) {
       unpipedStream.emit(unpipeEvent);
     }
@@ -4565,9 +5432,9 @@ var onInputStreamEnd = async ({ passThroughStream, stream, streams, ended, abort
   }
 };
 var onInputStreamUnpipe = async ({ stream, streams, ended, aborted: aborted2, unpipeEvent, controller: { signal } }) => {
-  await once2(stream, unpipeEvent, { signal });
+  await once7(stream, unpipeEvent, { signal });
   if (!stream.readable) {
-    return once2(signal, "abort", { signal });
+    return once7(signal, "abort", { signal });
   }
   streams.delete(stream);
   ended.delete(stream);
@@ -4608,20 +5475,7 @@ var updateMaxListeners = (passThroughStream, increment2) => {
 var PASSTHROUGH_LISTENERS_COUNT = 2;
 var PASSTHROUGH_LISTENERS_PER_STREAM = 1;
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/utils/max-listeners.js
-import { addAbortListener } from "node:events";
-var incrementMaxListeners = (eventEmitter, maxListenersIncrement, signal) => {
-  const maxListeners = eventEmitter.getMaxListeners();
-  if (maxListeners === 0 || maxListeners === Number.POSITIVE_INFINITY) {
-    return;
-  }
-  eventEmitter.setMaxListeners(maxListeners + maxListenersIncrement);
-  addAbortListener(signal, () => {
-    eventEmitter.setMaxListeners(eventEmitter.getMaxListeners() - maxListenersIncrement);
-  });
-};
-
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/io/pipeline.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/io/pipeline.js
 import { finished as finished3 } from "node:stream/promises";
 var pipeStreams = (source, destination) => {
   source.pipe(destination);
@@ -4659,7 +5513,7 @@ var abortSourceStream = (source) => {
   }
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/io/output-async.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/io/output-async.js
 var pipeOutputAsync = (subprocess, fileDescriptors, controller) => {
   const pipeGroups = /* @__PURE__ */ new Map();
   for (const [fdNumber, { stdioItems, direction }] of Object.entries(fileDescriptors)) {
@@ -4711,7 +5565,7 @@ var setStandardStreamMaxListeners = (stream, { signal }) => {
 };
 var MAX_LISTENERS_INCREMENT = 2;
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/terminate/cleanup.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/terminate/cleanup.js
 import { addAbortListener as addAbortListener2 } from "node:events";
 
 // ../../node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/signals.js
@@ -4739,7 +5593,7 @@ if (process.platform === "linux") {
 }
 
 // ../../node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js
-var processOk = (process9) => !!process9 && typeof process9 === "object" && typeof process9.removeListener === "function" && typeof process9.emit === "function" && typeof process9.reallyExit === "function" && typeof process9.listeners === "function" && typeof process9.kill === "function" && typeof process9.pid === "number" && typeof process9.on === "function";
+var processOk = (process10) => !!process10 && typeof process10 === "object" && typeof process10.removeListener === "function" && typeof process10.emit === "function" && typeof process10.reallyExit === "function" && typeof process10.listeners === "function" && typeof process10.kill === "function" && typeof process10.pid === "number" && typeof process10.on === "function";
 var kExitEmitter = Symbol.for("signal-exit emitter");
 var global2 = globalThis;
 var ObjectDefineProperty = Object.defineProperty.bind(Object);
@@ -4824,7 +5678,7 @@ var SignalExit = class extends SignalExitBase {
   // "SIGHUP" throws an `ENOSYS` error on Windows,
   // so use a supported signal instead
   /* c8 ignore start */
-  #hupSig = process8.platform === "win32" ? "SIGINT" : "SIGHUP";
+  #hupSig = process9.platform === "win32" ? "SIGINT" : "SIGHUP";
   /* c8 ignore stop */
   #emitter = new Emitter();
   #process;
@@ -4832,29 +5686,29 @@ var SignalExit = class extends SignalExitBase {
   #originalProcessReallyExit;
   #sigListeners = {};
   #loaded = false;
-  constructor(process9) {
+  constructor(process10) {
     super();
-    this.#process = process9;
+    this.#process = process10;
     this.#sigListeners = {};
     for (const sig of signals) {
       this.#sigListeners[sig] = () => {
         const listeners = this.#process.listeners(sig);
-        let { count } = this.#emitter;
-        const p = process9;
+        let { count: count2 } = this.#emitter;
+        const p = process10;
         if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
-          count += p.__signal_exit_emitter__.count;
+          count2 += p.__signal_exit_emitter__.count;
         }
-        if (listeners.length === count) {
+        if (listeners.length === count2) {
           this.unload();
           const ret = this.#emitter.emit("exit", null, sig);
           const s = sig === "SIGHUP" ? this.#hupSig : sig;
           if (!ret)
-            process9.kill(process9.pid, s);
+            process10.kill(process10.pid, s);
         }
       };
     }
-    this.#originalProcessReallyExit = process9.reallyExit;
-    this.#originalProcessEmit = process9.emit;
+    this.#originalProcessReallyExit = process10.reallyExit;
+    this.#originalProcessEmit = process10.emit;
   }
   onExit(cb, opts) {
     if (!processOk(this.#process)) {
@@ -4935,7 +5789,7 @@ var SignalExit = class extends SignalExitBase {
     }
   }
 };
-var process8 = globalThis.process;
+var process9 = globalThis.process;
 var {
   /**
    * Called when the process is exiting, whether via signal, explicit
@@ -4963,9 +5817,9 @@ var {
    * @internal
    */
   unload
-} = signalExitWrap(processOk(process8) ? new SignalExit(process8) : new SignalExitFallback());
+} = signalExitWrap(processOk(process9) ? new SignalExit(process9) : new SignalExitFallback());
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/terminate/cleanup.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/terminate/cleanup.js
 var cleanupOnExit = (subprocess, { cleanup, detached }, { signal }) => {
   if (!cleanup || detached) {
     return;
@@ -4978,7 +5832,7 @@ var cleanupOnExit = (subprocess, { cleanup, detached }, { signal }) => {
   });
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/pipe/pipe-arguments.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/pipe/pipe-arguments.js
 var normalizePipeArguments = ({ source, sourcePromise, boundOptions, createNested }, ...pipeArguments) => {
   const startTime = getStartTime();
   const {
@@ -5051,7 +5905,7 @@ var getSourceStream = (source, from) => {
   }
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/pipe/throw.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/pipe/throw.js
 var handlePipeArgumentsError = ({
   sourceStream,
   sourceError,
@@ -5100,7 +5954,7 @@ var createNonCommandError = ({ error, fileDescriptors, sourceOptions, startTime
 });
 var PIPE_COMMAND_MESSAGE = "source.pipe(destination)";
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/pipe/sequence.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/pipe/sequence.js
 var waitForBothSubprocesses = async (subprocessPromises) => {
   const [
     { status: sourceStatus, reason: sourceReason, value: sourceResult = sourceReason },
@@ -5118,7 +5972,7 @@ var waitForBothSubprocesses = async (subprocessPromises) => {
   return destinationResult;
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/pipe/streaming.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/pipe/streaming.js
 import { finished as finished4 } from "node:stream/promises";
 var pipeSubprocessStream = (sourceStream, destinationStream, maxListenersController) => {
   const mergedStream = MERGED_STREAMS.has(destinationStream) ? pipeMoreSubprocessStream(sourceStream, destinationStream) : pipeFirstSubprocessStream(sourceStream, destinationStream);
@@ -5149,7 +6003,7 @@ var MERGED_STREAMS = /* @__PURE__ */ new WeakMap();
 var SOURCE_LISTENERS_PER_PIPE = 2;
 var DESTINATION_LISTENERS_PER_PIPE = 1;
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/pipe/abort.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/pipe/abort.js
 import { aborted } from "node:util";
 var unpipeOnAbort = (unpipeSignal, unpipeContext) => unpipeSignal === void 0 ? [] : [unpipeOnSignalAbort(unpipeSignal, unpipeContext)];
 var unpipeOnSignalAbort = async (unpipeSignal, { sourceStream, mergedStream, fileDescriptors, sourceOptions, startTime }) => {
@@ -5164,7 +6018,7 @@ var unpipeOnSignalAbort = async (unpipeSignal, { sourceStream, mergedStream, fil
   });
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/pipe/setup.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/pipe/setup.js
 var pipeToSubprocess = (sourceInfo, ...pipeArguments) => {
   if (isPlainObject(pipeArguments[0])) {
     return pipeToSubprocess.bind(void 0, {
@@ -5223,11 +6077,11 @@ var handlePipePromise = async ({
 };
 var getSubprocessPromises = (sourcePromise, destination) => Promise.allSettled([sourcePromise, destination]);
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/io/contents.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/io/contents.js
 import { setImmediate } from "node:timers/promises";
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/io/iterate.js
-import { on as on3 } from "node:events";
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/io/iterate.js
+import { on as on5 } from "node:events";
 import { getDefaultHighWaterMark as getDefaultHighWaterMark3 } from "node:stream";
 var iterateOnSubprocessStream = ({ subprocessStdout, subprocess, binary, shouldEncode, encoding, preserveNewlines }) => {
   const controller = new AbortController();
@@ -5274,7 +6128,7 @@ var stopReadingOnStreamEnd = async (onStreamEnd, controller, stream) => {
   }
 };
 var iterateOnStream = ({ stream, controller, binary, shouldEncode, encoding, shouldSplit, preserveNewlines }) => {
-  const onStdoutChunk = on3(stream, "data", {
+  const onStdoutChunk = on5(stream, "data", {
     signal: controller.signal,
     highWaterMark: HIGH_WATER_MARK,
     // Backward compatibility with older name for this option
@@ -5319,7 +6173,7 @@ var getGenerators = ({ binary, shouldEncode, encoding, shouldSplit, preserveNewl
   getSplitLinesGenerator(binary, preserveNewlines, !shouldSplit, {})
 ].filter(Boolean);
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/io/contents.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/io/contents.js
 var getStreamOutput = async ({ stream, onStreamEnd, fdNumber, encoding, buffer, maxBuffer, lines, allMixed, stripFinalNewline: stripFinalNewline2, verboseInfo, streamInfo: { fileDescriptors } }) => {
   if (shouldLogOutput({
     stdioItems: fileDescriptors[fdNumber]?.stdioItems,
@@ -5394,7 +6248,7 @@ var getBufferedData = async (streamPromise) => {
 };
 var handleBufferedData = ({ bufferedData }) => isArrayBuffer(bufferedData) ? new Uint8Array(bufferedData) : bufferedData;
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/resolve/wait-stream.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/resolve/wait-stream.js
 import { finished as finished5 } from "node:stream/promises";
 var waitForStream = async (stream, fdNumber, streamInfo, { isSameDirection, stopOnExit = false } = {}) => {
   const state = handleStdinDestroy(stream, streamInfo);
@@ -5447,7 +6301,7 @@ var isInputFileDescriptor = ({ fileDescriptors }, fdNumber) => fdNumber !== "all
 var isStreamAbort = (error) => error?.code === "ERR_STREAM_PREMATURE_CLOSE";
 var isStreamEpipe = (error) => error?.code === "EPIPE";
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/resolve/stdio.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/resolve/stdio.js
 var waitForStdioStreams = ({ subprocess, encoding, buffer, maxBuffer, lines, stripFinalNewline: stripFinalNewline2, verboseInfo, streamInfo }) => subprocess.stdio.map((stream, fdNumber) => waitForSubprocessStream({
   stream,
   fdNumber,
@@ -5488,7 +6342,7 @@ var waitForSubprocessStream = async ({ stream, fdNumber, encoding, buffer, maxBu
   return output;
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/resolve/all-async.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/resolve/all-async.js
 var makeAllStream = ({ stdout, stderr }, { all }) => all && (stdout || stderr) ? mergeStreams([stdout, stderr].filter(Boolean)) : void 0;
 var waitForAllStream = ({ subprocess, encoding, buffer, maxBuffer, lines, stripFinalNewline: stripFinalNewline2, verboseInfo, streamInfo }) => waitForSubprocessStream({
   ...getAllStream(subprocess, buffer),
@@ -5516,11 +6370,69 @@ var getAllStream = ({ stdout, stderr, all }, [, bufferStdout, bufferStderr]) =>
 };
 var getAllMixed = ({ all, stdout, stderr }) => all && stdout && stderr && stdout.readableObjectMode !== stderr.readableObjectMode;
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/resolve/wait-subprocess.js
-import { once as once3 } from "node:events";
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/resolve/wait-subprocess.js
+import { once as once8 } from "node:events";
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/verbose/ipc.js
+var shouldLogIpc = ({ verbose }) => verbose.at(-1) === "full";
+var logIpcOutput = (message, { verboseId }) => {
+  verboseLog(serializeLogMessage(message), verboseId, "ipc");
+};
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/ipc/buffer-messages.js
+var waitForIpcOutput = async ({
+  subprocess,
+  buffer: bufferArray,
+  maxBuffer: maxBufferArray,
+  ipc,
+  ipcOutput,
+  verboseInfo
+}) => {
+  if (!ipc) {
+    return ipcOutput;
+  }
+  const isVerbose2 = 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 (isVerbose2) {
+      logIpcOutput(message, verboseInfo);
+    }
+  }
+  return ipcOutput;
+};
+var getBufferedIpcOutput = async (ipcOutputPromise, ipcOutput) => {
+  await Promise.allSettled([ipcOutputPromise]);
+  return ipcOutput;
+};
+
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/resolve/wait-subprocess.js
 var waitForSubprocessResult = async ({
   subprocess,
-  options: { encoding, buffer, maxBuffer, lines, timeoutDuration: timeout, stripFinalNewline: stripFinalNewline2 },
+  options: {
+    encoding,
+    buffer,
+    maxBuffer,
+    lines,
+    timeoutDuration: timeout,
+    cancelSignal,
+    gracefulCancel,
+    forceKillAfterDelay,
+    stripFinalNewline: stripFinalNewline2,
+    ipc,
+    ipcInput
+  },
   context,
   verboseInfo,
   fileDescriptors,
@@ -5528,7 +6440,7 @@ var waitForSubprocessResult = async ({
   onInternalError,
   controller
 }) => {
-  const exitPromise = waitForExit(subprocess);
+  const exitPromise = waitForExit(subprocess, context);
   const streamInfo = {
     originalStreams,
     fileDescriptors,
@@ -5556,6 +6468,15 @@ var 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);
   try {
@@ -5565,19 +6486,38 @@ var waitForSubprocessResult = async ({
         waitForSuccessfulExit(exitPromise),
         Promise.all(stdioPromises),
         allPromise,
+        ipcOutputPromise,
+        sendIpcInput(subprocess, ipcInput),
         ...originalPromises,
         ...customStreamsEndPromises
       ]),
       onInternalError,
       throwOnSubprocessError(subprocess, controller),
-      ...throwOnTimeout(subprocess, timeout, context, 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)
     ]);
@@ -5589,20 +6529,11 @@ var waitForCustomStreamsEnd = (fileDescriptors, streamInfo) => fileDescriptors.f
   stopOnExit: type === "native"
 })));
 var throwOnSubprocessError = async (subprocess, { signal }) => {
-  const [error] = await once3(subprocess, "error", { signal });
+  const [error] = await once8(subprocess, "error", { signal });
   throw error;
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/utils/deferred.js
-var createDeferred = () => {
-  const methods = {};
-  const promise = new Promise((resolve3, reject) => {
-    Object.assign(methods, { resolve: resolve3, reject });
-  });
-  return Object.assign(promise, methods);
-};
-
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/convert/concurrent.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/convert/concurrent.js
 var initializeConcurrentStreams = () => ({
   readableDestroy: /* @__PURE__ */ new WeakMap(),
   writableFinal: /* @__PURE__ */ new WeakMap(),
@@ -5628,11 +6559,11 @@ var waitForConcurrentStreams = async ({ resolve: resolve3, promises }, subproces
   return !isSubprocessExit;
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/convert/readable.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/convert/readable.js
 import { Readable as Readable3 } from "node:stream";
 import { callbackify as callbackify2 } from "node:util";
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/convert/shared.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/convert/shared.js
 import { finished as finished6 } from "node:stream/promises";
 var safeWaitForSubprocessStdin = async (subprocessStdin) => {
   if (subprocessStdin === void 0) {
@@ -5672,7 +6603,7 @@ var destroyOtherStream = (stream, isOpen, error) => {
   }
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/convert/readable.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/convert/readable.js
 var createReadable = ({ subprocess, concurrentStreams, encoding }, { from, binary: binaryOption = true, preserveNewlines = true } = {}) => {
   const binary = binaryOption || BINARY_ENCODINGS.has(encoding);
   const { subprocessStdout, waitReadableDestroy } = getSubprocessStdout(subprocess, from, concurrentStreams);
@@ -5757,7 +6688,7 @@ var destroyOtherReadable = (stream, error) => {
   destroyOtherStream(stream, stream.readable, error);
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/convert/writable.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/convert/writable.js
 import { Writable as Writable3 } from "node:stream";
 import { callbackify as callbackify3 } from "node:util";
 var createWritable = ({ subprocess, concurrentStreams }, { to } = {}) => {
@@ -5823,7 +6754,7 @@ var destroyOtherWritable = (stream, error) => {
   destroyOtherStream(stream, stream.writable, error);
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/convert/duplex.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/convert/duplex.js
 import { Duplex as Duplex3 } from "node:stream";
 import { callbackify as callbackify4 } from "node:util";
 var createDuplex = ({ subprocess, concurrentStreams, encoding }, { from, to, binary: binaryOption = true, preserveNewlines = true } = {}) => {
@@ -5877,7 +6808,7 @@ var onDuplexDestroy = async ({ subprocessStdout, subprocessStdin, subprocess, wa
   ]);
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/convert/iterable.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/convert/iterable.js
 var createIterable = (subprocess, encoding, {
   from,
   binary: binaryOption = false,
@@ -5906,7 +6837,7 @@ var iterateOnStdoutData = async function* (onStdoutData, subprocessStdout, subpr
   }
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/convert/add.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/convert/add.js
 var addConvertedStreams = (subprocess, { encoding }) => {
   const concurrentStreams = initializeConcurrentStreams();
   subprocess.readable = createReadable.bind(void 0, { subprocess, concurrentStreams, encoding });
@@ -5916,7 +6847,7 @@ var addConvertedStreams = (subprocess, { encoding }) => {
   subprocess[Symbol.asyncIterator] = createIterable.bind(void 0, subprocess, encoding, {});
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/methods/promise.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/methods/promise.js
 var mergePromise = (subprocess, promise) => {
   for (const [property, descriptor] of descriptors) {
     const value = descriptor.value.bind(promise);
@@ -5930,7 +6861,7 @@ var descriptors = ["then", "catch", "finally"].map((property) => [
   Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property)
 ]);
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/methods/main-async.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/methods/main-async.js
 var execaCoreAsync = (rawFile, rawArguments, rawOptions, createNested) => {
   const { file, commandArguments, command, escapedCommand, startTime, verboseInfo, options, fileDescriptors } = handleAsyncArguments(rawFile, rawArguments, rawOptions);
   const { subprocess, promise } = spawnSubprocessAsync({
@@ -5974,11 +6905,11 @@ var handleAsyncArguments = (rawFile, rawArguments, rawOptions) => {
     throw error;
   }
 };
-var handleAsyncOptions = ({ timeout, signal, cancelSignal, ...options }) => {
+var handleAsyncOptions = ({ timeout, signal, ...options }) => {
   if (signal !== void 0) {
     throw new TypeError('The "signal" option has been renamed to "cancelSignal" instead.');
   }
-  return { ...options, timeoutDuration: timeout, signal: cancelSignal };
+  return { ...options, timeoutDuration: timeout };
 };
 var spawnSubprocessAsync = ({ file, commandArguments, options, startTime, verboseInfo, command, escapedCommand, fileDescriptors }) => {
   let subprocess;
@@ -6000,15 +6931,18 @@ var spawnSubprocessAsync = ({ file, commandArguments, options, startTime, verbos
   const originalStreams = [...subprocess.stdio];
   pipeOutputAsync(subprocess, fileDescriptors, controller);
   cleanupOnExit(subprocess, options, controller);
+  const context = {};
   const onInternalError = createDeferred();
   subprocess.kill = subprocessKill.bind(void 0, {
     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,
@@ -6018,14 +6952,20 @@ var spawnSubprocessAsync = ({ file, commandArguments, options, startTime, verbos
     originalStreams,
     command,
     escapedCommand,
+    context,
     onInternalError,
     controller
   });
   return { subprocess, promise };
 };
-var handlePromise = async ({ subprocess, options, startTime, verboseInfo, fileDescriptors, originalStreams, command, escapedCommand, onInternalError, controller }) => {
-  const context = { timedOut: false };
-  const [errorInfo, [exitCode, signal], stdioResults, allResult] = await waitForSubprocessResult({
+var 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,
@@ -6045,6 +6985,7 @@ var handlePromise = async ({ subprocess, options, startTime, verboseInfo, fileDe
     signal,
     stdio,
     all,
+    ipcOutput,
     context,
     options,
     command,
@@ -6053,17 +6994,20 @@ var handlePromise = async ({ subprocess, options, startTime, verboseInfo, fileDe
   });
   return handleResult(result, verboseInfo, options);
 };
-var getAsyncResult = ({ errorInfo, exitCode, signal, stdio, all, context, options, command, escapedCommand, startTime }) => "error" in errorInfo ? makeError({
+var 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
@@ -6072,11 +7016,12 @@ var getAsyncResult = ({ errorInfo, exitCode, signal, stdio, all, context, option
   escapedCommand,
   stdio,
   all,
+  ipcOutput,
   options,
   startTime
 });
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/methods/bind.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/methods/bind.js
 var mergeOptions = (boundOptions, options) => {
   const newOptions = Object.fromEntries(
     Object.entries(options).map(([optionName, optionValue]) => [
@@ -6094,7 +7039,7 @@ var mergeOption = (optionName, boundOptionValue, optionValue) => {
 };
 var DEEP_OPTIONS = /* @__PURE__ */ new Set(["env", ...FD_SPECIFIC_OPTIONS]);
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/methods/create.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/methods/create.js
 var createExeca = (mapArguments, boundOptions, deepOptions, setBoundExeca) => {
   const createNested = (mapArguments2, boundOptions2, setBoundExeca2) => createExeca(mapArguments2, boundOptions2, deepOptions, setBoundExeca2);
   const boundExeca = (...execaArguments) => callBoundExeca({
@@ -6140,15 +7085,26 @@ var parseArguments = ({ mapArguments, firstArgument, nextArguments, deepOptions,
   };
 };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/methods/command.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/methods/command.js
 var mapCommandAsync = ({ file, commandArguments }) => parseCommand(file, commandArguments);
 var mapCommandSync = ({ file, commandArguments }) => ({ ...parseCommand(file, commandArguments), isSync: true });
 var 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 };
+};
+var 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)) {
     const previousToken = tokens.at(-1);
     if (previousToken && previousToken.endsWith("\\")) {
       tokens[tokens.length - 1] = `${previousToken.slice(0, -1)} ${token}`;
@@ -6156,12 +7112,11 @@ var parseCommand = (command, unusedArguments) => {
       tokens.push(token);
     }
   }
-  const [file, ...commandArguments] = tokens;
-  return { file, commandArguments };
+  return tokens;
 };
 var SPACES_REGEXP = / +/g;
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/lib/methods/script.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/lib/methods/script.js
 var setScriptSync = (boundExeca, createNested, boundOptions) => {
   boundExeca.sync = createNested(mapScriptSync, boundOptions);
   boundExeca.s = boundExeca.sync;
@@ -6172,13 +7127,19 @@ var getScriptOptions = (options) => ({ options: { ...getScriptStdinOption(option
 var getScriptStdinOption = ({ input, inputFile, stdio }) => input === void 0 && inputFile === void 0 && stdio === void 0 ? { stdin: "inherit" } : {};
 var deepScriptOptions = { preferLocal: true };
 
-// ../../node_modules/.pnpm/execa@9.1.0/node_modules/execa/index.js
+// ../../node_modules/.pnpm/execa@9.2.0/node_modules/execa/index.js
 var execa = createExeca(() => ({}));
 var execaSync = createExeca(() => ({ isSync: true }));
 var execaCommand = createExeca(mapCommandAsync);
 var execaCommandSync = createExeca(mapCommandSync);
 var execaNode = createExeca(mapNode);
 var $ = createExeca(mapScriptAsync, {}, deepScriptOptions, setScriptSync);
+var {
+  sendMessage: sendMessage2,
+  getOneMessage: getOneMessage2,
+  getEachMessage: getEachMessage2,
+  getCancelSignal: getCancelSignal2
+} = getIpcExport();
 export {
   $,
   ExecaError,
@@ -6187,5 +7148,10 @@ export {
   execaCommand,
   execaCommandSync,
   execaNode,
-  execaSync
+  execaSync,
+  getCancelSignal2 as getCancelSignal,
+  getEachMessage2 as getEachMessage,
+  getOneMessage2 as getOneMessage,
+  parseCommandString,
+  sendMessage2 as sendMessage
 };