@kubb/agent 5.0.0-beta.20 → 5.0.0-beta.22

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

@@ -4889,7 +4889,7 @@ function* collectLazy(node, options) {
       v = (_g = visitor.response) == null ? void 0 : _g.call(visitor, node, { parent });
       break;
   }
-  if (v !== void 0) yield v;
+  if (v != null) yield v;
   for (const child of getChildren(node, recurse)) yield* collectLazy(child, {
     ...options,
     parent: node
@@ -5037,9 +5037,9 @@ function extractStringsFromNodes(nodes) {
 }
 function resolveRefName(node) {
   var _a, _b, _c, _d, _e, _f, _g;
-  if (!node || node.type !== "ref") return void 0;
-  if (node.ref) return (_d = (_c = (_a = extractRefName(node.ref)) != null ? _a : node.name) != null ? _c : (_b = node.schema) == null ? void 0 : _b.name) != null ? _d : void 0;
-  return (_g = (_f = node.name) != null ? _f : (_e = node.schema) == null ? void 0 : _e.name) != null ? _g : void 0;
+  if (!node || node.type !== "ref") return null;
+  if (node.ref) return (_d = (_c = (_a = extractRefName(node.ref)) != null ? _a : node.name) != null ? _c : (_b = node.schema) == null ? void 0 : _b.name) != null ? _d : null;
+  return (_g = (_f = node.name) != null ? _f : (_e = node.schema) == null ? void 0 : _e.name) != null ? _g : null;
 }
 const collectSchemaRefs = memoize$1(/* @__PURE__ */ new WeakMap(), (node) => {
   const refs = /* @__PURE__ */ new Set();
@@ -5148,9 +5148,117 @@ var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !==
 var __accessCheck$1 = (obj, member, msg) => member.has(obj) || __typeError$1("Cannot " + msg);
 var __privateGet$1 = (obj, member, getter) => (__accessCheck$1(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 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 = (obj, member, value, setter) => (__accessCheck$1(obj, member, "write to private field"), member.set(obj, value), 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 _options, _URLPath_instances, transformParam_fn, eachParam_fn, _a$1, _cache, _filesCache, _FileManager_instances, store_fn, _b, _studio, _middlewareListeners, _eventGeneratorPlugins, _resolvers, _defaultResolvers, _hookListeners, _KubbDriver_instances, normalizePlugin_fn, registerAdapter_fn, registerMiddleware_fn, registerPlugin_fn, trackHookListener_fn, _getDefaultResolver, _c;
+var _emitter, _AsyncEventEmitter_instances, emitAll_fn, _a$1, _options, _URLPath_instances, transformParam_fn, eachParam_fn, _b, _cache, _sorted, _onUpsert, _FileManager_instances, store_fn, dedupe_fn, _c, _studio, _middlewareListeners, _fileProcessor, _eventGeneratorPlugins, _resolvers, _defaultResolvers, _hookListeners, _KubbDriver_instances, normalizePlugin_fn, registerAdapter_fn, registerMiddleware_fn, registerPlugin_fn, filesPayload_fn, emitPluginEnd_fn, runGenerators_fn, trackHookListener_fn, _getDefaultResolver, _d;
+var BuildError = class extends Error {
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    __publicField$1(this, "errors");
+    this.name = "BuildError";
+    this.errors = options.errors;
+  }
+};
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+var AsyncEventEmitter = (_a$1 = class {
+  /**
+  * Maximum number of listeners per event before Node emits a memory-leak warning.
+  * @default 10
+  */
+  constructor(maxListener = 10) {
+    __privateAdd$1(this, _AsyncEventEmitter_instances);
+    __privateAdd$1(this, _emitter, new EventEmitter());
+    __privateGet$1(this, _emitter).setMaxListeners(maxListener);
+  }
+  /**
+  * Emits `eventName` and awaits all registered listeners sequentially.
+  * Throws if any listener rejects, wrapping the cause with the event name and serialized arguments.
+  *
+  * @example
+  * ```ts
+  * await emitter.emit('build', 'petstore')
+  * ```
+  */
+  emit(eventName, ...eventArgs) {
+    const listeners = __privateGet$1(this, _emitter).listeners(eventName);
+    if (listeners.length === 0) return;
+    return __privateMethod$1(this, _AsyncEventEmitter_instances, emitAll_fn).call(this, eventName, listeners, eventArgs);
+  }
+  /**
+  * Registers a persistent listener for `eventName`.
+  *
+  * @example
+  * ```ts
+  * emitter.on('build', async (name) => { console.log(name) })
+  * ```
+  */
+  on(eventName, handler) {
+    __privateGet$1(this, _emitter).on(eventName, handler);
+  }
+  /**
+  * Registers a one-shot listener that removes itself after the first invocation.
+  *
+  * @example
+  * ```ts
+  * emitter.onOnce('build', async (name) => { console.log(name) })
+  * ```
+  */
+  onOnce(eventName, handler) {
+    const wrapper = (...args) => {
+      this.off(eventName, wrapper);
+      return handler(...args);
+    };
+    this.on(eventName, wrapper);
+  }
+  /**
+  * Removes a previously registered listener.
+  *
+  * @example
+  * ```ts
+  * emitter.off('build', handler)
+  * ```
+  */
+  off(eventName, handler) {
+    __privateGet$1(this, _emitter).off(eventName, handler);
+  }
+  /**
+  * Returns the number of listeners registered for `eventName`.
+  *
+  * @example
+  * ```ts
+  * emitter.on('build', handler)
+  * emitter.listenerCount('build') // 1
+  * ```
+  */
+  listenerCount(eventName) {
+    return __privateGet$1(this, _emitter).listenerCount(eventName);
+  }
+  /**
+  * Removes all listeners from every event channel.
+  *
+  * @example
+  * ```ts
+  * emitter.removeAll()
+  * ```
+  */
+  removeAll() {
+    __privateGet$1(this, _emitter).removeAllListeners();
+  }
+}, _emitter = new WeakMap(), _AsyncEventEmitter_instances = new WeakSet(), emitAll_fn = async function(eventName, listeners, eventArgs) {
+  for (const listener of listeners) try {
+    await listener(...eventArgs);
+  } catch (err) {
+    let serializedArgs;
+    try {
+      serializedArgs = JSON.stringify(eventArgs);
+    } catch {
+      serializedArgs = String(eventArgs);
+    }
+    throw new Error(`Error in async listener for "${eventName}" with eventArgs ${serializedArgs}`, { cause: toError(err) });
+  }
+}, _a$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;
@@ -5176,6 +5284,16 @@ function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
   }) : camelCase(part));
   return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
+function getElapsedMs(hrStart) {
+  const [seconds, nanoseconds] = process.hrtime(hrStart);
+  const ms = seconds * 1e3 + nanoseconds / 1e6;
+  return Math.round(ms * 100) / 100;
+}
+function formatMs(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* chunks(arr, size) {
   for (let i = 0; i < arr.length; i += size) yield arr.slice(i, i + size);
 }
@@ -5201,10 +5319,6 @@ async function forBatches(source, process2, options) {
     if (flush) await flush();
   }
 }
-async function withDrain(work, flush) {
-  await work(flush);
-  await flush();
-}
 function isPromise(result) {
   return result !== null && result !== void 0 && typeof result["then"] === "function";
 }
@@ -5310,7 +5424,7 @@ function isValidVarName(name) {
   if (!name || reservedWords.has(name)) return false;
   return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
-var URLPath = (_a$1 = class {
+var URLPath = (_b = class {
   constructor(path2, options = {}) {
     __privateAdd$1(this, _URLPath_instances);
     /**
@@ -5319,7 +5433,7 @@ var URLPath = (_a$1 = class {
     __publicField$1(this, "path");
     __privateAdd$1(this, _options);
     this.path = path2;
-    __privateSet(this, _options, options);
+    __privateSet$1(this, _options, options);
   }
   /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
   *
@@ -5397,12 +5511,13 @@ var URLPath = (_a$1 = class {
   * @example
   * new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
   */
-  toTemplateString({ prefix = "", replacer } = {}) {
-    return `\`${prefix}${this.path.split(/\{([^}]+)\}/).map((part, i) => {
+  toTemplateString({ prefix, replacer } = {}) {
+    const result = this.path.split(/\{([^}]+)\}/).map((part, i) => {
       if (i % 2 === 0) return part;
       const param = __privateMethod$1(this, _URLPath_instances, transformParam_fn).call(this, part);
       return `\${${replacer ? replacer(param) : param}}`;
-    }).join("")}\``;
+    }).join("");
+    return `\`${prefix != null ? prefix : ""}${result}\``;
   }
   /**
   * Extracts all `{param}` segments from the path and returns them as a key-value map.
@@ -5444,7 +5559,7 @@ eachParam_fn = function(fn) {
     const raw = match[1];
     fn(raw, __privateMethod$1(this, _URLPath_instances, transformParam_fn).call(this, raw));
   }
-}, _a$1);
+}, _b);
 const DEFAULT_STUDIO_URL = "https://kubb.studio";
 const DEFAULT_BANNER = "simple";
 const DEFAULT_EXTENSION = { ".ts": ".ts" };
@@ -5596,7 +5711,7 @@ function buildDefaultBanner({ title, description, version, config }) {
 function defaultResolveBanner(meta, { output, config }) {
   if (typeof (output == null ? void 0 : output.banner) === "function") return output.banner(meta);
   if (typeof (output == null ? void 0 : output.banner) === "string") return output.banner;
-  if (config.output.defaultBanner === false) return;
+  if (config.output.defaultBanner === false) return null;
   return buildDefaultBanner({
     title: meta == null ? void 0 : meta.title,
     version: meta == null ? void 0 : meta.version,
@@ -5606,6 +5721,7 @@ function defaultResolveBanner(meta, { output, config }) {
 function defaultResolveFooter(meta, { output }) {
   if (typeof (output == null ? void 0 : output.footer) === "function") return output.footer(meta);
   if (typeof (output == null ? void 0 : output.footer) === "string") return output.footer;
+  return null;
 }
 function defineResolver(build) {
   let resolver;
@@ -5649,38 +5765,42 @@ function mergeFile(a, b) {
     ...a,
     banner: b.banner,
     footer: b.footer,
-    sources: [...a.sources || [], ...b.sources || []],
-    imports: [...a.imports || [], ...b.imports || []],
-    exports: [...a.exports || [], ...b.exports || []]
+    sources: a.sources.length ? b.sources.length ? [...a.sources, ...b.sources] : a.sources : b.sources,
+    imports: a.imports.length ? b.imports.length ? [...a.imports, ...b.imports] : a.imports : b.imports,
+    exports: a.exports.length ? b.exports.length ? [...a.exports, ...b.exports] : a.exports : b.exports
   };
 }
-function mergeFilesByPath(files) {
-  const merged = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    const existing = merged.get(file.path);
-    merged.set(file.path, existing ? mergeFile(existing, file) : file);
-  }
-  return merged;
+function isIndexPath(path2) {
+  return path2.endsWith("/index.ts") || path2 === "index.ts";
 }
-var FileManager = (_b = class {
+function compareFiles(a, b) {
+  const lenDiff = a.path.length - b.path.length;
+  if (lenDiff !== 0) return lenDiff;
+  const aIsIndex = isIndexPath(a.path);
+  const bIsIndex = isIndexPath(b.path);
+  if (aIsIndex && !bIsIndex) return 1;
+  if (!aIsIndex && bIsIndex) return -1;
+  return 0;
+}
+var FileManager = (_c = class {
   constructor() {
     __privateAdd$1(this, _FileManager_instances);
     __privateAdd$1(this, _cache, /* @__PURE__ */ new Map());
-    __privateAdd$1(this, _filesCache, null);
+    __privateAdd$1(this, _sorted, null);
+    __privateAdd$1(this, _onUpsert, null);
   }
   /**
-  * Adds one or more files. Incoming files with the same path are merged
-  * (sources/imports/exports concatenated), but existing cache entries are
-  * replaced — use {@link upsert} when you want to merge into the cache too.
+  * Registers a callback invoked with the resolved {@link FileNode} on every
+  * `add` / `upsert`. Used by the build loop to track newly written files
+  * without keeping its own scan-based diff. Single subscriber by design —
+  * setting again replaces the previous callback. Pass `null` to detach.
   */
+  setOnUpsert(callback) {
+    __privateSet$1(this, _onUpsert, callback);
+  }
   add(...files) {
     return __privateMethod$1(this, _FileManager_instances, store_fn).call(this, files, false);
   }
-  /**
-  * Adds or merges one or more files.
-  * If a file with the same path already exists in the cache, its
-  * sources/imports/exports are merged into the incoming file.
-  */
   upsert(...files) {
     return __privateMethod$1(this, _FileManager_instances, store_fn).call(this, files, true);
   }
@@ -5689,54 +5809,180 @@ var FileManager = (_b = class {
     return (_a2 = __privateGet$1(this, _cache).get(path2)) != null ? _a2 : null;
   }
   deleteByPath(path2) {
-    __privateGet$1(this, _cache).delete(path2);
-    __privateSet(this, _filesCache, null);
+    if (!__privateGet$1(this, _cache).delete(path2)) return;
+    __privateSet$1(this, _sorted, null);
   }
   clear() {
     __privateGet$1(this, _cache).clear();
-    __privateSet(this, _filesCache, null);
+    __privateSet$1(this, _sorted, null);
   }
   /**
-  * Releases all stored files. Called by the core after `kubb:build:end` to
-  * free the per-plugin FileNode caches for the rest of the process lifetime.
+  * Releases all stored files. Called by the core after `kubb:build:end`.
   */
   dispose() {
     this.clear();
+    __privateSet$1(this, _onUpsert, null);
   }
   [Symbol.dispose]() {
     this.dispose();
   }
   /**
-  * All stored files, sorted by path length (shorter paths first).
+  * All stored files in stable sort order (shortest path first, barrel files
+  * last within a length bucket). Returns a cached view — do not mutate.
   */
   get files() {
-    if (__privateGet$1(this, _filesCache)) return __privateGet$1(this, _filesCache);
-    __privateSet(this, _filesCache, [...__privateGet$1(this, _cache).values()].sort((a, b) => {
-      const lenDiff = a.path.length - b.path.length;
-      if (lenDiff !== 0) return lenDiff;
-      const aIsIndex = a.path.endsWith("/index.ts") || a.path === "index.ts";
-      const bIsIndex = b.path.endsWith("/index.ts") || b.path === "index.ts";
-      if (aIsIndex && !bIsIndex) return 1;
-      if (!aIsIndex && bIsIndex) return -1;
-      return 0;
-    }));
-    return __privateGet$1(this, _filesCache);
-  }
-}, _cache = new WeakMap(), _filesCache = new WeakMap(), _FileManager_instances = new WeakSet(), store_fn = function(files, mergeExisting) {
-  const resolvedFiles = [];
-  for (const file of mergeFilesByPath(files).values()) {
-    const existing = mergeExisting ? __privateGet$1(this, _cache).get(file.path) : void 0;
-    const resolvedFile = createFile(existing ? mergeFile(existing, file) : file);
-    __privateGet$1(this, _cache).set(resolvedFile.path, resolvedFile);
-    resolvedFiles.push(resolvedFile);
-  }
-  __privateSet(this, _filesCache, null);
-  return resolvedFiles;
-}, _b);
+    var _a2;
+    return (_a2 = __privateGet$1(this, _sorted)) != null ? _a2 : __privateSet$1(this, _sorted, [...__privateGet$1(this, _cache).values()].sort(compareFiles));
+  }
+}, _cache = new WeakMap(), _sorted = new WeakMap(), _onUpsert = new WeakMap(), _FileManager_instances = new WeakSet(), store_fn = function(files, mergeExisting) {
+  var _a2;
+  const batch = files.length > 1 ? __privateMethod$1(this, _FileManager_instances, dedupe_fn).call(this, files) : files;
+  const resolved = [];
+  for (const file of batch) {
+    const existing = __privateGet$1(this, _cache).get(file.path);
+    const merged = existing && mergeExisting ? createFile(mergeFile(existing, file)) : createFile(file);
+    __privateGet$1(this, _cache).set(merged.path, merged);
+    resolved.push(merged);
+    (_a2 = __privateGet$1(this, _onUpsert)) == null ? void 0 : _a2.call(this, merged);
+  }
+  if (resolved.length > 0) __privateSet$1(this, _sorted, null);
+  return resolved;
+}, dedupe_fn = function(files) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const prev = seen.get(file.path);
+    seen.set(file.path, prev ? mergeFile(prev, file) : file);
+  }
+  return [...seen.values()];
+}, _c);
+function joinSources(file) {
+  const sources = file.sources;
+  if (sources.length === 0) return "";
+  const parts = [];
+  for (const source of sources) {
+    const s = extractStringsFromNodes(source.nodes);
+    if (s) parts.push(s);
+  }
+  return parts.join("\n\n");
+}
+var FileProcessor = class {
+  constructor() {
+    __publicField$1(this, "events", new AsyncEventEmitter());
+  }
+  parse(file, { parsers, extension } = {}) {
+    const parseExtName = (extension == null ? void 0 : extension[file.extname]) || void 0;
+    if (!parsers || !file.extname) return joinSources(file);
+    const parser = parsers.get(file.extname);
+    if (!parser) return joinSources(file);
+    return parser.parse(file, { extname: parseExtName });
+  }
+  *stream(files, options = {}) {
+    const total = files.length;
+    if (total === 0) return;
+    let processed = 0;
+    for (const file of files) {
+      const source = this.parse(file, options);
+      processed++;
+      yield {
+        file,
+        source,
+        processed,
+        total,
+        percentage: processed / total * 100
+      };
+    }
+  }
+  async run(files, options = {}) {
+    await this.events.emit("start", files);
+    for (const { file, source, processed, total, percentage } of this.stream(files, options)) await this.events.emit("update", {
+      file,
+      source,
+      processed,
+      percentage,
+      total
+    });
+    await this.events.emit("end", files);
+    return files;
+  }
+  /**
+  * Clears all registered event listeners.
+  */
+  dispose() {
+    this.events.removeAll();
+  }
+  [Symbol.dispose]() {
+    this.dispose();
+  }
+};
+function _usingCtx() {
+  var r = "function" == typeof SuppressedError ? SuppressedError : function(r2, e2) {
+    var n2 = Error();
+    return n2.name = "SuppressedError", n2.error = r2, n2.suppressed = e2, n2;
+  };
+  var e = {};
+  var n = [];
+  function using(r2, e2) {
+    if (null != e2) {
+      if (Object(e2) !== e2) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+      if (r2) var o = e2[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+      if (void 0 === o && (o = e2[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r2)) var t = o;
+      if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+      t && (o = function o2() {
+        try {
+          t.call(e2);
+        } catch (r3) {
+          return Promise.reject(r3);
+        }
+      }), n.push({
+        v: e2,
+        d: o,
+        a: r2
+      });
+    } else r2 && n.push({
+      d: e2,
+      a: r2
+    });
+    return e2;
+  }
+  return {
+    e,
+    u: using.bind(null, false),
+    a: using.bind(null, true),
+    d: function d() {
+      var o;
+      var t = this.e;
+      var s = 0;
+      function next() {
+        for (; o = n.pop(); ) try {
+          if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+          if (o.d) {
+            var r2 = o.d.call(o.v);
+            if (o.a) return s |= 2, Promise.resolve(r2).then(next, err);
+          } else s |= 1;
+        } catch (r3) {
+          return err(r3);
+        }
+        if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+        if (t !== e) throw t;
+      }
+      function err(n2) {
+        return t = t !== e ? new r(n2, t) : n2, next();
+      }
+      return next();
+    }
+  };
+}
 function enforceOrder(enforce) {
   return enforce === "pre" ? -1 : enforce === "post" ? 1 : 0;
 }
-var KubbDriver = (_c = class {
+const OPERATION_FILTER_TYPES = /* @__PURE__ */ new Set([
+  "tag",
+  "operationId",
+  "path",
+  "method",
+  "contentType"
+]);
+var KubbDriver = (_d = class {
   constructor(config, options) {
     __privateAdd$1(this, _KubbDriver_instances);
     __publicField$1(this, "config");
@@ -5745,8 +5991,8 @@ var KubbDriver = (_c = class {
     * The streaming `InputStreamNode` produced by the adapter.
     * Always set after adapter setup — parse-only adapters are wrapped automatically.
     */
-    __publicField$1(this, "inputNode");
-    __publicField$1(this, "adapter");
+    __publicField$1(this, "inputNode", null);
+    __publicField$1(this, "adapter", null);
     /**
     * Studio session state, kept together so `dispose()` can reset it atomically.
     *
@@ -5757,9 +6003,9 @@ var KubbDriver = (_c = class {
     *   per studio session, even when `openInStudio()` is called multiple times.
     */
     __privateAdd$1(this, _studio, {
-      source: void 0,
+      source: null,
       isOpen: false,
-      inputNode: void 0
+      inputNode: null
     });
     __privateAdd$1(this, _middlewareListeners, []);
     /**
@@ -5768,6 +6014,7 @@ var KubbDriver = (_c = class {
     * add files; this property gives direct read/write access when needed.
     */
     __publicField$1(this, "fileManager", new FileManager());
+    __privateAdd$1(this, _fileProcessor, new FileProcessor());
     __publicField$1(this, "plugins", /* @__PURE__ */ new Map());
     /**
     * Tracks which plugins have generators registered via `addGenerator()` (event-based path).
@@ -5781,9 +6028,10 @@ var KubbDriver = (_c = class {
       name: "default",
       pluginName
     }))));
+    var _a2;
     this.config = config;
     this.options = options;
-    this.adapter = config.adapter;
+    this.adapter = (_a2 = config.adapter) != null ? _a2 : null;
   }
   /**
   * Returns `'single'` when `fileOrFolder` has a file extension, `'split'` otherwise.
@@ -5906,24 +6154,165 @@ var KubbDriver = (_c = class {
     return __privateGet$1(this, _eventGeneratorPlugins).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
+  * Runs the full plugin pipeline. Returns timings/failures collected so far even
+  * when an outer hook throws — the orchestrator preserves partial state by capturing
+  * the error into `error` instead of propagating.
   */
-  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, _eventGeneratorPlugins).clear();
-    __privateGet$1(this, _resolvers).clear();
-    __privateGet$1(this, _defaultResolvers).clear();
-    this.fileManager.dispose();
-    this.inputNode = void 0;
-    __privateSet(this, _studio, {
-      source: void 0,
-      isOpen: false,
-      inputNode: void 0
-    });
+  async run({ storage }) {
+    var _a2;
+    const hooks = this.hooks;
+    const config = this.config;
+    const failedPlugins = /* @__PURE__ */ new Set();
+    const pluginTimings = /* @__PURE__ */ new Map();
+    const parsersMap = /* @__PURE__ */ new Map();
+    for (const parser of config.parsers) if (parser.extNames) for (const ext of parser.extNames) parsersMap.set(ext, parser);
+    const pendingFiles = /* @__PURE__ */ new Map();
+    this.fileManager.setOnUpsert((file) => {
+      pendingFiles.set(file.path, file);
+    });
+    try {
+      const flushPending = async () => {
+        if (pendingFiles.size === 0) return;
+        const files2 = [...pendingFiles.values()];
+        pendingFiles.clear();
+        await hooks.emit("kubb:debug", {
+          date: /* @__PURE__ */ new Date(),
+          logs: [`Writing ${files2.length} files...`]
+        });
+        await hooks.emit("kubb:files:processing:start", { files: files2 });
+        const items = [...__privateGet$1(this, _fileProcessor).stream(files2, {
+          parsers: parsersMap,
+          extension: config.output.extension
+        })];
+        await hooks.emit("kubb:files:processing:update", { files: items.map(({ file, source, processed, total, percentage }) => ({
+          file,
+          source,
+          processed,
+          total,
+          percentage,
+          config
+        })) });
+        const queue = [];
+        for (const { file, source } of items) if (source) {
+          queue.push(storage.setItem(file.path, source));
+          if (queue.length >= 50) await Promise.all(queue.splice(0));
+        }
+        await Promise.all(queue);
+        await hooks.emit("kubb:files:processing:end", { files: files2 });
+        await hooks.emit("kubb:debug", {
+          date: /* @__PURE__ */ new Date(),
+          logs: [`\u2713 File write process completed for ${files2.length} files`]
+        });
+      };
+      await this.emitSetupHooks();
+      if (this.adapter && this.inputNode) await hooks.emit("kubb:build:start", Object.assign({
+        config,
+        adapter: this.adapter,
+        meta: this.inputNode.meta,
+        getPlugin: this.getPlugin.bind(this)
+      }, __privateMethod$1(this, _KubbDriver_instances, filesPayload_fn).call(this)));
+      const generatorPlugins = [];
+      for (const plugin of this.plugins.values()) {
+        const context = this.getContext(plugin);
+        const hrStart = process.hrtime();
+        try {
+          await hooks.emit("kubb:plugin:start", { plugin });
+          await hooks.emit("kubb:debug", {
+            date: /* @__PURE__ */ new Date(),
+            logs: ["Starting plugin...", `  \u2022 Plugin Name: ${plugin.name}`]
+          });
+        } catch (caughtError) {
+          const error = caughtError;
+          const duration2 = getElapsedMs(hrStart);
+          pluginTimings.set(plugin.name, duration2);
+          await __privateMethod$1(this, _KubbDriver_instances, emitPluginEnd_fn).call(this, {
+            plugin,
+            duration: duration2,
+            success: false,
+            error
+          });
+          failedPlugins.add({
+            plugin,
+            error
+          });
+          continue;
+        }
+        if (((_a2 = plugin.generators) == null ? void 0 : _a2.length) || this.hasEventGenerators(plugin.name)) {
+          generatorPlugins.push({
+            plugin,
+            context,
+            hrStart
+          });
+          continue;
+        }
+        const duration = getElapsedMs(hrStart);
+        pluginTimings.set(plugin.name, duration);
+        await __privateMethod$1(this, _KubbDriver_instances, emitPluginEnd_fn).call(this, {
+          plugin,
+          duration,
+          success: true
+        });
+        await hooks.emit("kubb:debug", {
+          date: /* @__PURE__ */ new Date(),
+          logs: [`\u2713 Plugin started successfully (${formatMs(duration)})`]
+        });
+      }
+      if (generatorPlugins.length > 0) if (this.inputNode) {
+        const { timings, failed } = await __privateMethod$1(this, _KubbDriver_instances, runGenerators_fn).call(this, generatorPlugins, flushPending);
+        await flushPending();
+        for (const [name, duration] of timings) pluginTimings.set(name, duration);
+        for (const entry of failed) failedPlugins.add(entry);
+      } else for (const { plugin, hrStart } of generatorPlugins) {
+        const duration = getElapsedMs(hrStart);
+        pluginTimings.set(plugin.name, duration);
+        await __privateMethod$1(this, _KubbDriver_instances, emitPluginEnd_fn).call(this, {
+          plugin,
+          duration,
+          success: true
+        });
+      }
+      await hooks.emit("kubb:plugins:end", Object.assign({ config }, __privateMethod$1(this, _KubbDriver_instances, filesPayload_fn).call(this)));
+      await flushPending();
+      const files = this.fileManager.files;
+      await hooks.emit("kubb:build:end", {
+        files,
+        config,
+        outputDir: resolve(config.root, config.output.path)
+      });
+      return {
+        failedPlugins,
+        pluginTimings
+      };
+    } catch (caughtError) {
+      return {
+        failedPlugins,
+        pluginTimings,
+        error: caughtError
+      };
+    } finally {
+      this.fileManager.setOnUpsert(null);
+    }
+  }
+  /**
+  * 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, _eventGeneratorPlugins).clear();
+    __privateGet$1(this, _resolvers).clear();
+    __privateGet$1(this, _defaultResolvers).clear();
+    this.fileManager.dispose();
+    __privateGet$1(this, _fileProcessor).dispose();
+    this.inputNode = null;
+    __privateSet$1(this, _studio, {
+      source: null,
+      isOpen: false,
+      inputNode: null
+    });
     for (const [event, handler] of __privateGet$1(this, _middlewareListeners)) this.hooks.off(event, handler);
   }
   [Symbol.dispose]() {
@@ -5955,7 +6344,7 @@ var KubbDriver = (_c = class {
         return resolve(driver.config.root, driver.config.output.path);
       },
       getMode(output) {
-        return _c.getMode(resolve(driver.config.root, driver.config.output.path, output.path));
+        return _d.getMode(resolve(driver.config.root, driver.config.output.path, output.path));
       },
       hooks: driver.hooks,
       plugin,
@@ -5995,13 +6384,13 @@ var KubbDriver = (_c = class {
         driver.hooks.emit("kubb:info", { message });
       },
       async openInStudio(options) {
-        var _a2, _b2, _c2, _d;
+        var _a2, _b2, _c2, _d2;
         if (!driver.config.devtools || __privateGet$1(driver, _studio).isOpen) return;
         if (typeof driver.config.devtools !== "object") throw new Error("Devtools must be an object");
         if (!driver.adapter || !__privateGet$1(driver, _studio).source) throw new Error("adapter is not defined, make sure you have set the parser in kubb.config.ts");
         __privateGet$1(driver, _studio).isOpen = true;
         const studioUrl = (_b2 = (_a2 = driver.config.devtools) == null ? void 0 : _a2.studioUrl) != null ? _b2 : "https://kubb.studio";
-        (_d = (_c2 = __privateGet$1(driver, _studio)).inputNode) != null ? _d : _c2.inputNode = Promise.resolve(driver.adapter.parse(__privateGet$1(driver, _studio).source));
+        (_d2 = (_c2 = __privateGet$1(driver, _studio)).inputNode) != null ? _d2 : _c2.inputNode = Promise.resolve(driver.adapter.parse(__privateGet$1(driver, _studio).source));
         return openInStudio(await __privateGet$1(driver, _studio).inputNode, studioUrl, options);
       }
     };
@@ -6014,7 +6403,7 @@ var KubbDriver = (_c = class {
     if (!plugin) throw new Error(`[kubb] Plugin "${pluginName}" is required but not found. Make sure it is included in your Kubb config.`);
     return plugin;
   }
-}, _studio = new WeakMap(), _middlewareListeners = new WeakMap(), _eventGeneratorPlugins = new WeakMap(), _resolvers = new WeakMap(), _defaultResolvers = new WeakMap(), _hookListeners = new WeakMap(), _KubbDriver_instances = new WeakSet(), /**
+}, _studio = new WeakMap(), _middlewareListeners = new WeakMap(), _fileProcessor = new WeakMap(), _eventGeneratorPlugins = new WeakMap(), _resolvers = new WeakMap(), _defaultResolvers = new WeakMap(), _hookListeners = new WeakMap(), _KubbDriver_instances = new WeakSet(), /**
 * Creates an `NormalizedPlugin` from a hook-style plugin and registers
 * its lifecycle handlers on the `AsyncEventEmitter`.
 */
@@ -6115,6 +6504,208 @@ registerPlugin_fn = function(plugin) {
     this.hooks.on(event, handler);
     __privateMethod$1(this, _KubbDriver_instances, trackHookListener_fn).call(this, event, handler);
   }
+}, filesPayload_fn = function() {
+  const driver = this;
+  return {
+    get files() {
+      return driver.fileManager.files;
+    },
+    upsertFile: (...files) => driver.fileManager.upsert(...files)
+  };
+}, emitPluginEnd_fn = function({ plugin, duration, success, error }) {
+  return this.hooks.emit("kubb:plugin:end", Object.assign({
+    plugin,
+    duration,
+    success,
+    ...error ? { error } : {},
+    config: this.config
+  }, __privateMethod$1(this, _KubbDriver_instances, filesPayload_fn).call(this)));
+}, runGenerators_fn = async function(entries, flushPending) {
+  var _a2, _b2;
+  const timings = /* @__PURE__ */ new Map();
+  const failed = /* @__PURE__ */ new Set();
+  const driver = this;
+  const { schemas, operations } = this.inputNode;
+  const states = entries.map(({ plugin, context, hrStart }) => {
+    var _a3;
+    const { exclude, include, override } = plugin.options;
+    const hasExclude = Array.isArray(exclude) && exclude.length > 0;
+    const hasInclude = Array.isArray(include) && include.length > 0;
+    const hasOverride = Array.isArray(override) && override.length > 0;
+    return {
+      plugin,
+      generatorContext: {
+        ...context,
+        resolver: this.getResolver(plugin.name)
+      },
+      generators: (_a3 = plugin.generators) != null ? _a3 : [],
+      hrStart,
+      failed: false,
+      error: null,
+      optionsAreStatic: !hasExclude && !hasInclude && !hasOverride,
+      allowedSchemaNames: null
+    };
+  });
+  const emitsSchemaHook = this.hooks.listenerCount("kubb:generate:schema") > 0;
+  const emitsOperationHook = this.hooks.listenerCount("kubb:generate:operation") > 0;
+  const pruningStates = states.filter(({ plugin }) => {
+    var _a3, _b3;
+    const { include } = plugin.options;
+    return ((_a3 = include == null ? void 0 : include.some(({ type }) => OPERATION_FILTER_TYPES.has(type))) != null ? _a3 : false) && !((_b3 = include == null ? void 0 : include.some(({ type }) => type === "schemaName")) != null ? _b3 : false);
+  });
+  if (pruningStates.length > 0) {
+    const allSchemas = [];
+    for await (const schema of schemas) allSchemas.push(schema);
+    const includedOpsByState = new Map(pruningStates.map((s) => [s, []]));
+    for await (const operation of operations) for (const state of pruningStates) {
+      const { exclude, include, override } = state.plugin.options;
+      if (state.generatorContext.resolver.resolveOptions(operation, {
+        options: state.plugin.options,
+        exclude,
+        include,
+        override
+      }) !== null) (_a2 = includedOpsByState.get(state)) == null ? void 0 : _a2.push(operation);
+    }
+    for (const state of pruningStates) {
+      state.allowedSchemaNames = collectUsedSchemaNames((_b2 = includedOpsByState.get(state)) != null ? _b2 : [], allSchemas);
+      includedOpsByState.delete(state);
+    }
+  }
+  const resolveRendererFor = (gen, state) => {
+    var _a3, _b3;
+    return gen.renderer === null ? void 0 : (_b3 = (_a3 = gen.renderer) != null ? _a3 : state.plugin.renderer) != null ? _b3 : state.generatorContext.config.renderer;
+  };
+  const dispatchSchema = async (state, node) => {
+    if (state.failed) return;
+    try {
+      const { plugin, generatorContext, generators } = state;
+      const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
+      if (state.allowedSchemaNames !== null && transformedNode.name && !state.allowedSchemaNames.has(transformedNode.name)) return;
+      const { exclude, include, override } = plugin.options;
+      const options = state.optionsAreStatic ? plugin.options : generatorContext.resolver.resolveOptions(transformedNode, {
+        options: plugin.options,
+        exclude,
+        include,
+        override
+      });
+      if (options === null) return;
+      const ctx = {
+        ...generatorContext,
+        options
+      };
+      for (const gen of generators) {
+        if (!gen.schema) continue;
+        const raw = gen.schema(transformedNode, ctx);
+        const applied = applyHookResult({
+          result: isPromise(raw) ? await raw : raw,
+          driver,
+          rendererFactory: resolveRendererFor(gen, state)
+        });
+        if (isPromise(applied)) await applied;
+      }
+      if (emitsSchemaHook) await this.hooks.emit("kubb:generate:schema", transformedNode, ctx);
+    } catch (caughtError) {
+      state.failed = true;
+      state.error = caughtError;
+    }
+  };
+  const dispatchOperation = async (state, node) => {
+    if (state.failed) return;
+    try {
+      const { plugin, generatorContext, generators } = state;
+      const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
+      const { exclude, include, override } = plugin.options;
+      const options = state.optionsAreStatic ? plugin.options : generatorContext.resolver.resolveOptions(transformedNode, {
+        options: plugin.options,
+        exclude,
+        include,
+        override
+      });
+      if (options === null) return;
+      const ctx = {
+        ...generatorContext,
+        options
+      };
+      for (const gen of generators) {
+        if (!gen.operation) continue;
+        const raw = gen.operation(transformedNode, ctx);
+        const applied = applyHookResult({
+          result: isPromise(raw) ? await raw : raw,
+          driver,
+          rendererFactory: resolveRendererFor(gen, state)
+        });
+        if (isPromise(applied)) await applied;
+      }
+      if (emitsOperationHook) await this.hooks.emit("kubb:generate:operation", transformedNode, ctx);
+    } catch (caughtError) {
+      state.failed = true;
+      state.error = caughtError;
+    }
+  };
+  const needsCollectedOperations = this.hooks.listenerCount("kubb:generate:operations") > 0 || states.some((s) => s.generators.some((g) => !!g.operations));
+  const collectedOperations = needsCollectedOperations ? [] : void 0;
+  await forBatches(schemas, (nodes) => Promise.all(nodes.flatMap((n) => states.map((state) => dispatchSchema(state, n)))), {
+    concurrency: 8,
+    flush: flushPending
+  });
+  await forBatches(operations, (nodes) => {
+    if (needsCollectedOperations) collectedOperations.push(...nodes);
+    return Promise.all(nodes.flatMap((n) => states.map((state) => dispatchOperation(state, n))));
+  }, {
+    concurrency: 8,
+    flush: flushPending
+  });
+  for (const state of states) {
+    if (!state.failed && needsCollectedOperations) try {
+      const { plugin, generatorContext, generators } = state;
+      const ctx = {
+        ...generatorContext,
+        options: plugin.options
+      };
+      const pluginOperations = state.optionsAreStatic ? collectedOperations : collectedOperations.filter((node) => {
+        const transformed = plugin.transformer ? transform(node, plugin.transformer) : node;
+        const { exclude, include, override } = plugin.options;
+        return generatorContext.resolver.resolveOptions(transformed, {
+          options: plugin.options,
+          exclude,
+          include,
+          override
+        }) !== null;
+      });
+      for (const gen of generators) {
+        if (!gen.operations) continue;
+        await applyHookResult({
+          result: await gen.operations(pluginOperations, ctx),
+          driver,
+          rendererFactory: resolveRendererFor(gen, state)
+        });
+      }
+      await this.hooks.emit("kubb:generate:operations", pluginOperations, ctx);
+    } catch (caughtError) {
+      state.failed = true;
+      state.error = caughtError;
+    }
+    const duration = getElapsedMs(state.hrStart);
+    timings.set(state.plugin.name, duration);
+    await __privateMethod$1(this, _KubbDriver_instances, emitPluginEnd_fn).call(this, {
+      plugin: state.plugin,
+      duration,
+      success: !state.failed,
+      error: state.failed && state.error ? state.error : void 0
+    });
+    if (state.failed && state.error) failed.add({
+      plugin: state.plugin,
+      error: state.error
+    });
+    await this.hooks.emit("kubb:debug", {
+      date: /* @__PURE__ */ new Date(),
+      logs: [state.failed ? "\u2717 Plugin start failed" : `\u2713 Plugin started successfully (${formatMs(duration)})`]
+    });
+  }
+  return {
+    timings,
+    failed
+  };
 }, trackHookListener_fn = function(event, handler) {
   let handlers = __privateGet$1(this, _hookListeners).get(event);
   if (!handlers) {
@@ -6122,7 +6713,7 @@ registerPlugin_fn = function(plugin) {
     __privateGet$1(this, _hookListeners).set(event, handlers);
   }
   handlers.add(handler);
-}, _getDefaultResolver = new WeakMap(), _c);
+}, _getDefaultResolver = new WeakMap(), _d);
 function applyHookResult({ result, driver, rendererFactory }) {
   if (!result) return;
   if (Array.isArray(result)) {
@@ -6131,10 +6722,15 @@ function applyHookResult({ result, driver, rendererFactory }) {
   }
   if (!rendererFactory) return;
   const renderer = rendererFactory();
-  if (renderer.stream) {
-    for (const file of renderer.stream(result)) driver.fileManager.upsert(file);
-    renderer.unmount();
+  if (renderer.stream) try {
+    var _usingCtx$1 = _usingCtx();
+    const r = _usingCtx$1.u(renderer);
+    for (const file of r.stream(result)) driver.fileManager.upsert(file);
     return;
+  } catch (_) {
+    _usingCtx$1.e = _;
+  } finally {
+    _usingCtx$1.d();
   }
   return applyAsyncRender({
     renderer,
@@ -6143,9 +6739,16 @@ function applyHookResult({ result, driver, rendererFactory }) {
   });
 }
 async function applyAsyncRender({ renderer, result, driver }) {
-  await renderer.render(result);
-  driver.fileManager.upsert(...renderer.files);
-  renderer.unmount();
+  try {
+    var _usingCtx3 = _usingCtx();
+    const r = _usingCtx3.u(renderer);
+    await r.render(result);
+    driver.fileManager.upsert(...r.files);
+  } catch (_) {
+    _usingCtx3.e = _;
+  } finally {
+    _usingCtx3.d();
+  }
 }
 function inputToAdapterSource(config) {
   const input = config.input;
@@ -6169,130 +6772,13 @@ 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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __publicField = (obj, key, value) => __defNormalProp(obj, 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"), member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var _emitter, _AsyncEventEmitter_instances, emitAll_fn, _a;
-var BuildError = class extends Error {
-  constructor(message, options) {
-    super(message, { cause: options.cause });
-    __publicField(this, "errors");
-    this.name = "BuildError";
-    this.errors = options.errors;
-  }
-};
-function toError(value) {
-  return value instanceof Error ? value : new Error(String(value));
-}
-var AsyncEventEmitter = (_a = class {
-  /**
-  * Maximum number of listeners per event before Node emits a memory-leak warning.
-  * @default 10
-  */
-  constructor(maxListener = 10) {
-    __privateAdd(this, _AsyncEventEmitter_instances);
-    __privateAdd(this, _emitter, new EventEmitter());
-    __privateGet(this, _emitter).setMaxListeners(maxListener);
-  }
-  /**
-  * Emits `eventName` and awaits all registered listeners sequentially.
-  * Throws if any listener rejects, wrapping the cause with the event name and serialized arguments.
-  *
-  * @example
-  * ```ts
-  * await emitter.emit('build', 'petstore')
-  * ```
-  */
-  emit(eventName, ...eventArgs) {
-    const listeners = __privateGet(this, _emitter).listeners(eventName);
-    if (listeners.length === 0) return;
-    return __privateMethod(this, _AsyncEventEmitter_instances, emitAll_fn).call(this, eventName, listeners, eventArgs);
-  }
-  /**
-  * Registers a persistent listener for `eventName`.
-  *
-  * @example
-  * ```ts
-  * emitter.on('build', async (name) => { console.log(name) })
-  * ```
-  */
-  on(eventName, handler) {
-    __privateGet(this, _emitter).on(eventName, handler);
-  }
-  /**
-  * Registers a one-shot listener that removes itself after the first invocation.
-  *
-  * @example
-  * ```ts
-  * emitter.onOnce('build', async (name) => { console.log(name) })
-  * ```
-  */
-  onOnce(eventName, handler) {
-    const wrapper = (...args) => {
-      this.off(eventName, wrapper);
-      return handler(...args);
-    };
-    this.on(eventName, wrapper);
-  }
-  /**
-  * Removes a previously registered listener.
-  *
-  * @example
-  * ```ts
-  * emitter.off('build', handler)
-  * ```
-  */
-  off(eventName, handler) {
-    __privateGet(this, _emitter).off(eventName, handler);
-  }
-  /**
-  * Returns the number of listeners registered for `eventName`.
-  *
-  * @example
-  * ```ts
-  * emitter.on('build', handler)
-  * emitter.listenerCount('build') // 1
-  * ```
-  */
-  listenerCount(eventName) {
-    return __privateGet(this, _emitter).listenerCount(eventName);
-  }
-  /**
-  * Removes all listeners from every event channel.
-  *
-  * @example
-  * ```ts
-  * emitter.removeAll()
-  * ```
-  */
-  removeAll() {
-    __privateGet(this, _emitter).removeAllListeners();
-  }
-}, _emitter = new WeakMap(), _AsyncEventEmitter_instances = new WeakSet(), emitAll_fn = async function(eventName, listeners, eventArgs) {
-  for (const listener of listeners) try {
-    await listener(...eventArgs);
-  } catch (err) {
-    let serializedArgs;
-    try {
-      serializedArgs = JSON.stringify(eventArgs);
-    } catch {
-      serializedArgs = String(eventArgs);
-    }
-    throw new Error(`Error in async listener for "${eventName}" with eventArgs ${serializedArgs}`, { cause: toError(err) });
-  }
-}, _a);
-function getElapsedMs(hrStart) {
-  const [seconds, nanoseconds] = process.hrtime(hrStart);
-  const ms = seconds * 1e3 + nanoseconds / 1e6;
-  return Math.round(ms * 100) / 100;
-}
-function formatMs(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`;
-}
+var _userConfig, _config, _driver, _storage, _Kubb_instances, configLogs_fn, _a;
 async function exists(path) {
   if (typeof Bun !== "undefined") return Bun.file(path).exists();
   return access(path).then(() => true, () => false);
@@ -6333,60 +6819,10 @@ async function clean(path) {
     force: true
   });
 }
-var version$1 = "5.0.0-beta.20";
-function createStorage(build2) {
-  return (options) => build2(options != null ? options : {});
+var version$1 = "5.0.0-beta.22";
+function createStorage(build) {
+  return (options) => build(options != null ? options : {});
 }
-function joinSources(file) {
-  const sources = file.sources;
-  if (sources.length === 0) return "";
-  const parts = [];
-  for (const source of sources) {
-    const s = extractStringsFromNodes(source.nodes);
-    if (s) parts.push(s);
-  }
-  return parts.join("\n\n");
-}
-var FileProcessor = class {
-  constructor() {
-    __publicField(this, "events", new AsyncEventEmitter());
-  }
-  parse(file, { parsers, extension } = {}) {
-    const parseExtName = (extension == null ? void 0 : extension[file.extname]) || void 0;
-    if (!parsers || !file.extname) return joinSources(file);
-    const parser = parsers.get(file.extname);
-    if (!parser) return joinSources(file);
-    return parser.parse(file, { extname: parseExtName });
-  }
-  *stream(files, options = {}) {
-    const total = files.length;
-    if (total === 0) return;
-    let processed = 0;
-    for (const file of files) {
-      const source = this.parse(file, options);
-      processed++;
-      yield {
-        file,
-        source,
-        processed,
-        total,
-        percentage: processed / total * 100
-      };
-    }
-  }
-  async run(files, options = {}) {
-    await this.events.emit("start", files);
-    for (const { file, source, processed, total, percentage } of this.stream(files, options)) await this.events.emit("update", {
-      file,
-      source,
-      processed,
-      percentage,
-      total
-    });
-    await this.events.emit("end", files);
-    return files;
-  }
-};
 const fsStorage = createStorage(() => ({
   name: "fs",
   async hasItem(key) {
@@ -6434,64 +6870,6 @@ const fsStorage = createStorage(() => ({
     await clean(resolve(base));
   }
 }));
-function _usingCtx() {
-  var r = "function" == typeof SuppressedError ? SuppressedError : function(r2, e2) {
-    var n2 = Error();
-    return n2.name = "SuppressedError", n2.error = r2, n2.suppressed = e2, n2;
-  };
-  var e = {};
-  var n = [];
-  function using(r2, e2) {
-    if (null != e2) {
-      if (Object(e2) !== e2) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
-      if (r2) var o = e2[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
-      if (void 0 === o && (o = e2[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r2)) var t = o;
-      if ("function" != typeof o) throw new TypeError("Object is not disposable.");
-      t && (o = function o2() {
-        try {
-          t.call(e2);
-        } catch (r3) {
-          return Promise.reject(r3);
-        }
-      }), n.push({
-        v: e2,
-        d: o,
-        a: r2
-      });
-    } else r2 && n.push({
-      d: e2,
-      a: r2
-    });
-    return e2;
-  }
-  return {
-    e,
-    u: using.bind(null, false),
-    a: using.bind(null, true),
-    d: function d() {
-      var o;
-      var t = this.e;
-      var s = 0;
-      function next() {
-        for (; o = n.pop(); ) try {
-          if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
-          if (o.d) {
-            var r2 = o.d.call(o.v);
-            if (o.a) return s |= 2, Promise.resolve(r2).then(next, err);
-          } else s |= 1;
-        } catch (r3) {
-          return err(r3);
-        }
-        if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
-        if (t !== e) throw t;
-      }
-      function err(n2) {
-        return t = t !== e ? new r(n2, t) : n2, next();
-      }
-      return next();
-    }
-  };
-}
 function createSourcesView(storage) {
   const paths = /* @__PURE__ */ new Set();
   return createStorage(() => ({
@@ -6522,13 +6900,12 @@ function createSourcesView(storage) {
     }
   }))();
 }
-async function setup(userConfig, options = {}) {
-  var _a2, _b, _c, _d, _e, _f, _g, _h, _i;
-  const hooks = (_a2 = options.hooks) != null ? _a2 : new AsyncEventEmitter();
-  const config = {
+function resolveConfig(userConfig) {
+  var _a2, _b, _c;
+  return {
     ...userConfig,
     root: userConfig.root || process.cwd(),
-    parsers: (_b = userConfig.parsers) != null ? _b : [],
+    parsers: (_a2 = userConfig.parsers) != null ? _a2 : [],
     output: {
       format: false,
       lint: false,
@@ -6536,474 +6913,149 @@ async function setup(userConfig, options = {}) {
       defaultBanner: DEFAULT_BANNER,
       ...userConfig.output
     },
-    storage: (_c = userConfig.storage) != null ? _c : fsStorage(),
+    storage: (_b = userConfig.storage) != null ? _b : fsStorage(),
     devtools: userConfig.devtools ? {
       studioUrl: DEFAULT_STUDIO_URL,
       ...typeof userConfig.devtools === "boolean" ? {} : userConfig.devtools
     } : void 0,
-    plugins: (_d = userConfig.plugins) != null ? _d : []
+    plugins: (_c = userConfig.plugins) != null ? _c : []
   };
-  const driver = new KubbDriver(config, { hooks });
-  const storage = createSourcesView(config.storage);
-  const diagnosticInfo = getDiagnosticInfo();
-  await hooks.emit("kubb:debug", {
-    date: /* @__PURE__ */ new Date(),
-    logs: [
-      "Configuration:",
-      `  \u2022 Name: ${userConfig.name || "unnamed"}`,
-      `  \u2022 Root: ${userConfig.root || process.cwd()}`,
-      `  \u2022 Output: ${((_e = userConfig.output) == null ? void 0 : _e.path) || "not specified"}`,
-      `  \u2022 Plugins: ${((_f = userConfig.plugins) == null ? void 0 : _f.length) || 0}`,
-      "Output Settings:",
-      `  \u2022 Storage: ${config.storage.name}`,
-      `  \u2022 Formatter: ${((_g = userConfig.output) == null ? void 0 : _g.format) || "none"}`,
-      `  \u2022 Linter: ${((_h = userConfig.output) == null ? void 0 : _h.lint) || "none"}`,
-      `Running adapter: ${((_i = config.adapter) == null ? void 0 : _i.name) || "none"}`,
-      "Environment:",
-      Object.entries(diagnosticInfo).map(([key, value]) => `  \u2022 ${key}: ${value}`).join("\n")
-    ]
-  });
-  try {
-    if (isInputPath(userConfig) && !new URLPath(userConfig.input.path).isURL) {
-      await exists(userConfig.input.path);
-      await hooks.emit("kubb:debug", {
-        date: /* @__PURE__ */ new Date(),
-        logs: [`\u2713 Input file validated: ${userConfig.input.path}`]
-      });
-    }
-  } catch (caughtError) {
-    if (isInputPath(userConfig)) {
-      const error = caughtError;
-      throw new Error(`Cannot read file/URL defined in \`input.path\` or set with \`kubb generate PATH\` in the CLI of your Kubb config ${userConfig.input.path}`, { cause: error });
-    }
-  }
-  if (config.output.clean) {
-    await hooks.emit("kubb:debug", {
-      date: /* @__PURE__ */ new Date(),
-      logs: ["Cleaning output directories", `  \u2022 Output: ${config.output.path}`]
-    });
-    await config.storage.clear(resolve(config.root, config.output.path));
-  }
-  await driver.setup();
+}
+function getDiagnosticInfo() {
   return {
-    config,
-    hooks,
-    driver,
-    storage,
-    dispose,
-    [Symbol.dispose]: dispose
+    nodeVersion: version$2,
+    KubbVersion: version$1,
+    platform: process.platform,
+    arch: process.arch,
+    cwd: process.cwd()
   };
-  function dispose() {
-    driver.dispose();
-  }
 }
-async function safeBuild(setupResult) {
-  var _a2;
-  try {
-    var _usingCtx$1 = _usingCtx();
-    _usingCtx$1.u(setupResult);
-    const { driver, hooks, storage } = setupResult;
-    const failedPlugins = /* @__PURE__ */ new Set();
-    const pluginTimings = /* @__PURE__ */ new Map();
-    const config = driver.config;
-    const writtenPaths = /* @__PURE__ */ new Set();
-    const parsersMap = /* @__PURE__ */ new Map();
-    const fileProcessor = new FileProcessor();
-    for (const parser of config.parsers) if (parser.extNames) for (const extname of parser.extNames) parsersMap.set(extname, parser);
-    async function flushPendingFiles() {
-      const files = driver.fileManager.files.filter((f) => !writtenPaths.has(f.path));
-      if (files.length === 0) return;
-      await hooks.emit("kubb:debug", {
+function isInputPath(config) {
+  return typeof (config == null ? void 0 : config.input) === "object" && config.input !== null && "path" in config.input;
+}
+var Kubb = (_a = class {
+  constructor(userConfig, options = {}) {
+    __privateAdd(this, _Kubb_instances);
+    __publicField(this, "hooks");
+    __privateAdd(this, _userConfig);
+    __privateAdd(this, _config, null);
+    __privateAdd(this, _driver, null);
+    __privateAdd(this, _storage, null);
+    var _a2;
+    __privateSet(this, _userConfig, userConfig);
+    this.hooks = (_a2 = options.hooks) != null ? _a2 : new AsyncEventEmitter();
+  }
+  get storage() {
+    if (!__privateGet(this, _storage)) throw new Error("[kubb] setup() must be called before accessing storage");
+    return __privateGet(this, _storage);
+  }
+  get driver() {
+    if (!__privateGet(this, _driver)) throw new Error("[kubb] setup() must be called before accessing driver");
+    return __privateGet(this, _driver);
+  }
+  get config() {
+    if (!__privateGet(this, _config)) throw new Error("[kubb] setup() must be called before accessing config");
+    return __privateGet(this, _config);
+  }
+  /**
+  * Resolves config and initializes the driver. `build()` calls this automatically.
+  */
+  async setup() {
+    const config = resolveConfig(__privateGet(this, _userConfig));
+    const driver = new KubbDriver(config, { hooks: this.hooks });
+    const storage = createSourcesView(config.storage);
+    await this.hooks.emit("kubb:debug", {
+      date: /* @__PURE__ */ new Date(),
+      logs: __privateMethod(this, _Kubb_instances, configLogs_fn).call(this, config)
+    });
+    if (isInputPath(__privateGet(this, _userConfig)) && !new URLPath(__privateGet(this, _userConfig).input.path).isURL) try {
+      await exists(__privateGet(this, _userConfig).input.path);
+      await this.hooks.emit("kubb:debug", {
         date: /* @__PURE__ */ new Date(),
-        logs: [`Writing ${files.length} files...`]
+        logs: [`\u2713 Input file validated: ${__privateGet(this, _userConfig).input.path}`]
       });
-      await hooks.emit("kubb:files:processing:start", { files });
-      const stream = fileProcessor.stream(files, {
-        parsers: parsersMap,
-        extension: config.output.extension
-      });
-      const queue = [];
-      for (const { file, source, processed, total, percentage } of stream) {
-        writtenPaths.add(file.path);
-        queue.push((async () => {
-          await hooks.emit("kubb:file:processing:update", {
-            file,
-            source,
-            processed,
-            total,
-            percentage,
-            config
-          });
-          if (source) await storage.setItem(file.path, source);
-        })());
-        if (queue.length >= 50) await Promise.all(queue.splice(0));
-      }
-      await Promise.all(queue);
-      await hooks.emit("kubb:files:processing:end", { files });
-      await hooks.emit("kubb:debug", {
+    } catch (caughtError) {
+      throw new Error(`Cannot read file/URL defined in \`input.path\` or set with \`kubb generate PATH\` in the CLI of your Kubb config ${__privateGet(this, _userConfig).input.path}`, { cause: caughtError });
+    }
+    if (config.output.clean) {
+      await this.hooks.emit("kubb:debug", {
         date: /* @__PURE__ */ new Date(),
-        logs: [`\u2713 File write process completed for ${files.length} files`]
+        logs: ["Cleaning output directories", `  \u2022 Output: ${config.output.path}`]
       });
+      await config.storage.clear(resolve(config.root, config.output.path));
     }
-    async function dispatchOperationsToGenerators(generators, collectedOperations, ctx, rendererFor) {
-      for (const gen of generators) {
-        if (!gen.operations) continue;
-        await applyHookResult({
-          result: await gen.operations(collectedOperations, ctx),
-          driver,
-          rendererFactory: rendererFor(gen)
-        });
-      }
-      await driver.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
-    }
-    async function runPlugins(entries) {
-      var _a3, _b;
-      const { schemas, operations } = driver.inputNode;
-      const operationFilterTypes = /* @__PURE__ */ new Set([
-        "tag",
-        "operationId",
-        "path",
-        "method",
-        "contentType"
-      ]);
-      const states = entries.map(({ plugin, context, hrStart }) => {
-        var _a4;
-        const { exclude, include, override } = plugin.options;
-        const hasExclude = Array.isArray(exclude) && exclude.length > 0;
-        const hasInclude = Array.isArray(include) && include.length > 0;
-        const hasOverride = Array.isArray(override) && override.length > 0;
-        return {
-          plugin,
-          generatorContext: {
-            ...context,
-            resolver: driver.getResolver(plugin.name)
-          },
-          generators: (_a4 = plugin.generators) != null ? _a4 : [],
-          hrStart,
-          failed: false,
-          error: void 0,
-          optionsAreStatic: !hasExclude && !hasInclude && !hasOverride,
-          allowedSchemaNames: void 0
-        };
-      });
-      const pruningStates = states.filter(({ plugin }) => {
-        var _a4, _b2;
-        const { include } = plugin.options;
-        return ((_a4 = include == null ? void 0 : include.some(({ type }) => operationFilterTypes.has(type))) != null ? _a4 : false) && !((_b2 = include == null ? void 0 : include.some(({ type }) => type === "schemaName")) != null ? _b2 : false);
-      });
-      if (pruningStates.length > 0) {
-        const allSchemas = [];
-        for await (const schema of schemas) allSchemas.push(schema);
-        const includedOpsByState = new Map(pruningStates.map((s) => [s, []]));
-        for await (const operation of operations) for (const state of pruningStates) {
-          const { exclude, include, override } = state.plugin.options;
-          if (state.generatorContext.resolver.resolveOptions(operation, {
-            options: state.plugin.options,
-            exclude,
-            include,
-            override
-          }) !== null) (_a3 = includedOpsByState.get(state)) == null ? void 0 : _a3.push(operation);
-        }
-        for (const state of pruningStates) state.allowedSchemaNames = collectUsedSchemaNames((_b = includedOpsByState.get(state)) != null ? _b : [], allSchemas);
-      }
-      function resolveRendererFor(gen, state) {
-        var _a4, _b2;
-        return gen.renderer === null ? void 0 : (_b2 = (_a4 = gen.renderer) != null ? _a4 : state.plugin.renderer) != null ? _b2 : state.generatorContext.config.renderer;
-      }
-      async function dispatchSchema(state, node) {
-        if (state.failed) return;
-        try {
-          const { plugin, generatorContext, generators } = state;
-          const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
-          if (state.allowedSchemaNames !== void 0 && transformedNode.name && !state.allowedSchemaNames.has(transformedNode.name)) return;
-          const { exclude, include, override } = plugin.options;
-          const options = state.optionsAreStatic ? plugin.options : generatorContext.resolver.resolveOptions(transformedNode, {
-            options: plugin.options,
-            exclude,
-            include,
-            override
-          });
-          if (options === null) return;
-          const ctx = {
-            ...generatorContext,
-            options
-          };
-          for (const gen of generators) {
-            if (!gen.schema) continue;
-            const raw = gen.schema(transformedNode, ctx);
-            const applied = applyHookResult({
-              result: isPromise(raw) ? await raw : raw,
-              driver,
-              rendererFactory: resolveRendererFor(gen, state)
-            });
-            if (isPromise(applied)) await applied;
-          }
-          await driver.hooks.emit("kubb:generate:schema", transformedNode, ctx);
-        } catch (caughtError) {
-          state.failed = true;
-          state.error = caughtError;
-        }
-      }
-      async function dispatchOperation(state, node) {
-        if (state.failed) return;
-        try {
-          const { plugin, generatorContext, generators } = state;
-          const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
-          const { exclude, include, override } = plugin.options;
-          const options = state.optionsAreStatic ? plugin.options : generatorContext.resolver.resolveOptions(transformedNode, {
-            options: plugin.options,
-            exclude,
-            include,
-            override
-          });
-          if (options === null) return;
-          const ctx = {
-            ...generatorContext,
-            options
-          };
-          for (const gen of generators) {
-            if (!gen.operation) continue;
-            const raw = gen.operation(transformedNode, ctx);
-            const applied = applyHookResult({
-              result: isPromise(raw) ? await raw : raw,
-              driver,
-              rendererFactory: resolveRendererFor(gen, state)
-            });
-            if (isPromise(applied)) await applied;
-          }
-          await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
-        } catch (caughtError) {
-          state.failed = true;
-          state.error = caughtError;
-        }
-      }
-      await forBatches(schemas, (nodes) => Promise.all(nodes.flatMap((n) => states.map((state) => dispatchSchema(state, n)))), {
-        concurrency: 8,
-        flush: flushPendingFiles
-      });
-      const collectedOperations = [];
-      await forBatches(operations, (nodes) => {
-        collectedOperations.push(...nodes);
-        return Promise.all(nodes.flatMap((n) => states.map((state) => dispatchOperation(state, n))));
-      }, {
-        concurrency: 8,
-        flush: flushPendingFiles
-      });
-      for (const state of states) {
-        if (!state.failed) try {
-          const { plugin, generatorContext, generators } = state;
-          await dispatchOperationsToGenerators(generators, collectedOperations, {
-            ...generatorContext,
-            options: plugin.options
-          }, (gen) => resolveRendererFor(gen, state));
-        } catch (caughtError) {
-          state.failed = true;
-          state.error = caughtError;
-        }
-        const duration = getElapsedMs(state.hrStart);
-        pluginTimings.set(state.plugin.name, duration);
-        await driver.hooks.emit("kubb:plugin:end", {
-          plugin: state.plugin,
-          duration,
-          success: !state.failed,
-          ...state.failed && state.error ? { error: state.error } : {},
-          config: driver.config,
-          get files() {
-            return driver.fileManager.files;
-          },
-          upsertFile: (...files) => driver.fileManager.upsert(...files)
-        });
-        if (state.failed && state.error) failedPlugins.add({
-          plugin: state.plugin,
-          error: state.error
-        });
-        await driver.hooks.emit("kubb:debug", {
-          date: /* @__PURE__ */ new Date(),
-          logs: [state.failed ? "\u2717 Plugin start failed" : `\u2713 Plugin started successfully (${formatMs(duration)})`]
-        });
-      }
+    await driver.setup();
+    __privateSet(this, _config, config);
+    __privateSet(this, _driver, driver);
+    __privateSet(this, _storage, storage);
+  }
+  /**
+  * Runs the full pipeline and throws on any plugin error.
+  * Automatically calls `setup()` if needed.
+  */
+  async build() {
+    const out = await this.safeBuild();
+    if (out.error) throw out.error;
+    if (out.failedPlugins.size > 0) {
+      const errors = [...out.failedPlugins].map(({ error }) => error);
+      throw new BuildError(`Build Error with ${out.failedPlugins.size} failed plugins`, { errors });
     }
+    return out;
+  }
+  /**
+  * Runs the full pipeline and captures errors in `BuildOutput` instead of throwing.
+  * Automatically calls `setup()` if needed.
+  */
+  async safeBuild() {
     try {
-      await driver.emitSetupHooks();
-      if (driver.adapter && driver.inputNode) await hooks.emit("kubb:build:start", {
-        config,
-        adapter: driver.adapter,
-        meta: driver.inputNode.meta,
-        getPlugin: driver.getPlugin.bind(driver),
-        get files() {
-          return driver.fileManager.files;
-        },
-        upsertFile: (...files2) => driver.fileManager.upsert(...files2)
-      });
-      const generatorPlugins = [];
-      for (const plugin of driver.plugins.values()) {
-        const context = driver.getContext(plugin);
-        const hrStart = process.hrtime();
-        try {
-          await hooks.emit("kubb:plugin:start", { plugin });
-          await hooks.emit("kubb:debug", {
-            date: /* @__PURE__ */ new Date(),
-            logs: ["Starting plugin...", `  \u2022 Plugin Name: ${plugin.name}`]
-          });
-        } catch (caughtError) {
-          const error = caughtError;
-          const duration2 = getElapsedMs(hrStart);
-          pluginTimings.set(plugin.name, duration2);
-          await hooks.emit("kubb:plugin:end", {
-            plugin,
-            duration: duration2,
-            success: false,
-            error,
-            config,
-            get files() {
-              return driver.fileManager.files;
-            },
-            upsertFile: (...files2) => driver.fileManager.upsert(...files2)
-          });
-          failedPlugins.add({
-            plugin,
-            error
-          });
-          continue;
-        }
-        if (((_a2 = plugin.generators) == null ? void 0 : _a2.length) || driver.hasEventGenerators(plugin.name)) {
-          generatorPlugins.push({
-            plugin,
-            context,
-            hrStart
-          });
-          continue;
-        }
-        const duration = getElapsedMs(hrStart);
-        pluginTimings.set(plugin.name, duration);
-        await hooks.emit("kubb:plugin:end", {
-          plugin,
-          duration,
-          success: true,
-          config,
-          get files() {
-            return driver.fileManager.files;
-          },
-          upsertFile: (...files2) => driver.fileManager.upsert(...files2)
-        });
-        await hooks.emit("kubb:debug", {
-          date: /* @__PURE__ */ new Date(),
-          logs: [`\u2713 Plugin started successfully (${formatMs(duration)})`]
-        });
-      }
-      if (generatorPlugins.length > 0) if (driver.inputNode) await withDrain(() => runPlugins(generatorPlugins), flushPendingFiles);
-      else for (const { plugin, hrStart } of generatorPlugins) {
-        const duration = getElapsedMs(hrStart);
-        pluginTimings.set(plugin.name, duration);
-        await hooks.emit("kubb:plugin:end", {
-          plugin,
-          duration,
-          success: true,
-          config,
-          get files() {
-            return driver.fileManager.files;
-          },
-          upsertFile: (...files2) => driver.fileManager.upsert(...files2)
-        });
-      }
-      await hooks.emit("kubb:plugins:end", {
-        config,
-        get files() {
-          return driver.fileManager.files;
-        },
-        upsertFile: (...files2) => driver.fileManager.upsert(...files2)
-      });
-      await flushPendingFiles();
-      const files = driver.fileManager.files;
-      await hooks.emit("kubb:build:end", {
-        files,
-        config,
-        outputDir: resolve(config.root, config.output.path)
-      });
-      return {
-        failedPlugins,
-        files,
-        driver,
-        pluginTimings,
-        storage
-      };
-    } catch (error) {
+      var _usingCtx$1 = _usingCtx();
+      if (!__privateGet(this, _driver)) await this.setup();
+      const cleanup = _usingCtx$1.u(this);
+      const driver = cleanup.driver;
+      const storage = cleanup.storage;
+      const { failedPlugins, pluginTimings, error } = await driver.run({ storage });
       return {
         failedPlugins,
-        files: [],
+        files: driver.fileManager.files,
         driver,
         pluginTimings,
-        error,
-        storage
+        storage,
+        ...error ? { error } : {}
       };
+    } catch (_) {
+      _usingCtx$1.e = _;
+    } finally {
+      _usingCtx$1.d();
     }
-  } catch (_) {
-    _usingCtx$1.e = _;
-  } finally {
-    _usingCtx$1.d();
   }
-}
-async function build(setupResult) {
-  const { files, driver, failedPlugins, pluginTimings, error, storage } = await safeBuild(setupResult);
-  if (error) throw error;
-  if (failedPlugins.size > 0) {
-    const errors = [...failedPlugins].map(({ error: error2 }) => error2);
-    throw new BuildError(`Build Error with ${failedPlugins.size} failed plugins`, { errors });
+  dispose() {
+    var _a2;
+    (_a2 = __privateGet(this, _driver)) == null ? void 0 : _a2.dispose();
   }
-  return {
-    failedPlugins,
-    files,
-    driver,
-    pluginTimings,
-    error: void 0,
-    storage
-  };
-}
-function getDiagnosticInfo() {
-  return {
-    nodeVersion: version$2,
-    KubbVersion: version$1,
-    platform: process.platform,
-    arch: process.arch,
-    cwd: process.cwd()
-  };
-}
-function isInputPath(config) {
-  return typeof (config == null ? void 0 : config.input) === "object" && config.input !== null && "path" in config.input;
-}
+  [Symbol.dispose]() {
+    this.dispose();
+  }
+}, _userConfig = new WeakMap(), _config = new WeakMap(), _driver = new WeakMap(), _storage = new WeakMap(), _Kubb_instances = new WeakSet(), configLogs_fn = function(config) {
+  var _a2, _b, _c, _d, _e;
+  const u = __privateGet(this, _userConfig);
+  const diag = getDiagnosticInfo();
+  return [
+    "Configuration:",
+    `  \u2022 Name: ${u.name || "unnamed"}`,
+    `  \u2022 Root: ${u.root || process.cwd()}`,
+    `  \u2022 Output: ${((_a2 = u.output) == null ? void 0 : _a2.path) || "not specified"}`,
+    `  \u2022 Plugins: ${((_b = u.plugins) == null ? void 0 : _b.length) || 0}`,
+    "Output Settings:",
+    `  \u2022 Storage: ${config.storage.name}`,
+    `  \u2022 Formatter: ${((_c = u.output) == null ? void 0 : _c.format) || "none"}`,
+    `  \u2022 Linter: ${((_d = u.output) == null ? void 0 : _d.lint) || "none"}`,
+    `Running adapter: ${((_e = config.adapter) == null ? void 0 : _e.name) || "none"}`,
+    "Environment:",
+    Object.entries(diag).map(([key, value]) => `  \u2022 ${key}: ${value}`).join("\n")
+  ];
+}, _a);
 function createKubb(userConfig, options = {}) {
-  var _a2;
-  const hooks = (_a2 = options.hooks) != null ? _a2 : new AsyncEventEmitter();
-  let setupResult;
-  const instance = {
-    get hooks() {
-      return hooks;
-    },
-    get storage() {
-      if (!setupResult) throw new Error("[kubb] setup() must be called before accessing storage");
-      return setupResult.storage;
-    },
-    get driver() {
-      if (!setupResult) throw new Error("[kubb] setup() must be called before accessing driver");
-      return setupResult.driver;
-    },
-    get config() {
-      if (!setupResult) throw new Error("[kubb] setup() must be called before accessing config");
-      return setupResult.config;
-    },
-    async setup() {
-      setupResult = await setup(userConfig, { hooks });
-    },
-    async build() {
-      if (!setupResult) await instance.setup();
-      return build(setupResult);
-    },
-    async safeBuild() {
-      if (!setupResult) await instance.setup();
-      return safeBuild(setupResult);
-    }
-  };
-  return instance;
+  return new Kubb(userConfig, options);
 }
 const memoryStorage = createStorage(() => {
   const store = /* @__PURE__ */ new Map();
@@ -7036,7 +7088,7 @@ const memoryStorage = createStorage(() => {
   };
 });
 
-var version = "5.0.0-beta.20";
+var version = "5.0.0-beta.22";
 
 function isCommandMessage(msg) {
   return msg.type === "command";
@@ -7390,15 +7442,17 @@ function setupEventsStream(ws, hooks) {
       timestamp: Date.now()
     });
   });
-  hooks.on("kubb:file:processing:update", (ctx) => {
+  hooks.on("kubb:files:processing:update", ({ files }) => {
     sendDataMessage({
-      type: "kubb:file:processing:update",
+      type: "kubb:files:processing:update",
       data: [
         {
-          file: ctx.file.path,
-          processed: ctx.processed,
-          total: ctx.total,
-          percentage: ctx.percentage
+          files: files.map((ctx) => ({
+            file: ctx.file.path,
+            processed: ctx.processed,
+            total: ctx.total,
+            percentage: ctx.percentage
+          }))
         }
       ],
       timestamp: Date.now()