@kubb/agent 5.0.0-alpha.42 → 5.0.0-alpha.44

package/.output/server/chunks/nitro/nitro.mjs

@@ -7,14 +7,13 @@ import https, { Server } from 'node:https';
 import { EventEmitter } from 'node:events';
 import { Buffer as Buffer$1 } from 'node:buffer';
 import { promises, existsSync } from 'node:fs';
-import path$1, { resolve, dirname, relative, join, extname, basename, posix } from 'node:path';
+import path$1, { resolve, dirname, relative, join, extname, posix } from 'node:path';
 import anymatch from 'anymatch';
 import { createHash, randomBytes } from 'node:crypto';
 import process$1, { version as version$2 } from 'node:process';
 import { spawn } from 'node:child_process';
 import { Logtail } from '@logtail/node';
 import { consola } from 'consola';
-import { performance } from 'node:perf_hooks';
 import { deflateSync } from 'fflate';
 import { x } from 'tinyexec';
 import { access, rm, readFile as readFile$1, readdir as readdir$1, mkdir, writeFile as writeFile$1 } from 'node:fs/promises';
@@ -4438,6 +4437,36 @@ const logger = {
 const _KZ9YuROWp70nNn4X1C4BxF_W0D7H9EWgBo03XvMd7w0 = defineNitroPlugin(() => {
 });
 
+function formatMs$1(ms) {
+  if (ms >= 6e4) return `${Math.floor(ms / 6e4)}m ${(ms % 6e4 / 1e3).toFixed(1)}s`;
+  if (ms >= 1e3) return `${(ms / 1e3).toFixed(2)}s`;
+  return `${Math.round(ms)}ms`;
+}
+function parseHex(color) {
+  const int = Number.parseInt(color.replace("#", ""), 16);
+  return Number.isNaN(int) ? {
+    r: 255,
+    g: 255,
+    b: 255
+  } : {
+    r: int >> 16 & 255,
+    g: int >> 8 & 255,
+    b: int & 255
+  };
+}
+function hex(color) {
+  const { r, g, b } = parseHex(color);
+  return (text) => `\x1B[38;2;${r};${g};${b}m${text}\x1B[0m`;
+}
+({
+  lid: hex("#F55A17"),
+  woodTop: hex("#F5A217"),
+  woodMid: hex("#F58517"),
+  woodBase: hex("#B45309"),
+  eye: hex("#FFFFFF"),
+  highlight: hex("#adadc6"),
+  blush: hex("#FDA4AF")
+});
 const formatters = {
   prettier: {
     command: "prettier",
@@ -4516,36 +4545,6 @@ async function detectLinter() {
   for (const linter of linterNames) if (await isLinterAvailable(linter)) return linter;
   return null;
 }
-function formatMs$1(ms) {
-  if (ms >= 6e4) return `${Math.floor(ms / 6e4)}m ${(ms % 6e4 / 1e3).toFixed(1)}s`;
-  if (ms >= 1e3) return `${(ms / 1e3).toFixed(2)}s`;
-  return `${Math.round(ms)}ms`;
-}
-function parseHex(color) {
-  const int = Number.parseInt(color.replace("#", ""), 16);
-  return Number.isNaN(int) ? {
-    r: 255,
-    g: 255,
-    b: 255
-  } : {
-    r: int >> 16 & 255,
-    g: int >> 8 & 255,
-    b: int & 255
-  };
-}
-function hex(color) {
-  const { r, g, b } = parseHex(color);
-  return (text) => `\x1B[38;2;${r};${g};${b}m${text}\x1B[0m`;
-}
-({
-  lid: hex("#F55A17"),
-  woodTop: hex("#F5A217"),
-  woodMid: hex("#F58517"),
-  woodBase: hex("#B45309"),
-  eye: hex("#FFFFFF"),
-  highlight: hex("#adadc6"),
-  blush: hex("#FDA4AF")
-});
 function serializePluginOptions(options) {
   if (options === null || options === void 0) return {};
   if (typeof options !== "object") return options;
@@ -4702,18 +4701,22 @@ function combineExports(exports$1) {
   const result = [];
   const namedByPath = /* @__PURE__ */ new Map();
   const seen = /* @__PURE__ */ new Set();
-  for (const curr of [...exports$1].sort((a, b) => {
-    const ka = sortKey(a);
-    const kb = sortKey(b);
-    return ka < kb ? -1 : ka > kb ? 1 : 0;
-  })) {
+  const keyed = exports$1.map((node) => ({
+    node,
+    key: sortKey(node)
+  }));
+  keyed.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+  for (const { node: curr } of keyed) {
     const { name, path: path2, isTypeOnly, asAlias } = curr;
     if (Array.isArray(name)) {
       if (!name.length) continue;
       const key = pathTypeKey(path2, isTypeOnly);
       const existing = namedByPath.get(key);
-      if (existing && Array.isArray(existing.name)) existing.name = [.../* @__PURE__ */ new Set([...existing.name, ...name])];
-      else {
+      if (existing && Array.isArray(existing.name)) {
+        const merged = new Set(existing.name);
+        for (const n of name) merged.add(n);
+        existing.name = [...merged];
+      } else {
         const newItem = {
           ...curr,
           name: [...new Set(name)]
@@ -4737,11 +4740,12 @@ function combineImports(imports, exports$1, source) {
   const result = [];
   const namedByPath = /* @__PURE__ */ new Map();
   const seen = /* @__PURE__ */ new Set();
-  for (const curr of [...imports].sort((a, b) => {
-    const ka = sortKey(a);
-    const kb = sortKey(b);
-    return ka < kb ? -1 : ka > kb ? 1 : 0;
-  })) {
+  const keyed = imports.map((node) => ({
+    node,
+    key: sortKey(node)
+  }));
+  keyed.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+  for (const { node: curr } of keyed) {
     if (curr.path === curr.root) continue;
     const { path: path2, isTypeOnly } = curr;
     let { name } = curr;
@@ -4750,8 +4754,11 @@ function combineImports(imports, exports$1, source) {
       if (!name.length) continue;
       const key = pathTypeKey(path2, isTypeOnly);
       const existing = namedByPath.get(key);
-      if (existing && Array.isArray(existing.name)) existing.name = [.../* @__PURE__ */ new Set([...existing.name, ...name])];
-      else {
+      if (existing && Array.isArray(existing.name)) {
+        const merged = new Set(existing.name);
+        for (const n of name) merged.add(n);
+        existing.name = [...merged];
+      } else {
         const newItem = {
           ...curr,
           name
@@ -5084,15 +5091,7 @@ var __privateGet$1 = (obj, member, getter) => (__accessCheck$1(obj, member, "rea
 var __privateAdd$1 = (obj, member, value) => member.has(obj) ? __typeError$1("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet$1 = (obj, member, value, setter) => (__accessCheck$1(obj, member, "write to private field"), member.set(obj, value), value);
 var __privateMethod$1 = (obj, member, method) => (__accessCheck$1(obj, member, "access private method"), method);
-var __privateWrapper = (obj, member, setter, getter) => ({
-  set _(value) {
-    __privateSet$1(obj, member, value);
-  },
-  get _() {
-    return __privateGet$1(obj, member, getter);
-  }
-});
-var _a$1, _head, _tail, _size, _b$1, _cache, _filesCache, _c$1, _studioIsOpen, _pluginsWithEventGenerators, _resolvers, _defaultResolvers, _hookListeners, _PluginDriver_instances, normalizeHookStylePlugin_fn, trackHookListener_fn, createDefaultResolver_fn, emitProcessingEnd_fn, execute_fn, executeSync_fn, _d$1;
+var _cache, _filesCache, _a$1, _studioIsOpen, _pluginsWithEventGenerators, _resolvers, _defaultResolvers, _hookListeners, _PluginDriver_instances, normalizePlugin_fn, trackHookListener_fn, createDefaultResolver_fn, _b$1;
 function toCamelOrPascal(text, pascal) {
   return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
     if (word.length > 1 && word === word.toUpperCase()) return word;
@@ -5118,254 +5117,41 @@ function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
   }) : camelCase(part));
   return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
-function isPromiseRejectedResult(result) {
-  return result.status === "rejected";
-}
-const reservedWords = /* @__PURE__ */ new Set([
-  "abstract",
-  "arguments",
-  "boolean",
-  "break",
-  "byte",
-  "case",
-  "catch",
-  "char",
-  "class",
-  "const",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "double",
-  "else",
-  "enum",
-  "eval",
-  "export",
-  "extends",
-  "false",
-  "final",
-  "finally",
-  "float",
-  "for",
-  "function",
-  "goto",
-  "if",
-  "implements",
-  "import",
-  "in",
-  "instanceof",
-  "int",
-  "interface",
-  "let",
-  "long",
-  "native",
-  "new",
-  "null",
-  "package",
-  "private",
-  "protected",
-  "public",
-  "return",
-  "short",
-  "static",
-  "super",
-  "switch",
-  "synchronized",
-  "this",
-  "throw",
-  "throws",
-  "transient",
-  "true",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "volatile",
-  "while",
-  "with",
-  "yield",
-  "Array",
-  "Date",
-  "hasOwnProperty",
-  "Infinity",
-  "isFinite",
-  "isNaN",
-  "isPrototypeOf",
-  "length",
-  "Math",
-  "name",
-  "NaN",
-  "Number",
-  "Object",
-  "prototype",
-  "String",
-  "toString",
-  "undefined",
-  "valueOf"
-]);
-function transformReservedWord(word) {
-  const firstChar = word.charCodeAt(0);
-  if (word && (reservedWords.has(word) || firstChar >= 48 && firstChar <= 57)) return `_${word}`;
-  return word;
-}
-function isValidVarName(name) {
-  try {
-    new Function(`var ${name}`);
-  } catch {
-    return false;
-  }
-  return true;
-}
 function trimExtName$1(text) {
   const dotIndex = text.lastIndexOf(".");
   if (dotIndex > 0 && !text.includes("/", dotIndex)) return text.slice(0, dotIndex);
   return text;
 }
 const DEFAULT_STUDIO_URL = "https://studio.kubb.dev";
-const BARREL_FILENAME = "index.ts";
+const BARREL_BASENAME = "index";
+const BARREL_FILENAME = `${BARREL_BASENAME}.ts`;
 const DEFAULT_BANNER = "simple";
 const DEFAULT_EXTENSION = { ".ts": ".ts" };
-var Node$1 = (_a$1 = class {
-  constructor(value) {
-    __publicField$1(this, "value");
-    __publicField$1(this, "next");
-    this.value = value;
-  }
-}, __name(_a$1, "Node"), _a$1);
-var Queue = (_b$1 = class {
-  constructor() {
-    __privateAdd$1(this, _head);
-    __privateAdd$1(this, _tail);
-    __privateAdd$1(this, _size);
-    this.clear();
-  }
-  enqueue(value) {
-    const node = new Node$1(value);
-    if (__privateGet$1(this, _head)) {
-      __privateGet$1(this, _tail).next = node;
-      __privateSet$1(this, _tail, node);
-    } else {
-      __privateSet$1(this, _head, node);
-      __privateSet$1(this, _tail, node);
-    }
-    __privateWrapper(this, _size)._++;
-  }
-  dequeue() {
-    const current = __privateGet$1(this, _head);
-    if (!current) return;
-    __privateSet$1(this, _head, __privateGet$1(this, _head).next);
-    __privateWrapper(this, _size)._--;
-    if (!__privateGet$1(this, _head)) __privateSet$1(this, _tail, void 0);
-    return current.value;
-  }
-  peek() {
-    if (!__privateGet$1(this, _head)) return;
-    return __privateGet$1(this, _head).value;
-  }
-  clear() {
-    __privateSet$1(this, _head, void 0);
-    __privateSet$1(this, _tail, void 0);
-    __privateSet$1(this, _size, 0);
-  }
-  get size() {
-    return __privateGet$1(this, _size);
-  }
-  *[Symbol.iterator]() {
-    let current = __privateGet$1(this, _head);
-    while (current) {
-      yield current.value;
-      current = current.next;
+const stringPatternCache = /* @__PURE__ */ new Map();
+function testPattern(value, pattern) {
+  if (typeof pattern === "string") {
+    let regex = stringPatternCache.get(pattern);
+    if (!regex) {
+      regex = new RegExp(pattern);
+      stringPatternCache.set(pattern, regex);
     }
+    return regex.test(value);
   }
-  *drain() {
-    while (__privateGet$1(this, _head)) yield this.dequeue();
-  }
-}, _head = new WeakMap(), _tail = new WeakMap(), _size = new WeakMap(), _b$1);
-function pLimit(concurrency) {
-  let rejectOnClear = false;
-  if (typeof concurrency === "object") ({ concurrency, rejectOnClear = false } = concurrency);
-  validateConcurrency(concurrency);
-  if (typeof rejectOnClear !== "boolean") throw new TypeError("Expected `rejectOnClear` to be a boolean");
-  const queue = new Queue();
-  let activeCount = 0;
-  const resumeNext = () => {
-    if (activeCount < concurrency && queue.size > 0) {
-      activeCount++;
-      queue.dequeue().run();
-    }
-  };
-  const next = () => {
-    activeCount--;
-    resumeNext();
-  };
-  const run = async (function_, resolve2, arguments_) => {
-    const result = (async () => function_(...arguments_))();
-    resolve2(result);
-    try {
-      await result;
-    } catch {
-    }
-    next();
-  };
-  const enqueue = (function_, resolve2, reject, arguments_) => {
-    const queueItem = { reject };
-    new Promise((internalResolve) => {
-      queueItem.run = internalResolve;
-      queue.enqueue(queueItem);
-    }).then(run.bind(void 0, function_, resolve2, arguments_));
-    if (activeCount < concurrency) resumeNext();
-  };
-  const generator = (function_, ...arguments_) => new Promise((resolve2, reject) => {
-    enqueue(function_, resolve2, reject, arguments_);
-  });
-  Object.defineProperties(generator, {
-    activeCount: { get: () => activeCount },
-    pendingCount: { get: () => queue.size },
-    clearQueue: { value() {
-      if (!rejectOnClear) {
-        queue.clear();
-        return;
-      }
-      const abortError = AbortSignal.abort().reason;
-      while (queue.size > 0) queue.dequeue().reject(abortError);
-    } },
-    concurrency: {
-      get: () => concurrency,
-      set(newConcurrency) {
-        validateConcurrency(newConcurrency);
-        concurrency = newConcurrency;
-        queueMicrotask(() => {
-          while (activeCount < concurrency && queue.size > 0) resumeNext();
-        });
-      }
-    },
-    map: { async value(iterable, function_) {
-      const promises = Array.from(iterable, (value, index) => this(function_, value, index));
-      return Promise.all(promises);
-    } }
-  });
-  return generator;
-}
-function validateConcurrency(concurrency) {
-  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) throw new TypeError("Expected `concurrency` to be a number from 1 and up");
-}
-function isHookStylePlugin(plugin) {
-  return typeof plugin === "object" && plugin !== null && "hooks" in plugin;
+  return value.match(pattern) !== null;
 }
 function matchesOperationPattern(node, type, pattern) {
-  var _a2, _b2;
+  var _a2;
   switch (type) {
     case "tag":
-      return node.tags.some((tag) => !!tag.match(pattern));
+      return node.tags.some((tag) => testPattern(tag, pattern));
     case "operationId":
-      return !!node.operationId.match(pattern);
+      return testPattern(node.operationId, pattern);
     case "path":
-      return !!node.path.match(pattern);
+      return testPattern(node.path, pattern);
     case "method":
-      return !!node.method.toLowerCase().match(pattern);
+      return testPattern(node.method.toLowerCase(), pattern);
     case "contentType":
-      return !!((_b2 = (_a2 = node.requestBody) == null ? void 0 : _a2.contentType) == null ? void 0 : _b2.match(pattern));
+      return ((_a2 = node.requestBody) == null ? void 0 : _a2.contentType) ? testPattern(node.requestBody.contentType, pattern) : false;
     default:
       return false;
   }
@@ -5373,7 +5159,7 @@ function matchesOperationPattern(node, type, pattern) {
 function matchesSchemaPattern(node, type, pattern) {
   switch (type) {
     case "schemaName":
-      return node.name ? !!node.name.match(pattern) : false;
+      return node.name ? testPattern(node.name, pattern) : false;
     default:
       return null;
   }
@@ -5520,7 +5306,7 @@ function mergeFile(a, b) {
     exports: [...a.exports || [], ...b.exports || []]
   };
 }
-var FileManager = (_c$1 = class {
+var FileManager = (_a$1 = class {
   constructor() {
     __privateAdd$1(this, _cache, /* @__PURE__ */ new Map());
     __privateAdd$1(this, _filesCache, null);
@@ -5532,17 +5318,16 @@ var FileManager = (_c$1 = class {
   add(...files) {
     const resolvedFiles = [];
     const mergedFiles = /* @__PURE__ */ new Map();
-    files.forEach((file) => {
+    for (const file of files) {
       const existing = mergedFiles.get(file.path);
-      if (existing) mergedFiles.set(file.path, mergeFile(existing, file));
-      else mergedFiles.set(file.path, file);
-    });
+      mergedFiles.set(file.path, existing ? mergeFile(existing, file) : file);
+    }
     for (const file of mergedFiles.values()) {
       const resolvedFile = createFile(file);
       __privateGet$1(this, _cache).set(resolvedFile.path, resolvedFile);
-      __privateSet$1(this, _filesCache, null);
       resolvedFiles.push(resolvedFile);
     }
+    __privateSet$1(this, _filesCache, null);
     return resolvedFiles;
   }
   /**
@@ -5552,18 +5337,17 @@ var FileManager = (_c$1 = class {
   upsert(...files) {
     const resolvedFiles = [];
     const mergedFiles = /* @__PURE__ */ new Map();
-    files.forEach((file) => {
+    for (const file of files) {
       const existing = mergedFiles.get(file.path);
-      if (existing) mergedFiles.set(file.path, mergeFile(existing, file));
-      else mergedFiles.set(file.path, file);
-    });
+      mergedFiles.set(file.path, existing ? mergeFile(existing, file) : file);
+    }
     for (const file of mergedFiles.values()) {
       const existing = __privateGet$1(this, _cache).get(file.path);
       const resolvedFile = createFile(existing ? mergeFile(existing, file) : file);
       __privateGet$1(this, _cache).set(resolvedFile.path, resolvedFile);
-      __privateSet$1(this, _filesCache, null);
       resolvedFiles.push(resolvedFile);
     }
+    __privateSet$1(this, _filesCache, null);
     return resolvedFiles;
   }
   getByPath(path2) {
@@ -5584,10 +5368,17 @@ var FileManager = (_c$1 = class {
   */
   get files() {
     if (__privateGet$1(this, _filesCache)) return __privateGet$1(this, _filesCache);
-    const keys = [...__privateGet$1(this, _cache).keys()].sort((a, b) => {
-      if (a.length !== b.length) return a.length - b.length;
-      const aIsIndex = trimExtName$1(a).endsWith("index");
-      if (aIsIndex !== trimExtName$1(b).endsWith("index")) return aIsIndex ? 1 : -1;
+    const keys = [...__privateGet$1(this, _cache).keys()];
+    const meta = /* @__PURE__ */ new Map();
+    for (const key of keys) meta.set(key, {
+      length: key.length,
+      isIndex: trimExtName$1(key).endsWith(BARREL_BASENAME)
+    });
+    keys.sort((a, b) => {
+      const ma = meta.get(a);
+      const mb = meta.get(b);
+      if (ma.length !== mb.length) return ma.length - mb.length;
+      if (ma.isIndex !== mb.isIndex) return ma.isIndex ? 1 : -1;
       return 0;
     });
     const files = [];
@@ -5598,7 +5389,7 @@ var FileManager = (_c$1 = class {
     __privateSet$1(this, _filesCache, files);
     return files;
   }
-}, _cache = new WeakMap(), _filesCache = new WeakMap(), _c$1);
+}, _cache = new WeakMap(), _filesCache = new WeakMap(), _a$1);
 async function applyHookResult(result, driver, rendererFactory) {
   if (!result) return;
   if (Array.isArray(result)) {
@@ -5611,31 +5402,7 @@ async function applyHookResult(result, driver, rendererFactory) {
   driver.fileManager.upsert(...renderer.files);
   renderer.unmount();
 }
-function hookSeq(promises) {
-  return promises.filter(Boolean).reduce((promise, func) => {
-    if (typeof func !== "function") throw new Error("HookSeq needs a function that returns a promise `() => Promise<unknown>`");
-    return promise.then((state) => {
-      const calledFunc = func(state);
-      if (calledFunc) return calledFunc.then(Array.prototype.concat.bind(state));
-      return state;
-    });
-  }, Promise.resolve([]));
-}
-function hookFirst(promises, nullCheck = (state) => state !== null) {
-  let promise = Promise.resolve(null);
-  for (const func of promises.filter(Boolean)) promise = promise.then((state) => {
-    if (nullCheck(state)) return state;
-    return func(state);
-  });
-  return promise;
-}
-function hookParallel(promises, concurrency = Number.POSITIVE_INFINITY) {
-  const limit = pLimit(concurrency);
-  const tasks = promises.filter(Boolean).map((promise) => limit(() => promise()));
-  return Promise.allSettled(tasks);
-}
-const hookFirstNullCheck = (state) => !!(state == null ? void 0 : state.result);
-var PluginDriver = (_d$1 = class {
+var PluginDriver = (_b$1 = class {
   constructor(config, options) {
     __privateAdd$1(this, _PluginDriver_instances);
     __publicField$1(this, "config");
@@ -5662,62 +5429,9 @@ var PluginDriver = (_d$1 = class {
     __privateAdd$1(this, _resolvers, /* @__PURE__ */ new Map());
     __privateAdd$1(this, _defaultResolvers, /* @__PURE__ */ new Map());
     __privateAdd$1(this, _hookListeners, /* @__PURE__ */ new Map());
-    /**
-    * @deprecated use resolvers context instead
-    */
-    __publicField$1(this, "resolvePath", (params) => {
-      var _a2, _b2;
-      const defaultPath = resolve(resolve(this.config.root, this.config.output.path), params.baseName);
-      if (params.pluginName) return ((_a2 = this.hookForPluginSync({
-        pluginName: params.pluginName,
-        hookName: "resolvePath",
-        parameters: [
-          params.baseName,
-          params.mode,
-          params.options
-        ]
-      })) == null ? void 0 : _a2.at(0)) || defaultPath;
-      return ((_b2 = this.hookFirstSync({
-        hookName: "resolvePath",
-        parameters: [
-          params.baseName,
-          params.mode,
-          params.options
-        ]
-      })) == null ? void 0 : _b2.result) || defaultPath;
-    });
-    /**
-    * @deprecated use resolvers context instead
-    */
-    __publicField$1(this, "resolveName", (params) => {
-      var _a2, _b2, _c2;
-      if (params.pluginName) return transformReservedWord((_b2 = (_a2 = this.hookForPluginSync({
-        pluginName: params.pluginName,
-        hookName: "resolveName",
-        parameters: [params.name.trim(), params.type]
-      })) == null ? void 0 : _a2.at(0)) != null ? _b2 : params.name);
-      const name = (_c2 = this.hookFirstSync({
-        hookName: "resolveName",
-        parameters: [params.name.trim(), params.type]
-      })) == null ? void 0 : _c2.result;
-      return transformReservedWord(name != null ? name : params.name);
-    });
     this.config = config;
-    this.options = {
-      ...options,
-      hooks: options.hooks
-    };
-    config.plugins.map((rawPlugin) => {
-      var _a2, _b2;
-      if (isHookStylePlugin(rawPlugin)) return __privateMethod$1(this, _PluginDriver_instances, normalizeHookStylePlugin_fn).call(this, rawPlugin);
-      return {
-        ...rawPlugin,
-        buildStart: (_a2 = rawPlugin.buildStart) != null ? _a2 : (() => {
-        }),
-        buildEnd: (_b2 = rawPlugin.buildEnd) != null ? _b2 : (() => {
-        })
-      };
-    }).filter((plugin) => {
+    this.options = options;
+    config.plugins.map((rawPlugin) => __privateMethod$1(this, _PluginDriver_instances, normalizePlugin_fn).call(this, rawPlugin)).filter((plugin) => {
       if (typeof plugin.apply === "function") return plugin.apply(config);
       return true;
     }).sort((a, b) => {
@@ -5743,7 +5457,6 @@ var PluginDriver = (_d$1 = class {
     return extname(fileOrFolder) ? "single" : "split";
   }
   get hooks() {
-    if (!this.options.hooks) throw new Error("hooks are not defined");
     return this.options.hooks;
   }
   /**
@@ -5758,6 +5471,8 @@ var PluginDriver = (_d$1 = class {
   *
   * External tooling can subscribe to any of these events via `hooks.on(...)` to observe
   * the plugin lifecycle without modifying plugin behavior.
+  *
+  * @internal
   */
   registerPluginHooks(hookPlugin, normalizedPlugin) {
     const { hooks } = hookPlugin;
@@ -5785,16 +5500,13 @@ var PluginDriver = (_d$1 = class {
               ...opts
             };
           },
-          injectFile: (file) => {
-            var _a3;
-            const fileNode = createFile({
-              baseName: file.baseName,
-              path: file.path,
-              sources: (_a3 = file.sources) != null ? _a3 : [],
+          injectFile: ({ sources = [], ...rest }) => {
+            this.fileManager.add(createFile({
               imports: [],
-              exports: []
-            });
-            this.fileManager.add(fileNode);
+              exports: [],
+              sources,
+              ...rest
+            }));
           }
         };
         return hooks["kubb:plugin:setup"](pluginCtx);
@@ -5815,23 +5527,18 @@ var PluginDriver = (_d$1 = class {
   * Call this once from `safeBuild` before the plugin execution loop begins.
   */
   async emitSetupHooks() {
+    const noop = () => {
+    };
     await this.hooks.emit("kubb:plugin:setup", {
       config: this.config,
-      addGenerator: () => {
-      },
-      setResolver: () => {
-      },
-      setTransformer: () => {
-      },
-      setRenderer: () => {
-      },
-      setOptions: () => {
-      },
-      injectFile: () => {
-      },
-      updateConfig: () => {
-      },
-      options: {}
+      options: {},
+      addGenerator: noop,
+      setResolver: noop,
+      setTransformer: noop,
+      setRenderer: noop,
+      setOptions: noop,
+      injectFile: noop,
+      updateConfig: noop
     });
   }
   /**
@@ -5890,11 +5597,22 @@ var PluginDriver = (_d$1 = class {
   hasRegisteredGenerators(pluginName) {
     return __privateGet$1(this, _pluginsWithEventGenerators).has(pluginName);
   }
+  /**
+  * Unregisters all plugin lifecycle listeners from the shared event emitter.
+  * Called at the end of a build to prevent listener leaks across repeated builds.
+  *
+  * @internal
+  */
   dispose() {
     for (const [event, handlers] of __privateGet$1(this, _hookListeners)) for (const handler of handlers) this.hooks.off(event, handler);
     __privateGet$1(this, _hookListeners).clear();
     __privateGet$1(this, _pluginsWithEventGenerators).clear();
   }
+  /**
+  * Merges `partial` with the plugin's default resolver and stores the result.
+  * Also mirrors it onto `plugin.resolver` so callers using `getPlugin(name).resolver`
+  * get the up-to-date resolver without going through `getResolver()`.
+  */
   setPluginResolver(pluginName, partial) {
     const merged = {
       ...__privateMethod$1(this, _PluginDriver_instances, createDefaultResolver_fn).call(this, pluginName),
@@ -5904,23 +5622,25 @@ var PluginDriver = (_d$1 = class {
     const plugin = this.plugins.get(pluginName);
     if (plugin) plugin.resolver = merged;
   }
+  /**
+  * Returns the resolver for the given plugin.
+  *
+  * Resolution order: dynamic resolver set via `setPluginResolver` → static resolver on the
+  * plugin → lazily created default resolver (identity name, no path transforms).
+  */
   getResolver(pluginName) {
-    var _a2;
-    const dynamicResolver = __privateGet$1(this, _resolvers).get(pluginName);
-    if (dynamicResolver) return dynamicResolver;
-    const pluginResolver = (_a2 = this.plugins.get(pluginName)) == null ? void 0 : _a2.resolver;
-    if (pluginResolver) return pluginResolver;
-    return __privateMethod$1(this, _PluginDriver_instances, createDefaultResolver_fn).call(this, pluginName);
+    var _a2, _b2, _c;
+    return (_c = (_b2 = __privateGet$1(this, _resolvers).get(pluginName)) != null ? _b2 : (_a2 = this.plugins.get(pluginName)) == null ? void 0 : _a2.resolver) != null ? _c : __privateMethod$1(this, _PluginDriver_instances, createDefaultResolver_fn).call(this, pluginName);
   }
   getContext(plugin) {
     const driver = this;
-    const baseContext = {
+    return {
       config: driver.config,
       get root() {
         return resolve(driver.config.root, driver.config.output.path);
       },
       getMode(output) {
-        return _d$1.getMode(resolve(driver.config.root, driver.config.output.path, output.path));
+        return _b$1.getMode(resolve(driver.config.root, driver.config.output.path, output.path));
       },
       hooks: driver.hooks,
       plugin,
@@ -5964,188 +5684,6 @@ var PluginDriver = (_d$1 = class {
         return openInStudio(driver.inputNode, studioUrl, options);
       }
     };
-    let mergedExtras = {};
-    for (const p of this.plugins.values()) if (typeof p.inject === "function") {
-      const result = p.inject.call(baseContext);
-      if (result !== null && typeof result === "object") mergedExtras = {
-        ...mergedExtras,
-        ...result
-      };
-    }
-    return {
-      ...baseContext,
-      ...mergedExtras
-    };
-  }
-  /**
-  * @deprecated use resolvers context instead
-  */
-  getFile({ name, mode, extname: extname2, pluginName, options }) {
-    const resolvedName = mode ? mode === "single" ? "" : this.resolveName({
-      name,
-      pluginName,
-      type: "file"
-    }) : name;
-    const path2 = this.resolvePath({
-      baseName: `${resolvedName}${extname2}`,
-      mode,
-      pluginName,
-      options
-    });
-    if (!path2) throw new Error(`Filepath should be defined for resolvedName "${resolvedName}" and pluginName "${pluginName}"`);
-    return createFile({
-      path: path2,
-      baseName: basename(path2),
-      meta: { pluginName },
-      sources: [],
-      imports: [],
-      exports: []
-    });
-  }
-  /**
-  * Run a specific hookName for plugin x.
-  */
-  async hookForPlugin({ pluginName, hookName, parameters }) {
-    const plugin = this.plugins.get(pluginName);
-    if (!plugin) return [null];
-    this.hooks.emit("kubb:plugins:hook:progress:start", {
-      hookName,
-      plugins: [plugin]
-    });
-    const result = await __privateMethod$1(this, _PluginDriver_instances, execute_fn).call(this, {
-      strategy: "hookFirst",
-      hookName,
-      parameters,
-      plugin
-    });
-    this.hooks.emit("kubb:plugins:hook:progress:end", { hookName });
-    return [result];
-  }
-  /**
-  * Run a specific hookName for plugin x.
-  */
-  hookForPluginSync({ pluginName, hookName, parameters }) {
-    const plugin = this.plugins.get(pluginName);
-    if (!plugin) return null;
-    const result = __privateMethod$1(this, _PluginDriver_instances, executeSync_fn).call(this, {
-      strategy: "hookFirst",
-      hookName,
-      parameters,
-      plugin
-    });
-    return result !== null ? [result] : [];
-  }
-  /**
-  * Returns the first non-null result.
-  */
-  async hookFirst({ hookName, parameters, skipped }) {
-    const plugins = [];
-    for (const plugin of this.plugins.values()) if (hookName in plugin && (skipped ? !skipped.has(plugin) : true)) plugins.push(plugin);
-    this.hooks.emit("kubb:plugins:hook:progress:start", {
-      hookName,
-      plugins
-    });
-    const result = await hookFirst(plugins.map((plugin) => {
-      return async () => {
-        const value = await __privateMethod$1(this, _PluginDriver_instances, execute_fn).call(this, {
-          strategy: "hookFirst",
-          hookName,
-          parameters,
-          plugin
-        });
-        return Promise.resolve({
-          plugin,
-          result: value
-        });
-      };
-    }), hookFirstNullCheck);
-    this.hooks.emit("kubb:plugins:hook:progress:end", { hookName });
-    return result;
-  }
-  /**
-  * Returns the first non-null result.
-  */
-  hookFirstSync({ hookName, parameters, skipped }) {
-    let parseResult = null;
-    for (const plugin of this.plugins.values()) {
-      if (!(hookName in plugin)) continue;
-      if (skipped == null ? void 0 : skipped.has(plugin)) continue;
-      parseResult = {
-        result: __privateMethod$1(this, _PluginDriver_instances, executeSync_fn).call(this, {
-          strategy: "hookFirst",
-          hookName,
-          parameters,
-          plugin
-        }),
-        plugin
-      };
-      if (parseResult.result != null) break;
-    }
-    return parseResult;
-  }
-  /**
-  * Runs all plugins in parallel based on `this.plugin` order and `dependencies` settings.
-  */
-  async hookParallel({ hookName, parameters }) {
-    const plugins = [];
-    for (const plugin of this.plugins.values()) if (hookName in plugin) plugins.push(plugin);
-    this.hooks.emit("kubb:plugins:hook:progress:start", {
-      hookName,
-      plugins
-    });
-    const pluginStartTimes = /* @__PURE__ */ new Map();
-    const results = await hookParallel(plugins.map((plugin) => {
-      return () => {
-        pluginStartTimes.set(plugin, performance.now());
-        return __privateMethod$1(this, _PluginDriver_instances, execute_fn).call(this, {
-          strategy: "hookParallel",
-          hookName,
-          parameters,
-          plugin
-        });
-      };
-    }), this.options.concurrency);
-    results.forEach((result, index) => {
-      var _a2;
-      if (isPromiseRejectedResult(result)) {
-        const plugin = plugins[index];
-        if (plugin) {
-          const startTime = (_a2 = pluginStartTimes.get(plugin)) != null ? _a2 : performance.now();
-          this.hooks.emit("kubb:error", result.reason, {
-            plugin,
-            hookName,
-            strategy: "hookParallel",
-            duration: Math.round(performance.now() - startTime),
-            parameters
-          });
-        }
-      }
-    });
-    this.hooks.emit("kubb:plugins:hook:progress:end", { hookName });
-    return results.reduce((acc, result) => {
-      if (result.status === "fulfilled") acc.push(result.value);
-      return acc;
-    }, []);
-  }
-  /**
-  * Execute a lifecycle hook sequentially for all plugins that implement it.
-  */
-  async hookSeq({ hookName, parameters }) {
-    const plugins = [];
-    for (const plugin of this.plugins.values()) if (hookName in plugin) plugins.push(plugin);
-    this.hooks.emit("kubb:plugins:hook:progress:start", {
-      hookName,
-      plugins
-    });
-    await hookSeq(plugins.map((plugin) => {
-      return () => __privateMethod$1(this, _PluginDriver_instances, execute_fn).call(this, {
-        strategy: "hookSeq",
-        hookName,
-        parameters,
-        plugin
-      });
-    }));
-    this.hooks.emit("kubb:plugins:hook:progress:end", { hookName });
   }
   getPlugin(pluginName) {
     return this.plugins.get(pluginName);
@@ -6156,16 +5694,10 @@ var PluginDriver = (_d$1 = class {
     return plugin;
   }
 }, _studioIsOpen = new WeakMap(), _pluginsWithEventGenerators = new WeakMap(), _resolvers = new WeakMap(), _defaultResolvers = new WeakMap(), _hookListeners = new WeakMap(), _PluginDriver_instances = new WeakSet(), /**
-* Creates a `Plugin`-compatible object from a hook-style plugin and registers
+* Creates an `NormalizedPlugin` from a hook-style plugin and registers
 * its lifecycle handlers on the `AsyncEventEmitter`.
-*
-* The normalized plugin has an empty `buildStart` — generators registered via
-* `addGenerator()` in `kubb:plugin:setup` are stored on `normalizedPlugin.generators`
-* and used by `runPluginAstHooks` during the build.
 */
-normalizeHookStylePlugin_fn = function(hookPlugin) {
-  const generators = [];
-  const driver = this;
+normalizePlugin_fn = function(hookPlugin) {
   const normalizedPlugin = {
     name: hookPlugin.name,
     dependencies: hookPlugin.dependencies,
@@ -6173,30 +5705,6 @@ normalizeHookStylePlugin_fn = function(hookPlugin) {
       output: { path: "." },
       exclude: [],
       override: []
-    },
-    generators,
-    inject: () => void 0,
-    resolveName(name, type) {
-      return driver.getResolver(hookPlugin.name).default(name, type);
-    },
-    resolvePath(baseName, pathMode, resolveOptions) {
-      const resolver = driver.getResolver(hookPlugin.name);
-      const opts = normalizedPlugin.options;
-      const group = resolveOptions == null ? void 0 : resolveOptions.group;
-      return resolver.resolvePath({
-        baseName,
-        pathMode,
-        tag: group == null ? void 0 : group.tag,
-        path: group == null ? void 0 : group.path
-      }, {
-        root: resolve(driver.config.root, driver.config.output.path),
-        output: opts.output,
-        group: opts.group
-      });
-    },
-    buildStart() {
-    },
-    buildEnd() {
     }
   };
   this.registerPluginHooks(hookPlugin, normalizedPlugin);
@@ -6217,84 +5725,7 @@ normalizeHookStylePlugin_fn = function(hookPlugin) {
   }));
   __privateGet$1(this, _defaultResolvers).set(pluginName, resolver);
   return resolver;
-}, /**
-* Emit hook-processing completion metadata after a plugin hook resolves.
-*/
-emitProcessingEnd_fn = function({ startTime, output, strategy, hookName, plugin, parameters }) {
-  this.hooks.emit("kubb:plugins:hook:processing:end", {
-    duration: Math.round(performance.now() - startTime),
-    parameters,
-    output,
-    strategy,
-    hookName,
-    plugin
-  });
-}, execute_fn = function({ strategy, hookName, parameters, plugin }) {
-  const hook = plugin[hookName];
-  if (!hook) return null;
-  this.hooks.emit("kubb:plugins:hook:processing:start", {
-    strategy,
-    hookName,
-    parameters,
-    plugin
-  });
-  const startTime = performance.now();
-  return (async () => {
-    try {
-      const output = typeof hook === "function" ? await Promise.resolve(hook.apply(this.getContext(plugin), parameters != null ? parameters : [])) : hook;
-      __privateMethod$1(this, _PluginDriver_instances, emitProcessingEnd_fn).call(this, {
-        startTime,
-        output,
-        strategy,
-        hookName,
-        plugin,
-        parameters
-      });
-      return output;
-    } catch (error) {
-      this.hooks.emit("kubb:error", error, {
-        plugin,
-        hookName,
-        strategy,
-        duration: Math.round(performance.now() - startTime)
-      });
-      return null;
-    }
-  })();
-}, /**
-* Execute a plugin lifecycle hook synchronously and return its output.
-*/
-executeSync_fn = function({ strategy, hookName, parameters, plugin }) {
-  const hook = plugin[hookName];
-  if (!hook) return null;
-  this.hooks.emit("kubb:plugins:hook:processing:start", {
-    strategy,
-    hookName,
-    parameters,
-    plugin
-  });
-  const startTime = performance.now();
-  try {
-    const output = typeof hook === "function" ? hook.apply(this.getContext(plugin), parameters) : hook;
-    __privateMethod$1(this, _PluginDriver_instances, emitProcessingEnd_fn).call(this, {
-      startTime,
-      output,
-      strategy,
-      hookName,
-      plugin,
-      parameters
-    });
-    return output;
-  } catch (error) {
-    this.hooks.emit("kubb:error", error, {
-      plugin,
-      hookName,
-      strategy,
-      duration: Math.round(performance.now() - startTime)
-    });
-    return null;
-  }
-}, _d$1);
+}, _b$1);
 
 var __defProp = Object.defineProperty;
 var __typeError = (msg) => {
@@ -6307,7 +5738,15 @@ 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"), member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var _emitter, _a, _options, _URLPath_instances, transformParam_fn, eachParam_fn, _b, _limit, _c, _cachedLeaves, _d;
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var _emitter, _a, _options, _URLPath_instances, transformParam_fn, eachParam_fn, _b, _c, _head, _tail, _size, _d, _limit, _e, _cachedLeaves, _f;
 var BuildError = class extends Error {
   constructor(message, options) {
     super(message, { cause: options.cause });
@@ -6472,6 +5911,14 @@ async function clean(path2) {
     force: true
   });
 }
+function isValidVarName(name) {
+  try {
+    new Function(`var ${name}`);
+  } catch {
+    return false;
+  }
+  return true;
+}
 var URLPath = (_b = class {
   constructor(path2, options = {}) {
     __privateAdd(this, _URLPath_instances);
@@ -6607,10 +6054,134 @@ eachParam_fn = function(fn) {
     fn(raw, __privateMethod(this, _URLPath_instances, transformParam_fn).call(this, raw));
   }
 }, _b);
+var Node$1 = (_c = class {
+  constructor(value) {
+    __publicField(this, "value");
+    __publicField(this, "next");
+    this.value = value;
+  }
+}, __name(_c, "Node"), _c);
+var Queue = (_d = class {
+  constructor() {
+    __privateAdd(this, _head);
+    __privateAdd(this, _tail);
+    __privateAdd(this, _size);
+    this.clear();
+  }
+  enqueue(value) {
+    const node = new Node$1(value);
+    if (__privateGet(this, _head)) {
+      __privateGet(this, _tail).next = node;
+      __privateSet(this, _tail, node);
+    } else {
+      __privateSet(this, _head, node);
+      __privateSet(this, _tail, node);
+    }
+    __privateWrapper(this, _size)._++;
+  }
+  dequeue() {
+    const current = __privateGet(this, _head);
+    if (!current) return;
+    __privateSet(this, _head, __privateGet(this, _head).next);
+    __privateWrapper(this, _size)._--;
+    if (!__privateGet(this, _head)) __privateSet(this, _tail, void 0);
+    return current.value;
+  }
+  peek() {
+    if (!__privateGet(this, _head)) return;
+    return __privateGet(this, _head).value;
+  }
+  clear() {
+    __privateSet(this, _head, void 0);
+    __privateSet(this, _tail, void 0);
+    __privateSet(this, _size, 0);
+  }
+  get size() {
+    return __privateGet(this, _size);
+  }
+  *[Symbol.iterator]() {
+    let current = __privateGet(this, _head);
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+  *drain() {
+    while (__privateGet(this, _head)) yield this.dequeue();
+  }
+}, _head = new WeakMap(), _tail = new WeakMap(), _size = new WeakMap(), _d);
+function pLimit(concurrency) {
+  let rejectOnClear = false;
+  if (typeof concurrency === "object") ({ concurrency, rejectOnClear = false } = concurrency);
+  validateConcurrency(concurrency);
+  if (typeof rejectOnClear !== "boolean") throw new TypeError("Expected `rejectOnClear` to be a boolean");
+  const queue = new Queue();
+  let activeCount = 0;
+  const resumeNext = () => {
+    if (activeCount < concurrency && queue.size > 0) {
+      activeCount++;
+      queue.dequeue().run();
+    }
+  };
+  const next = () => {
+    activeCount--;
+    resumeNext();
+  };
+  const run = async (function_, resolve2, arguments_) => {
+    const result = (async () => function_(...arguments_))();
+    resolve2(result);
+    try {
+      await result;
+    } catch {
+    }
+    next();
+  };
+  const enqueue = (function_, resolve2, reject, arguments_) => {
+    const queueItem = { reject };
+    new Promise((internalResolve) => {
+      queueItem.run = internalResolve;
+      queue.enqueue(queueItem);
+    }).then(run.bind(void 0, function_, resolve2, arguments_));
+    if (activeCount < concurrency) resumeNext();
+  };
+  const generator = (function_, ...arguments_) => new Promise((resolve2, reject) => {
+    enqueue(function_, resolve2, reject, arguments_);
+  });
+  Object.defineProperties(generator, {
+    activeCount: { get: () => activeCount },
+    pendingCount: { get: () => queue.size },
+    clearQueue: { value() {
+      if (!rejectOnClear) {
+        queue.clear();
+        return;
+      }
+      const abortError = AbortSignal.abort().reason;
+      while (queue.size > 0) queue.dequeue().reject(abortError);
+    } },
+    concurrency: {
+      get: () => concurrency,
+      set(newConcurrency) {
+        validateConcurrency(newConcurrency);
+        concurrency = newConcurrency;
+        queueMicrotask(() => {
+          while (activeCount < concurrency && queue.size > 0) resumeNext();
+        });
+      }
+    },
+    map: { async value(iterable, function_) {
+      const promises = Array.from(iterable, (value, index) => this(function_, value, index));
+      return Promise.all(promises);
+    } }
+  });
+  return generator;
+}
+function validateConcurrency(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+}
 function joinSources(file) {
   return file.sources.map((item) => extractStringsFromNodes(item.nodes)).filter(Boolean).join("\n\n");
 }
-var FileProcessor = (_c = class {
+var FileProcessor = (_e = class {
   constructor() {
     __privateAdd(this, _limit, pLimit(100));
   }
@@ -6645,7 +6216,7 @@ var FileProcessor = (_c = class {
     await (onEnd == null ? void 0 : onEnd(files));
     return files;
   }
-}, _limit = new WeakMap(), _c);
+}, _limit = new WeakMap(), _e);
 function createStorage(build2) {
   return (options) => build2(options != null ? options : {});
 }
@@ -6702,7 +6273,7 @@ const fsStorage = createStorage(() => ({
     await clean(resolve(base));
   }
 }));
-var version$1 = "5.0.0-alpha.42";
+var version$1 = "5.0.0-alpha.44";
 function getDiagnosticInfo() {
   return {
     nodeVersion: version$2,
@@ -6712,7 +6283,7 @@ function getDiagnosticInfo() {
     cwd: process.cwd()
   };
 }
-var TreeNode = (_d = class {
+var TreeNode = (_f = class {
   constructor(data, parent) {
     __publicField(this, "data");
     __publicField(this, "parent");
@@ -6722,7 +6293,7 @@ var TreeNode = (_d = class {
     this.parent = parent;
   }
   addChild(data) {
-    const child = new _d(data, this);
+    const child = new _f(data, this);
     if (!this.children) this.children = [];
     this.children.push(child);
     return child;
@@ -6795,7 +6366,7 @@ var TreeNode = (_d = class {
     try {
       const filteredTree = buildDirectoryTree(files, root);
       if (!filteredTree) return null;
-      const treeNode = new _d({
+      const treeNode = new _f({
         name: filteredTree.name,
         path: filteredTree.path,
         file: filteredTree.file,
@@ -6821,7 +6392,7 @@ var TreeNode = (_d = class {
       throw new Error("Something went wrong with creating barrel files with the TreeNode class", { cause: error });
     }
   }
-}, _cachedLeaves = new WeakMap(), _d);
+}, _cachedLeaves = new WeakMap(), _f);
 const normalizePath = (p) => p.replaceAll("\\", "/");
 function buildDirectoryTree(files, rootFolder = "") {
   const normalizedRootFolder = normalizePath(rootFolder);
@@ -6868,8 +6439,8 @@ function getBarrelFilesByRoot(root, files) {
     var _a3, _b2;
     if (!(treeNode == null ? void 0 : treeNode.children) || !((_a3 = treeNode.parent) == null ? void 0 : _a3.data.path)) return;
     const barrelFile = createFile({
-      path: join((_b2 = treeNode.parent) == null ? void 0 : _b2.data.path, "index.ts"),
-      baseName: "index.ts",
+      path: join((_b2 = treeNode.parent) == null ? void 0 : _b2.data.path, BARREL_FILENAME),
+      baseName: BARREL_FILENAME,
       exports: [],
       imports: [],
       sources: []
@@ -6934,7 +6505,7 @@ function isInputPath(config) {
   return typeof (config == null ? void 0 : config.input) === "object" && config.input !== null && "path" in config.input;
 }
 async function setup(userConfig, options = {}) {
-  var _a2, _b2, _c2, _d2, _e, _f, _g, _h, _i;
+  var _a2, _b2, _c2, _d2, _e2, _f2, _g, _h, _i;
   const hooks = (_a2 = options.hooks) != null ? _a2 : new AsyncEventEmitter();
   const sources = /* @__PURE__ */ new Map();
   const diagnosticInfo = getDiagnosticInfo();
@@ -6948,8 +6519,8 @@ async function setup(userConfig, options = {}) {
       `  \u2022 Output: ${((_b2 = userConfig.output) == null ? void 0 : _b2.path) || "not specified"}`,
       `  \u2022 Plugins: ${((_c2 = userConfig.plugins) == null ? void 0 : _c2.length) || 0}`,
       "Output Settings:",
-      `  \u2022 Storage: ${((_d2 = userConfig.output) == null ? void 0 : _d2.storage) ? `custom(${userConfig.output.storage.name})` : ((_e = userConfig.output) == null ? void 0 : _e.write) === false ? "disabled" : "filesystem (default)"}`,
-      `  \u2022 Formatter: ${((_f = userConfig.output) == null ? void 0 : _f.format) || "none"}`,
+      `  \u2022 Storage: ${((_d2 = userConfig.output) == null ? void 0 : _d2.storage) ? `custom(${userConfig.output.storage.name})` : ((_e2 = userConfig.output) == null ? void 0 : _e2.write) === false ? "disabled" : "filesystem (default)"}`,
+      `  \u2022 Formatter: ${((_f2 = userConfig.output) == null ? void 0 : _f2.format) || "none"}`,
       `  \u2022 Linter: ${((_g = userConfig.output) == null ? void 0 : _g.lint) || "none"}`,
       "Environment:",
       Object.entries(diagnosticInfo).map(([key, value]) => `  \u2022 ${key}: ${value}`).join("\n")
@@ -6996,10 +6567,7 @@ async function setup(userConfig, options = {}) {
     });
     await (storage == null ? void 0 : storage.clear(resolve(config.root, config.output.path)));
   }
-  const driver = new PluginDriver(config, {
-    hooks,
-    concurrency: 15
-  });
+  const driver = new PluginDriver(config, { hooks });
   const adapter = config.adapter;
   if (!adapter) throw new Error("No adapter configured. Please provide an adapter in your kubb.config.ts.");
   const source = inputToAdapterSource(config);
@@ -7096,7 +6664,7 @@ async function runPluginAstHooks(plugin, context) {
   }
 }
 async function safeBuild(setupResult) {
-  var _a2, _b2, _c2, _d2, _e, _f;
+  var _a2, _b2, _c2, _d2, _e2, _f2;
   const { driver, hooks, sources, storage } = setupResult;
   const failedPlugins = /* @__PURE__ */ new Set();
   const pluginTimings = /* @__PURE__ */ new Map();
@@ -7121,7 +6689,6 @@ async function safeBuild(setupResult) {
           date: timestamp,
           logs: ["Starting plugin...", `  \u2022 Plugin Name: ${plugin.name}`]
         });
-        await plugin.buildStart.call(context);
         if (((_b2 = plugin.generators) == null ? void 0 : _b2.length) || driver.hasRegisteredGenerators(plugin.name)) await runPluginAstHooks(plugin, context);
         if (output) {
           const barrelFiles = await getBarrelFiles(driver.fileManager.files, {
@@ -7192,7 +6759,7 @@ async function safeBuild(setupResult) {
         exports: buildBarrelExports({
           barrelFiles,
           rootDir,
-          existingExports: new Set((_e = (_d2 = existingBarrel == null ? void 0 : existingBarrel.exports) == null ? void 0 : _d2.flatMap((e) => Array.isArray(e.name) ? e.name : [e.name]).filter((n) => Boolean(n))) != null ? _e : []),
+          existingExports: new Set((_e2 = (_d2 = existingBarrel == null ? void 0 : existingBarrel.exports) == null ? void 0 : _d2.flatMap((e) => Array.isArray(e.name) ? e.name : [e.name]).filter((n) => Boolean(n))) != null ? _e2 : []),
           config,
           driver
         }).map((e) => createExport(e)),
@@ -7203,7 +6770,7 @@ async function safeBuild(setupResult) {
       driver.fileManager.upsert(rootFile);
       await hooks.emit("kubb:debug", {
         date: /* @__PURE__ */ new Date(),
-        logs: [`\u2713 Generated barrel file (${((_f = rootFile.exports) == null ? void 0 : _f.length) || 0} exports)`]
+        logs: [`\u2713 Generated barrel file (${((_f2 = rootFile.exports) == null ? void 0 : _f2.length) || 0} exports)`]
       });
     }
     const files = driver.fileManager.files;
@@ -7242,10 +6809,6 @@ async function safeBuild(setupResult) {
         });
       }
     });
-    for (const plugin of driver.plugins.values()) if (plugin.buildEnd) {
-      const context = driver.getContext(plugin);
-      await plugin.buildEnd.call(context);
-    }
     await hooks.emit("kubb:build:end", {
       files,
       config,
@@ -7390,7 +6953,7 @@ const memoryStorage = createStorage(() => {
   };
 });
 
-var version = "5.0.0-alpha.42";
+var version = "5.0.0-alpha.44";
 
 function isCommandMessage(msg) {
   return msg.type === "command";
@@ -7598,9 +7161,7 @@ async function loadPluginFactory(packageName) {
   if (typeof mod["default"] === "function") return mod["default"];
   const firstFn = Object.values(mod).find((v) => typeof v === "function");
   if (firstFn) return firstFn;
-  throw new Error(
-    `Plugin "${packageName}" does not export a callable factory. Tried: named export "${exportName}", "default", and any exported function.`
-  );
+  throw new Error(`Plugin "${packageName}" does not export a callable factory. Tried: named export "${exportName}", "default", and any exported function.`);
 }
 async function resolvePlugins(plugins) {
   return Promise.all(