@kubb/cli 3.0.0-alpha.4 → 3.0.0-alpha.6

package/dist/{chunk-7CMTKETP.cjs → chunk-MXBF3FNZ.cjs}

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var __create = Object.create;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -42,6 +42,14 @@ var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read fr
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
 
 // ../../node_modules/.pnpm/tsup@8.2.4_@microsoft+api-extractor@7.47.7_@types+node@20.16.1__jiti@1.21.6_postcss@8.4.41_typescript@5.5.4_yaml@2.4.5/node_modules/tsup/assets/cjs_shims.js
 var init_cjs_shims = __esm({
@@ -564,6 +572,169 @@ var require_cross_spawn = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.js
+var require_eventemitter3 = __commonJS({
+  "../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.js"(exports, module) {
+    "use strict";
+    init_cjs_shims();
+    var has = Object.prototype.hasOwnProperty;
+    var prefix = "~";
+    function Events() {
+    }
+    if (Object.create) {
+      Events.prototype = /* @__PURE__ */ Object.create(null);
+      if (!new Events().__proto__) prefix = false;
+    }
+    function EE(fn, context, once9) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once9 || false;
+    }
+    function addListener(emitter, event, fn, context, once9) {
+      if (typeof fn !== "function") {
+        throw new TypeError("The listener must be a function");
+      }
+      var listener = new EE(fn, context || emitter, once9), evt = prefix ? prefix + event : event;
+      if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+      else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+      else emitter._events[evt] = [emitter._events[evt], listener];
+      return emitter;
+    }
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0) emitter._events = new Events();
+      else delete emitter._events[evt];
+    }
+    function EventEmitter3() {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+    EventEmitter3.prototype.eventNames = function eventNames() {
+      var names = [], events, name;
+      if (this._eventsCount === 0) return names;
+      for (name in events = this._events) {
+        if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+      }
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    };
+    EventEmitter3.prototype.listeners = function listeners(event) {
+      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+      if (!handlers) return [];
+      if (handlers.fn) return [handlers.fn];
+      for (var i2 = 0, l = handlers.length, ee = new Array(l); i2 < l; i2++) {
+        ee[i2] = handlers[i2].fn;
+      }
+      return ee;
+    };
+    EventEmitter3.prototype.listenerCount = function listenerCount(event) {
+      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+      if (!listeners) return 0;
+      if (listeners.fn) return 1;
+      return listeners.length;
+    };
+    EventEmitter3.prototype.emit = function emit(event, a1, a22, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return false;
+      var listeners = this._events[evt], len = arguments.length, args, i2;
+      if (listeners.fn) {
+        if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a22), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a22, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a22, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a22, a3, a4, a5), true;
+        }
+        for (i2 = 1, args = new Array(len - 1); i2 < len; i2++) {
+          args[i2 - 1] = arguments[i2];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length, j;
+        for (i2 = 0; i2 < length; i2++) {
+          if (listeners[i2].once) this.removeListener(event, listeners[i2].fn, void 0, true);
+          switch (len) {
+            case 1:
+              listeners[i2].fn.call(listeners[i2].context);
+              break;
+            case 2:
+              listeners[i2].fn.call(listeners[i2].context, a1);
+              break;
+            case 3:
+              listeners[i2].fn.call(listeners[i2].context, a1, a22);
+              break;
+            case 4:
+              listeners[i2].fn.call(listeners[i2].context, a1, a22, a3);
+              break;
+            default:
+              if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+              listeners[i2].fn.apply(listeners[i2].context, args);
+          }
+        }
+      }
+      return true;
+    };
+    EventEmitter3.prototype.on = function on6(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    };
+    EventEmitter3.prototype.once = function once9(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    };
+    EventEmitter3.prototype.removeListener = function removeListener(event, fn, context, once9) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once9 || listeners.once) && (!context || listeners.context === context)) {
+          clearEvent(this, evt);
+        }
+      } else {
+        for (var i2 = 0, events = [], length = listeners.length; i2 < length; i2++) {
+          if (listeners[i2].fn !== fn || once9 && !listeners[i2].once || context && listeners[i2].context !== context) {
+            events.push(listeners[i2]);
+          }
+        }
+        if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+        else clearEvent(this, evt);
+      }
+      return this;
+    };
+    EventEmitter3.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt]) clearEvent(this, evt);
+      } else {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
+      return this;
+    };
+    EventEmitter3.prototype.off = EventEmitter3.prototype.removeListener;
+    EventEmitter3.prototype.addListener = EventEmitter3.prototype.on;
+    EventEmitter3.prefixed = prefix;
+    EventEmitter3.EventEmitter = EventEmitter3;
+    if ("undefined" !== typeof module) {
+      module.exports = EventEmitter3;
+    }
+  }
+});
+
 // ../../node_modules/.pnpm/tinyrainbow@1.2.0/node_modules/tinyrainbow/dist/node.js
 init_cjs_shims();
 
@@ -839,17 +1010,17 @@ var parseExpression = (expression) => {
   }
   throw new TypeError(`Unexpected "${typeOfExpression}" in template expression`);
 };
-var getSubprocessResult = ({ stdout }) => {
-  if (typeof stdout === "string") {
-    return stdout;
+var getSubprocessResult = ({ stdout: stdout2 }) => {
+  if (typeof stdout2 === "string") {
+    return stdout2;
   }
-  if (isUint8Array(stdout)) {
-    return uint8ArrayToString(stdout);
+  if (isUint8Array(stdout2)) {
+    return uint8ArrayToString(stdout2);
   }
-  if (stdout === void 0) {
+  if (stdout2 === void 0) {
     throw new TypeError(`Missing result.stdout in template expression. This is probably due to the previous subprocess' "stdout" option.`);
   }
-  throw new TypeError(`Unexpected "${typeof stdout}" stdout in template expression`);
+  throw new TypeError(`Unexpected "${typeof stdout2}" stdout in template expression`);
 };
 
 // ../../node_modules/.pnpm/execa@9.3.1/node_modules/execa/lib/methods/main-sync.js
@@ -871,9 +1042,9 @@ var _util = require('util');
 
 // ../../node_modules/.pnpm/execa@9.3.1/node_modules/execa/lib/utils/standard-stream.js
 init_cjs_shims();
-var _process2 = require('process'); var _process3 = _interopRequireDefault(_process2);
+var _process2 = require('process'); var process10 = _interopRequireWildcard(_process2);
 var isStandardStream = (stream) => STANDARD_STREAMS.includes(stream);
-var STANDARD_STREAMS = [_process3.default.stdin, _process3.default.stdout, _process3.default.stderr];
+var STANDARD_STREAMS = [process10.default.stdin, process10.default.stdout, process10.default.stderr];
 var STANDARD_STREAMS_ALIASES = ["stdin", "stdout", "stderr"];
 var getStreamName = (fdNumber) => _nullishCoalesce(STANDARD_STREAMS_ALIASES[fdNumber], () => ( `stdio[${fdNumber}]`));
 
@@ -1020,10 +1191,10 @@ init_cjs_shims();
 init_cjs_shims();
 
 function isUnicodeSupported() {
-  if (_process3.default.platform !== "win32") {
-    return _process3.default.env.TERM !== "linux";
+  if (process10.default.platform !== "win32") {
+    return process10.default.env.TERM !== "linux";
   }
-  return Boolean(_process3.default.env.WT_SESSION) || Boolean(_process3.default.env.TERMINUS_SUBLIME) || _process3.default.env.ConEmuTask === "{cmd::Cmder}" || _process3.default.env.TERM_PROGRAM === "Terminus-Sublime" || _process3.default.env.TERM_PROGRAM === "vscode" || _process3.default.env.TERM === "xterm-256color" || _process3.default.env.TERM === "alacritty" || _process3.default.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+  return Boolean(process10.default.env.WT_SESSION) || Boolean(process10.default.env.TERMINUS_SUBLIME) || process10.default.env.ConEmuTask === "{cmd::Cmder}" || process10.default.env.TERM_PROGRAM === "Terminus-Sublime" || process10.default.env.TERM_PROGRAM === "vscode" || process10.default.env.TERM === "xterm-256color" || process10.default.env.TERM === "alacritty" || process10.default.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
 }
 
 // ../../node_modules/.pnpm/figures@6.1.0/node_modules/figures/index.js
@@ -1550,10 +1721,10 @@ function pathKey(options = {}) {
 
 // ../../node_modules/.pnpm/npm-run-path@5.3.0/node_modules/npm-run-path/index.js
 var npmRunPath = ({
-  cwd = _process3.default.cwd(),
-  path: pathOption = _process3.default.env[pathKey()],
+  cwd = process10.default.cwd(),
+  path: pathOption = process10.default.env[pathKey()],
   preferLocal = true,
-  execPath: execPath2 = _process3.default.execPath,
+  execPath: execPath2 = process10.default.execPath,
   addExecPath = true
 } = {}) => {
   const cwdString = cwd instanceof URL ? _url.fileURLToPath.call(void 0, cwd) : cwd;
@@ -1579,7 +1750,7 @@ var applyExecPath = (result, execPath2, cwdPath) => {
   const execPathString = execPath2 instanceof URL ? _url.fileURLToPath.call(void 0, execPath2) : execPath2;
   result.push(_path2.default.resolve(cwdPath, execPathString, ".."));
 };
-var npmRunPathEnv = ({ env = _process3.default.env, ...options } = {}) => {
+var npmRunPathEnv = ({ env = process10.default.env, ...options } = {}) => {
   env = { ...env };
   const pathName = pathKey({ env });
   options.path = env[pathName];
@@ -2115,10 +2286,10 @@ init_cjs_shims();
 
 // ../../node_modules/.pnpm/execa@9.3.1/node_modules/execa/lib/utils/abort-signal.js
 init_cjs_shims();
-var _events = require('events');
+var _events2 = require('events');
 var onAbortedSignal = async (mainSignal, stopSignal) => {
   if (!mainSignal.aborted) {
-    await _events.once.call(void 0, mainSignal, "abort", { signal: stopSignal });
+    await _events2.once.call(void 0, mainSignal, "abort", { signal: stopSignal });
   }
 };
 
@@ -2292,13 +2463,13 @@ var getInvalidStdioOptionMessage = (fdNumber, fdName, options, isWritable) => {
   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 }) => {
+var getInvalidStdioOption = (fdNumber, { stdin, stdout: stdout2, 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 === 1 && stdout2 !== void 0) {
+    return { optionName: "stdout", optionValue: stdout2 };
   }
   if (usedDescriptor === 2 && stderr !== void 0) {
     return { optionName: "stderr", optionValue: stderr };
@@ -2327,7 +2498,7 @@ var incrementMaxListeners = (eventEmitter, maxListenersIncrement, signal) => {
     return;
   }
   eventEmitter.setMaxListeners(maxListeners + maxListenersIncrement);
-  _events.addAbortListener.call(void 0, signal, () => {
+  _events2.addAbortListener.call(void 0, signal, () => {
     eventEmitter.setMaxListeners(eventEmitter.getMaxListeners() - maxListenersIncrement);
   });
 };
@@ -2404,7 +2575,7 @@ var onDisconnect = async ({ anyProcess, channel, isSubprocess, ipcEmitter, bound
   abortOnDisconnect();
   const incomingMessages = INCOMING_MESSAGES.get(anyProcess);
   while (_optionalChain([incomingMessages, 'optionalAccess', _6 => _6.length]) > 0) {
-    await _events.once.call(void 0, ipcEmitter, "message:done");
+    await _events2.once.call(void 0, ipcEmitter, "message:done");
   }
   anyProcess.removeListener("message", boundOnMessage);
   redoAddedReferences(channel, isSubprocess);
@@ -2418,7 +2589,7 @@ var getIpcEmitter = (anyProcess, channel, isSubprocess) => {
   if (IPC_EMITTERS.has(anyProcess)) {
     return IPC_EMITTERS.get(anyProcess);
   }
-  const ipcEmitter = new (0, _events.EventEmitter)();
+  const ipcEmitter = new (0, _events2.EventEmitter)();
   ipcEmitter.connected = true;
   IPC_EMITTERS.set(anyProcess, ipcEmitter);
   forwardEvents({
@@ -2529,7 +2700,7 @@ var waitForStrictResponse = async (wrappedMessage, anyProcess, isSubprocess) =>
 var STRICT_RESPONSES = {};
 var throwOnDisconnect = async (anyProcess, isSubprocess, { signal }) => {
   incrementMaxListeners(anyProcess, 1, signal);
-  await _events.once.call(void 0, anyProcess, "disconnect", { signal });
+  await _events2.once.call(void 0, anyProcess, "disconnect", { signal });
   throwOnStrictDisconnect(isSubprocess);
 };
 var REQUEST_TYPE = "execa:ipc:request";
@@ -2888,7 +3059,7 @@ var normalizeCwd = (cwd = getDefaultCwd()) => {
 };
 var getDefaultCwd = () => {
   try {
-    return _process3.default.cwd();
+    return process10.default.cwd();
   } catch (error) {
     error.message = `The current directory does not exist.
 ${error.message}`;
@@ -2931,7 +3102,7 @@ var normalizeOptions = (filePath, rawArguments, rawOptions) => {
   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 (_process3.default.platform === "win32" && _path2.default.basename(file, ".exe") === "cmd") {
+  if (process10.default.platform === "win32" && _path2.default.basename(file, ".exe") === "cmd") {
     commandArguments.unshift("/q");
   }
   return { file, commandArguments, options };
@@ -2972,7 +3143,7 @@ var addDefaultOptions = ({
   serialization
 });
 var getEnv = ({ env: envOption, extendEnv, preferLocal, node, localDirectory, nodePath }) => {
-  const env = extendEnv ? { ..._process3.default.env, ...envOption } : envOption;
+  const env = extendEnv ? { ...process10.default.env, ...envOption } : envOption;
   if (preferLocal || node) {
     return npmRunPathEnv({
       env,
@@ -3410,7 +3581,7 @@ var stringMethods = {
 };
 
 // ../../node_modules/.pnpm/get-stream@9.0.1/node_modules/get-stream/source/index.js
-Object.assign(nodeImports, { on: _events.on, finished: _promises3.finished });
+Object.assign(nodeImports, { on: _events2.on, finished: _promises3.finished });
 
 // ../../node_modules/.pnpm/execa@9.3.1/node_modules/execa/lib/io/max-buffer.js
 var handleMaxBuffer = ({ error, stream, readableObjectMode, lines, encoding, fdNumber }) => {
@@ -4231,10 +4402,10 @@ var guessStreamDirection = {
   }
 };
 var getStandardStreamDirection = (value) => {
-  if ([0, _process3.default.stdin].includes(value)) {
+  if ([0, process10.default.stdin].includes(value)) {
     return "input";
   }
-  if ([1, 2, _process3.default.stdout, _process3.default.stderr].includes(value)) {
+  if ([1, 2, process10.default.stdout, process10.default.stderr].includes(value)) {
     return "output";
   }
 };
@@ -5145,26 +5316,26 @@ var writeToFiles = (serializedResult, stdioItems, outputFiles) => {
 
 // ../../node_modules/.pnpm/execa@9.3.1/node_modules/execa/lib/resolve/all-sync.js
 init_cjs_shims();
-var getAllSync = ([, stdout, stderr], options) => {
+var getAllSync = ([, stdout2, stderr], options) => {
   if (!options.all) {
     return;
   }
-  if (stdout === void 0) {
+  if (stdout2 === void 0) {
     return stderr;
   }
   if (stderr === void 0) {
-    return stdout;
+    return stdout2;
   }
-  if (Array.isArray(stdout)) {
-    return Array.isArray(stderr) ? [...stdout, ...stderr] : [...stdout, stripNewline(stderr, options, "all")];
+  if (Array.isArray(stdout2)) {
+    return Array.isArray(stderr) ? [...stdout2, ...stderr] : [...stdout2, stripNewline(stderr, options, "all")];
   }
   if (Array.isArray(stderr)) {
-    return [stripNewline(stdout, options, "all"), ...stderr];
+    return [stripNewline(stdout2, options, "all"), ...stderr];
   }
-  if (isUint8Array(stdout) && isUint8Array(stderr)) {
-    return concatUint8Arrays([stdout, stderr]);
+  if (isUint8Array(stdout2) && isUint8Array(stderr)) {
+    return concatUint8Arrays([stdout2, stderr]);
   }
-  return `${stdout}${stderr}`;
+  return `${stdout2}${stderr}`;
 };
 
 // ../../node_modules/.pnpm/execa@9.3.1/node_modules/execa/lib/resolve/exit-sync.js
@@ -5180,8 +5351,8 @@ var waitForExit = async (subprocess, context) => {
 };
 var waitForExitOrError = async (subprocess) => {
   const [spawnPayload, exitPayload] = await Promise.allSettled([
-    _events.once.call(void 0, subprocess, "spawn"),
-    _events.once.call(void 0, subprocess, "exit")
+    _events2.once.call(void 0, subprocess, "spawn"),
+    _events2.once.call(void 0, subprocess, "exit")
   ]);
   if (spawnPayload.status === "rejected") {
     return [];
@@ -5190,7 +5361,7 @@ var waitForExitOrError = async (subprocess) => {
 };
 var waitForSubprocessExit = async (subprocess) => {
   try {
-    return await _events.once.call(void 0, subprocess, "exit");
+    return await _events2.once.call(void 0, subprocess, "exit");
   } catch (e4) {
     return waitForSubprocessExit(subprocess);
   }
@@ -5404,21 +5575,21 @@ var getOneMessageAsync = async ({ anyProcess, channel, isSubprocess, filter, ref
 };
 var getMessage = async (ipcEmitter, filter, { signal }) => {
   if (filter === void 0) {
-    const [message] = await _events.once.call(void 0, ipcEmitter, "message", { signal });
+    const [message] = await _events2.once.call(void 0, ipcEmitter, "message", { signal });
     return message;
   }
-  for await (const [message] of _events.on.call(void 0, ipcEmitter, "message", { signal })) {
+  for await (const [message] of _events2.on.call(void 0, ipcEmitter, "message", { signal })) {
     if (filter(message)) {
       return message;
     }
   }
 };
 var throwOnDisconnect2 = async (ipcEmitter, isSubprocess, { signal }) => {
-  await _events.once.call(void 0, ipcEmitter, "disconnect", { signal });
+  await _events2.once.call(void 0, ipcEmitter, "disconnect", { signal });
   throwOnEarlyDisconnect(isSubprocess);
 };
 var throwOnStrictError = async (ipcEmitter, isSubprocess, { signal }) => {
-  const [error] = await _events.once.call(void 0, ipcEmitter, "strict:error", { signal });
+  const [error] = await _events2.once.call(void 0, ipcEmitter, "strict:error", { signal });
   throw getStrictResponseError(error, isSubprocess);
 };
 
@@ -5464,14 +5635,14 @@ var loopOnMessages = ({ anyProcess, channel, isSubprocess, ipc, shouldAwait, ref
 };
 var stopOnDisconnect = async (anyProcess, ipcEmitter, controller) => {
   try {
-    await _events.once.call(void 0, ipcEmitter, "disconnect", { signal: controller.signal });
+    await _events2.once.call(void 0, ipcEmitter, "disconnect", { signal: controller.signal });
     controller.abort();
   } catch (e5) {
   }
 };
 var abortOnStrictError = async ({ ipcEmitter, isSubprocess, controller, state }) => {
   try {
-    const [error] = await _events.once.call(void 0, ipcEmitter, "strict:error", { signal: controller.signal });
+    const [error] = await _events2.once.call(void 0, ipcEmitter, "strict:error", { signal: controller.signal });
     state.error = getStrictResponseError(error, isSubprocess);
     controller.abort();
   } catch (e6) {
@@ -5479,7 +5650,7 @@ var abortOnStrictError = async ({ ipcEmitter, isSubprocess, controller, state })
 };
 var iterateOnMessages = async function* ({ anyProcess, channel, ipcEmitter, isSubprocess, shouldAwait, controller, state, reference }) {
   try {
-    for await (const [message] of _events.on.call(void 0, ipcEmitter, "message", { signal: controller.signal })) {
+    for await (const [message] of _events2.on.call(void 0, ipcEmitter, "message", { signal: controller.signal })) {
       throwIfStrictError(state);
       yield message;
     }
@@ -5507,9 +5678,9 @@ var addIpcMethods = (subprocess, { ipc }) => {
   Object.assign(subprocess, getIpcMethods(subprocess, false, ipc));
 };
 var getIpcExport = () => {
-  const anyProcess = _process3.default;
+  const anyProcess = process10.default;
   const isSubprocess = true;
-  const ipc = _process3.default.channel !== void 0;
+  const ipc = process10.default.channel !== void 0;
   return {
     ...getIpcMethods(anyProcess, isSubprocess, ipc),
     getCancelSignal: getCancelSignal.bind(void 0, {
@@ -5569,14 +5740,14 @@ var handleEarlyError = ({ error, command, escapedCommand, fileDescriptors, optio
 };
 var createDummyStreams = (subprocess, fileDescriptors) => {
   const stdin = createDummyStream();
-  const stdout = createDummyStream();
+  const stdout2 = createDummyStream();
   const stderr = createDummyStream();
   const extraStdio = Array.from({ length: fileDescriptors.length - 3 }, createDummyStream);
   const all = createDummyStream();
-  const stdio = [stdin, stdout, stderr, ...extraStdio];
+  const stdio = [stdin, stdout2, stderr, ...extraStdio];
   Object.assign(subprocess, {
     stdin,
-    stdout,
+    stdout: stdout2,
     stderr,
     all,
     stdio
@@ -5749,7 +5920,7 @@ var onMergedStreamEnd = async (passThroughStream, { signal }) => {
   }
 };
 var onInputStreamsUnpipe = async (passThroughStream, streams, unpipeEvent, { signal }) => {
-  for await (const [unpipedStream] of _events.on.call(void 0, passThroughStream, "unpipe", { signal })) {
+  for await (const [unpipedStream] of _events2.on.call(void 0, passThroughStream, "unpipe", { signal })) {
     if (streams.has(unpipedStream)) {
       unpipedStream.emit(unpipeEvent);
     }
@@ -5830,9 +6001,9 @@ var onInputStreamEnd = async ({ passThroughStream, stream, streams, ended, abort
   }
 };
 var onInputStreamUnpipe = async ({ stream, streams, ended, aborted: aborted2, unpipeEvent, controller: { signal } }) => {
-  await _events.once.call(void 0, stream, unpipeEvent, { signal });
+  await _events2.once.call(void 0, stream, unpipeEvent, { signal });
   if (!stream.readable) {
-    return _events.once.call(void 0, signal, "abort", { signal });
+    return _events2.once.call(void 0, signal, "abort", { signal });
   }
   streams.delete(stream);
   ended.delete(stream);
@@ -5997,7 +6168,7 @@ if (process.platform === "linux") {
 }
 
 // ../../node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js
-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 processOk = (process11) => !!process11 && typeof process11 === "object" && typeof process11.removeListener === "function" && typeof process11.emit === "function" && typeof process11.reallyExit === "function" && typeof process11.listeners === "function" && typeof process11.kill === "function" && typeof process11.pid === "number" && typeof process11.on === "function";
 var kExitEmitter = Symbol.for("signal-exit emitter");
 var global2 = globalThis;
 var ObjectDefineProperty = Object.defineProperty.bind(Object);
@@ -6080,7 +6251,7 @@ var SignalExitFallback = class extends SignalExitBase {
 };
 var _hupSig, _emitter, _process, _originalProcessEmit, _originalProcessReallyExit, _sigListeners, _loaded, _SignalExit_instances, processReallyExit_fn, processEmit_fn;
 var SignalExit = class extends SignalExitBase {
-  constructor(process10) {
+  constructor(process11) {
     super();
     __privateAdd(this, _SignalExit_instances);
     // "SIGHUP" throws an `ENOSYS` error on Windows,
@@ -6094,13 +6265,13 @@ var SignalExit = class extends SignalExitBase {
     __privateAdd(this, _originalProcessReallyExit);
     __privateAdd(this, _sigListeners, {});
     __privateAdd(this, _loaded, false);
-    __privateSet(this, _process, process10);
+    __privateSet(this, _process, process11);
     __privateSet(this, _sigListeners, {});
     for (const sig of signals) {
       __privateGet(this, _sigListeners)[sig] = () => {
         const listeners = __privateGet(this, _process).listeners(sig);
         let { count: count2 } = __privateGet(this, _emitter);
-        const p3 = process10;
+        const p3 = process11;
         if (typeof p3.__signal_exit_emitter__ === "object" && typeof p3.__signal_exit_emitter__.count === "number") {
           count2 += p3.__signal_exit_emitter__.count;
         }
@@ -6109,12 +6280,12 @@ var SignalExit = class extends SignalExitBase {
           const ret = __privateGet(this, _emitter).emit("exit", null, sig);
           const s = sig === "SIGHUP" ? __privateGet(this, _hupSig) : sig;
           if (!ret)
-            process10.kill(process10.pid, s);
+            process11.kill(process11.pid, s);
         }
       };
     }
-    __privateSet(this, _originalProcessReallyExit, process10.reallyExit);
-    __privateSet(this, _originalProcessEmit, process10.emit);
+    __privateSet(this, _originalProcessReallyExit, process11.reallyExit);
+    __privateSet(this, _originalProcessEmit, process11.emit);
   }
   onExit(cb, opts) {
     if (!processOk(__privateGet(this, _process))) {
@@ -6241,7 +6412,7 @@ var cleanupOnExit = (subprocess, { cleanup, detached }, { signal }) => {
   const removeExitHandler = onExit(() => {
     subprocess.kill();
   });
-  _events.addAbortListener.call(void 0, signal, () => {
+  _events2.addAbortListener.call(void 0, signal, () => {
     removeExitHandler();
   });
 };
@@ -6558,7 +6729,7 @@ var stopReadingOnStreamEnd = async (onStreamEnd, controller, stream) => {
   }
 };
 var iterateOnStream = ({ stream, controller, binary, shouldEncode, encoding, shouldSplit, preserveNewlines }) => {
-  const onStdoutChunk = _events.on.call(void 0, stream, "data", {
+  const onStdoutChunk = _events2.on.call(void 0, stream, "data", {
     signal: controller.signal,
     highWaterMark: HIGH_WATER_MARK,
     // Backward compatibility with older name for this option
@@ -6790,7 +6961,7 @@ var waitForSubprocessStream = async ({ stream, fdNumber, encoding, buffer, maxBu
 };
 
 // ../../node_modules/.pnpm/execa@9.3.1/node_modules/execa/lib/resolve/all-async.js
-var makeAllStream = ({ stdout, stderr }, { all }) => all && (stdout || stderr) ? mergeStreams([stdout, stderr].filter(Boolean)) : void 0;
+var makeAllStream = ({ stdout: stdout2, stderr }, { all }) => all && (stdout2 || stderr) ? mergeStreams([stdout2, stderr].filter(Boolean)) : void 0;
 var waitForAllStream = ({ subprocess, encoding, buffer, maxBuffer, lines, stripFinalNewline: stripFinalNewline2, verboseInfo, streamInfo }) => waitForSubprocessStream({
   ...getAllStream(subprocess, buffer),
   fdNumber: "all",
@@ -6802,7 +6973,7 @@ var waitForAllStream = ({ subprocess, encoding, buffer, maxBuffer, lines, stripF
   verboseInfo,
   streamInfo
 });
-var getAllStream = ({ stdout, stderr, all }, [, bufferStdout, bufferStderr]) => {
+var getAllStream = ({ stdout: stdout2, stderr, all }, [, bufferStdout, bufferStderr]) => {
   const buffer = bufferStdout || bufferStderr;
   if (!buffer) {
     return { stream: all, buffer };
@@ -6811,11 +6982,11 @@ var getAllStream = ({ stdout, stderr, all }, [, bufferStdout, bufferStderr]) =>
     return { stream: stderr, buffer };
   }
   if (!bufferStderr) {
-    return { stream: stdout, buffer };
+    return { stream: stdout2, buffer };
   }
   return { stream: all, buffer };
 };
-var getAllMixed = ({ all, stdout, stderr }) => all && stdout && stderr && stdout.readableObjectMode !== stderr.readableObjectMode;
+var getAllMixed = ({ all, stdout: stdout2, stderr }) => all && stdout2 && stderr && stdout2.readableObjectMode !== stderr.readableObjectMode;
 
 // ../../node_modules/.pnpm/execa@9.3.1/node_modules/execa/lib/resolve/wait-subprocess.js
 init_cjs_shims();
@@ -6987,7 +7158,7 @@ var waitForCustomStreamsEnd = (fileDescriptors, streamInfo) => fileDescriptors.f
   stopOnExit: type === "native"
 })));
 var throwOnSubprocessError = async (subprocess, { signal }) => {
-  const [error] = await _events.once.call(void 0, subprocess, "error", { signal });
+  const [error] = await _events2.once.call(void 0, subprocess, "error", { signal });
   throw error;
 };
 
@@ -7390,7 +7561,7 @@ var spawnSubprocessAsync = ({ file, commandArguments, options, startTime, verbos
     });
   }
   const controller = new AbortController();
-  _events.setMaxListeners.call(void 0, Number.POSITIVE_INFINITY, controller.signal);
+  _events2.setMaxListeners.call(void 0, Number.POSITIVE_INFINITY, controller.signal);
   const originalStreams = [...subprocess.stdio];
   pipeOutputAsync(subprocess, fileDescriptors, controller);
   cleanupOnExit(subprocess, options, controller);
@@ -7619,6 +7790,7 @@ var _stringargv = require('string-argv');
 // src/utils/Writables.ts
 init_cjs_shims();
 
+
 var ConsolaWritable = class extends _stream.Writable {
   constructor(consola, command, opts) {
     super(opts);
@@ -7626,49 +7798,501 @@ var ConsolaWritable = class extends _stream.Writable {
     this.consola = consola;
   }
   _write(chunk, _encoding, callback) {
-    if (this.command) {
-      this.consola.log(`${p2.bold(p2.blue(this.command))}: ${_optionalChain([chunk, 'optionalAccess', _38 => _38.toString, 'call', _39 => _39()])}`);
-    } else {
-      this.consola.log(`${p2.bold(p2.blue(this.command))}: ${_optionalChain([chunk, 'optionalAccess', _40 => _40.toString, 'call', _41 => _41()])}`);
-    }
+    process10.stdout.write(`${p2.dim(_optionalChain([chunk, 'optionalAccess', _38 => _38.toString, 'call', _39 => _39()]))}`);
     callback();
   }
 };
 
 // src/utils/executeHooks.ts
 
+
+// ../../node_modules/.pnpm/p-queue@8.0.1/node_modules/p-queue/dist/index.js
+init_cjs_shims();
+
+// ../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.mjs
+init_cjs_shims();
+var import_index = __toESM(require_eventemitter3(), 1);
+
+// ../../node_modules/.pnpm/p-timeout@6.1.2/node_modules/p-timeout/index.js
+init_cjs_shims();
+var TimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+var AbortError = class extends Error {
+  constructor(message) {
+    super();
+    this.name = "AbortError";
+    this.message = message;
+  }
+};
+var getDOMException = (errorMessage) => globalThis.DOMException === void 0 ? new AbortError(errorMessage) : new DOMException(errorMessage);
+var getAbortedReason = (signal) => {
+  const reason = signal.reason === void 0 ? getDOMException("This operation was aborted.") : signal.reason;
+  return reason instanceof Error ? reason : getDOMException(reason);
+};
+function pTimeout(promise, options) {
+  const {
+    milliseconds,
+    fallback,
+    message,
+    customTimers = { setTimeout, clearTimeout }
+  } = options;
+  let timer;
+  const wrappedPromise = new Promise((resolve2, reject) => {
+    if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
+      throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
+    }
+    if (options.signal) {
+      const { signal } = options;
+      if (signal.aborted) {
+        reject(getAbortedReason(signal));
+      }
+      signal.addEventListener("abort", () => {
+        reject(getAbortedReason(signal));
+      });
+    }
+    if (milliseconds === Number.POSITIVE_INFINITY) {
+      promise.then(resolve2, reject);
+      return;
+    }
+    const timeoutError = new TimeoutError();
+    timer = customTimers.setTimeout.call(void 0, () => {
+      if (fallback) {
+        try {
+          resolve2(fallback());
+        } catch (error) {
+          reject(error);
+        }
+        return;
+      }
+      if (typeof promise.cancel === "function") {
+        promise.cancel();
+      }
+      if (message === false) {
+        resolve2();
+      } else if (message instanceof Error) {
+        reject(message);
+      } else {
+        timeoutError.message = _nullishCoalesce(message, () => ( `Promise timed out after ${milliseconds} milliseconds`));
+        reject(timeoutError);
+      }
+    }, milliseconds);
+    (async () => {
+      try {
+        resolve2(await promise);
+      } catch (error) {
+        reject(error);
+      }
+    })();
+  });
+  const cancelablePromise = wrappedPromise.finally(() => {
+    cancelablePromise.clear();
+  });
+  cancelablePromise.clear = () => {
+    customTimers.clearTimeout.call(void 0, timer);
+    timer = void 0;
+  };
+  return cancelablePromise;
+}
+
+// ../../node_modules/.pnpm/p-queue@8.0.1/node_modules/p-queue/dist/priority-queue.js
+init_cjs_shims();
+
+// ../../node_modules/.pnpm/p-queue@8.0.1/node_modules/p-queue/dist/lower-bound.js
+init_cjs_shims();
+function lowerBound(array, value, comparator) {
+  let first = 0;
+  let count2 = array.length;
+  while (count2 > 0) {
+    const step = Math.trunc(count2 / 2);
+    let it = first + step;
+    if (comparator(array[it], value) <= 0) {
+      first = ++it;
+      count2 -= step + 1;
+    } else {
+      count2 = step;
+    }
+  }
+  return first;
+}
+
+// ../../node_modules/.pnpm/p-queue@8.0.1/node_modules/p-queue/dist/priority-queue.js
+var _queue;
+var PriorityQueue = class {
+  constructor() {
+    __privateAdd(this, _queue, []);
+  }
+  enqueue(run, options) {
+    options = {
+      priority: 0,
+      ...options
+    };
+    const element = {
+      priority: options.priority,
+      run
+    };
+    if (this.size && __privateGet(this, _queue)[this.size - 1].priority >= options.priority) {
+      __privateGet(this, _queue).push(element);
+      return;
+    }
+    const index = lowerBound(__privateGet(this, _queue), element, (a3, b) => b.priority - a3.priority);
+    __privateGet(this, _queue).splice(index, 0, element);
+  }
+  dequeue() {
+    const item = __privateGet(this, _queue).shift();
+    return _optionalChain([item, 'optionalAccess', _40 => _40.run]);
+  }
+  filter(options) {
+    return __privateGet(this, _queue).filter((element) => element.priority === options.priority).map((element) => element.run);
+  }
+  get size() {
+    return __privateGet(this, _queue).length;
+  }
+};
+_queue = new WeakMap();
+
+// ../../node_modules/.pnpm/p-queue@8.0.1/node_modules/p-queue/dist/index.js
+var _carryoverConcurrencyCount, _isIntervalIgnored, _intervalCount, _intervalCap, _interval, _intervalEnd, _intervalId, _timeoutId, _queue2, _queueClass, _pending, _concurrency, _isPaused, _throwOnTimeout, _PQueue_instances, doesIntervalAllowAnother_get, doesConcurrentAllowAnother_get, next_fn, onResumeInterval_fn, isIntervalPaused_get, tryToStartAnother_fn, initializeIntervalIfNeeded_fn, onInterval_fn, processQueue_fn, throwOnAbort_fn, onEvent_fn;
+var PQueue = class extends import_index.default {
+  // TODO: The `throwOnTimeout` option should affect the return types of `add()` and `addAll()`
+  constructor(options) {
+    super();
+    __privateAdd(this, _PQueue_instances);
+    __privateAdd(this, _carryoverConcurrencyCount);
+    __privateAdd(this, _isIntervalIgnored);
+    __privateAdd(this, _intervalCount, 0);
+    __privateAdd(this, _intervalCap);
+    __privateAdd(this, _interval);
+    __privateAdd(this, _intervalEnd, 0);
+    __privateAdd(this, _intervalId);
+    __privateAdd(this, _timeoutId);
+    __privateAdd(this, _queue2);
+    __privateAdd(this, _queueClass);
+    __privateAdd(this, _pending, 0);
+    // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194
+    __privateAdd(this, _concurrency);
+    __privateAdd(this, _isPaused);
+    __privateAdd(this, _throwOnTimeout);
+    /**
+        Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
+    
+        Applies to each future operation.
+        */
+    __publicField(this, "timeout");
+    options = {
+      carryoverConcurrencyCount: false,
+      intervalCap: Number.POSITIVE_INFINITY,
+      interval: 0,
+      concurrency: Number.POSITIVE_INFINITY,
+      autoStart: true,
+      queueClass: PriorityQueue,
+      ...options
+    };
+    if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
+      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${_nullishCoalesce(_optionalChain([options, 'access', _41 => _41.intervalCap, 'optionalAccess', _42 => _42.toString, 'call', _43 => _43()]), () => ( ""))}\` (${typeof options.intervalCap})`);
+    }
+    if (options.interval === void 0 || !(Number.isFinite(options.interval) && options.interval >= 0)) {
+      throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${_nullishCoalesce(_optionalChain([options, 'access', _44 => _44.interval, 'optionalAccess', _45 => _45.toString, 'call', _46 => _46()]), () => ( ""))}\` (${typeof options.interval})`);
+    }
+    __privateSet(this, _carryoverConcurrencyCount, options.carryoverConcurrencyCount);
+    __privateSet(this, _isIntervalIgnored, options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0);
+    __privateSet(this, _intervalCap, options.intervalCap);
+    __privateSet(this, _interval, options.interval);
+    __privateSet(this, _queue2, new options.queueClass());
+    __privateSet(this, _queueClass, options.queueClass);
+    this.concurrency = options.concurrency;
+    this.timeout = options.timeout;
+    __privateSet(this, _throwOnTimeout, options.throwOnTimeout === true);
+    __privateSet(this, _isPaused, options.autoStart === false);
+  }
+  get concurrency() {
+    return __privateGet(this, _concurrency);
+  }
+  set concurrency(newConcurrency) {
+    if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) {
+      throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
+    }
+    __privateSet(this, _concurrency, newConcurrency);
+    __privateMethod(this, _PQueue_instances, processQueue_fn).call(this);
+  }
+  async add(function_, options = {}) {
+    options = {
+      timeout: this.timeout,
+      throwOnTimeout: __privateGet(this, _throwOnTimeout),
+      ...options
+    };
+    return new Promise((resolve2, reject) => {
+      __privateGet(this, _queue2).enqueue(async () => {
+        __privateWrapper(this, _pending)._++;
+        __privateWrapper(this, _intervalCount)._++;
+        try {
+          _optionalChain([options, 'access', _47 => _47.signal, 'optionalAccess', _48 => _48.throwIfAborted, 'call', _49 => _49()]);
+          let operation = function_({ signal: options.signal });
+          if (options.timeout) {
+            operation = pTimeout(Promise.resolve(operation), { milliseconds: options.timeout });
+          }
+          if (options.signal) {
+            operation = Promise.race([operation, __privateMethod(this, _PQueue_instances, throwOnAbort_fn).call(this, options.signal)]);
+          }
+          const result = await operation;
+          resolve2(result);
+          this.emit("completed", result);
+        } catch (error) {
+          if (error instanceof TimeoutError && !options.throwOnTimeout) {
+            resolve2();
+            return;
+          }
+          reject(error);
+          this.emit("error", error);
+        } finally {
+          __privateMethod(this, _PQueue_instances, next_fn).call(this);
+        }
+      }, options);
+      this.emit("add");
+      __privateMethod(this, _PQueue_instances, tryToStartAnother_fn).call(this);
+    });
+  }
+  async addAll(functions, options) {
+    return Promise.all(functions.map(async (function_) => this.add(function_, options)));
+  }
+  /**
+  Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
+  */
+  start() {
+    if (!__privateGet(this, _isPaused)) {
+      return this;
+    }
+    __privateSet(this, _isPaused, false);
+    __privateMethod(this, _PQueue_instances, processQueue_fn).call(this);
+    return this;
+  }
+  /**
+  Put queue execution on hold.
+  */
+  pause() {
+    __privateSet(this, _isPaused, true);
+  }
+  /**
+  Clear the queue.
+  */
+  clear() {
+    __privateSet(this, _queue2, new (__privateGet(this, _queueClass))());
+  }
+  /**
+      Can be called multiple times. Useful if you for example add additional items at a later time.
+  
+      @returns A promise that settles when the queue becomes empty.
+      */
+  async onEmpty() {
+    if (__privateGet(this, _queue2).size === 0) {
+      return;
+    }
+    await __privateMethod(this, _PQueue_instances, onEvent_fn).call(this, "empty");
+  }
+  /**
+      @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.
+  
+      If you want to avoid having the queue grow beyond a certain size you can `await queue.onSizeLessThan()` before adding a new item.
+  
+      Note that this only limits the number of items waiting to start. There could still be up to `concurrency` jobs already running that this call does not include in its calculation.
+      */
+  async onSizeLessThan(limit) {
+    if (__privateGet(this, _queue2).size < limit) {
+      return;
+    }
+    await __privateMethod(this, _PQueue_instances, onEvent_fn).call(this, "next", () => __privateGet(this, _queue2).size < limit);
+  }
+  /**
+      The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
+  
+      @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
+      */
+  async onIdle() {
+    if (__privateGet(this, _pending) === 0 && __privateGet(this, _queue2).size === 0) {
+      return;
+    }
+    await __privateMethod(this, _PQueue_instances, onEvent_fn).call(this, "idle");
+  }
+  /**
+  Size of the queue, the number of queued items waiting to run.
+  */
+  get size() {
+    return __privateGet(this, _queue2).size;
+  }
+  /**
+      Size of the queue, filtered by the given options.
+  
+      For example, this can be used to find the number of items remaining in the queue with a specific priority level.
+      */
+  sizeBy(options) {
+    return __privateGet(this, _queue2).filter(options).length;
+  }
+  /**
+  Number of running items (no longer in the queue).
+  */
+  get pending() {
+    return __privateGet(this, _pending);
+  }
+  /**
+  Whether the queue is currently paused.
+  */
+  get isPaused() {
+    return __privateGet(this, _isPaused);
+  }
+};
+_carryoverConcurrencyCount = new WeakMap();
+_isIntervalIgnored = new WeakMap();
+_intervalCount = new WeakMap();
+_intervalCap = new WeakMap();
+_interval = new WeakMap();
+_intervalEnd = new WeakMap();
+_intervalId = new WeakMap();
+_timeoutId = new WeakMap();
+_queue2 = new WeakMap();
+_queueClass = new WeakMap();
+_pending = new WeakMap();
+_concurrency = new WeakMap();
+_isPaused = new WeakMap();
+_throwOnTimeout = new WeakMap();
+_PQueue_instances = new WeakSet();
+doesIntervalAllowAnother_get = function() {
+  return __privateGet(this, _isIntervalIgnored) || __privateGet(this, _intervalCount) < __privateGet(this, _intervalCap);
+};
+doesConcurrentAllowAnother_get = function() {
+  return __privateGet(this, _pending) < __privateGet(this, _concurrency);
+};
+next_fn = function() {
+  __privateWrapper(this, _pending)._--;
+  __privateMethod(this, _PQueue_instances, tryToStartAnother_fn).call(this);
+  this.emit("next");
+};
+onResumeInterval_fn = function() {
+  __privateMethod(this, _PQueue_instances, onInterval_fn).call(this);
+  __privateMethod(this, _PQueue_instances, initializeIntervalIfNeeded_fn).call(this);
+  __privateSet(this, _timeoutId, void 0);
+};
+isIntervalPaused_get = function() {
+  const now = Date.now();
+  if (__privateGet(this, _intervalId) === void 0) {
+    const delay = __privateGet(this, _intervalEnd) - now;
+    if (delay < 0) {
+      __privateSet(this, _intervalCount, __privateGet(this, _carryoverConcurrencyCount) ? __privateGet(this, _pending) : 0);
+    } else {
+      if (__privateGet(this, _timeoutId) === void 0) {
+        __privateSet(this, _timeoutId, setTimeout(() => {
+          __privateMethod(this, _PQueue_instances, onResumeInterval_fn).call(this);
+        }, delay));
+      }
+      return true;
+    }
+  }
+  return false;
+};
+tryToStartAnother_fn = function() {
+  if (__privateGet(this, _queue2).size === 0) {
+    if (__privateGet(this, _intervalId)) {
+      clearInterval(__privateGet(this, _intervalId));
+    }
+    __privateSet(this, _intervalId, void 0);
+    this.emit("empty");
+    if (__privateGet(this, _pending) === 0) {
+      this.emit("idle");
+    }
+    return false;
+  }
+  if (!__privateGet(this, _isPaused)) {
+    const canInitializeInterval = !__privateGet(this, _PQueue_instances, isIntervalPaused_get);
+    if (__privateGet(this, _PQueue_instances, doesIntervalAllowAnother_get) && __privateGet(this, _PQueue_instances, doesConcurrentAllowAnother_get)) {
+      const job = __privateGet(this, _queue2).dequeue();
+      if (!job) {
+        return false;
+      }
+      this.emit("active");
+      job();
+      if (canInitializeInterval) {
+        __privateMethod(this, _PQueue_instances, initializeIntervalIfNeeded_fn).call(this);
+      }
+      return true;
+    }
+  }
+  return false;
+};
+initializeIntervalIfNeeded_fn = function() {
+  if (__privateGet(this, _isIntervalIgnored) || __privateGet(this, _intervalId) !== void 0) {
+    return;
+  }
+  __privateSet(this, _intervalId, setInterval(() => {
+    __privateMethod(this, _PQueue_instances, onInterval_fn).call(this);
+  }, __privateGet(this, _interval)));
+  __privateSet(this, _intervalEnd, Date.now() + __privateGet(this, _interval));
+};
+onInterval_fn = function() {
+  if (__privateGet(this, _intervalCount) === 0 && __privateGet(this, _pending) === 0 && __privateGet(this, _intervalId)) {
+    clearInterval(__privateGet(this, _intervalId));
+    __privateSet(this, _intervalId, void 0);
+  }
+  __privateSet(this, _intervalCount, __privateGet(this, _carryoverConcurrencyCount) ? __privateGet(this, _pending) : 0);
+  __privateMethod(this, _PQueue_instances, processQueue_fn).call(this);
+};
+/**
+Executes all queued functions until it reaches the limit.
+*/
+processQueue_fn = function() {
+  while (__privateMethod(this, _PQueue_instances, tryToStartAnother_fn).call(this)) {
+  }
+};
+throwOnAbort_fn = async function(signal) {
+  return new Promise((_resolve, reject) => {
+    signal.addEventListener("abort", () => {
+      reject(signal.reason);
+    }, { once: true });
+  });
+};
+onEvent_fn = async function(event, filter) {
+  return new Promise((resolve2) => {
+    const listener = () => {
+      if (filter && !filter()) {
+        return;
+      }
+      this.off(event, listener);
+      resolve2();
+    };
+    this.on(event, listener);
+  });
+};
+
+// src/utils/executeHooks.ts
 async function executeHooks({ hooks, logger }) {
   const commands = Array.isArray(hooks.done) ? hooks.done : [hooks.done].filter(Boolean);
-  const executors = commands.map(async (command) => {
+  const queue = new PQueue({ concurrency: 1 });
+  const promises = commands.map(async (command) => {
     const consolaWritable = new ConsolaWritable(logger.consola, command);
-    const abortController = new AbortController();
     const [cmd, ..._args] = [..._stringargv.parseArgsStringToArgv.call(void 0, command)];
     if (!cmd) {
       return null;
     }
-    logger.emit("start", `Executing hook ${logger.logLevel !== _logger.LogMapper.silent ? p2.dim(command) : ""}`);
-    const subProcess = await execa(cmd, _args, {
-      detached: true,
-      cancelSignal: abortController.signal,
-      stdout: logger.logLevel === _logger.LogMapper.silent ? void 0 : ["pipe", consolaWritable]
+    await queue.add(async () => {
+      logger.emit("start", `Executing hook ${logger.logLevel !== _logger.LogMapper.silent ? p2.dim(command) : ""}`);
+      const subProcess = await execa(cmd, _args, {
+        detached: true,
+        stdout: logger.logLevel === _logger.LogMapper.silent ? void 0 : ["pipe", consolaWritable],
+        stripFinalNewline: true
+      });
+      logger.emit("success", `Executed hook ${logger.logLevel !== _logger.LogMapper.silent ? p2.dim(command) : ""}`);
     });
-    logger.emit("success", `Executing hook ${logger.logLevel !== _logger.LogMapper.silent ? p2.dim(command) : ""}`);
-    if (subProcess) {
-      logger.emit("info", `Executing hooks
- ${subProcess.stdout}`);
-    }
-    consolaWritable.destroy();
-    return { subProcess, abort: abortController.abort.bind(abortController) };
-  }).filter(Boolean);
-  await Promise.all(executors);
-  logger.emit("success", "Executing hooks");
+  });
+  await Promise.all(promises);
+  logger.emit("success", "Executed hooks");
 }
 
 // src/utils/getErrorCauses.ts
 init_cjs_shims();
 function getErrorCauses(errors) {
   return errors.reduce((prev, error) => {
-    const causedError = _optionalChain([error, 'optionalAccess', _42 => _42.cause]);
+    const causedError = _optionalChain([error, 'optionalAccess', _50 => _50.cause]);
     if (causedError) {
       prev = [...prev, ...getErrorCauses([causedError])];
       return prev;
@@ -7691,43 +8315,37 @@ function parseHrtimeToSeconds(hrtime2) {
 }
 
 // src/utils/getSummary.ts
-function getSummary({ pluginManager, status, hrStart, config, logger }) {
+function getSummary({ pluginManager, status, hrStart, config }) {
   const logs = [];
   const elapsedSeconds = parseHrtimeToSeconds(process.hrtime(hrStart));
   const buildStartPlugins = pluginManager.executed.filter((item) => item.hookName === "buildStart" && item.plugin.name !== "core").map((item) => item.plugin.name);
   const buildEndPlugins = pluginManager.executed.filter((item) => item.hookName === "buildEnd" && item.plugin.name !== "core").map((item) => item.plugin.name);
-  const failedPlugins = _optionalChain([config, 'access', _43 => _43.plugins, 'optionalAccess', _44 => _44.filter, 'call', _45 => _45((plugin) => !buildEndPlugins.includes(plugin.name)), 'optionalAccess', _46 => _46.map, 'call', _47 => _47((plugin) => plugin.name)]);
-  const pluginsCount = _optionalChain([config, 'access', _48 => _48.plugins, 'optionalAccess', _49 => _49.length]) || 0;
+  const failedPlugins = _optionalChain([config, 'access', _51 => _51.plugins, 'optionalAccess', _52 => _52.filter, 'call', _53 => _53((plugin) => !buildEndPlugins.includes(plugin.name)), 'optionalAccess', _54 => _54.map, 'call', _55 => _55((plugin) => plugin.name)]);
+  const pluginsCount = _optionalChain([config, 'access', _56 => _56.plugins, 'optionalAccess', _57 => _57.length]) || 0;
   const files = pluginManager.fileManager.files.sort((a3, b) => {
-    if (!_optionalChain([a3, 'access', _50 => _50.meta, 'optionalAccess', _51 => _51.pluginKey, 'optionalAccess', _52 => _52[0]]) || !_optionalChain([b, 'access', _53 => _53.meta, 'optionalAccess', _54 => _54.pluginKey, 'optionalAccess', _55 => _55[0]])) {
+    if (!_optionalChain([a3, 'access', _58 => _58.meta, 'optionalAccess', _59 => _59.pluginKey, 'optionalAccess', _60 => _60[0]]) || !_optionalChain([b, 'access', _61 => _61.meta, 'optionalAccess', _62 => _62.pluginKey, 'optionalAccess', _63 => _63[0]])) {
       return 0;
     }
-    if (_optionalChain([a3, 'access', _56 => _56.meta, 'optionalAccess', _57 => _57.pluginKey, 'optionalAccess', _58 => _58[0], 'optionalAccess', _59 => _59.length]) < _optionalChain([b, 'access', _60 => _60.meta, 'optionalAccess', _61 => _61.pluginKey, 'optionalAccess', _62 => _62[0], 'optionalAccess', _63 => _63.length])) {
+    if (_optionalChain([a3, 'access', _64 => _64.meta, 'optionalAccess', _65 => _65.pluginKey, 'optionalAccess', _66 => _66[0], 'optionalAccess', _67 => _67.length]) < _optionalChain([b, 'access', _68 => _68.meta, 'optionalAccess', _69 => _69.pluginKey, 'optionalAccess', _70 => _70[0], 'optionalAccess', _71 => _71.length])) {
       return 1;
     }
-    if (_optionalChain([a3, 'access', _64 => _64.meta, 'optionalAccess', _65 => _65.pluginKey, 'optionalAccess', _66 => _66[0], 'optionalAccess', _67 => _67.length]) > _optionalChain([b, 'access', _68 => _68.meta, 'optionalAccess', _69 => _69.pluginKey, 'optionalAccess', _70 => _70[0], 'optionalAccess', _71 => _71.length])) {
+    if (_optionalChain([a3, 'access', _72 => _72.meta, 'optionalAccess', _73 => _73.pluginKey, 'optionalAccess', _74 => _74[0], 'optionalAccess', _75 => _75.length]) > _optionalChain([b, 'access', _76 => _76.meta, 'optionalAccess', _77 => _77.pluginKey, 'optionalAccess', _78 => _78[0], 'optionalAccess', _79 => _79.length])) {
       return -1;
     }
     return 0;
   });
   const meta = {
-    plugins: status === "success" ? `${p2.green(`${buildStartPlugins.length} successful`)}, ${pluginsCount} total` : `${p2.red(`${_nullishCoalesce(_optionalChain([failedPlugins, 'optionalAccess', _72 => _72.length]), () => ( 1))} failed`)}, ${pluginsCount} total`,
-    pluginsFailed: status === "failed" ? _optionalChain([failedPlugins, 'optionalAccess', _73 => _73.map, 'call', _74 => _74((name) => _logger.randomCliColour.call(void 0, name)), 'optionalAccess', _75 => _75.join, 'call', _76 => _76(", ")]) : void 0,
+    plugins: status === "success" ? `${p2.green(`${buildStartPlugins.length} successful`)}, ${pluginsCount} total` : `${p2.red(`${_nullishCoalesce(_optionalChain([failedPlugins, 'optionalAccess', _80 => _80.length]), () => ( 1))} failed`)}, ${pluginsCount} total`,
+    pluginsFailed: status === "failed" ? _optionalChain([failedPlugins, 'optionalAccess', _81 => _81.map, 'call', _82 => _82((name) => _logger.randomCliColour.call(void 0, name)), 'optionalAccess', _83 => _83.join, 'call', _84 => _84(", ")]) : void 0,
     filesCreated: files.length,
-    time: `${p2.yellow(`${elapsedSeconds}s`)} - finished at ${p2.yellow((/* @__PURE__ */ new Date()).toLocaleString("en-GB", { timeZone: "UTC" }))}`,
+    time: `${p2.yellow(`${elapsedSeconds}s`)}`,
     output: _path2.default.isAbsolute(config.root) ? _path2.default.resolve(config.root, config.output.path) : config.root
   };
-  logger.emit("debug", ["\nGenerated files:\n"]);
-  logger.emit(
-    "debug",
-    files.map((file) => `${_logger.randomCliColour.call(void 0, JSON.stringify(_optionalChain([file, 'access', _77 => _77.meta, 'optionalAccess', _78 => _78.pluginKey])))} ${file.path}`)
-  );
   logs.push(
     [
       [`${p2.bold("Plugins:")}        ${meta.plugins}`, true],
       [`${p2.dim("Failed:")}          ${meta.pluginsFailed || "none"}`, !!meta.pluginsFailed],
-      [`${p2.bold("Generated:")}      ${meta.filesCreated} files`, true],
-      [`${p2.bold("Time:")}           ${meta.time}`, true],
+      [`${p2.bold("Generated:")}      ${meta.filesCreated} files in ${meta.time}`, true],
       [`${p2.bold("Output:")}         ${meta.output}`, true]
     ].map((item) => {
       if (item.at(1)) {
@@ -7743,17 +8361,20 @@ function getSummary({ pluginManager, status, hrStart, config, logger }) {
 init_cjs_shims();
 
 var _fs3 = require('@kubb/fs');
-async function writeLog(data) {
+async function writeLog({ data, override, fileName = "kubb.log" }) {
   if (data.trim() === "") {
     return void 0;
   }
-  const path6 = _path.resolve.call(void 0, process.cwd(), "kubb-log.log");
+  const path6 = _path.resolve.call(void 0, process.cwd(), fileName);
   let previousLogs = "";
   try {
     previousLogs = await _fs3.read.call(void 0, _path.resolve.call(void 0, path6));
   } catch (_err) {
   }
-  return _fs3.write.call(void 0, path6, [previousLogs, data.trim()].filter(Boolean).join("\n\n\n"), { sanity: false });
+  if (override) {
+    return _fs3.write.call(void 0, path6, data.trim(), { sanity: false });
+  }
+  return _fs3.write.call(void 0, path6, [previousLogs, data.trim()].filter(Boolean).join("\n"), { sanity: false });
 }
 
 // src/generate.ts
@@ -7765,12 +8386,41 @@ async function generate({ input, config, args }) {
     logLevel,
     name: config.name
   });
-  logger.on("debug", async (messages) => {
-    await writeLog(messages.join("\n"));
+  const progressBars = {};
+  logger.on("progress_start", ({ id, size }) => {
+    _optionalChain([logger, 'access', _85 => _85.consola, 'optionalAccess', _86 => _86.pauseLogs, 'call', _87 => _87()]);
+    if (!progressBars[id]) {
+      progressBars[id] = new (0, _cliprogress.SingleBar)(
+        {
+          format: logLevel === _logger.LogMapper.info ? "{percentage}% {bar} {value}/{total} {id} | {data}" : "{percentage}% {bar} ETA: {eta}s",
+          barsize: 25,
+          clearOnComplete: true
+        },
+        _cliprogress.Presets.shades_grey
+      );
+      progressBars[id].start(size, 1, { id, data: "" });
+    }
+  });
+  logger.on("progress_stop", ({ id }) => {
+    const progressBar = progressBars[id];
+    _optionalChain([progressBar, 'optionalAccess', _88 => _88.stop, 'call', _89 => _89()]);
+    _optionalChain([logger, 'access', _90 => _90.consola, 'optionalAccess', _91 => _91.resumeLogs, 'call', _92 => _92()]);
+  });
+  logger.on("progress", ({ id, count: count2, data = "" }) => {
+    const progressBar = progressBars[id];
+    const payload = { id, data };
+    if (count2) {
+      _optionalChain([progressBar, 'optionalAccess', _93 => _93.update, 'call', _94 => _94(count2, payload)]);
+    } else {
+      _optionalChain([progressBar, 'optionalAccess', _95 => _95.increment, 'call', _96 => _96(1, payload)]);
+    }
+  });
+  logger.on("debug", async ({ logs, override, fileName }) => {
+    await writeLog({ data: logs.join("\n"), fileName, override });
   });
   const { root = process.cwd(), ...userConfig } = config;
   const inputPath = _nullishCoalesce(input, () => ( ("path" in userConfig.input ? userConfig.input.path : void 0)));
-  logger.emit("start", `\u{1F680} Building ${logLevel !== _logger.LogMapper.silent ? p2.dim(inputPath) : ""}`);
+  logger.emit("start", `Building ${logLevel !== _logger.LogMapper.silent ? p2.dim(inputPath) : ""}`);
   const definedConfig = {
     root,
     ...userConfig,
@@ -7796,7 +8446,7 @@ async function generate({ input, config, args }) {
     logger
   });
   if (error && logger.consola) {
-    logger.consola.error(`\u{1F680} Build failed ${logLevel !== _logger.LogMapper.silent ? p2.dim(inputPath) : ""}`);
+    logger.consola.error(`Build failed ${logLevel !== _logger.LogMapper.silent ? p2.dim(inputPath) : ""}`);
     logger.consola.box({
       title: `${config.name || ""}`,
       message: summary.join(""),
@@ -7809,17 +8459,17 @@ async function generate({ input, config, args }) {
     const errors = getErrorCauses([error]);
     if (logger.consola && errors.length && logLevel === _logger.LogMapper.debug) {
       errors.forEach((err) => {
-        _optionalChain([logger, 'access', _79 => _79.consola, 'optionalAccess', _80 => _80.error, 'call', _81 => _81(err)]);
+        _optionalChain([logger, 'access', _97 => _97.consola, 'optionalAccess', _98 => _98.error, 'call', _99 => _99(err)]);
       });
     }
-    _optionalChain([logger, 'access', _82 => _82.consola, 'optionalAccess', _83 => _83.error, 'call', _84 => _84(error)]);
+    _optionalChain([logger, 'access', _100 => _100.consola, 'optionalAccess', _101 => _101.error, 'call', _102 => _102(error)]);
     process.exit(0);
   }
   if (config.hooks) {
     await executeHooks({ hooks: config.hooks, logger });
   }
-  _optionalChain([logger, 'access', _85 => _85.consola, 'optionalAccess', _86 => _86.success, 'call', _87 => _87(`\u{1F680} Build completed ${logLevel !== _logger.LogMapper.silent ? p2.dim(inputPath) : ""}`)]);
-  _optionalChain([logger, 'access', _88 => _88.consola, 'optionalAccess', _89 => _89.box, 'call', _90 => _90({
+  _optionalChain([logger, 'access', _103 => _103.consola, 'optionalAccess', _104 => _104.log, 'call', _105 => _105(`\u26A1Build completed ${logLevel !== _logger.LogMapper.silent ? p2.dim(inputPath) : ""}`)]);
+  _optionalChain([logger, 'access', _106 => _106.consola, 'optionalAccess', _107 => _107.box, 'call', _108 => _108({
     title: `${config.name || ""}`,
     message: summary.join(""),
     style: {
@@ -7836,4 +8486,4 @@ async function generate({ input, config, args }) {
 
 
 exports.init_cjs_shims = init_cjs_shims; exports.p = p2; exports.execa = execa; exports.generate = generate;
-//# sourceMappingURL=chunk-7CMTKETP.cjs.map
+//# sourceMappingURL=chunk-MXBF3FNZ.cjs.map