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

package/dist/{chunk-MXBF3FNZ.cjs → chunk-WV2IQQKV.cjs}

@@ -1,13 +1,9 @@
-"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;
+"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 _class; var _class2;var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a3, b) => (typeof require !== "undefined" ? require : a3)[b]
 }) : x)(function(x) {
@@ -36,24 +32,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-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
+// ../../node_modules/.pnpm/tsup@8.2.4_@microsoft+api-extractor@7.47.7_@types+node@20.16.2__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({
-  "../../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"() {
+  "../../node_modules/.pnpm/tsup@8.2.4_@microsoft+api-extractor@7.47.7_@types+node@20.16.2__jiti@1.21.6_postcss@8.4.41_typescript@5.5.4_yaml@2.4.5/node_modules/tsup/assets/cjs_shims.js"() {
     "use strict";
   }
 });
@@ -1042,7 +1024,7 @@ 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 process10 = _interopRequireWildcard(_process2);
+var _process = require('process'); var process10 = _interopRequireWildcard(_process);
 var isStandardStream = (stream) => STANDARD_STREAMS.includes(stream);
 var STANDARD_STREAMS = [process10.default.stdin, process10.default.stdout, process10.default.stderr];
 var STANDARD_STREAMS_ALIASES = ["stdin", "stdout", "stderr"];
@@ -1177,7 +1159,7 @@ var quoteString = (escapedArgument) => {
   if (NO_ESCAPE_REGEXP.test(escapedArgument)) {
     return escapedArgument;
   }
-  return _process2.platform === "win32" ? `"${escapedArgument.replaceAll('"', '""')}"` : `'${escapedArgument.replaceAll("'", "'\\''")}'`;
+  return _process.platform === "win32" ? `"${escapedArgument.replaceAll('"', '""')}"` : `'${escapedArgument.replaceAll("'", "'\\''")}'`;
 };
 var NO_ESCAPE_REGEXP = /^[\w./-]+$/;
 
@@ -1676,8 +1658,8 @@ var validateVerbose = (verbose) => {
 // ../../node_modules/.pnpm/execa@9.3.1/node_modules/execa/lib/return/duration.js
 init_cjs_shims();
 
-var getStartTime = () => _process2.hrtime.bigint();
-var getDurationMs = (startTime) => Number(_process2.hrtime.bigint() - startTime) / 1e6;
+var getStartTime = () => _process.hrtime.bigint();
+var getDurationMs = (startTime) => Number(_process.hrtime.bigint() - startTime) / 1e6;
 
 // ../../node_modules/.pnpm/execa@9.3.1/node_modules/execa/lib/arguments/command.js
 var handleCommand = (filePath, rawArguments, rawOptions) => {
@@ -2275,7 +2257,7 @@ var killOnTimeout = async ({ kill, forceKillAfterDelay, context, controllerSigna
   try {
     await _promises.setTimeout.call(void 0, forceKillAfterDelay, void 0, { signal: controllerSignal });
     if (kill("SIGKILL")) {
-      _nullishCoalesce(context.isForcefullyTerminated, () => ( (context.isForcefullyTerminated = true)));
+      context.isForcefullyTerminated ??= true;
     }
   } catch (e3) {
   }
@@ -2302,7 +2284,7 @@ var validateCancelSignal = ({ 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);
-  _nullishCoalesce(context.terminationReason, () => ( (context.terminationReason = "cancel")));
+  context.terminationReason ??= "cancel";
   subprocess.kill();
   throw cancelSignal.reason;
 };
@@ -2893,7 +2875,7 @@ var sendOnAbort = async ({ subprocess, cancelSignal, forceKillAfterDelay, contex
     context,
     controllerSignal: signal
   });
-  _nullishCoalesce(context.terminationReason, () => ( (context.terminationReason = "gracefulCancel")));
+  context.terminationReason ??= "gracefulCancel";
   throw cancelSignal.reason;
 };
 var getReason = ({ reason }) => {
@@ -2921,7 +2903,7 @@ var validateTimeout = ({ 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 _promises.setTimeout.call(void 0, timeout, void 0, { signal });
-  _nullishCoalesce(context.terminationReason, () => ( (context.terminationReason = "timeout")));
+  context.terminationReason ??= "timeout";
   subprocess.kill();
   throw new DiscardedError();
 };
@@ -2938,8 +2920,8 @@ var mapNode = ({ options }) => {
 };
 var handleNodeOption = (file, commandArguments, {
   node: shouldHandleNode = false,
-  nodePath = _process2.execPath,
-  nodeOptions = _process2.execArgv.filter((nodeOption) => !nodeOption.startsWith("--inspect")),
+  nodePath = _process.execPath,
+  nodeOptions = _process.execArgv.filter((nodeOption) => !nodeOption.startsWith("--inspect")),
   cwd,
   execPath: formerNodePath,
   ...options
@@ -3219,61 +3201,54 @@ var a2 = Object.getPrototypeOf(
     }
   ).prototype
 );
-var _t, _n, _r, _e, _c_instances, s_fn, i_fn;
 var c = class {
+  #t;
+  #n;
+  #r = false;
+  #e = void 0;
   constructor(e, t) {
-    __privateAdd(this, _c_instances);
-    __privateAdd(this, _t);
-    __privateAdd(this, _n);
-    __privateAdd(this, _r, false);
-    __privateAdd(this, _e);
-    __privateSet(this, _t, e), __privateSet(this, _n, t);
+    this.#t = e, this.#n = t;
   }
   next() {
-    const e = () => __privateMethod(this, _c_instances, s_fn).call(this);
-    return __privateSet(this, _e, __privateGet(this, _e) ? __privateGet(this, _e).then(e, e) : e()), __privateGet(this, _e);
+    const e = () => this.#s();
+    return this.#e = this.#e ? this.#e.then(e, e) : e(), this.#e;
   }
   return(e) {
-    const t = () => __privateMethod(this, _c_instances, i_fn).call(this, e);
-    return __privateGet(this, _e) ? __privateGet(this, _e).then(t, t) : t();
+    const t = () => this.#i(e);
+    return this.#e ? this.#e.then(t, t) : t();
   }
-};
-_t = new WeakMap();
-_n = new WeakMap();
-_r = new WeakMap();
-_e = new WeakMap();
-_c_instances = new WeakSet();
-s_fn = async function() {
-  if (__privateGet(this, _r))
-    return {
-      done: true,
-      value: void 0
-    };
-  let e;
-  try {
-    e = await __privateGet(this, _t).read();
-  } catch (t) {
-    throw __privateSet(this, _e, void 0), __privateSet(this, _r, true), __privateGet(this, _t).releaseLock(), t;
+  async #s() {
+    if (this.#r)
+      return {
+        done: true,
+        value: void 0
+      };
+    let e;
+    try {
+      e = await this.#t.read();
+    } catch (t) {
+      throw this.#e = void 0, this.#r = true, this.#t.releaseLock(), t;
+    }
+    return e.done && (this.#e = void 0, this.#r = true, this.#t.releaseLock()), e;
   }
-  return e.done && (__privateSet(this, _e, void 0), __privateSet(this, _r, true), __privateGet(this, _t).releaseLock()), e;
-};
-i_fn = async function(e) {
-  if (__privateGet(this, _r))
-    return {
-      done: true,
-      value: e
-    };
-  if (__privateSet(this, _r, true), !__privateGet(this, _n)) {
-    const t = __privateGet(this, _t).cancel(e);
-    return __privateGet(this, _t).releaseLock(), await t, {
+  async #i(e) {
+    if (this.#r)
+      return {
+        done: true,
+        value: e
+      };
+    if (this.#r = true, !this.#n) {
+      const t = this.#t.cancel(e);
+      return this.#t.releaseLock(), await t, {
+        done: true,
+        value: e
+      };
+    }
+    return this.#t.releaseLock(), {
       done: true,
       value: e
     };
   }
-  return __privateGet(this, _t).releaseLock(), {
-    done: true,
-    value: e
-  };
 };
 var n = Symbol();
 function i() {
@@ -3452,12 +3427,12 @@ var getChunkType = (chunk) => {
   return "others";
 };
 var { toString: objectToString2 } = Object.prototype;
-var MaxBufferError = class extends Error {
+var MaxBufferError = (_class = class extends Error {
+  __init2() {this.name = "MaxBufferError"}
   constructor() {
-    super("maxBuffer exceeded");
-    __publicField(this, "name", "MaxBufferError");
+    super("maxBuffer exceeded");_class.prototype.__init2.call(this);;
   }
-};
+}, _class);
 
 // ../../node_modules/.pnpm/get-stream@9.0.1/node_modules/get-stream/source/utils.js
 init_cjs_shims();
@@ -5299,7 +5274,7 @@ var logOutputSync = ({ serializedResult, fdNumber, state, verboseInfo, encoding,
   try {
     logLinesSync(linesArray, fdNumber, verboseInfo);
   } catch (error) {
-    _nullishCoalesce(state.error, () => ( (state.error = error)));
+    state.error ??= error;
   }
 };
 var writeToFiles = (serializedResult, stdioItems, outputFiles) => {
@@ -5346,7 +5321,7 @@ init_cjs_shims();
 
 var waitForExit = async (subprocess, context) => {
   const [exitCode, signal] = await waitForExitOrError(subprocess);
-  _nullishCoalesce(context.isForcefullyTerminated, () => ( (context.isForcefullyTerminated = false)));
+  context.isForcefullyTerminated ??= false;
   return [exitCode, signal];
 };
 var waitForExitOrError = async (subprocess) => {
@@ -5847,57 +5822,47 @@ var getHighWaterMark = (streams, objectMode) => {
   const highWaterMarks = streams.filter(({ readableObjectMode }) => readableObjectMode === objectMode).map(({ readableHighWaterMark }) => readableHighWaterMark);
   return Math.max(...highWaterMarks);
 };
-var _streams, _ended, _aborted, _onFinished, _unpipeEvent, _streamPromises;
 var MergedStream = class extends _stream.PassThrough {
-  constructor() {
-    super(...arguments);
-    __privateAdd(this, _streams, /* @__PURE__ */ new Set([]));
-    __privateAdd(this, _ended, /* @__PURE__ */ new Set([]));
-    __privateAdd(this, _aborted, /* @__PURE__ */ new Set([]));
-    __privateAdd(this, _onFinished);
-    __privateAdd(this, _unpipeEvent, Symbol("unpipe"));
-    __privateAdd(this, _streamPromises, /* @__PURE__ */ new WeakMap());
-  }
+  #streams = /* @__PURE__ */ new Set([]);
+  #ended = /* @__PURE__ */ new Set([]);
+  #aborted = /* @__PURE__ */ new Set([]);
+  #onFinished;
+  #unpipeEvent = Symbol("unpipe");
+  #streamPromises = /* @__PURE__ */ new WeakMap();
   add(stream) {
     validateStream(stream);
-    if (__privateGet(this, _streams).has(stream)) {
+    if (this.#streams.has(stream)) {
       return;
     }
-    __privateGet(this, _streams).add(stream);
-    _nullishCoalesce(__privateGet(this, _onFinished), () => ( __privateSet(this, _onFinished, onMergedStreamFinished(this, __privateGet(this, _streams), __privateGet(this, _unpipeEvent)))));
+    this.#streams.add(stream);
+    this.#onFinished ??= onMergedStreamFinished(this, this.#streams, this.#unpipeEvent);
     const streamPromise = endWhenStreamsDone({
       passThroughStream: this,
       stream,
-      streams: __privateGet(this, _streams),
-      ended: __privateGet(this, _ended),
-      aborted: __privateGet(this, _aborted),
-      onFinished: __privateGet(this, _onFinished),
-      unpipeEvent: __privateGet(this, _unpipeEvent)
+      streams: this.#streams,
+      ended: this.#ended,
+      aborted: this.#aborted,
+      onFinished: this.#onFinished,
+      unpipeEvent: this.#unpipeEvent
     });
-    __privateGet(this, _streamPromises).set(stream, streamPromise);
+    this.#streamPromises.set(stream, streamPromise);
     stream.pipe(this, { end: false });
   }
   async remove(stream) {
     validateStream(stream);
-    if (!__privateGet(this, _streams).has(stream)) {
+    if (!this.#streams.has(stream)) {
       return false;
     }
-    const streamPromise = __privateGet(this, _streamPromises).get(stream);
+    const streamPromise = this.#streamPromises.get(stream);
     if (streamPromise === void 0) {
       return false;
     }
-    __privateGet(this, _streamPromises).delete(stream);
+    this.#streamPromises.delete(stream);
     stream.unpipe(this);
     await streamPromise;
     return true;
   }
 };
-_streams = new WeakMap();
-_ended = new WeakMap();
-_aborted = new WeakMap();
-_onFinished = new WeakMap();
-_unpipeEvent = new WeakMap();
-_streamPromises = new WeakMap();
 var onMergedStreamFinished = async (passThroughStream, streams, unpipeEvent) => {
   updateMaxListeners(passThroughStream, PASSTHROUGH_LISTENERS_COUNT);
   const controller = new AbortController();
@@ -6172,18 +6137,18 @@ var processOk = (process11) => !!process11 && typeof process11 === "object" && t
 var kExitEmitter = Symbol.for("signal-exit emitter");
 var global2 = globalThis;
 var ObjectDefineProperty = Object.defineProperty.bind(Object);
-var Emitter = class {
-  constructor() {
-    __publicField(this, "emitted", {
-      afterExit: false,
-      exit: false
-    });
-    __publicField(this, "listeners", {
-      afterExit: [],
-      exit: []
-    });
-    __publicField(this, "count", 0);
-    __publicField(this, "id", Math.random());
+var Emitter = (_class2 = class {
+  __init3() {this.emitted = {
+    afterExit: false,
+    exit: false
+  }}
+  __init4() {this.listeners = {
+    afterExit: [],
+    exit: []
+  }}
+  __init5() {this.count = 0}
+  __init6() {this.id = Math.random()}
+  constructor() {;_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);
     if (global2[kExitEmitter]) {
       return global2[kExitEmitter];
     }
@@ -6223,7 +6188,7 @@ var Emitter = class {
     }
     return ret;
   }
-};
+}, _class2);
 var SignalExitBase = class {
 };
 var signalExitWrap = (handler) => {
@@ -6249,129 +6214,119 @@ var SignalExitFallback = class extends SignalExitBase {
   unload() {
   }
 };
-var _hupSig, _emitter, _process, _originalProcessEmit, _originalProcessReallyExit, _sigListeners, _loaded, _SignalExit_instances, processReallyExit_fn, processEmit_fn;
 var SignalExit = class extends SignalExitBase {
+  // "SIGHUP" throws an `ENOSYS` error on Windows,
+  // so use a supported signal instead
+  /* c8 ignore start */
+  #hupSig = process9.platform === "win32" ? "SIGINT" : "SIGHUP";
+  /* c8 ignore stop */
+  #emitter = new Emitter();
+  #process;
+  #originalProcessEmit;
+  #originalProcessReallyExit;
+  #sigListeners = {};
+  #loaded = false;
   constructor(process11) {
     super();
-    __privateAdd(this, _SignalExit_instances);
-    // "SIGHUP" throws an `ENOSYS` error on Windows,
-    // so use a supported signal instead
-    /* c8 ignore start */
-    __privateAdd(this, _hupSig, process9.platform === "win32" ? "SIGINT" : "SIGHUP");
-    /* c8 ignore stop */
-    __privateAdd(this, _emitter, new Emitter());
-    __privateAdd(this, _process);
-    __privateAdd(this, _originalProcessEmit);
-    __privateAdd(this, _originalProcessReallyExit);
-    __privateAdd(this, _sigListeners, {});
-    __privateAdd(this, _loaded, false);
-    __privateSet(this, _process, process11);
-    __privateSet(this, _sigListeners, {});
+    this.#process = process11;
+    this.#sigListeners = {};
     for (const sig of signals) {
-      __privateGet(this, _sigListeners)[sig] = () => {
-        const listeners = __privateGet(this, _process).listeners(sig);
-        let { count: count2 } = __privateGet(this, _emitter);
+      this.#sigListeners[sig] = () => {
+        const listeners = this.#process.listeners(sig);
+        let { count: count2 } = this.#emitter;
         const p3 = process11;
         if (typeof p3.__signal_exit_emitter__ === "object" && typeof p3.__signal_exit_emitter__.count === "number") {
           count2 += p3.__signal_exit_emitter__.count;
         }
         if (listeners.length === count2) {
           this.unload();
-          const ret = __privateGet(this, _emitter).emit("exit", null, sig);
-          const s = sig === "SIGHUP" ? __privateGet(this, _hupSig) : sig;
+          const ret = this.#emitter.emit("exit", null, sig);
+          const s = sig === "SIGHUP" ? this.#hupSig : sig;
           if (!ret)
             process11.kill(process11.pid, s);
         }
       };
     }
-    __privateSet(this, _originalProcessReallyExit, process11.reallyExit);
-    __privateSet(this, _originalProcessEmit, process11.emit);
+    this.#originalProcessReallyExit = process11.reallyExit;
+    this.#originalProcessEmit = process11.emit;
   }
   onExit(cb, opts) {
-    if (!processOk(__privateGet(this, _process))) {
+    if (!processOk(this.#process)) {
       return () => {
       };
     }
-    if (__privateGet(this, _loaded) === false) {
+    if (this.#loaded === false) {
       this.load();
     }
     const ev = _optionalChain([opts, 'optionalAccess', _33 => _33.alwaysLast]) ? "afterExit" : "exit";
-    __privateGet(this, _emitter).on(ev, cb);
+    this.#emitter.on(ev, cb);
     return () => {
-      __privateGet(this, _emitter).removeListener(ev, cb);
-      if (__privateGet(this, _emitter).listeners["exit"].length === 0 && __privateGet(this, _emitter).listeners["afterExit"].length === 0) {
+      this.#emitter.removeListener(ev, cb);
+      if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) {
         this.unload();
       }
     };
   }
   load() {
-    if (__privateGet(this, _loaded)) {
+    if (this.#loaded) {
       return;
     }
-    __privateSet(this, _loaded, true);
-    __privateGet(this, _emitter).count += 1;
+    this.#loaded = true;
+    this.#emitter.count += 1;
     for (const sig of signals) {
       try {
-        const fn = __privateGet(this, _sigListeners)[sig];
+        const fn = this.#sigListeners[sig];
         if (fn)
-          __privateGet(this, _process).on(sig, fn);
+          this.#process.on(sig, fn);
       } catch (_) {
       }
     }
-    __privateGet(this, _process).emit = (ev, ...a3) => {
-      return __privateMethod(this, _SignalExit_instances, processEmit_fn).call(this, ev, ...a3);
+    this.#process.emit = (ev, ...a3) => {
+      return this.#processEmit(ev, ...a3);
     };
-    __privateGet(this, _process).reallyExit = (code) => {
-      return __privateMethod(this, _SignalExit_instances, processReallyExit_fn).call(this, code);
+    this.#process.reallyExit = (code) => {
+      return this.#processReallyExit(code);
     };
   }
   unload() {
-    if (!__privateGet(this, _loaded)) {
+    if (!this.#loaded) {
       return;
     }
-    __privateSet(this, _loaded, false);
+    this.#loaded = false;
     signals.forEach((sig) => {
-      const listener = __privateGet(this, _sigListeners)[sig];
+      const listener = this.#sigListeners[sig];
       if (!listener) {
         throw new Error("Listener not defined for signal: " + sig);
       }
       try {
-        __privateGet(this, _process).removeListener(sig, listener);
+        this.#process.removeListener(sig, listener);
       } catch (_) {
       }
     });
-    __privateGet(this, _process).emit = __privateGet(this, _originalProcessEmit);
-    __privateGet(this, _process).reallyExit = __privateGet(this, _originalProcessReallyExit);
-    __privateGet(this, _emitter).count -= 1;
-  }
-};
-_hupSig = new WeakMap();
-_emitter = new WeakMap();
-_process = new WeakMap();
-_originalProcessEmit = new WeakMap();
-_originalProcessReallyExit = new WeakMap();
-_sigListeners = new WeakMap();
-_loaded = new WeakMap();
-_SignalExit_instances = new WeakSet();
-processReallyExit_fn = function(code) {
-  if (!processOk(__privateGet(this, _process))) {
-    return 0;
+    this.#process.emit = this.#originalProcessEmit;
+    this.#process.reallyExit = this.#originalProcessReallyExit;
+    this.#emitter.count -= 1;
   }
-  __privateGet(this, _process).exitCode = code || 0;
-  __privateGet(this, _emitter).emit("exit", __privateGet(this, _process).exitCode, null);
-  return __privateGet(this, _originalProcessReallyExit).call(__privateGet(this, _process), __privateGet(this, _process).exitCode);
-};
-processEmit_fn = function(ev, ...args) {
-  const og = __privateGet(this, _originalProcessEmit);
-  if (ev === "exit" && processOk(__privateGet(this, _process))) {
-    if (typeof args[0] === "number") {
-      __privateGet(this, _process).exitCode = args[0];
+  #processReallyExit(code) {
+    if (!processOk(this.#process)) {
+      return 0;
+    }
+    this.#process.exitCode = code || 0;
+    this.#emitter.emit("exit", this.#process.exitCode, null);
+    return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+  }
+  #processEmit(ev, ...args) {
+    const og = this.#originalProcessEmit;
+    if (ev === "exit" && processOk(this.#process)) {
+      if (typeof args[0] === "number") {
+        this.#process.exitCode = args[0];
+      }
+      const ret = og.call(this.#process, ev, ...args);
+      this.#emitter.emit("exit", this.#process.exitCode, null);
+      return ret;
+    } else {
+      return og.call(this.#process, ev, ...args);
     }
-    const ret = og.call(__privateGet(this, _process), ev, ...args);
-    __privateGet(this, _emitter).emit("exit", __privateGet(this, _process).exitCode, null);
-    return ret;
-  } else {
-    return og.call(__privateGet(this, _process), ev, ...args);
   }
 };
 var process9 = globalThis.process;
@@ -7140,7 +7095,7 @@ var waitForSubprocessResult = async ({
       })
     ]);
   } catch (error) {
-    _nullishCoalesce(context.terminationReason, () => ( (context.terminationReason = "other")));
+    context.terminationReason ??= "other";
     return Promise.all([
       { error },
       exitPromise,
@@ -7792,6 +7747,8 @@ init_cjs_shims();
 
 
 var ConsolaWritable = class extends _stream.Writable {
+  
+  
   constructor(consola, command, opts) {
     super(opts);
     this.command = command;
@@ -7920,11 +7877,8 @@ function lowerBound(array, value, comparator) {
 }
 
 // ../../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, []);
-  }
+  #queue = [];
   enqueue(run, options) {
     options = {
       priority: 0,
@@ -7934,54 +7888,51 @@ var PriorityQueue = class {
       priority: options.priority,
       run
     };
-    if (this.size && __privateGet(this, _queue)[this.size - 1].priority >= options.priority) {
-      __privateGet(this, _queue).push(element);
+    if (this.size && this.#queue[this.size - 1].priority >= options.priority) {
+      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);
+    const index = lowerBound(this.#queue, element, (a3, b) => b.priority - a3.priority);
+    this.#queue.splice(index, 0, element);
   }
   dequeue() {
-    const item = __privateGet(this, _queue).shift();
+    const item = 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);
+    return this.#queue.filter((element) => element.priority === options.priority).map((element) => element.run);
   }
   get size() {
-    return __privateGet(this, _queue).length;
+    return 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 {
+  #carryoverConcurrencyCount;
+  #isIntervalIgnored;
+  #intervalCount = 0;
+  #intervalCap;
+  #interval;
+  #intervalEnd = 0;
+  #intervalId;
+  #timeoutId;
+  #queue;
+  #queueClass;
+  #pending = 0;
+  // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194
+  #concurrency;
+  #isPaused;
+  #throwOnTimeout;
+  /**
+      Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
+  
+      Applies to each future operation.
+      */
+  
   // 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,
@@ -7997,37 +7948,130 @@ var PQueue = class extends import_index.default {
     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.#carryoverConcurrencyCount = options.carryoverConcurrencyCount;
+    this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
+    this.#intervalCap = options.intervalCap;
+    this.#interval = options.interval;
+    this.#queue = new options.queueClass();
+    this.#queueClass = options.queueClass;
     this.concurrency = options.concurrency;
     this.timeout = options.timeout;
-    __privateSet(this, _throwOnTimeout, options.throwOnTimeout === true);
-    __privateSet(this, _isPaused, options.autoStart === false);
+    this.#throwOnTimeout = options.throwOnTimeout === true;
+    this.#isPaused = options.autoStart === false;
+  }
+  get #doesIntervalAllowAnother() {
+    return this.#isIntervalIgnored || this.#intervalCount < this.#intervalCap;
+  }
+  get #doesConcurrentAllowAnother() {
+    return this.#pending < this.#concurrency;
+  }
+  #next() {
+    this.#pending--;
+    this.#tryToStartAnother();
+    this.emit("next");
+  }
+  #onResumeInterval() {
+    this.#onInterval();
+    this.#initializeIntervalIfNeeded();
+    this.#timeoutId = void 0;
+  }
+  get #isIntervalPaused() {
+    const now = Date.now();
+    if (this.#intervalId === void 0) {
+      const delay = this.#intervalEnd - now;
+      if (delay < 0) {
+        this.#intervalCount = this.#carryoverConcurrencyCount ? this.#pending : 0;
+      } else {
+        if (this.#timeoutId === void 0) {
+          this.#timeoutId = setTimeout(() => {
+            this.#onResumeInterval();
+          }, delay);
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+  #tryToStartAnother() {
+    if (this.#queue.size === 0) {
+      if (this.#intervalId) {
+        clearInterval(this.#intervalId);
+      }
+      this.#intervalId = void 0;
+      this.emit("empty");
+      if (this.#pending === 0) {
+        this.emit("idle");
+      }
+      return false;
+    }
+    if (!this.#isPaused) {
+      const canInitializeInterval = !this.#isIntervalPaused;
+      if (this.#doesIntervalAllowAnother && this.#doesConcurrentAllowAnother) {
+        const job = this.#queue.dequeue();
+        if (!job) {
+          return false;
+        }
+        this.emit("active");
+        job();
+        if (canInitializeInterval) {
+          this.#initializeIntervalIfNeeded();
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+  #initializeIntervalIfNeeded() {
+    if (this.#isIntervalIgnored || this.#intervalId !== void 0) {
+      return;
+    }
+    this.#intervalId = setInterval(() => {
+      this.#onInterval();
+    }, this.#interval);
+    this.#intervalEnd = Date.now() + this.#interval;
+  }
+  #onInterval() {
+    if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {
+      clearInterval(this.#intervalId);
+      this.#intervalId = void 0;
+    }
+    this.#intervalCount = this.#carryoverConcurrencyCount ? this.#pending : 0;
+    this.#processQueue();
+  }
+  /**
+  Executes all queued functions until it reaches the limit.
+  */
+  #processQueue() {
+    while (this.#tryToStartAnother()) {
+    }
   }
   get concurrency() {
-    return __privateGet(this, _concurrency);
+    return 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);
+    this.#concurrency = newConcurrency;
+    this.#processQueue();
+  }
+  async #throwOnAbort(signal) {
+    return new Promise((_resolve, reject) => {
+      signal.addEventListener("abort", () => {
+        reject(signal.reason);
+      }, { once: true });
+    });
   }
   async add(function_, options = {}) {
     options = {
       timeout: this.timeout,
-      throwOnTimeout: __privateGet(this, _throwOnTimeout),
+      throwOnTimeout: this.#throwOnTimeout,
       ...options
     };
     return new Promise((resolve2, reject) => {
-      __privateGet(this, _queue2).enqueue(async () => {
-        __privateWrapper(this, _pending)._++;
-        __privateWrapper(this, _intervalCount)._++;
+      this.#queue.enqueue(async () => {
+        this.#pending++;
+        this.#intervalCount++;
         try {
           _optionalChain([options, 'access', _47 => _47.signal, 'optionalAccess', _48 => _48.throwIfAborted, 'call', _49 => _49()]);
           let operation = function_({ signal: options.signal });
@@ -8035,7 +8079,7 @@ var PQueue = class extends import_index.default {
             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)]);
+            operation = Promise.race([operation, this.#throwOnAbort(options.signal)]);
           }
           const result = await operation;
           resolve2(result);
@@ -8048,11 +8092,11 @@ var PQueue = class extends import_index.default {
           reject(error);
           this.emit("error", error);
         } finally {
-          __privateMethod(this, _PQueue_instances, next_fn).call(this);
+          this.#next();
         }
       }, options);
       this.emit("add");
-      __privateMethod(this, _PQueue_instances, tryToStartAnother_fn).call(this);
+      this.#tryToStartAnother();
     });
   }
   async addAll(functions, options) {
@@ -8062,24 +8106,24 @@ var PQueue = class extends import_index.default {
   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)) {
+    if (!this.#isPaused) {
       return this;
     }
-    __privateSet(this, _isPaused, false);
-    __privateMethod(this, _PQueue_instances, processQueue_fn).call(this);
+    this.#isPaused = false;
+    this.#processQueue();
     return this;
   }
   /**
   Put queue execution on hold.
   */
   pause() {
-    __privateSet(this, _isPaused, true);
+    this.#isPaused = true;
   }
   /**
   Clear the queue.
   */
   clear() {
-    __privateSet(this, _queue2, new (__privateGet(this, _queueClass))());
+    this.#queue = new this.#queueClass();
   }
   /**
       Can be called multiple times. Useful if you for example add additional items at a later time.
@@ -8087,10 +8131,10 @@ var PQueue = class extends import_index.default {
       @returns A promise that settles when the queue becomes empty.
       */
   async onEmpty() {
-    if (__privateGet(this, _queue2).size === 0) {
+    if (this.#queue.size === 0) {
       return;
     }
-    await __privateMethod(this, _PQueue_instances, onEvent_fn).call(this, "empty");
+    await this.#onEvent("empty");
   }
   /**
       @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.
@@ -8100,10 +8144,10 @@ var PQueue = class extends import_index.default {
       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) {
+    if (this.#queue.size < limit) {
       return;
     }
-    await __privateMethod(this, _PQueue_instances, onEvent_fn).call(this, "next", () => __privateGet(this, _queue2).size < limit);
+    await this.#onEvent("next", () => this.#queue.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.
@@ -8111,16 +8155,28 @@ var PQueue = class extends import_index.default {
       @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) {
+    if (this.#pending === 0 && this.#queue.size === 0) {
       return;
     }
-    await __privateMethod(this, _PQueue_instances, onEvent_fn).call(this, "idle");
+    await this.#onEvent("idle");
+  }
+  async #onEvent(event, filter) {
+    return new Promise((resolve2) => {
+      const listener = () => {
+        if (filter && !filter()) {
+          return;
+        }
+        this.off(event, listener);
+        resolve2();
+      };
+      this.on(event, listener);
+    });
   }
   /**
   Size of the queue, the number of queued items waiting to run.
   */
   get size() {
-    return __privateGet(this, _queue2).size;
+    return this.#queue.size;
   }
   /**
       Size of the queue, filtered by the given options.
@@ -8128,140 +8184,20 @@ var PQueue = class extends import_index.default {
       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;
+    return this.#queue.filter(options).length;
   }
   /**
   Number of running items (no longer in the queue).
   */
   get pending() {
-    return __privateGet(this, _pending);
+    return 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 this.#isPaused;
   }
-  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
@@ -8315,29 +8251,17 @@ function parseHrtimeToSeconds(hrtime2) {
 }
 
 // src/utils/getSummary.ts
-function getSummary({ pluginManager, status, hrStart, config }) {
+function getSummary({ pluginManager, filesCreated, 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', _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', _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', _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', _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', _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,
+    plugins: status === "success" ? `${p2.green(`${buildStartPlugins.length} successful`)}, ${pluginsCount} total` : `${p2.red(`${_nullishCoalesce(_optionalChain([failedPlugins, 'optionalAccess', _58 => _58.length]), () => ( 1))} failed`)}, ${pluginsCount} total`,
+    pluginsFailed: status === "failed" ? _optionalChain([failedPlugins, 'optionalAccess', _59 => _59.map, 'call', _60 => _60((name) => _logger.randomCliColour.call(void 0, name)), 'optionalAccess', _61 => _61.join, 'call', _62 => _62(", ")]) : void 0,
+    filesCreated,
     time: `${p2.yellow(`${elapsedSeconds}s`)}`,
     output: _path2.default.isAbsolute(config.root) ? _path2.default.resolve(config.root, config.output.path) : config.root
   };
@@ -8378,7 +8302,6 @@ async function writeLog({ data, override, fileName = "kubb.log" }) {
 }
 
 // src/generate.ts
-
 var _cliprogress = require('cli-progress');
 async function generate({ input, config, args }) {
   const logLevel = _logger.LogMapper[args.logLevel] || 3;
@@ -8388,13 +8311,14 @@ async function generate({ input, config, args }) {
   });
   const progressBars = {};
   logger.on("progress_start", ({ id, size }) => {
-    _optionalChain([logger, 'access', _85 => _85.consola, 'optionalAccess', _86 => _86.pauseLogs, 'call', _87 => _87()]);
+    _optionalChain([logger, 'access', _63 => _63.consola, 'optionalAccess', _64 => _64.pauseLogs, 'call', _65 => _65()]);
     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",
+          format: logLevel === _logger.LogMapper.info ? "{percentage}% {bar} {value}/{total} {id} | {data} | ETA: {eta_formatted} | Duration: {duration_formatted} " : "{percentage}% {bar} ETA: {eta_formatted}",
           barsize: 25,
-          clearOnComplete: true
+          clearOnComplete: true,
+          emptyOnZero: true
         },
         _cliprogress.Presets.shades_grey
       );
@@ -8403,16 +8327,16 @@ async function generate({ input, config, args }) {
   });
   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()]);
+    _optionalChain([progressBar, 'optionalAccess', _66 => _66.stop, 'call', _67 => _67()]);
+    _optionalChain([logger, 'access', _68 => _68.consola, 'optionalAccess', _69 => _69.resumeLogs, 'call', _70 => _70()]);
   });
   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)]);
+      _optionalChain([progressBar, 'optionalAccess', _71 => _71.update, 'call', _72 => _72(count2, payload)]);
     } else {
-      _optionalChain([progressBar, 'optionalAccess', _95 => _95.increment, 'call', _96 => _96(1, payload)]);
+      _optionalChain([progressBar, 'optionalAccess', _73 => _73.increment, 'call', _74 => _74(1, payload)]);
     }
   });
   logger.on("debug", async ({ logs, override, fileName }) => {
@@ -8430,15 +8354,17 @@ async function generate({ input, config, args }) {
     } : userConfig.input,
     output: {
       write: true,
+      exportType: "barrelNamed",
       ...userConfig.output
     }
   };
   const hrStart = process.hrtime();
-  const { pluginManager, error } = await _core.safeBuild.call(void 0, {
+  const { pluginManager, files, error } = await _core.safeBuild.call(void 0, {
     config: definedConfig,
     logger
   });
   const summary = getSummary({
+    filesCreated: files.length,
     pluginManager,
     config: definedConfig,
     status: error ? "failed" : "success",
@@ -8446,6 +8372,7 @@ async function generate({ input, config, args }) {
     logger
   });
   if (error && logger.consola) {
+    _optionalChain([logger, 'access', _75 => _75.consola, 'optionalAccess', _76 => _76.resumeLogs, 'call', _77 => _77()]);
     logger.consola.error(`Build failed ${logLevel !== _logger.LogMapper.silent ? p2.dim(inputPath) : ""}`);
     logger.consola.box({
       title: `${config.name || ""}`,
@@ -8459,17 +8386,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', _97 => _97.consola, 'optionalAccess', _98 => _98.error, 'call', _99 => _99(err)]);
+        _optionalChain([logger, 'access', _78 => _78.consola, 'optionalAccess', _79 => _79.error, 'call', _80 => _80(err)]);
       });
     }
-    _optionalChain([logger, 'access', _100 => _100.consola, 'optionalAccess', _101 => _101.error, 'call', _102 => _102(error)]);
+    _optionalChain([logger, 'access', _81 => _81.consola, 'optionalAccess', _82 => _82.error, 'call', _83 => _83(error)]);
     process.exit(0);
   }
   if (config.hooks) {
     await executeHooks({ hooks: config.hooks, logger });
   }
-  _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({
+  _optionalChain([logger, 'access', _84 => _84.consola, 'optionalAccess', _85 => _85.log, 'call', _86 => _86(`\u26A1Build completed ${logLevel !== _logger.LogMapper.silent ? p2.dim(inputPath) : ""}`)]);
+  _optionalChain([logger, 'access', _87 => _87.consola, 'optionalAccess', _88 => _88.box, 'call', _89 => _89({
     title: `${config.name || ""}`,
     message: summary.join(""),
     style: {
@@ -8486,4 +8413,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-MXBF3FNZ.cjs.map
+//# sourceMappingURL=chunk-WV2IQQKV.cjs.map