@kubb/agent 5.0.0-beta.3 → 5.0.0-beta.31

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

@@ -18,7 +18,7 @@ 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';
 import { styleText } from 'node:util';
-import { unrun } from 'unrun';
+import { createJiti } from 'jiti';
 import { mergeDeep } from 'remeda';
 import WebSocket from 'ws';
 
@@ -4426,12 +4426,17 @@ function sendToBetterStack(level, tag, message, ctx) {
     const fullMessage = message !== void 0 ? `[${tag}] ${message}` : tag;
     const context = toBetterStackContext(ctx);
     if (level === "error") {
-      client.error(fullMessage, context).then(() => client.flush());
-    } else if (level === "warn") {
-      client.warn(fullMessage, context).then(() => client.flush());
-    } else {
-      client.info(fullMessage, context).then(() => client.flush());
+      client.error(fullMessage, context).then(() => client.flush()).catch(() => {
+      });
+      return;
+    }
+    if (level === "warn") {
+      client.warn(fullMessage, context).then(() => client.flush()).catch(() => {
+      });
+      return;
     }
+    client.info(fullMessage, context).then(() => client.flush()).catch(() => {
+    });
   } catch (_e) {
   }
 }
@@ -4705,15 +4710,17 @@ async function disconnect({ sessionId, token, studioUrl }) {
   }
 }
 
-var __defProp$2 = Object.defineProperty;
-var __name = (target, value) => __defProp$2(target, "name", {
-  value,
-  configurable: true
-});
-
 const visitorDepths = {
   deep: "deep"
 };
+function memoize$1(store, factory) {
+  return (key) => {
+    if (store.has(key)) return store.get(key);
+    const value = factory(key);
+    store.set(key, value);
+    return value;
+  };
+}
 function trimExtName(text) {
   const dotIndex = text.lastIndexOf(".");
   if (dotIndex > 0 && !text.includes("/", dotIndex)) return text.slice(0, dotIndex);
@@ -4728,265 +4735,112 @@ function extractRefName(ref) {
   var _a;
   return (_a = ref.split("/").at(-1)) != null ? _a : ref;
 }
-function createLimit(concurrency) {
-  let active = 0;
-  const queue = [];
-  function next() {
-    if (active < concurrency && queue.length > 0) {
-      active++;
-      queue.shift()();
-    }
-  }
-  return function limit(fn) {
-    return new Promise((resolve, reject) => {
-      queue.push(() => {
-        Promise.resolve(fn()).then(resolve, reject).finally(() => {
-          active--;
-          next();
-        });
-      });
-      next();
-    });
-  };
-}
-function getChildren(node, recurse) {
-  var _a, _b, _c;
-  switch (node.kind) {
-    case "Input":
-      return [...node.schemas, ...node.operations];
-    case "Output":
-      return [];
-    case "Operation":
-      return [
-        ...node.parameters,
-        ...(_c = (_b = (_a = node.requestBody) == null ? void 0 : _a.content) == null ? void 0 : _b.flatMap((c) => c.schema ? [c.schema] : [])) != null ? _c : [],
-        ...node.responses
-      ];
-    case "Schema": {
-      const children = [];
-      if (!recurse) return [];
-      if ("properties" in node && node.properties.length > 0) children.push(...node.properties);
-      if ("items" in node && node.items) children.push(...node.items);
-      if ("members" in node && node.members) children.push(...node.members);
-      if ("additionalProperties" in node && node.additionalProperties && node.additionalProperties !== true) children.push(node.additionalProperties);
-      return children;
-    }
-    case "Property":
-      return [node.schema];
-    case "Parameter":
-      return [node.schema];
-    case "Response":
-      return node.schema ? [node.schema] : [];
-    case "FunctionParameter":
-    case "ParameterGroup":
-    case "FunctionParameters":
-    case "Type":
-      return [];
-    default:
-      return [];
-  }
-}
-async function walk(node, options) {
-  var _a, _b;
-  return _walk(node, options, ((_a = options.depth) != null ? _a : visitorDepths.deep) === visitorDepths.deep, createLimit((_b = options.concurrency) != null ? _b : 30), void 0);
-}
-async function _walk(node, visitor, recurse, limit, parent) {
-  switch (node.kind) {
-    case "Input":
-      await limit(() => {
-        var _a;
-        return (_a = visitor.input) == null ? void 0 : _a.call(visitor, node, { parent });
-      });
-      break;
-    case "Output":
-      await limit(() => {
-        var _a;
-        return (_a = visitor.output) == null ? void 0 : _a.call(visitor, node, { parent });
-      });
-      break;
-    case "Operation":
-      await limit(() => {
-        var _a;
-        return (_a = visitor.operation) == null ? void 0 : _a.call(visitor, node, { parent });
-      });
-      break;
-    case "Schema":
-      await limit(() => {
-        var _a;
-        return (_a = visitor.schema) == null ? void 0 : _a.call(visitor, node, { parent });
-      });
-      break;
-    case "Property":
-      await limit(() => {
-        var _a;
-        return (_a = visitor.property) == null ? void 0 : _a.call(visitor, node, { parent });
-      });
-      break;
-    case "Parameter":
-      await limit(() => {
-        var _a;
-        return (_a = visitor.parameter) == null ? void 0 : _a.call(visitor, node, { parent });
-      });
-      break;
-    case "Response":
-      await limit(() => {
-        var _a;
-        return (_a = visitor.response) == null ? void 0 : _a.call(visitor, node, { parent });
-      });
-      break;
-  }
-  const children = getChildren(node, recurse);
-  for (const child of children) await _walk(child, visitor, recurse, limit, node);
+const visitorKeysByKind = {
+  Input: ["schemas", "operations"],
+  Operation: [
+    "parameters",
+    "requestBody",
+    "responses"
+  ],
+  RequestBody: ["content"],
+  Content: ["schema"],
+  Response: ["content"],
+  Schema: [
+    "properties",
+    "items",
+    "members",
+    "additionalProperties"
+  ],
+  Property: ["schema"],
+  Parameter: ["schema"]
+};
+function isNode(value) {
+  return typeof value === "object" && value !== null && "kind" in value;
+}
+function* getChildren(node, recurse) {
+  if (node.kind === "Schema" && !recurse) return;
+  const keys = visitorKeysByKind[node.kind];
+  if (!keys) return;
+  const record = node;
+  for (const key of keys) {
+    const value = record[key];
+    if (Array.isArray(value)) {
+      for (const item of value) if (isNode(item)) yield item;
+    } else if (isNode(value)) yield value;
+  }
+}
+const VISITOR_KEY_BY_KIND = {
+  Input: "input",
+  Output: "output",
+  Operation: "operation",
+  Schema: "schema",
+  Property: "property",
+  Parameter: "parameter",
+  Response: "response"
+};
+function applyVisitor(node, visitor, parent) {
+  const key = VISITOR_KEY_BY_KIND[node.kind];
+  if (!key) return void 0;
+  const fn = visitor[key];
+  return fn == null ? void 0 : fn(node, { parent });
 }
 function transform(node, options) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  var _a;
   const { depth, parent, ...visitor } = options;
   const recurse = (depth != null ? depth : visitorDepths.deep) === visitorDepths.deep;
-  switch (node.kind) {
-    case "Input": {
-      let input = node;
-      const replaced = (_a = visitor.input) == null ? void 0 : _a.call(visitor, input, { parent });
-      if (replaced) input = replaced;
-      return {
-        ...input,
-        schemas: input.schemas.map((s) => transform(s, {
-          ...options,
-          parent: input
-        })),
-        operations: input.operations.map((op) => transform(op, {
-          ...options,
-          parent: input
-        }))
-      };
-    }
-    case "Output": {
-      let output = node;
-      const replaced = (_b = visitor.output) == null ? void 0 : _b.call(visitor, output, { parent });
-      if (replaced) output = replaced;
-      return output;
-    }
-    case "Operation": {
-      let op = node;
-      const replaced = (_c = visitor.operation) == null ? void 0 : _c.call(visitor, op, { parent });
-      if (replaced) op = replaced;
-      return {
-        ...op,
-        parameters: op.parameters.map((p) => transform(p, {
-          ...options,
-          parent: op
-        })),
-        requestBody: op.requestBody ? {
-          ...op.requestBody,
-          content: (_d = op.requestBody.content) == null ? void 0 : _d.map((c) => ({
-            ...c,
-            schema: c.schema ? transform(c.schema, {
-              ...options,
-              parent: op
-            }) : void 0
-          }))
-        } : void 0,
-        responses: op.responses.map((r) => transform(r, {
-          ...options,
-          parent: op
-        }))
-      };
-    }
-    case "Schema": {
-      let schema = node;
-      const replaced = (_e = visitor.schema) == null ? void 0 : _e.call(visitor, schema, { parent });
-      if (replaced) schema = replaced;
-      const childOptions = {
-        ...options,
-        parent: schema
-      };
-      return {
-        ...schema,
-        ..."properties" in schema && recurse ? { properties: schema.properties.map((p) => transform(p, childOptions)) } : {},
-        ..."items" in schema && recurse ? { items: (_f = schema.items) == null ? void 0 : _f.map((i) => transform(i, childOptions)) } : {},
-        ..."members" in schema && recurse ? { members: (_g = schema.members) == null ? void 0 : _g.map((m) => transform(m, childOptions)) } : {},
-        ..."additionalProperties" in schema && recurse && schema.additionalProperties && schema.additionalProperties !== true ? { additionalProperties: transform(schema.additionalProperties, childOptions) } : {}
-      };
-    }
-    case "Property": {
-      let prop = node;
-      const replaced = (_h = visitor.property) == null ? void 0 : _h.call(visitor, prop, { parent });
-      if (replaced) prop = replaced;
-      return createProperty({
-        ...prop,
-        schema: transform(prop.schema, {
-          ...options,
-          parent: prop
-        })
-      });
-    }
-    case "Parameter": {
-      let param = node;
-      const replaced = (_i = visitor.parameter) == null ? void 0 : _i.call(visitor, param, { parent });
-      if (replaced) param = replaced;
-      return createParameter({
-        ...param,
-        schema: transform(param.schema, {
-          ...options,
-          parent: param
-        })
+  const rebuilt = transformChildren((_a = applyVisitor(node, visitor, parent)) != null ? _a : node, options, recurse);
+  if (rebuilt === node) return node;
+  const finalize = nodeFinalizers[rebuilt.kind];
+  return finalize ? finalize(rebuilt) : rebuilt;
+}
+const nodeFinalizers = {
+  Property: (node) => createProperty(node),
+  Parameter: (node) => createParameter(node)
+};
+function transformChildren(node, options, recurse) {
+  if (node.kind === "Schema" && !recurse) return node;
+  const keys = visitorKeysByKind[node.kind];
+  if (!keys) return node;
+  const record = node;
+  const childOptions = {
+    ...options,
+    parent: node
+  };
+  let updates;
+  for (const key of keys) {
+    if (!(key in record)) continue;
+    const value = record[key];
+    if (Array.isArray(value)) {
+      let changed = false;
+      const mapped = value.map((item) => {
+        if (!isNode(item)) return item;
+        const next = transform(item, childOptions);
+        if (next !== item) changed = true;
+        return next;
       });
+      if (changed) (updates != null ? updates : updates = {})[key] = mapped;
+    } else if (isNode(value)) {
+      const next = transform(value, childOptions);
+      if (next !== value) (updates != null ? updates : updates = {})[key] = next;
     }
-    case "Response": {
-      let response = node;
-      const replaced = (_j = visitor.response) == null ? void 0 : _j.call(visitor, response, { parent });
-      if (replaced) response = replaced;
-      return {
-        ...response,
-        schema: transform(response.schema, {
-          ...options,
-          parent: response
-        })
-      };
-    }
-    case "FunctionParameter":
-    case "ParameterGroup":
-    case "FunctionParameters":
-    case "Type":
-      return node;
-    default:
-      return node;
   }
+  return updates ? {
+    ...node,
+    ...updates
+  } : node;
 }
-function collect(node, options) {
-  var _a, _b, _c, _d, _e, _f, _g;
+function* collectLazy(node, options) {
   const { depth, parent, ...visitor } = options;
   const recurse = (depth != null ? depth : visitorDepths.deep) === visitorDepths.deep;
-  const results = [];
-  let v;
-  switch (node.kind) {
-    case "Input":
-      v = (_a = visitor.input) == null ? void 0 : _a.call(visitor, node, { parent });
-      break;
-    case "Output":
-      v = (_b = visitor.output) == null ? void 0 : _b.call(visitor, node, { parent });
-      break;
-    case "Operation":
-      v = (_c = visitor.operation) == null ? void 0 : _c.call(visitor, node, { parent });
-      break;
-    case "Schema":
-      v = (_d = visitor.schema) == null ? void 0 : _d.call(visitor, node, { parent });
-      break;
-    case "Property":
-      v = (_e = visitor.property) == null ? void 0 : _e.call(visitor, node, { parent });
-      break;
-    case "Parameter":
-      v = (_f = visitor.parameter) == null ? void 0 : _f.call(visitor, node, { parent });
-      break;
-    case "Response":
-      v = (_g = visitor.response) == null ? void 0 : _g.call(visitor, node, { parent });
-      break;
-  }
-  if (v !== void 0) results.push(v);
-  for (const child of getChildren(node, recurse)) for (const item of collect(child, {
+  const v = applyVisitor(node, visitor, parent);
+  if (v != null) yield v;
+  for (const child of getChildren(node, recurse)) yield* collectLazy(child, {
     ...options,
     parent: node
-  })) results.push(item);
-  return results;
+  });
+}
+function collect(node, options) {
+  return Array.from(collectLazy(node, options));
 }
 function sourceKey(source) {
   var _a, _b, _c;
@@ -5017,11 +4871,16 @@ function combineSources(sources) {
   }
   return [...seen.values()];
 }
-function combineExports(exports$1) {
+function mergeNameArrays(existing, incoming) {
+  const merged = new Set(existing);
+  for (const name of incoming) merged.add(name);
+  return [...merged];
+}
+function combineExports(exports) {
   const result = [];
   const namedByPath = /* @__PURE__ */ new Map();
   const seen = /* @__PURE__ */ new Set();
-  const keyed = exports$1.map((node) => ({
+  const keyed = exports.map((node) => ({
     node,
     key: sortKey(node)
   }));
@@ -5032,11 +4891,8 @@ function combineExports(exports$1) {
       if (!name.length) continue;
       const key = pathTypeKey(path2, isTypeOnly);
       const existing = namedByPath.get(key);
-      if (existing && Array.isArray(existing.name)) {
-        const merged = new Set(existing.name);
-        for (const n of name) merged.add(n);
-        existing.name = [...merged];
-      } else {
+      if (existing && Array.isArray(existing.name)) existing.name = mergeNameArrays(existing.name, name);
+      else {
         const newItem = {
           ...curr,
           name: [...new Set(name)]
@@ -5054,8 +4910,8 @@ function combineExports(exports$1) {
   }
   return result;
 }
-function combineImports(imports, exports$1, source) {
-  const exportedNames = new Set(exports$1.flatMap((e) => Array.isArray(e.name) ? e.name : e.name ? [e.name] : []));
+function combineImports(imports, exports, source) {
+  const exportedNames = new Set(exports.flatMap((e) => Array.isArray(e.name) ? e.name : e.name ? [e.name] : []));
   const isUsed = (importName) => !source || source.includes(importName) || exportedNames.has(importName);
   const importNameMemo = /* @__PURE__ */ new Map();
   const canonicalizeName = (n) => {
@@ -5065,6 +4921,14 @@ function combineImports(imports, exports$1, source) {
     if (!importNameMemo.has(key)) importNameMemo.set(key, n);
     return importNameMemo.get(key);
   };
+  const pathsWithUsedNamedImport = /* @__PURE__ */ new Set();
+  for (const node of imports) {
+    if (!Array.isArray(node.name)) continue;
+    if (node.name.some((item) => {
+      var _a;
+      return typeof item === "string" ? isUsed(item) : isUsed((_a = item.name) != null ? _a : item.propertyName);
+    })) pathsWithUsedNamedImport.add(node.path);
+  }
   const result = [];
   const namedByPath = /* @__PURE__ */ new Map();
   const seen = /* @__PURE__ */ new Set();
@@ -5085,11 +4949,8 @@ 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)) {
-        const merged = new Set(existing.name);
-        for (const n of name) merged.add(n);
-        existing.name = [...merged];
-      } else {
+      if (existing && Array.isArray(existing.name)) existing.name = mergeNameArrays(existing.name, name);
+      else {
         const newItem = {
           ...curr,
           name
@@ -5098,7 +4959,7 @@ function combineImports(imports, exports$1, source) {
         namedByPath.set(key, newItem);
       }
     } else {
-      if (name && !isUsed(name)) continue;
+      if (name && !isUsed(name) && !pathsWithUsedNamedImport.has(path2)) continue;
       const key = importKey(path2, name, isTypeOnly);
       if (!seen.has(key)) {
         result.push(curr);
@@ -5127,21 +4988,27 @@ 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;
 }
-function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
-  if (!node) return out;
+const collectSchemaRefs = memoize$1(/* @__PURE__ */ new WeakMap(), (node) => {
+  const refs = /* @__PURE__ */ new Set();
   collect(node, { schema(child) {
     if (child.type === "ref") {
       const name = resolveRefName(child);
-      if (name) out.add(name);
+      if (name) refs.add(name);
     }
   } });
+  return refs;
+});
+function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
+  if (!node) return out;
+  for (const name of collectSchemaRefs(node)) out.add(name);
   return out;
 }
-function collectUsedSchemaNames(operations, schemas) {
+const collectUsedSchemaNamesMemo = memoize$1(/* @__PURE__ */ new WeakMap(), (ops) => memoize$1(/* @__PURE__ */ new WeakMap(), (schemas) => computeUsedSchemaNames(ops, schemas)));
+function computeUsedSchemaNames(operations, schemas) {
   const schemaMap = /* @__PURE__ */ new Map();
   for (const schema of schemas) if (schema.name) schemaMap.set(schema.name, schema);
   const result = /* @__PURE__ */ new Set();
@@ -5153,12 +5020,15 @@ function collectUsedSchemaNames(operations, schemas) {
       if (namedSchema) visitSchema(namedSchema);
     }
   }
-  for (const op of operations) for (const schema of collect(op, {
+  for (const op of operations) for (const schema of collectLazy(op, {
     depth: "shallow",
     schema: (node) => node
   })) visitSchema(schema);
   return result;
 }
+function collectUsedSchemaNames(operations, schemas) {
+  return collectUsedSchemaNamesMemo(operations)(schemas);
+}
 function syncOptionality(schema, required) {
   var _a;
   const nullable = (_a = schema.nullable) != null ? _a : false;
@@ -5168,6 +5038,14 @@ function syncOptionality(schema, required) {
     nullish: !required && nullable ? true : void 0
   };
 }
+function createStreamInput(schemas, operations, meta) {
+  return {
+    kind: "Input",
+    schemas,
+    operations,
+    meta
+  };
+}
 function createProperty(props) {
   var _a;
   const required = (_a = props.required) != null ? _a : false;
@@ -5223,7 +5101,115 @@ 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 _cache, _filesCache, _FileManager_instances, store_fn, _a$1, _studioIsOpen, _pluginsWithEventGenerators, _resolvers, _defaultResolvers, _hookListeners, _PluginDriver_instances, normalizePlugin_fn, trackHookListener_fn, createDefaultResolver_fn, _b$1;
+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;
@@ -5249,1170 +5235,1543 @@ function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
   }) : camelCase(part));
   return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
-const DEFAULT_STUDIO_URL = "https://studio.kubb.dev";
-const DEFAULT_BANNER = "simple";
-const DEFAULT_EXTENSION = { ".ts": ".ts" };
-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);
-  }
-  return value.match(pattern) !== null;
-}
-function matchesOperationPattern(node, type, pattern) {
-  var _a2, _b2, _c;
-  switch (type) {
-    case "tag":
-      return node.tags.some((tag) => testPattern(tag, pattern));
-    case "operationId":
-      return testPattern(node.operationId, pattern);
-    case "path":
-      return testPattern(node.path, pattern);
-    case "method":
-      return testPattern(node.method.toLowerCase(), pattern);
-    case "contentType":
-      return (_c = (_b2 = (_a2 = node.requestBody) == null ? void 0 : _a2.content) == null ? void 0 : _b2.some((c) => testPattern(c.contentType, pattern))) != null ? _c : false;
-    default:
-      return false;
-  }
+function getElapsedMs(hrStart) {
+  const [seconds, nanoseconds] = process.hrtime(hrStart);
+  const ms = seconds * 1e3 + nanoseconds / 1e6;
+  return Math.round(ms * 100) / 100;
 }
-function matchesSchemaPattern(node, type, pattern) {
-  switch (type) {
-    case "schemaName":
-      return node.name ? testPattern(node.name, pattern) : false;
-    default:
-      return null;
-  }
+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 defaultResolver(name, type) {
-  let resolvedName = camelCase(name);
-  if (type === "file" || type === "function") resolvedName = camelCase(name, { isFile: type === "file" });
-  if (type === "type") resolvedName = pascalCase(name);
-  return resolvedName;
+function* chunks(arr, size) {
+  for (let i = 0; i < arr.length; i += size) yield arr.slice(i, i + size);
 }
-function defaultResolveOptions(node, { options, exclude = [], include, override = [] }) {
-  var _a2, _b2;
-  if (isOperationNode(node)) {
-    if (exclude.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) return null;
-    if (include && !include.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) return null;
-    const overrideOptions = (_a2 = override.find(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) == null ? void 0 : _a2.options;
-    return {
-      ...options,
-      ...overrideOptions
-    };
+async function forBatches(source, process2, options) {
+  const { concurrency, flush } = options;
+  if (Array.isArray(source)) {
+    for (const batch2 of chunks(source, concurrency)) {
+      await process2(batch2);
+      if (flush) await flush();
+    }
+    return;
   }
-  if (isSchemaNode(node)) {
-    if (exclude.some(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)) return null;
-    if (include) {
-      const applicable = include.map(({ type, pattern }) => matchesSchemaPattern(node, type, pattern)).filter((r) => r !== null);
-      if (applicable.length > 0 && !applicable.includes(true)) return null;
+  const batch = [];
+  for await (const item of source) {
+    batch.push(item);
+    if (batch.length >= concurrency) {
+      await process2(batch.splice(0));
+      if (flush) await flush();
     }
-    const overrideOptions = (_b2 = override.find(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)) == null ? void 0 : _b2.options;
-    return {
-      ...options,
-      ...overrideOptions
-    };
   }
-  return options;
+  if (batch.length > 0) {
+    await process2(batch.splice(0));
+    if (flush) await flush();
+  }
 }
-function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }, { root, output, group }) {
-  var _a2;
-  if ((pathMode != null ? pathMode : PluginDriver.getMode(path$1.resolve(root, output.path))) === "single") return path$1.resolve(root, output.path);
-  let result;
-  if (group && (groupPath || tag)) {
-    const groupValue = group.type === "path" ? groupPath : tag;
-    const defaultName = group.type === "tag" ? ({ group: g }) => `${camelCase(g)}Controller` : ({ group: g }) => {
-      const segment = g.split("/").filter((s) => s !== "" && s !== "." && s !== "..")[0];
-      return segment ? camelCase(segment) : "";
-    };
-    const resolveName = (_a2 = group.name) != null ? _a2 : defaultName;
-    result = path$1.resolve(root, output.path, resolveName({ group: groupValue }), baseName);
-  } else result = path$1.resolve(root, output.path, baseName);
-  const outputDir = path$1.resolve(root, output.path);
-  const outputDirWithSep = outputDir.endsWith(path$1.sep) ? outputDir : `${outputDir}${path$1.sep}`;
-  if (result !== outputDir && !result.startsWith(outputDirWithSep)) throw new Error(`[Kubb] Resolved path "${result}" is outside the output directory "${outputDir}". This may indicate a path traversal attempt in the OpenAPI specification or a misconfigured group.name function.`);
-  return result;
+function isPromise(result) {
+  return result !== null && result !== void 0 && typeof result["then"] === "function";
 }
-function defaultResolveFile({ name, extname: extname2, tag, path: groupPath }, context, ctx) {
-  const pathMode = PluginDriver.getMode(path$1.resolve(context.root, context.output.path));
-  const baseName = `${pathMode === "single" ? "" : ctx.default(name, "file")}${extname2}`;
-  const filePath = ctx.resolvePath({
-    baseName,
-    pathMode,
-    tag,
-    path: groupPath
-  }, context);
-  return createFile({
-    path: filePath,
-    baseName: path$1.basename(filePath),
-    meta: { pluginName: ctx.pluginName },
-    sources: [],
-    imports: [],
-    exports: []
-  });
+function memoize(store, factory) {
+  return (key) => {
+    if (store.has(key)) return store.get(key);
+    const value = factory(key);
+    store.set(key, value);
+    return value;
+  };
 }
-function buildDefaultBanner({ title, description, version, config }) {
-  try {
-    let source = "";
-    if (Array.isArray(config.input)) {
-      const first = config.input[0];
-      if (first && "path" in first) source = path$1.basename(first.path);
-    } else if ("path" in config.input) source = path$1.basename(config.input.path);
-    else if ("data" in config.input) source = "text content";
-    let banner = "/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n";
-    if (config.output.defaultBanner === "simple") {
-      banner += "*/\n";
-      return banner;
-    }
-    if (source) banner += `* Source: ${source}
-`;
-    if (title) banner += `* Title: ${title}
-`;
-    if (description) {
-      const formattedDescription = description.replace(/\n/gm, "\n* ");
-      banner += `* Description: ${formattedDescription}
-`;
-    }
-    if (version) banner += `* OpenAPI spec version: ${version}
-`;
-    banner += "*/\n";
-    return banner;
-  } catch (_error) {
-    return "/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n*/";
-  }
-}
-function defaultResolveBanner(node, { output, config }) {
-  var _a2, _b2;
-  if (typeof (output == null ? void 0 : output.banner) === "function") return output.banner(node);
-  if (typeof (output == null ? void 0 : output.banner) === "string") return output.banner;
-  if (config.output.defaultBanner === false) return;
-  return buildDefaultBanner({
-    title: (_a2 = node == null ? void 0 : node.meta) == null ? void 0 : _a2.title,
-    version: (_b2 = node == null ? void 0 : node.meta) == null ? void 0 : _b2.version,
-    config
-  });
-}
-function defaultResolveFooter(node, { output }) {
-  if (typeof (output == null ? void 0 : output.footer) === "function") return node ? output.footer(node) : void 0;
-  if (typeof (output == null ? void 0 : output.footer) === "string") return output.footer;
-}
-function defineResolver(build) {
-  const resolver = {};
-  Object.assign(resolver, {
-    default: defaultResolver,
-    resolveOptions: defaultResolveOptions,
-    resolvePath: defaultResolvePath,
-    resolveFile: (params, context) => defaultResolveFile(params, context, resolver),
-    resolveBanner: defaultResolveBanner,
-    resolveFooter: defaultResolveFooter,
-    ...build(resolver)
-  });
-  return resolver;
-}
-function encodeAst(input) {
-  const compressed = deflateSync(new TextEncoder().encode(JSON.stringify(input)));
-  return Buffer.from(compressed).toString("base64url");
-}
-function getStudioUrl(input, studioUrl, options = {}) {
-  return `${studioUrl.replace(/\/$/, "")}${options.ast ? "/ast" : ""}?root=${encodeAst(input)}`;
-}
-async function openInStudio(input, studioUrl, options = {}) {
-  const url = getStudioUrl(input, studioUrl, options);
-  const cmd = process.platform === "win32" ? "cmd" : process.platform === "darwin" ? "open" : "xdg-open";
-  const args = process.platform === "win32" ? [
-    "/c",
-    "start",
-    "",
-    url
-  ] : [url];
-  try {
-    await x(cmd, args);
-  } catch {
-    console.log(`
-  ${url}
-`);
-  }
-}
-function mergeFile(a, b) {
-  return {
-    ...a,
-    banner: b.banner,
-    footer: b.footer,
-    sources: [...a.sources || [], ...b.sources || []],
-    imports: [...a.imports || [], ...b.imports || []],
-    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;
-}
-var FileManager = (_a$1 = class {
-  constructor() {
-    __privateAdd$1(this, _FileManager_instances);
-    __privateAdd$1(this, _cache, /* @__PURE__ */ new Map());
-    __privateAdd$1(this, _filesCache, 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.
-  */
-  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);
-  }
-  getByPath(path2) {
-    var _a2;
-    return (_a2 = __privateGet$1(this, _cache).get(path2)) != null ? _a2 : null;
-  }
-  deleteByPath(path2) {
-    __privateGet$1(this, _cache).delete(path2);
-    __privateSet$1(this, _filesCache, null);
-  }
-  clear() {
-    __privateGet$1(this, _cache).clear();
-    __privateSet$1(this, _filesCache, null);
-  }
-  /**
-  * All stored files, sorted by path length (shorter paths first).
-  */
-  get files() {
-    if (__privateGet$1(this, _filesCache)) return __privateGet$1(this, _filesCache);
-    __privateSet$1(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$1(this, _filesCache, null);
-  return resolvedFiles;
-}, _a$1);
-async function applyHookResult(result, driver, rendererFactory) {
-  if (!result) return;
-  if (Array.isArray(result)) {
-    driver.fileManager.upsert(...result);
-    return;
-  }
-  if (!rendererFactory) return;
-  const renderer = rendererFactory();
-  await renderer.render(result);
-  driver.fileManager.upsert(...renderer.files);
-  renderer.unmount();
+function arrayToAsyncIterable(arr) {
+  return { [Symbol.asyncIterator]() {
+    return (async function* () {
+      yield* arr;
+    })();
+  } };
 }
-function enforceOrder(enforce) {
-  return enforce === "pre" ? -1 : enforce === "post" ? 1 : 0;
+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 isValidVarName(name) {
+  if (!name || reservedWords.has(name)) return false;
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
-var PluginDriver = (_b$1 = class {
-  constructor(config, options) {
-    __privateAdd$1(this, _PluginDriver_instances);
-    __publicField$1(this, "config");
-    __publicField$1(this, "options");
-    /**
-    * The universal `@kubb/ast` `InputNode` produced by the adapter, set by
-    * the build pipeline after the adapter's `parse()` resolves.
-    */
-    __publicField$1(this, "inputNode");
-    __publicField$1(this, "adapter");
-    __privateAdd$1(this, _studioIsOpen, false);
-    /**
-    * Central file store for all generated files.
-    * Plugins should use `this.addFile()` / `this.upsertFile()` (via their context) to
-    * add files; this property gives direct read/write access when needed.
-    */
-    __publicField$1(this, "fileManager", new FileManager());
-    __publicField$1(this, "plugins", /* @__PURE__ */ new Map());
+var URLPath = (_b = class {
+  constructor(path2, options = {}) {
+    __privateAdd$1(this, _URLPath_instances);
     /**
-    * Tracks which plugins have generators registered via `addGenerator()` (event-based path).
-    * Used by the build loop to decide whether to emit generator events for a given plugin.
+    * The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
     */
-    __privateAdd$1(this, _pluginsWithEventGenerators, /* @__PURE__ */ new Set());
-    __privateAdd$1(this, _resolvers, /* @__PURE__ */ new Map());
-    __privateAdd$1(this, _defaultResolvers, /* @__PURE__ */ new Map());
-    __privateAdd$1(this, _hookListeners, /* @__PURE__ */ new Map());
-    this.config = config;
-    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) => {
-      var _a2, _b2;
-      if ((_a2 = b.dependencies) == null ? void 0 : _a2.includes(a.name)) return -1;
-      if ((_b2 = a.dependencies) == null ? void 0 : _b2.includes(b.name)) return 1;
-      return enforceOrder(a.enforce) - enforceOrder(b.enforce);
-    }).forEach((plugin) => {
-      this.plugins.set(plugin.name, plugin);
-    });
+    __publicField$1(this, "path");
+    __privateAdd$1(this, _options);
+    this.path = path2;
+    __privateSet$1(this, _options, options);
   }
-  /**
-  * Returns `'single'` when `fileOrFolder` has a file extension, `'split'` otherwise.
+  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
   *
   * @example
   * ```ts
-  * PluginDriver.getMode('src/gen/types.ts')  // 'single'
-  * PluginDriver.getMode('src/gen/types')     // 'split'
+  * new URLPath('/pet/{petId}').URL // '/pet/:petId'
   * ```
   */
-  static getMode(fileOrFolder) {
-    if (!fileOrFolder) return "split";
-    return extname(fileOrFolder) ? "single" : "split";
-  }
-  get hooks() {
-    return this.options.hooks;
+  get URL() {
+    return this.toURLPath();
   }
-  /**
-  * Registers a hook-style plugin's lifecycle handlers on the shared `AsyncEventEmitter`.
-  *
-  * For `kubb:plugin:setup`, the registered listener wraps the globally emitted context with a
-  * plugin-specific one so that `addGenerator`, `setResolver`, `setTransformer`, and
-  * `setRenderer` all target the correct `normalizedPlugin` entry in the plugins map.
-  *
-  * All other hooks are iterated and registered directly as pass-through listeners.
-  * Any event key present in the global `KubbHooks` interface can be subscribed to.
-  *
-  * External tooling can subscribe to any of these events via `hooks.on(...)` to observe
-  * the plugin lifecycle without modifying plugin behavior.
+  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
   *
-  * @internal
+  * @example
+  * ```ts
+  * new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
+  * new URLPath('/pet/{petId}').isURL                       // false
+  * ```
   */
-  registerPluginHooks(hookPlugin, normalizedPlugin) {
-    const { hooks } = hookPlugin;
-    if (hooks["kubb:plugin:setup"]) {
-      const setupHandler = (globalCtx) => {
-        var _a2;
-        const pluginCtx = {
-          ...globalCtx,
-          options: (_a2 = hookPlugin.options) != null ? _a2 : {},
-          addGenerator: (gen) => {
-            this.registerGenerator(normalizedPlugin.name, gen);
-          },
-          setResolver: (resolver) => {
-            this.setPluginResolver(normalizedPlugin.name, resolver);
-          },
-          setTransformer: (visitor) => {
-            normalizedPlugin.transformer = visitor;
-          },
-          setRenderer: (renderer) => {
-            normalizedPlugin.renderer = renderer;
-          },
-          setOptions: (opts) => {
-            normalizedPlugin.options = {
-              ...normalizedPlugin.options,
-              ...opts
-            };
-          },
-          injectFile: (userFileNode) => {
-            this.fileManager.add(createFile(userFileNode));
-          }
-        };
-        return hooks["kubb:plugin:setup"](pluginCtx);
-      };
-      this.hooks.on("kubb:plugin:setup", setupHandler);
-      __privateMethod$1(this, _PluginDriver_instances, trackHookListener_fn).call(this, "kubb:plugin:setup", setupHandler);
-    }
-    for (const [event, handler] of Object.entries(hooks)) {
-      if (event === "kubb:plugin:setup" || !handler) continue;
-      this.hooks.on(event, handler);
-      __privateMethod$1(this, _PluginDriver_instances, trackHookListener_fn).call(this, event, handler);
+  get isURL() {
+    try {
+      return !!new URL(this.path).href;
+    } catch {
+      return false;
     }
   }
   /**
-  * Emits the `kubb:plugin:setup` event so that all registered hook-style plugin listeners
-  * can configure generators, resolvers, transformers and renderers before `buildStart` runs.
+  * Converts the OpenAPI path to a TypeScript template literal string.
   *
-  * 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,
-      options: {},
-      addGenerator: noop,
-      setResolver: noop,
-      setTransformer: noop,
-      setRenderer: noop,
-      setOptions: noop,
-      injectFile: noop,
-      updateConfig: noop
-    });
-  }
-  /**
-  * Registers a generator for the given plugin on the shared event emitter.
-  *
-  * The generator's `schema`, `operation`, and `operations` methods are registered as
-  * listeners on `kubb:generate:schema`, `kubb:generate:operation`, and `kubb:generate:operations`
-  * respectively. Each listener is scoped to the owning plugin via a `ctx.plugin.name` check
-  * so that generators from different plugins do not cross-fire.
-  *
-  * The renderer resolution chain is: `generator.renderer → plugin.renderer → config.renderer`.
-  * Set `generator.renderer = null` to explicitly opt out of rendering even when the plugin
-  * declares a renderer.
-  *
-  * Call this method inside `addGenerator()` (in `kubb:plugin:setup`) to wire up a generator.
-  */
-  registerGenerator(pluginName, gen) {
-    const resolveRenderer = () => {
-      var _a2, _b2;
-      const plugin = this.plugins.get(pluginName);
-      return gen.renderer === null ? void 0 : (_b2 = (_a2 = gen.renderer) != null ? _a2 : plugin == null ? void 0 : plugin.renderer) != null ? _b2 : this.config.renderer;
-    };
-    if (gen.schema) {
-      const schemaHandler = async (node, ctx) => {
-        if (ctx.plugin.name !== pluginName) return;
-        await applyHookResult(await gen.schema(node, ctx), this, resolveRenderer());
-      };
-      this.hooks.on("kubb:generate:schema", schemaHandler);
-      __privateMethod$1(this, _PluginDriver_instances, trackHookListener_fn).call(this, "kubb:generate:schema", schemaHandler);
-    }
-    if (gen.operation) {
-      const operationHandler = async (node, ctx) => {
-        if (ctx.plugin.name !== pluginName) return;
-        await applyHookResult(await gen.operation(node, ctx), this, resolveRenderer());
-      };
-      this.hooks.on("kubb:generate:operation", operationHandler);
-      __privateMethod$1(this, _PluginDriver_instances, trackHookListener_fn).call(this, "kubb:generate:operation", operationHandler);
-    }
-    if (gen.operations) {
-      const operationsHandler = async (nodes, ctx) => {
-        if (ctx.plugin.name !== pluginName) return;
-        await applyHookResult(await gen.operations(nodes, ctx), this, resolveRenderer());
-      };
-      this.hooks.on("kubb:generate:operations", operationsHandler);
-      __privateMethod$1(this, _PluginDriver_instances, trackHookListener_fn).call(this, "kubb:generate:operations", operationsHandler);
-    }
-    __privateGet$1(this, _pluginsWithEventGenerators).add(pluginName);
-  }
-  /**
-  * Returns `true` when at least one generator was registered for the given plugin
-  * via `addGenerator()` in `kubb:plugin:setup` (event-based path).
-  *
-  * Used by the build loop to decide whether to walk the AST and emit generator events
-  * for a plugin that has no static `plugin.generators`.
+  * @example
+  * new URLPath('/pet/{petId}').template              // '`/pet/${petId}`'
+  * new URLPath('/account/monetary-accountID').template // '`/account/${monetaryAccountId}`'
   */
-  hasRegisteredGenerators(pluginName) {
-    return __privateGet$1(this, _pluginsWithEventGenerators).has(pluginName);
+  get template() {
+    return this.toTemplateString();
   }
-  /**
-  * Unregisters all plugin lifecycle listeners from the shared event emitter.
-  * Called at the end of a build to prevent listener leaks across repeated builds.
+  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
   *
-  * @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),
-      ...partial
-    };
-    __privateGet$1(this, _resolvers).set(pluginName, merged);
-    const plugin = this.plugins.get(pluginName);
-    if (plugin) plugin.resolver = merged;
-  }
-  getResolver(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;
-    return {
-      config: driver.config,
-      get root() {
-        return resolve(driver.config.root, driver.config.output.path);
-      },
-      getMode(output) {
-        return _b$1.getMode(resolve(driver.config.root, driver.config.output.path, output.path));
-      },
-      hooks: driver.hooks,
-      plugin,
-      getPlugin: driver.getPlugin.bind(driver),
-      requirePlugin: driver.requirePlugin.bind(driver),
-      getResolver: driver.getResolver.bind(driver),
-      driver,
-      addFile: async (...files) => {
-        driver.fileManager.add(...files);
-      },
-      upsertFile: async (...files) => {
-        driver.fileManager.upsert(...files);
-      },
-      get inputNode() {
-        return driver.inputNode;
-      },
-      get adapter() {
-        return driver.adapter;
-      },
-      get resolver() {
-        return driver.getResolver(plugin.name);
-      },
-      get transformer() {
-        return plugin.transformer;
-      },
-      warn(message) {
-        driver.hooks.emit("kubb:warn", { message });
-      },
-      error(error) {
-        driver.hooks.emit("kubb:error", { error: typeof error === "string" ? new Error(error) : error });
-      },
-      info(message) {
-        driver.hooks.emit("kubb:info", { message });
-      },
-      openInStudio(options) {
-        var _a2, _b2;
-        if (!driver.config.devtools || __privateGet$1(driver, _studioIsOpen)) return;
-        if (typeof driver.config.devtools !== "object") throw new Error("Devtools must be an object");
-        if (!driver.inputNode || !driver.adapter) throw new Error("adapter is not defined, make sure you have set the parser in kubb.config.ts");
-        __privateSet$1(driver, _studioIsOpen, true);
-        const studioUrl = (_b2 = (_a2 = driver.config.devtools) == null ? void 0 : _a2.studioUrl) != null ? _b2 : "https://studio.kubb.dev";
-        return openInStudio(driver.inputNode, studioUrl, options);
-      }
-    };
-  }
-  getPlugin(pluginName) {
-    return this.plugins.get(pluginName);
-  }
-  requirePlugin(pluginName) {
-    const plugin = this.plugins.get(pluginName);
-    if (!plugin) throw new Error(`[kubb] Plugin "${pluginName}" is required but not found. Make sure it is included in your Kubb config.`);
-    return plugin;
-  }
-}, _studioIsOpen = new WeakMap(), _pluginsWithEventGenerators = new WeakMap(), _resolvers = new WeakMap(), _defaultResolvers = new WeakMap(), _hookListeners = new WeakMap(), _PluginDriver_instances = new WeakSet(), /**
-* Creates an `NormalizedPlugin` from a hook-style plugin and registers
-* its lifecycle handlers on the `AsyncEventEmitter`.
-*/
-normalizePlugin_fn = function(hookPlugin) {
-  const normalizedPlugin = {
-    name: hookPlugin.name,
-    dependencies: hookPlugin.dependencies,
-    enforce: hookPlugin.enforce,
-    options: {
-      output: { path: "." },
-      exclude: [],
-      override: []
-    }
-  };
-  this.registerPluginHooks(hookPlugin, normalizedPlugin);
-  return normalizedPlugin;
-}, trackHookListener_fn = function(event, handler) {
-  let handlers = __privateGet$1(this, _hookListeners).get(event);
-  if (!handlers) {
-    handlers = /* @__PURE__ */ new Set();
-    __privateGet$1(this, _hookListeners).set(event, handlers);
-  }
-  handlers.add(handler);
-}, createDefaultResolver_fn = function(pluginName) {
-  const existingResolver = __privateGet$1(this, _defaultResolvers).get(pluginName);
-  if (existingResolver) return existingResolver;
-  const resolver = defineResolver((_ctx) => ({
-    name: "default",
-    pluginName
-  }));
-  __privateGet$1(this, _defaultResolvers).set(pluginName, resolver);
-  return resolver;
-}, _b$1);
-
-var __defProp = Object.defineProperty;
-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 __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 __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;
-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
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').object
+  * // { url: '/pet/:petId', params: { petId: 'petId' } }
+  * ```
   */
-  constructor(maxListener = 10) {
-    __privateAdd(this, _emitter, new EventEmitter());
-    __privateGet(this, _emitter).setMaxListeners(maxListener);
+  get object() {
+    return this.toObject();
   }
-  /**
-  * Emits `eventName` and awaits all registered listeners sequentially.
-  * Throws if any listener rejects, wrapping the cause with the event name and serialized arguments.
+  /** Returns a map of path parameter names, or `undefined` when the path has no parameters.
   *
   * @example
   * ```ts
-  * await emitter.emit('build', 'petstore')
+  * new URLPath('/pet/{petId}').params // { petId: 'petId' }
+  * new URLPath('/pet').params         // undefined
   * ```
   */
-  async emit(eventName, ...eventArgs) {
-    const listeners = __privateGet(this, _emitter).listeners(eventName);
-    if (listeners.length === 0) return;
-    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) });
+  get params() {
+    return this.getParams();
+  }
+  toObject({ type = "path", replacer, stringify } = {}) {
+    const object = {
+      url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
+      params: this.getParams()
+    };
+    if (stringify) {
+      if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
+      if (object.params) return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
+      return `{ url: '${object.url}' }`;
     }
+    return object;
   }
   /**
-  * Registers a persistent listener for `eventName`.
+  * Converts the OpenAPI path to a TypeScript template literal string.
+  * An optional `replacer` can transform each extracted parameter name before interpolation.
   *
   * @example
-  * ```ts
-  * emitter.on('build', async (name) => { console.log(name) })
-  * ```
+  * new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
   */
-  on(eventName, handler) {
-    __privateGet(this, _emitter).on(eventName, handler);
+  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("");
+    return `\`${prefix != null ? prefix : ""}${result}\``;
   }
   /**
-  * Registers a one-shot listener that removes itself after the first invocation.
+  * Extracts all `{param}` segments from the path and returns them as a key-value map.
+  * An optional `replacer` transforms each parameter name in both key and value positions.
+  * Returns `undefined` when no path parameters are found.
   *
   * @example
   * ```ts
-  * emitter.onOnce('build', async (name) => { console.log(name) })
+  * new URLPath('/pet/{petId}/tag/{tagId}').getParams()
+  * // { petId: 'petId', tagId: 'tagId' }
   * ```
   */
-  onOnce(eventName, handler) {
-    const wrapper = (...args) => {
-      this.off(eventName, wrapper);
-      return handler(...args);
-    };
-    this.on(eventName, wrapper);
+  getParams(replacer) {
+    const params = {};
+    __privateMethod$1(this, _URLPath_instances, eachParam_fn).call(this, (_raw, param) => {
+      const key = replacer ? replacer(param) : param;
+      params[key] = key;
+    });
+    return Object.keys(params).length > 0 ? params : void 0;
   }
-  /**
-  * Removes a previously registered listener.
+  /** Converts the OpenAPI path to Express-style colon syntax.
   *
   * @example
   * ```ts
-  * emitter.off('build', handler)
+  * new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
   * ```
   */
-  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);
+  toURLPath() {
+    return this.path.replace(/\{([^}]+)\}/g, ":$1");
   }
-  /**
-  * Removes all listeners from every event channel.
-  *
-  * @example
-  * ```ts
-  * emitter.removeAll()
-  * ```
-  */
-  removeAll() {
-    __privateGet(this, _emitter).removeAllListeners();
+}, _options = new WeakMap(), _URLPath_instances = new WeakSet(), transformParam_fn = function(raw) {
+  const param = isValidVarName(raw) ? raw : camelCase(raw);
+  return __privateGet$1(this, _options).casing === "camelcase" ? camelCase(param) : param;
+}, /**
+* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
+*/
+eachParam_fn = function(fn) {
+  for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
+    const raw = match[1];
+    fn(raw, __privateMethod$1(this, _URLPath_instances, transformParam_fn).call(this, raw));
   }
-}, _emitter = new WeakMap(), _a);
-function getElapsedMs(hrStart) {
-  const [seconds, nanoseconds] = process.hrtime(hrStart);
-  const ms = seconds * 1e3 + nanoseconds / 1e6;
-  return Math.round(ms * 100) / 100;
+}, _b);
+const DEFAULT_STUDIO_URL = "https://kubb.studio";
+const DEFAULT_BANNER = "simple";
+const DEFAULT_EXTENSION = { ".ts": ".ts" };
+function getMode(fileOrFolder) {
+  if (!fileOrFolder) return "split";
+  return extname(fileOrFolder) ? "single" : "split";
 }
-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 buildBannerMeta({ meta, file }) {
+  var _a2, _b2, _c2, _d2, _e, _f;
+  return {
+    title: meta == null ? void 0 : meta.title,
+    description: meta == null ? void 0 : meta.description,
+    version: meta == null ? void 0 : meta.version,
+    baseURL: meta == null ? void 0 : meta.baseURL,
+    circularNames: (_a2 = meta == null ? void 0 : meta.circularNames) != null ? _a2 : [],
+    enumNames: (_b2 = meta == null ? void 0 : meta.enumNames) != null ? _b2 : [],
+    filePath: (_c2 = file == null ? void 0 : file.path) != null ? _c2 : "",
+    baseName: (_d2 = file == null ? void 0 : file.baseName) != null ? _d2 : "",
+    isBarrel: (_e = file == null ? void 0 : file.isBarrel) != null ? _e : false,
+    isAggregation: (_f = file == null ? void 0 : file.isAggregation) != null ? _f : false
+  };
 }
-async function exists(path) {
-  if (typeof Bun !== "undefined") return Bun.file(path).exists();
-  return access(path).then(() => true, () => false);
+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);
+  }
+  return value.match(pattern) !== null;
 }
-async function write(path, data, options = {}) {
-  const trimmed = data.trim();
-  if (trimmed === "") return null;
-  const resolved = resolve(path);
-  if (typeof Bun !== "undefined") {
-    const file = Bun.file(resolved);
-    if ((await file.exists() ? await file.text() : null) === trimmed) return null;
-    await Bun.write(resolved, trimmed);
-    return trimmed;
+function matchesOperationPattern(node, type, pattern) {
+  var _a2, _b2, _c2;
+  if (type === "tag") return node.tags.some((tag) => testPattern(tag, pattern));
+  if (type === "operationId") return testPattern(node.operationId, pattern);
+  if (type === "path") return node.path !== void 0 && testPattern(node.path, pattern);
+  if (type === "method") return node.method !== void 0 && testPattern(node.method.toLowerCase(), pattern);
+  if (type === "contentType") return (_c2 = (_b2 = (_a2 = node.requestBody) == null ? void 0 : _a2.content) == null ? void 0 : _b2.some((c) => testPattern(c.contentType, pattern))) != null ? _c2 : false;
+  return false;
+}
+function matchesSchemaPattern(node, type, pattern) {
+  if (type === "schemaName") return node.name ? testPattern(node.name, pattern) : false;
+  return null;
+}
+function defaultResolver(name, type) {
+  if (type === "file" || type === "function") return camelCase(name, { isFile: type === "file" });
+  if (type === "type") return pascalCase(name);
+  return camelCase(name);
+}
+const resolveOptionsCache = /* @__PURE__ */ new WeakMap();
+function computeOptions(node, options, exclude, include, override) {
+  var _a2, _b2;
+  if (isOperationNode(node)) {
+    if (exclude.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) return null;
+    if (include && !include.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) return null;
+    const overrideOptions = (_a2 = override.find(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) == null ? void 0 : _a2.options;
+    return {
+      ...options,
+      ...overrideOptions
+    };
   }
+  if (isSchemaNode(node)) {
+    if (exclude.some(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)) return null;
+    if (include) {
+      const applicable = include.map(({ type, pattern }) => matchesSchemaPattern(node, type, pattern)).filter((r) => r !== null);
+      if (applicable.length > 0 && !applicable.includes(true)) return null;
+    }
+    const overrideOptions = (_b2 = override.find(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)) == null ? void 0 : _b2.options;
+    return {
+      ...options,
+      ...overrideOptions
+    };
+  }
+  return options;
+}
+function defaultResolveOptions(node, { options, exclude = [], include, override = [] }) {
+  const optionsKey = options;
+  let byOptions = resolveOptionsCache.get(optionsKey);
+  if (!byOptions) {
+    byOptions = /* @__PURE__ */ new WeakMap();
+    resolveOptionsCache.set(optionsKey, byOptions);
+  }
+  const cached = byOptions.get(node);
+  if (cached !== void 0) return cached.value;
+  const result = computeOptions(node, options, exclude, include, override);
+  byOptions.set(node, { value: result });
+  return result;
+}
+function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }, { root, output, group }) {
+  if ((pathMode != null ? pathMode : getMode(path$1.resolve(root, output.path))) === "single") return path$1.resolve(root, output.path);
+  const result = (() => {
+    var _a2;
+    if (group && (groupPath || tag)) {
+      const groupValue = group.type === "path" ? groupPath : tag;
+      const defaultName = group.type === "tag" ? ({ group: g }) => `${camelCase(g)}Controller` : ({ group: g }) => {
+        const segment = g.split("/").filter((s) => s !== "" && s !== "." && s !== "..")[0];
+        return segment ? camelCase(segment) : "";
+      };
+      const resolveName = (_a2 = group.name) != null ? _a2 : defaultName;
+      return path$1.resolve(root, output.path, resolveName({ group: groupValue }), baseName);
+    }
+    return path$1.resolve(root, output.path, baseName);
+  })();
+  const outputDir = path$1.resolve(root, output.path);
+  const outputDirWithSep = outputDir.endsWith(path$1.sep) ? outputDir : `${outputDir}${path$1.sep}`;
+  if (result !== outputDir && !result.startsWith(outputDirWithSep)) throw new Error(`[Kubb] Resolved path "${result}" is outside the output directory "${outputDir}". This may indicate a path traversal attempt in the OpenAPI specification or a misconfigured group.name function.`);
+  return result;
+}
+function defaultResolveFile({ name, extname: extname2, tag, path: groupPath }, context) {
+  const pathMode = getMode(path$1.resolve(context.root, context.output.path));
+  const baseName = `${pathMode === "single" ? "" : this.default(name, "file")}${extname2}`;
+  const filePath = this.resolvePath({
+    baseName,
+    pathMode,
+    tag,
+    path: groupPath
+  }, context);
+  return createFile({
+    path: filePath,
+    baseName: path$1.basename(filePath),
+    meta: { pluginName: this.pluginName },
+    sources: [],
+    imports: [],
+    exports: []
+  });
+}
+function buildDefaultBanner({ title, description, version, config }) {
   try {
-    if (await readFile$1(resolved, { encoding: "utf-8" }) === trimmed) return null;
-  } catch {
+    const source = (() => {
+      if (Array.isArray(config.input)) {
+        const first = config.input[0];
+        if (first && "path" in first) return path$1.basename(first.path);
+        return "";
+      }
+      if (config.input && "path" in config.input) return path$1.basename(config.input.path);
+      if (config.input && "data" in config.input) return "text content";
+      return "";
+    })();
+    let banner = "/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n";
+    if (config.output.defaultBanner === "simple") {
+      banner += "*/\n";
+      return banner;
+    }
+    if (source) banner += `* Source: ${source}
+`;
+    if (title) banner += `* Title: ${title}
+`;
+    if (description) {
+      const formattedDescription = description.replace(/\n/gm, "\n* ");
+      banner += `* Description: ${formattedDescription}
+`;
+    }
+    if (version) banner += `* OpenAPI spec version: ${version}
+`;
+    banner += "*/\n";
+    return banner;
+  } catch (_error) {
+    return "/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n*/";
   }
-  await mkdir(dirname(resolved), { recursive: true });
-  await writeFile$1(resolved, trimmed, { encoding: "utf-8" });
-  if (options.sanity) {
-    const savedData = await readFile$1(resolved, { encoding: "utf-8" });
-    if (savedData !== trimmed) throw new Error(`Sanity check failed for ${path}
-
-Data[${data.length}]:
-${data}
-
-Saved[${savedData.length}]:
-${savedData}
+}
+function defaultResolveBanner(meta, { output, config, file }) {
+  if (typeof (output == null ? void 0 : output.banner) === "function") return output.banner(buildBannerMeta({
+    meta,
+    file
+  }));
+  if (typeof (output == null ? void 0 : output.banner) === "string") return output.banner;
+  if (config.output.defaultBanner === false) return null;
+  return buildDefaultBanner({
+    title: meta == null ? void 0 : meta.title,
+    version: meta == null ? void 0 : meta.version,
+    config
+  });
+}
+function defaultResolveFooter(meta, { output, file }) {
+  if (typeof (output == null ? void 0 : output.footer) === "function") return output.footer(buildBannerMeta({
+    meta,
+    file
+  }));
+  if (typeof (output == null ? void 0 : output.footer) === "string") return output.footer;
+  return null;
+}
+function defineResolver(build) {
+  let resolver;
+  resolver = {
+    default: defaultResolver,
+    resolveOptions: defaultResolveOptions,
+    resolvePath: defaultResolvePath,
+    resolveFile: (params, context) => defaultResolveFile.call(resolver, params, context),
+    resolveBanner: defaultResolveBanner,
+    resolveFooter: defaultResolveFooter,
+    ...build()
+  };
+  return resolver;
+}
+function encodeAst(input) {
+  const compressed = deflateSync(new TextEncoder().encode(JSON.stringify(input)));
+  return Buffer.from(compressed).toString("base64url");
+}
+function getStudioUrl(input, studioUrl, options = {}) {
+  return `${studioUrl.replace(/\/$/, "")}${options.ast ? "/ast" : ""}?root=${encodeAst(input)}`;
+}
+async function openInStudio(input, studioUrl, options = {}) {
+  const url = getStudioUrl(input, studioUrl, options);
+  const cmd = process.platform === "win32" ? "cmd" : process.platform === "darwin" ? "open" : "xdg-open";
+  const args = process.platform === "win32" ? [
+    "/c",
+    "start",
+    "",
+    url
+  ] : [url];
+  try {
+    await x(cmd, args);
+  } catch {
+    console.log(`
+  ${url}
 `);
-    return savedData;
   }
-  return trimmed;
 }
-async function clean(path) {
-  return rm(path, {
-    recursive: true,
-    force: true
-  });
+function mergeFile(a, b) {
+  return {
+    ...a,
+    banner: b.banner,
+    footer: b.footer,
+    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
+  };
 }
-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 isValidVarName(name) {
-  if (!name || reservedWords.has(name)) return false;
-  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+function isIndexPath(path2) {
+  return path2.endsWith("/index.ts") || path2 === "index.ts";
+}
+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, _sorted, null);
+    __privateAdd$1(this, _onUpsert, null);
+  }
+  /**
+  * 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);
+  }
+  upsert(...files) {
+    return __privateMethod$1(this, _FileManager_instances, store_fn).call(this, files, true);
+  }
+  getByPath(path2) {
+    var _a2;
+    return (_a2 = __privateGet$1(this, _cache).get(path2)) != null ? _a2 : null;
+  }
+  deleteByPath(path2) {
+    if (!__privateGet$1(this, _cache).delete(path2)) return;
+    __privateSet$1(this, _sorted, null);
+  }
+  clear() {
+    __privateGet$1(this, _cache).clear();
+    __privateSet$1(this, _sorted, null);
+  }
+  /**
+  * 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 in stable sort order (shortest path first, barrel files
+  * last within a length bucket). Returns a cached view — do not mutate.
+  */
+  get files() {
+    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 URLPath = (_b = class {
-  constructor(path, options = {}) {
-    __privateAdd(this, _URLPath_instances);
+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;
+}
+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");
+    __publicField$1(this, "options");
     /**
-    * The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
+    * The streaming `InputStreamNode` produced by the adapter.
+    * Always set after adapter setup — parse-only adapters are wrapped automatically.
+    */
+    __publicField$1(this, "inputNode", null);
+    __publicField$1(this, "adapter", null);
+    /**
+    * Studio session state, kept together so `dispose()` can reset it atomically.
+    *
+    * - `source` holds the raw adapter source so `adapter.parse()` can be called lazily.
+    *   Intentionally outlives the build; cleared by `dispose()`.
+    * - `isOpen` prevents opening the studio more than once per build.
+    * - `inputNode` caches the parse promise so `adapter.parse()` is called at most once
+    *   per studio session, even when `openInStudio()` is called multiple times.
+    */
+    __privateAdd$1(this, _studio, {
+      source: null,
+      isOpen: false,
+      inputNode: null
+    });
+    __privateAdd$1(this, _middlewareListeners, []);
+    /**
+    * Central file store for all generated files.
+    * Plugins should use `this.addFile()` / `this.upsertFile()` (via their context) to
+    * 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).
+    * Used by the build loop to decide whether to emit generator events for a given plugin.
     */
-    __publicField(this, "path");
-    __privateAdd(this, _options);
-    this.path = path;
-    __privateSet(this, _options, options);
+    __privateAdd$1(this, _eventGeneratorPlugins, /* @__PURE__ */ new Set());
+    __privateAdd$1(this, _resolvers, /* @__PURE__ */ new Map());
+    __privateAdd$1(this, _defaultResolvers, /* @__PURE__ */ new Map());
+    __privateAdd$1(this, _hookListeners, /* @__PURE__ */ new Map());
+    __privateAdd$1(this, _getDefaultResolver, memoize(__privateGet$1(this, _defaultResolvers), (pluginName) => defineResolver(() => ({
+      name: "default",
+      pluginName
+    }))));
+    var _a2;
+    this.config = config;
+    this.options = options;
+    this.adapter = (_a2 = config.adapter) != null ? _a2 : null;
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+  /**
+  * Returns `'single'` when `fileOrFolder` has a file extension, `'split'` otherwise.
   *
   * @example
   * ```ts
-  * new URLPath('/pet/{petId}').URL // '/pet/:petId'
+  * KubbDriver.getMode('src/gen/types.ts')  // 'single'
+  * KubbDriver.getMode('src/gen/types')     // 'split'
   * ```
   */
-  get URL() {
-    return this.toURLPath();
+  static getMode(fileOrFolder) {
+    return getMode(fileOrFolder);
   }
-  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
-  *
-  * @example
-  * ```ts
-  * new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
-  * new URLPath('/pet/{petId}').isURL                       // false
-  * ```
-  */
-  get isURL() {
-    try {
-      return !!new URL(this.path).href;
-    } catch {
-      return false;
+  async setup() {
+    const normalized = this.config.plugins.map((rawPlugin) => __privateMethod$1(this, _KubbDriver_instances, normalizePlugin_fn).call(this, rawPlugin));
+    normalized.sort((a, b) => {
+      var _a2, _b2;
+      if ((_a2 = b.dependencies) == null ? void 0 : _a2.includes(a.name)) return -1;
+      if ((_b2 = a.dependencies) == null ? void 0 : _b2.includes(b.name)) return 1;
+      return enforceOrder(a.enforce) - enforceOrder(b.enforce);
+    });
+    for (const plugin of normalized) {
+      if (plugin.apply) plugin.apply(this.config);
+      __privateMethod$1(this, _KubbDriver_instances, registerPlugin_fn).call(this, plugin);
+      this.plugins.set(plugin.name, plugin);
     }
+    if (this.config.middleware) for (const middleware of this.config.middleware) for (const event of Object.keys(middleware.hooks)) __privateMethod$1(this, _KubbDriver_instances, registerMiddleware_fn).call(this, event, middleware.hooks);
+    if (this.config.adapter) await __privateMethod$1(this, _KubbDriver_instances, registerAdapter_fn).call(this, this.config.adapter);
+  }
+  get hooks() {
+    return this.options.hooks;
   }
   /**
-  * Converts the OpenAPI path to a TypeScript template literal string.
+  * Emits the `kubb:plugin:setup` event so that all registered hook-style plugin listeners
+  * can configure generators, resolvers, transformers and renderers before `buildStart` runs.
   *
-  * @example
-  * new URLPath('/pet/{petId}').template              // '`/pet/${petId}`'
-  * new URLPath('/account/monetary-accountID').template // '`/account/${monetaryAccountId}`'
+  * Call this once from `safeBuild` before the plugin execution loop begins.
   */
-  get template() {
-    return this.toTemplateString();
+  async emitSetupHooks() {
+    const noop = () => {
+    };
+    await this.hooks.emit("kubb:plugin:setup", {
+      config: this.config,
+      options: {},
+      addGenerator: noop,
+      setResolver: noop,
+      setTransformer: noop,
+      setRenderer: noop,
+      setOptions: noop,
+      injectFile: noop,
+      updateConfig: noop
+    });
   }
-  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
+  /**
+  * Registers a generator for the given plugin on the shared event emitter.
   *
-  * @example
-  * ```ts
-  * new URLPath('/pet/{petId}').object
-  * // { url: '/pet/:petId', params: { petId: 'petId' } }
-  * ```
-  */
-  get object() {
-    return this.toObject();
-  }
-  /** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+  * The generator's `schema`, `operation`, and `operations` methods are registered as
+  * listeners on `kubb:generate:schema`, `kubb:generate:operation`, and `kubb:generate:operations`
+  * respectively. Each listener is scoped to the owning plugin via a `ctx.plugin.name` check
+  * so that generators from different plugins do not cross-fire.
   *
-  * @example
-  * ```ts
-  * new URLPath('/pet/{petId}').params // { petId: 'petId' }
-  * new URLPath('/pet').params         // undefined
-  * ```
+  * The renderer resolution chain is: `generator.renderer → plugin.renderer → config.renderer`.
+  * Set `generator.renderer = null` to explicitly opt out of rendering even when the plugin
+  * declares a renderer.
+  *
+  * Call this method inside `addGenerator()` (in `kubb:plugin:setup`) to wire up a generator.
   */
-  get params() {
-    return this.getParams();
-  }
-  toObject({ type = "path", replacer, stringify } = {}) {
-    const object = {
-      url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
-      params: this.getParams()
+  registerGenerator(pluginName, gen) {
+    const resolveRenderer = () => {
+      var _a2, _b2;
+      const plugin = this.plugins.get(pluginName);
+      return gen.renderer === null ? void 0 : (_b2 = (_a2 = gen.renderer) != null ? _a2 : plugin == null ? void 0 : plugin.renderer) != null ? _b2 : this.config.renderer;
     };
-    if (stringify) {
-      if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
-      if (object.params) return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
-      return `{ url: '${object.url}' }`;
+    if (gen.schema) {
+      const schemaHandler = async (node, ctx) => {
+        if (ctx.plugin.name !== pluginName) return;
+        await applyHookResult({
+          result: await gen.schema(node, ctx),
+          driver: this,
+          rendererFactory: resolveRenderer()
+        });
+      };
+      this.hooks.on("kubb:generate:schema", schemaHandler);
+      __privateMethod$1(this, _KubbDriver_instances, trackHookListener_fn).call(this, "kubb:generate:schema", schemaHandler);
     }
-    return object;
+    if (gen.operation) {
+      const operationHandler = async (node, ctx) => {
+        if (ctx.plugin.name !== pluginName) return;
+        await applyHookResult({
+          result: await gen.operation(node, ctx),
+          driver: this,
+          rendererFactory: resolveRenderer()
+        });
+      };
+      this.hooks.on("kubb:generate:operation", operationHandler);
+      __privateMethod$1(this, _KubbDriver_instances, trackHookListener_fn).call(this, "kubb:generate:operation", operationHandler);
+    }
+    if (gen.operations) {
+      const operationsHandler = async (nodes, ctx) => {
+        if (ctx.plugin.name !== pluginName) return;
+        await applyHookResult({
+          result: await gen.operations(nodes, ctx),
+          driver: this,
+          rendererFactory: resolveRenderer()
+        });
+      };
+      this.hooks.on("kubb:generate:operations", operationsHandler);
+      __privateMethod$1(this, _KubbDriver_instances, trackHookListener_fn).call(this, "kubb:generate:operations", operationsHandler);
+    }
+    __privateGet$1(this, _eventGeneratorPlugins).add(pluginName);
   }
   /**
-  * Converts the OpenAPI path to a TypeScript template literal string.
-  * An optional `replacer` can transform each extracted parameter name before interpolation.
+  * Returns `true` when at least one generator was registered for the given plugin
+  * via `addGenerator()` in `kubb:plugin:setup` (event-based path).
   *
-  * @example
-  * new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
+  * Used by the build loop to decide whether to walk the AST and emit generator events
+  * for a plugin that has no static `plugin.generators`.
   */
-  toTemplateString({ prefix = "", replacer } = {}) {
-    return `\`${prefix}${this.path.split(/\{([^}]+)\}/).map((part, i) => {
-      if (i % 2 === 0) return part;
-      const param = __privateMethod(this, _URLPath_instances, transformParam_fn).call(this, part);
-      return `\${${replacer ? replacer(param) : param}}`;
-    }).join("")}\``;
+  hasEventGenerators(pluginName) {
+    return __privateGet$1(this, _eventGeneratorPlugins).has(pluginName);
   }
   /**
-  * Extracts all `{param}` segments from the path and returns them as a key-value map.
-  * An optional `replacer` transforms each parameter name in both key and value positions.
-  * Returns `undefined` when no path parameters are found.
+  * 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.
+  */
+  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.
   *
-  * @example
-  * ```ts
-  * new URLPath('/pet/{petId}/tag/{tagId}').getParams()
-  * // { petId: 'petId', tagId: 'tagId' }
-  * ```
+  * @internal
   */
-  getParams(replacer) {
-    const params = {};
-    __privateMethod(this, _URLPath_instances, eachParam_fn).call(this, (_raw, param) => {
-      const key = replacer ? replacer(param) : param;
-      params[key] = key;
+  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
     });
-    return Object.keys(params).length > 0 ? params : void 0;
+    for (const [event, handler] of __privateGet$1(this, _middlewareListeners)) this.hooks.off(event, handler);
   }
-  /** Converts the OpenAPI path to Express-style colon syntax.
-  *
-  * @example
-  * ```ts
-  * new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
-  * ```
+  [Symbol.dispose]() {
+    this.dispose();
+  }
+  /**
+  * 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()`.
   */
-  toURLPath() {
-    return this.path.replace(/\{([^}]+)\}/g, ":$1");
+  setPluginResolver(pluginName, partial) {
+    const merged = {
+      ...__privateGet$1(this, _getDefaultResolver).call(this, pluginName),
+      ...partial
+    };
+    __privateGet$1(this, _resolvers).set(pluginName, merged);
+    const plugin = this.plugins.get(pluginName);
+    if (plugin) plugin.resolver = merged;
   }
-}, _options = new WeakMap(), _URLPath_instances = new WeakSet(), transformParam_fn = function(raw) {
-  const param = isValidVarName(raw) ? raw : camelCase(raw);
-  return __privateGet(this, _options).casing === "camelcase" ? camelCase(param) : param;
-}, /**
-* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
-*/
-eachParam_fn = function(fn) {
-  for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
-    const raw = match[1];
-    fn(raw, __privateMethod(this, _URLPath_instances, transformParam_fn).call(this, raw));
+  getResolver(pluginName) {
+    var _a2, _b2, _c2;
+    return (_c2 = (_b2 = __privateGet$1(this, _resolvers).get(pluginName)) != null ? _b2 : (_a2 = this.plugins.get(pluginName)) == null ? void 0 : _a2.resolver) != null ? _c2 : __privateGet$1(this, _getDefaultResolver).call(this, pluginName);
   }
-}, _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();
+  getContext(plugin) {
+    const driver = this;
+    return {
+      config: driver.config,
+      get root() {
+        return resolve(driver.config.root, driver.config.output.path);
+      },
+      getMode(output) {
+        return _d.getMode(resolve(driver.config.root, driver.config.output.path, output.path));
+      },
+      hooks: driver.hooks,
+      plugin,
+      getPlugin: driver.getPlugin.bind(driver),
+      requirePlugin: driver.requirePlugin.bind(driver),
+      getResolver: driver.getResolver.bind(driver),
+      driver,
+      addFile: async (...files) => {
+        driver.fileManager.add(...files);
+      },
+      upsertFile: async (...files) => {
+        driver.fileManager.upsert(...files);
+      },
+      get meta() {
+        var _a2, _b2;
+        return (_b2 = (_a2 = driver.inputNode) == null ? void 0 : _a2.meta) != null ? _b2 : {
+          circularNames: [],
+          enumNames: []
+        };
+      },
+      get adapter() {
+        return driver.adapter;
+      },
+      get resolver() {
+        return driver.getResolver(plugin.name);
+      },
+      get transformer() {
+        return plugin.transformer;
+      },
+      warn(message) {
+        driver.hooks.emit("kubb:warn", { message });
+      },
+      error(error) {
+        driver.hooks.emit("kubb:error", { error: typeof error === "string" ? new Error(error) : error });
+      },
+      info(message) {
+        driver.hooks.emit("kubb:info", { message });
+      },
+      async openInStudio(options) {
+        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";
+        (_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);
+      }
+    };
   }
-  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);
+  getPlugin(pluginName) {
+    return this.plugins.get(pluginName);
+  }
+  requirePlugin(pluginName) {
+    const plugin = this.plugins.get(pluginName);
+    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(), _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`.
+*/
+normalizePlugin_fn = function(plugin) {
+  var _a2;
+  const normalized = {
+    name: plugin.name,
+    dependencies: plugin.dependencies,
+    enforce: plugin.enforce,
+    hooks: plugin.hooks,
+    options: (_a2 = plugin.options) != null ? _a2 : {
+      output: { path: "." },
+      exclude: [],
+      override: []
     }
-    __privateWrapper(this, _size)._++;
+  };
+  if ("apply" in plugin && typeof plugin.apply === "function") normalized.apply = plugin.apply;
+  return normalized;
+}, registerAdapter_fn = async function(adapter) {
+  const source = inputToAdapterSource(this.config);
+  __privateGet$1(this, _studio).source = source;
+  if (adapter.stream) {
+    this.inputNode = await adapter.stream(source);
+    await this.hooks.emit("kubb:debug", {
+      date: /* @__PURE__ */ new Date(),
+      logs: [`\u2713 Adapter '${adapter.name}' producing input stream`]
+    });
+  } else {
+    const inputNode = await adapter.parse(source);
+    this.inputNode = createStreamInput(arrayToAsyncIterable(inputNode.schemas), arrayToAsyncIterable(inputNode.operations), inputNode.meta);
+    await this.hooks.emit("kubb:debug", {
+      date: /* @__PURE__ */ new Date(),
+      logs: [
+        `\u2713 Adapter '${adapter.name}' resolved InputNode (wrapped as stream)`,
+        `  \u2022 Schemas: ${inputNode.schemas.length}`,
+        `  \u2022 Operations: ${inputNode.operations.length}`
+      ]
+    });
   }
-  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;
+}, registerMiddleware_fn = function(event, middlewareHooks) {
+  const handler = middlewareHooks[event];
+  if (!handler) return;
+  this.hooks.on(event, handler);
+  __privateGet$1(this, _middlewareListeners).push([event, handler]);
+}, /**
+* Registers a hook-style plugin's lifecycle handlers on the shared `AsyncEventEmitter`.
+*
+* For `kubb:plugin:setup`, the registered listener wraps the globally emitted context with a
+* plugin-specific one so that `addGenerator`, `setResolver`, `setTransformer`, and
+* `setRenderer` all target the correct `normalizedPlugin` entry in the plugins map.
+*
+* All other hooks are iterated and registered directly as pass-through listeners.
+* Any event key present in the global `KubbHooks` interface can be subscribed to.
+*
+* External tooling can subscribe to any of these events via `hooks.on(...)` to observe
+* the plugin lifecycle without modifying plugin behavior.
+*
+* @internal
+*/
+registerPlugin_fn = function(plugin) {
+  const { hooks } = plugin;
+  if (!hooks) return;
+  if (hooks["kubb:plugin:setup"]) {
+    const setupHandler = (globalCtx) => {
+      var _a2;
+      const pluginCtx = {
+        ...globalCtx,
+        options: (_a2 = plugin.options) != null ? _a2 : {},
+        addGenerator: (gen) => {
+          this.registerGenerator(plugin.name, gen);
+        },
+        setResolver: (resolver) => {
+          this.setPluginResolver(plugin.name, resolver);
+        },
+        setTransformer: (visitor) => {
+          plugin.transformer = visitor;
+        },
+        setRenderer: (renderer) => {
+          plugin.renderer = renderer;
+        },
+        setOptions: (opts) => {
+          plugin.options = {
+            ...plugin.options,
+            ...opts
+          };
+        },
+        injectFile: (userFileNode) => {
+          this.fileManager.add(createFile(userFileNode));
+        }
+      };
+      return hooks["kubb:plugin:setup"](pluginCtx);
+    };
+    this.hooks.on("kubb:plugin:setup", setupHandler);
+    __privateMethod$1(this, _KubbDriver_instances, trackHookListener_fn).call(this, "kubb:plugin:setup", setupHandler);
   }
-  peek() {
-    if (!__privateGet(this, _head)) return;
-    return __privateGet(this, _head).value;
+  for (const [event, handler] of Object.entries(hooks)) {
+    if (event === "kubb:plugin:setup" || !handler) continue;
+    this.hooks.on(event, handler);
+    __privateMethod$1(this, _KubbDriver_instances, trackHookListener_fn).call(this, event, handler);
   }
-  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();
-    }
+}, filesPayload_fn = function() {
+  const driver = this;
+  return {
+    get files() {
+      return driver.fileManager.files;
+    },
+    upsertFile: (...files) => driver.fileManager.upsert(...files)
   };
-  const next = () => {
-    activeCount--;
-    resumeNext();
+}, 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 run = async (function_, resolve2, arguments_) => {
-    const result = (async () => function_(...arguments_))();
-    resolve2(result);
+  const dispatchNode = async (state, node, dispatch) => {
+    if (state.failed) return;
     try {
-      await result;
-    } catch {
+      const { plugin, generatorContext, generators } = state;
+      const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
+      if (dispatch.checkAllowedNames && state.allowedSchemaNames !== null && "name" in transformedNode && 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) {
+        const generate = gen[dispatch.method];
+        if (!generate) continue;
+        const raw = generate(transformedNode, ctx);
+        const applied = applyHookResult({
+          result: isPromise(raw) ? await raw : raw,
+          driver,
+          rendererFactory: resolveRendererFor(gen, state)
+        });
+        if (isPromise(applied)) await applied;
+      }
+      if (dispatch.emit) await dispatch.emit(transformedNode, ctx);
+    } catch (caughtError) {
+      state.failed = true;
+      state.error = caughtError;
     }
-    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 schemaDispatch = {
+    method: "schema",
+    checkAllowedNames: true,
+    emit: emitsSchemaHook ? (node, ctx) => this.hooks.emit("kubb:generate:schema", node, ctx) : null
+  };
+  const operationDispatch = {
+    method: "operation",
+    checkAllowedNames: false,
+    emit: emitsOperationHook ? (node, ctx) => this.hooks.emit("kubb:generate:operation", node, ctx) : null
   };
-  const generator = (function_, ...arguments_) => new Promise((resolve2, reject) => {
-    enqueue(function_, resolve2, reject, arguments_);
+  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) => dispatchNode(state, n, schemaDispatch)))), {
+    concurrency: 8,
+    flush: flushPending
   });
-  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();
+  await forBatches(operations, (nodes) => {
+    if (needsCollectedOperations) collectedOperations.push(...nodes);
+    return Promise.all(nodes.flatMap((n) => states.map((state) => dispatchNode(state, n, operationDispatch))));
+  }, {
+    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)
         });
       }
-    },
-    map: { async value(iterable, function_) {
-      const promises = Array.from(iterable, (value, index) => this(function_, value, index));
-      return Promise.all(promises);
-    } }
+      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) {
+    handlers = /* @__PURE__ */ new Set();
+    __privateGet$1(this, _hookListeners).set(event, handlers);
+  }
+  handlers.add(handler);
+}, _getDefaultResolver = new WeakMap(), _d);
+function applyHookResult({ result, driver, rendererFactory }) {
+  if (!result) return;
+  if (Array.isArray(result)) {
+    driver.fileManager.upsert(...result);
+    return;
+  }
+  if (!rendererFactory) return;
+  const renderer = rendererFactory();
+  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,
+    result,
+    driver
   });
-  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");
+async function applyAsyncRender({ renderer, result, driver }) {
+  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 joinSources(file) {
-  return file.sources.map((item) => extractStringsFromNodes(item.nodes)).filter(Boolean).join("\n\n");
+function inputToAdapterSource(config) {
+  const input = config.input;
+  if (!input) throw new Error("[kubb] input is required when using an adapter. Provide input.path or input.data in your config.");
+  if ("data" in input) return {
+    type: "data",
+    data: input.data
+  };
+  if (new URLPath(input.path).isURL) return {
+    type: "path",
+    path: input.path
+  };
+  return {
+    type: "path",
+    path: resolve(config.root, input.path)
+  };
 }
-var FileProcessor = (_e = class {
-  constructor() {
-    __privateAdd(this, _limit, pLimit(100));
+
+var __defProp = Object.defineProperty;
+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, 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 _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);
+}
+async function write(path, data, options = {}) {
+  const trimmed = data.trim();
+  if (trimmed === "") return null;
+  const resolved = resolve(path);
+  if (typeof Bun !== "undefined") {
+    const file = Bun.file(resolved);
+    if ((await file.exists() ? await file.text() : null) === trimmed) return null;
+    await Bun.write(resolved, trimmed);
+    return trimmed;
   }
-  async 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 });
+  try {
+    if (await readFile$1(resolved, { encoding: "utf-8" }) === trimmed) return null;
+  } catch {
   }
-  async run(files, { parsers, mode = "sequential", extension, onStart, onEnd, onUpdate } = {}) {
-    await (onStart == null ? void 0 : onStart(files));
-    const total = files.length;
-    let processed = 0;
-    const processOne = async (file) => {
-      const source = await this.parse(file, {
-        extension,
-        parsers
-      });
-      const currentProcessed = ++processed;
-      const percentage = currentProcessed / total * 100;
-      await (onUpdate == null ? void 0 : onUpdate({
-        file,
-        source,
-        processed: currentProcessed,
-        percentage,
-        total
-      }));
-    };
-    if (mode === "sequential") for (const file of files) await processOne(file);
-    else await Promise.all(files.map((file) => __privateGet(this, _limit).call(this, () => processOne(file))));
-    await (onEnd == null ? void 0 : onEnd(files));
-    return files;
+  await mkdir(dirname(resolved), { recursive: true });
+  await writeFile$1(resolved, trimmed, { encoding: "utf-8" });
+  if (options.sanity) {
+    const savedData = await readFile$1(resolved, { encoding: "utf-8" });
+    if (savedData !== trimmed) throw new Error(`Sanity check failed for ${path}
+
+Data[${data.length}]:
+${data}
+
+Saved[${savedData.length}]:
+${savedData}
+`);
+    return savedData;
   }
-}, _limit = new WeakMap(), _e);
-function createStorage(build2) {
-  return (options) => build2(options != null ? options : {});
+  return trimmed;
+}
+async function clean(path) {
+  return rm(path, {
+    recursive: true,
+    force: true
+  });
 }
-function isMissingPathError(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+var version$1 = "5.0.0-beta.31";
+function createStorage(build) {
+  return (options) => build(options != null ? options : {});
 }
 const fsStorage = createStorage(() => ({
   name: "fs",
@@ -6420,17 +6779,15 @@ const fsStorage = createStorage(() => ({
     try {
       await access(resolve(key));
       return true;
-    } catch (error) {
-      if (isMissingPathError(error)) return false;
-      throw new Error(`Failed to access storage item "${key}"`, { cause: error });
+    } catch (_error) {
+      return false;
     }
   },
   async getItem(key) {
     try {
       return await readFile$1(resolve(key), "utf8");
-    } catch (error) {
-      if (isMissingPathError(error)) return null;
-      throw new Error(`Failed to read storage item "${key}"`, { cause: error });
+    } catch (_error) {
+      return null;
     }
   },
   async setItem(key, value) {
@@ -6440,23 +6797,22 @@ const fsStorage = createStorage(() => ({
     await rm(resolve(key), { force: true });
   },
   async getKeys(base) {
-    const keys = [];
     const resolvedBase = resolve(base != null ? base : process.cwd());
-    async function walk2(dir, prefix) {
+    async function* walk(dir, prefix) {
       let entries;
       try {
         entries = await readdir$1(dir, { withFileTypes: true });
-      } catch (error) {
-        if (isMissingPathError(error)) return;
-        throw new Error(`Failed to list storage keys under "${resolvedBase}"`, { cause: error });
+      } catch (_error) {
+        return;
       }
       for (const entry of entries) {
         const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-        if (entry.isDirectory()) await walk2(join(dir, entry.name), rel);
-        else keys.push(rel);
+        if (entry.isDirectory()) yield* walk(join(dir, entry.name), rel);
+        else yield rel;
       }
     }
-    await walk2(resolvedBase, "");
+    const keys = [];
+    for await (const key of walk(resolvedBase, "")) keys.push(key);
     return keys;
   },
   async clear(base) {
@@ -6464,410 +6820,192 @@ const fsStorage = createStorage(() => ({
     await clean(resolve(base));
   }
 }));
-var version$1 = "5.0.0-beta.3";
-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;
-}
-async function setup(userConfig, options = {}) {
-  var _a2, _b2, _c2, _d2, _e2, _f, _g, _h, _i;
-  const hooks = (_a2 = options.hooks) != null ? _a2 : new AsyncEventEmitter();
-  const sources = /* @__PURE__ */ new Map();
-  const diagnosticInfo = getDiagnosticInfo();
-  if (Array.isArray(userConfig.input)) await hooks.emit("kubb:warn", { message: "This feature is still under development \u2014 use with caution" });
-  await hooks.emit("kubb:debug", {
-    date: /* @__PURE__ */ new Date(),
-    logs: [
-      "Configuration:",
-      `  \u2022 Name: ${userConfig.name || "unnamed"}`,
-      `  \u2022 Root: ${userConfig.root || process.cwd()}`,
-      `  \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: ${userConfig.storage ? `custom(${userConfig.storage.name})` : ((_d2 = userConfig.output) == null ? void 0 : _d2.write) === false ? "disabled" : "filesystem (default)"}`,
-      `  \u2022 Formatter: ${((_e2 = userConfig.output) == null ? void 0 : _e2.format) || "none"}`,
-      `  \u2022 Linter: ${((_f = userConfig.output) == null ? void 0 : _f.lint) || "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 });
+function createSourcesView(storage) {
+  const paths = /* @__PURE__ */ new Set();
+  return createStorage(() => ({
+    name: `${storage.name}:sources`,
+    async hasItem(key) {
+      return paths.has(key) && await storage.hasItem(key);
+    },
+    async getItem(key) {
+      return paths.has(key) ? storage.getItem(key) : null;
+    },
+    async setItem(key, value) {
+      paths.add(key);
+      await storage.setItem(key, value);
+    },
+    async removeItem(key) {
+      paths.delete(key);
+      await storage.removeItem(key);
+    },
+    async getKeys(base) {
+      if (!base) return [...paths];
+      const result = [];
+      for (const key of paths) if (key.startsWith(base)) result.push(key);
+      return result;
+    },
+    async clear() {
+      paths.clear();
+      await storage.clear();
     }
-  }
-  if (!userConfig.adapter) throw new Error("Adapter should be defined");
-  const config = {
+  }))();
+}
+function resolveConfig(userConfig) {
+  var _a2, _b, _c;
+  return {
     ...userConfig,
     root: userConfig.root || process.cwd(),
-    parsers: (_g = userConfig.parsers) != null ? _g : [],
-    adapter: userConfig.adapter,
+    parsers: (_a2 = userConfig.parsers) != null ? _a2 : [],
     output: {
       format: false,
       lint: false,
-      write: true,
       extension: DEFAULT_EXTENSION,
       defaultBanner: DEFAULT_BANNER,
       ...userConfig.output
     },
+    storage: (_b = userConfig.storage) != null ? _b : fsStorage(),
     devtools: userConfig.devtools ? {
       studioUrl: DEFAULT_STUDIO_URL,
       ...typeof userConfig.devtools === "boolean" ? {} : userConfig.devtools
     } : void 0,
-    plugins: userConfig.plugins
+    plugins: (_c = userConfig.plugins) != null ? _c : []
   };
-  const storage = config.output.write === false ? null : (_h = config.storage) != null ? _h : fsStorage();
-  if (config.output.clean) {
-    await hooks.emit("kubb:debug", {
-      date: /* @__PURE__ */ new Date(),
-      logs: ["Cleaning output directories", `  \u2022 Output: ${config.output.path}`]
-    });
-    await (storage == null ? void 0 : storage.clear(resolve(config.root, config.output.path)));
-  }
-  const driver = new PluginDriver(config, { hooks });
-  function registerMiddlewareHook(event, middlewareHooks) {
-    const handler = middlewareHooks[event];
-    if (handler) hooks.on(event, handler);
-  }
-  for (const middleware of (_i = config.middleware) != null ? _i : []) for (const event of Object.keys(middleware.hooks)) registerMiddlewareHook(event, middleware.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);
-  await hooks.emit("kubb:debug", {
-    date: /* @__PURE__ */ new Date(),
-    logs: [`Running adapter: ${adapter.name}`]
-  });
-  driver.adapter = adapter;
-  driver.inputNode = await adapter.parse(source);
-  await hooks.emit("kubb:debug", {
-    date: /* @__PURE__ */ new Date(),
-    logs: [
-      `\u2713 Adapter '${adapter.name}' resolved InputNode`,
-      `  \u2022 Schemas: ${driver.inputNode.schemas.length}`,
-      `  \u2022 Operations: ${driver.inputNode.operations.length}`
-    ]
-  });
+}
+function getDiagnosticInfo() {
   return {
-    config,
-    hooks,
-    driver,
-    sources,
-    storage
+    nodeVersion: version$2,
+    KubbVersion: version$1,
+    platform: process.platform,
+    arch: process.arch,
+    cwd: process.cwd()
   };
 }
-async function runPluginAstHooks(plugin, context) {
-  var _a2, _b2, _c2;
-  const { adapter, inputNode, resolver, driver } = context;
-  const { exclude, include, override } = plugin.options;
-  if (!adapter || !inputNode) throw new Error(`[${plugin.name}] No adapter found. Add an OAS adapter (e.g. pluginOas()) before this plugin in your Kubb config.`);
-  function resolveRenderer(gen) {
-    var _a3, _b3;
-    return gen.renderer === null ? void 0 : (_b3 = (_a3 = gen.renderer) != null ? _a3 : plugin.renderer) != null ? _b3 : context.config.renderer;
+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();
   }
-  const generators = (_a2 = plugin.generators) != null ? _a2 : [];
-  const collectedOperations = [];
-  const generatorContext = {
-    ...context,
-    resolver: driver.getResolver(plugin.name)
-  };
-  const operationFilterTypes = /* @__PURE__ */ new Set([
-    "tag",
-    "operationId",
-    "path",
-    "method",
-    "contentType"
-  ]);
-  const hasOperationBasedIncludes = (_b2 = include == null ? void 0 : include.some(({ type }) => operationFilterTypes.has(type))) != null ? _b2 : false;
-  const hasSchemaNameIncludes = (_c2 = include == null ? void 0 : include.some(({ type }) => type === "schemaName")) != null ? _c2 : false;
-  let allowedSchemaNames;
-  if (hasOperationBasedIncludes && !hasSchemaNameIncludes) allowedSchemaNames = collectUsedSchemaNames(inputNode.operations.filter((op) => resolver.resolveOptions(op, {
-    options: plugin.options,
-    exclude,
-    include,
-    override
-  }) !== null), inputNode.schemas);
-  await walk(inputNode, {
-    depth: "shallow",
-    async schema(node) {
-      const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
-      if (allowedSchemaNames !== void 0 && transformedNode.name && !allowedSchemaNames.has(transformedNode.name)) return;
-      const options = 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;
-        await applyHookResult(await gen.schema(transformedNode, ctx), driver, resolveRenderer(gen));
-      }
-      await driver.hooks.emit("kubb:generate:schema", transformedNode, ctx);
-    },
-    async operation(node) {
-      const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
-      const options = resolver.resolveOptions(transformedNode, {
-        options: plugin.options,
-        exclude,
-        include,
-        override
+  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: [`\u2713 Input file validated: ${__privateGet(this, _userConfig).input.path}`]
       });
-      if (options !== null) {
-        collectedOperations.push(transformedNode);
-        const ctx = {
-          ...generatorContext,
-          options
-        };
-        for (const gen of generators) {
-          if (!gen.operation) continue;
-          await applyHookResult(await gen.operation(transformedNode, ctx), driver, resolveRenderer(gen));
-        }
-        await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
-      }
+    } 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 (collectedOperations.length > 0) {
-    const ctx = {
-      ...generatorContext,
-      options: plugin.options
-    };
-    for (const gen of generators) {
-      if (!gen.operations) continue;
-      await applyHookResult(await gen.operations(collectedOperations, ctx), driver, resolveRenderer(gen));
+    if (config.output.clean) {
+      await this.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.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
+    await driver.setup();
+    __privateSet(this, _config, config);
+    __privateSet(this, _driver, driver);
+    __privateSet(this, _storage, storage);
   }
-}
-async function safeBuild(setupResult) {
-  var _a2;
-  const { driver, hooks, sources, storage } = setupResult;
-  const failedPlugins = /* @__PURE__ */ new Set();
-  const pluginTimings = /* @__PURE__ */ new Map();
-  const config = driver.config;
-  try {
-    await driver.emitSetupHooks();
-    if (driver.adapter && driver.inputNode) await hooks.emit("kubb:build:start", {
-      config,
-      adapter: driver.adapter,
-      inputNode: driver.inputNode,
-      getPlugin: driver.getPlugin.bind(driver),
-      get files() {
-        return driver.fileManager.files;
-      },
-      upsertFile: (...files2) => driver.fileManager.upsert(...files2)
-    });
-    for (const plugin of driver.plugins.values()) {
-      const context = driver.getContext(plugin);
-      const hrStart = process.hrtime();
-      try {
-        const timestamp = /* @__PURE__ */ new Date();
-        await hooks.emit("kubb:plugin:start", { plugin });
-        await hooks.emit("kubb:debug", {
-          date: timestamp,
-          logs: ["Starting plugin...", `  \u2022 Plugin Name: ${plugin.name}`]
-        });
-        if (((_a2 = plugin.generators) == null ? void 0 : _a2.length) || driver.hasRegisteredGenerators(plugin.name)) await runPluginAstHooks(plugin, context);
-        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)})`]
-        });
-      } catch (caughtError) {
-        const error = caughtError;
-        const errorTimestamp = /* @__PURE__ */ new Date();
-        const duration = getElapsedMs(hrStart);
-        await hooks.emit("kubb:plugin:end", {
-          plugin,
-          duration,
-          success: false,
-          error,
-          config,
-          get files() {
-            return driver.fileManager.files;
-          },
-          upsertFile: (...files2) => driver.fileManager.upsert(...files2)
-        });
-        await hooks.emit("kubb:debug", {
-          date: errorTimestamp,
-          logs: [
-            "\u2717 Plugin start failed",
-            `  \u2022 Plugin Name: ${plugin.name}`,
-            `  \u2022 Error: ${error.constructor.name} - ${error.message}`,
-            "  \u2022 Stack Trace:",
-            error.stack || "No stack trace available"
-          ]
-        });
-        failedPlugins.add({
-          plugin,
-          error
-        });
-      }
+  /**
+  * 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 });
     }
-    await hooks.emit("kubb:plugins:end", {
-      config,
-      get files() {
-        return driver.fileManager.files;
-      },
-      upsertFile: (...files2) => driver.fileManager.upsert(...files2)
-    });
-    const files = driver.fileManager.files;
-    const parsersMap = /* @__PURE__ */ new Map();
-    for (const parser of config.parsers) if (parser.extNames) for (const extname of parser.extNames) parsersMap.set(extname, parser);
-    const fileProcessor = new FileProcessor();
-    await hooks.emit("kubb:debug", {
-      date: /* @__PURE__ */ new Date(),
-      logs: [`Writing ${files.length} files...`]
-    });
-    await fileProcessor.run(files, {
-      parsers: parsersMap,
-      extension: config.output.extension,
-      onStart: async (processingFiles) => {
-        await hooks.emit("kubb:files:processing:start", { files: processingFiles });
-      },
-      onUpdate: async ({ file, source, processed, total, percentage }) => {
-        await hooks.emit("kubb:file:processing:update", {
-          file,
-          source,
-          processed,
-          total,
-          percentage,
-          config
-        });
-        if (source) {
-          await (storage == null ? void 0 : storage.setItem(file.path, source));
-          sources.set(file.path, source);
-        }
-      },
-      onEnd: async (processedFiles) => {
-        await hooks.emit("kubb:files:processing:end", { files: processedFiles });
-        await hooks.emit("kubb:debug", {
-          date: /* @__PURE__ */ new Date(),
-          logs: [`\u2713 File write process completed for ${processedFiles.length} files`]
-        });
-      }
-    });
-    await hooks.emit("kubb:build:end", {
-      files,
-      config,
-      outputDir: resolve(config.root, config.output.path)
-    });
-    return {
-      failedPlugins,
-      files,
-      driver,
-      pluginTimings,
-      sources
-    };
-  } catch (error) {
-    return {
-      failedPlugins,
-      files: [],
-      driver,
-      pluginTimings,
-      error,
-      sources
-    };
-  } finally {
-    driver.dispose();
+    return out;
   }
-}
-async function build(setupResult) {
-  const { files, driver, failedPlugins, pluginTimings, error, sources } = 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 });
+  /**
+  * Runs the full pipeline and captures errors in `BuildOutput` instead of throwing.
+  * Automatically calls `setup()` if needed.
+  */
+  async safeBuild() {
+    try {
+      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: driver.fileManager.files,
+        driver,
+        pluginTimings,
+        storage,
+        ...error ? { error } : {}
+      };
+    } catch (_) {
+      _usingCtx$1.e = _;
+    } finally {
+      _usingCtx$1.d();
+    }
   }
-  return {
-    failedPlugins,
-    files,
-    driver,
-    pluginTimings,
-    error: void 0,
-    sources
-  };
-}
-function inputToAdapterSource(config) {
-  if (Array.isArray(config.input)) return {
-    type: "paths",
-    paths: config.input.map((i) => new URLPath(i.path).isURL ? i.path : resolve(config.root, i.path))
-  };
-  if ("data" in config.input) return {
-    type: "data",
-    data: config.input.data
-  };
-  if (new URLPath(config.input.path).isURL) return {
-    type: "path",
-    path: config.input.path
-  };
-  return {
-    type: "path",
-    path: resolve(config.root, config.input.path)
-  };
-}
+  dispose() {
+    var _a2;
+    (_a2 = __privateGet(this, _driver)) == null ? void 0 : _a2.dispose();
+  }
+  [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 sources() {
-      var _a3;
-      return (_a3 = setupResult == null ? void 0 : setupResult.sources) != null ? _a3 : /* @__PURE__ */ new Map();
-    },
-    get driver() {
-      return setupResult == null ? void 0 : setupResult.driver;
-    },
-    get config() {
-      return setupResult == null ? void 0 : 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();
@@ -6900,7 +7038,7 @@ const memoryStorage = createStorage(() => {
   };
 });
 
-var version = "5.0.0-beta.3";
+var version = "5.0.0-beta.31";
 
 function isCommandMessage(msg) {
   return msg.type === "command";
@@ -6911,9 +7049,6 @@ function isPongMessage(msg) {
 function isDisconnectMessage(msg) {
   return msg.type === "disconnect";
 }
-function isPublishCommandMessage(msg) {
-  return msg.type === "command" && msg.command === "publish";
-}
 
 function getStorage() {
   return useStorage("kubb");
@@ -6957,7 +7092,7 @@ async function generate({ config, hooks }) {
   const kubb = createKubb(config, { hooks });
   await kubb.setup();
   await hooks.emit("kubb:info", { message: config.name ? `Build generation ${config.name}` : "Build generation" });
-  const { files, failedPlugins, error } = await kubb.safeBuild();
+  const { failedPlugins, error } = await kubb.safeBuild();
   await hooks.emit("kubb:info", { message: "Load summary" });
   const hasFailures = failedPlugins.size > 0 || error;
   if (hasFailures) {
@@ -6968,11 +7103,11 @@ async function generate({ config, hooks }) {
     allErrors.forEach((err) => {
       hooks.emit("kubb:error", { error: err });
     });
-    await hooks.emit("kubb:generation:end", { config, files, sources: kubb.sources });
+    await hooks.emit("kubb:generation:end", { config, storage: kubb.storage });
     throw new Error("Generation failed");
   }
   await hooks.emit("kubb:success", { message: "Generation successfully" });
-  await hooks.emit("kubb:generation:end", { config, files, sources: kubb.sources });
+  await hooks.emit("kubb:generation:end", { config, storage: kubb.storage });
   if (config.output.format) {
     await hooks.emit("kubb:format:start");
     let formatter = config.output.format;
@@ -7047,20 +7182,15 @@ async function generate({ config, hooks }) {
   }
 }
 
-const unrunInputOptions = {
-  transform: {
-    jsx: {
-      runtime: "automatic",
-      importSource: "@kubb/renderer-jsx"
-    }
-  }
-};
+const jiti = createJiti(globalThis._importMeta_.url, {
+  jsx: {
+    runtime: "automatic",
+    importSource: "@kubb/renderer-jsx"
+  },
+  moduleCache: false
+});
 const tsLoader = async (configFile) => {
-  const { module } = await unrun({
-    path: configFile,
-    inputOptions: unrunInputOptions
-  });
-  return module;
+  return jiti.import(configFile, { default: true });
 };
 async function getCosmiConfig(configPath) {
   var _a;
@@ -7121,6 +7251,21 @@ async function resolvePlugins(plugins) {
     })
   );
 }
+async function resolveMiddlewares(middlewares) {
+  return Promise.all(
+    middlewares.map(async ({ name, options }) => {
+      const factory = await loadPluginFactory(name);
+      return factory(options != null ? options : {});
+    })
+  );
+}
+async function checkPeerDependencies() {
+  try {
+    await import('@kubb/renderer-jsx');
+  } catch {
+    logger.warn("Missing peer dependency @kubb/renderer-jsx. Install it alongside kubb plugins.");
+  }
+}
 
 async function mergePlugins(diskPlugins, studioPlugins) {
   if (!diskPlugins && !studioPlugins) return void 0;
@@ -7149,44 +7294,6 @@ async function mergePlugins(diskPlugins, studioPlugins) {
   return [...mergedDisk, ...studioOnly];
 }
 
-async function publish({ command, outputPath, root, hooks }) {
-  var _a, _b, _c, _d;
-  const resolvedOutputPath = path$1.isAbsolute(outputPath) ? outputPath : path$1.resolve(root, outputPath);
-  const [cmd, ...args] = tokenize(command);
-  if (!cmd) {
-    throw new Error(`[plugin-publish] Invalid publish command: "${command}"`);
-  }
-  const commandWithArgs = args.length ? `${cmd} ${args.join(" ")}` : cmd;
-  await hooks.emit("kubb:info", { message: `[publish] Running "${commandWithArgs}" in "${resolvedOutputPath}"` });
-  const startTime = Date.now();
-  let exitCode = null;
-  try {
-    const proc = x(cmd, args, {
-      nodeOptions: { cwd: resolvedOutputPath }
-    });
-    for await (const line of proc) {
-      if (line.trim()) {
-        await hooks.emit("kubb:info", { message: line.trim() });
-      }
-    }
-    const result = await proc;
-    exitCode = (_a = result.exitCode) != null ? _a : null;
-  } catch (err) {
-    const message = (_d = (_c = (_b = err == null ? void 0 : err.stderr) == null ? void 0 : _b.trim()) != null ? _c : err == null ? void 0 : err.message) != null ? _d : String(err);
-    const error = new Error(`[publish] Failed to run "${commandWithArgs}": ${message}`);
-    error.cause = err;
-    await hooks.emit("kubb:error", { error });
-    throw error;
-  }
-  if (exitCode !== 0) {
-    const error = new Error(`[publish] "${commandWithArgs}" exited with code ${exitCode}`);
-    await hooks.emit("kubb:error", { error });
-    throw error;
-  }
-  const duration = Date.now() - startTime;
-  await hooks.emit("kubb:success", { message: `[publish] Published successfully in ${duration}ms` });
-}
-
 function setupHookListener(hooks, root) {
   hooks.on("kubb:hook:start", async (ctx) => {
     const { id, command, args } = ctx;
@@ -7222,7 +7329,7 @@ function setupHookListener(hooks, root) {
 }
 
 const agentDefaults = {
-  studioUrl: "https://studio.kubb.dev",
+  studioUrl: "https://kubb.studio",
   configPath: "kubb.config.ts",
   retryIntervalMs: 3e4,
   heartbeatIntervalMs: 3e4,
@@ -7257,24 +7364,38 @@ function sendAgentMessage(ws, message) {
     throw new Error("Failed to send message to Kubb Studio", { cause: error });
   }
 }
-function setupEventsStream(ws, hooks, getSource) {
+function setupEventsStream(ws, hooks) {
   function sendDataMessage(payload) {
     sendAgentMessage(ws, {
       type: "data",
-      payload: { ...payload, source: getSource == null ? void 0 : getSource() }
+      payload
     });
   }
   hooks.on("kubb:plugin:start", (ctx) => {
     sendDataMessage({
       type: "kubb:plugin:start",
-      data: [ctx.plugin],
+      data: [{ plugin: ctx.plugin }],
       timestamp: Date.now()
     });
   });
   hooks.on("kubb:plugin:end", (ctx) => {
     sendDataMessage({
       type: "kubb:plugin:end",
-      data: [ctx.plugin, { duration: ctx.duration, success: ctx.success }],
+      data: [{ plugin: ctx.plugin, duration: ctx.duration, success: ctx.success }],
+      timestamp: Date.now()
+    });
+  });
+  hooks.on("kubb:build:start", ({ config, adapter }) => {
+    sendDataMessage({
+      type: "kubb:build:start",
+      data: [{ config: { name: config.name }, adapter: { name: adapter.name } }],
+      timestamp: Date.now()
+    });
+  });
+  hooks.on("kubb:build:end", ({ files, outputDir }) => {
+    sendDataMessage({
+      type: "kubb:build:end",
+      data: [{ files: files.map((file) => ({ path: file.path, name: file.name })), outputDir }],
       timestamp: Date.now()
     });
   });
@@ -7285,15 +7406,17 @@ function setupEventsStream(ws, hooks, getSource) {
       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()
@@ -7309,21 +7432,21 @@ function setupEventsStream(ws, hooks, getSource) {
   hooks.on("kubb:info", ({ message, info }) => {
     sendDataMessage({
       type: "kubb:info",
-      data: [message, info],
+      data: [{ message, info }],
       timestamp: Date.now()
     });
   });
   hooks.on("kubb:success", ({ message, info }) => {
     sendDataMessage({
       type: "kubb:success",
-      data: [message, info],
+      data: [{ message, info }],
       timestamp: Date.now()
     });
   });
   hooks.on("kubb:warn", ({ message, info }) => {
     sendDataMessage({
       type: "kubb:warn",
-      data: [message, info],
+      data: [{ message, info }],
       timestamp: Date.now()
     });
   });
@@ -7339,14 +7462,17 @@ function setupEventsStream(ws, hooks, getSource) {
       timestamp: Date.now()
     });
   });
-  hooks.on("kubb:generation:end", ({ config, files, sources }) => {
+  hooks.on("kubb:generation:end", async ({ config, storage }) => {
     const sourcesRecord = {};
-    sources.forEach((value, key) => {
-      sourcesRecord[key] = value;
-    });
+    for (const key of await storage.getKeys()) {
+      const value = await storage.getItem(key);
+      if (value !== null) {
+        sourcesRecord[key] = value;
+      }
+    }
     sendDataMessage({
       type: "kubb:generation:end",
-      data: [config, files, sourcesRecord],
+      data: [{ config, storage: sourcesRecord }],
       timestamp: Date.now()
     });
   });
@@ -7362,6 +7488,33 @@ function setupEventsStream(ws, hooks, getSource) {
       timestamp: Date.now()
     });
   });
+  hooks.on("kubb:generation:summary", ({ failedPlugins, status, hrStart, filesCreated }) => {
+    const [seconds, nanoseconds] = process.hrtime(hrStart);
+    const duration = Math.round(seconds * 1e3 + nanoseconds / 1e6);
+    sendDataMessage({
+      type: "kubb:generation:summary",
+      data: [{ duration, fileCount: filesCreated, failedPlugins: failedPlugins.size, status }],
+      timestamp: Date.now()
+    });
+  });
+  hooks.on("kubb:lifecycle:start", () => {
+    sendDataMessage({ type: "kubb:lifecycle:start", data: [], timestamp: Date.now() });
+  });
+  hooks.on("kubb:lifecycle:end", () => {
+    sendDataMessage({ type: "kubb:lifecycle:end", data: [], timestamp: Date.now() });
+  });
+  hooks.on("kubb:format:start", () => {
+    sendDataMessage({ type: "kubb:format:start", data: [], timestamp: Date.now() });
+  });
+  hooks.on("kubb:format:end", () => {
+    sendDataMessage({ type: "kubb:format:end", data: [], timestamp: Date.now() });
+  });
+  hooks.on("kubb:lint:start", () => {
+    sendDataMessage({ type: "kubb:lint:start", data: [], timestamp: Date.now() });
+  });
+  hooks.on("kubb:lint:end", () => {
+    sendDataMessage({ type: "kubb:lint:end", data: [], timestamp: Date.now() });
+  });
 }
 
 async function connectToStudio(options) {
@@ -7373,7 +7526,6 @@ async function connectToStudio(options) {
     resolvedConfigPath,
     allowAll,
     allowWrite,
-    allowPublish,
     root,
     retryInterval,
     heartbeatInterval = 3e4,
@@ -7381,7 +7533,6 @@ async function connectToStudio(options) {
     nitro
   } = options;
   const hooks = new AsyncEventEmitter();
-  let currentSource;
   async function reconnect() {
     logger.info(`Retrying connection in ${formatMs$1(retryInterval)} to Kubb Studio ...`);
     setTimeout(() => connectToStudio({ ...options, initialSession: void 0 }), retryInterval);
@@ -7396,7 +7547,6 @@ async function connectToStudio(options) {
     const maskedSessionId = maskString(sessionId);
     const effectiveAllowAll = isSandbox ? false : allowAll;
     const effectiveWrite = isSandbox ? false : allowWrite;
-    const effectivePublish = isSandbox ? false : allowPublish;
     let serverDisconnected = false;
     let heartbeatTimer;
     async function cleanup(reason = "cleanup") {
@@ -7408,6 +7558,7 @@ async function connectToStudio(options) {
         ws.removeEventListener("open", onOpen);
         ws.removeEventListener("close", onClose);
         ws.removeEventListener("error", onError);
+        ws.removeEventListener("message", onMessage);
       } catch (_error) {
       }
     }
@@ -7440,9 +7591,9 @@ async function connectToStudio(options) {
       });
     });
     heartbeatTimer = setInterval(() => sendAgentMessage(ws, { type: "ping" }), heartbeatInterval);
-    setupEventsStream(ws, hooks, () => currentSource);
-    ws.addEventListener("message", async (message) => {
-      var _a2, _b, _c, _d, _e, _f;
+    setupEventsStream(ws, hooks);
+    const onMessage = async (message) => {
+      var _a2, _b, _c, _d;
       try {
         const data = JSON.parse(message.data);
         logger.info(`[${maskedSessionId}] Received "${data.type}" from Studio`);
@@ -7464,11 +7615,11 @@ async function connectToStudio(options) {
         }
         if (isCommandMessage(data)) {
           if (data.command === "generate") {
-            currentSource = "generate";
             const config = await loadConfig(resolvedConfigPath);
             const storedConfig = data.payload ? null : await getLatestStudioConfigFromStorage({ sessionId }).catch(() => null);
             const patch = (_b = (_a2 = data.payload) != null ? _a2 : storedConfig) != null ? _b : void 0;
             const plugins = await mergePlugins(config.plugins, patch == null ? void 0 : patch.plugins);
+            const middleware = (patch == null ? void 0 : patch.middleware) ? await resolveMiddlewares(patch.middleware) : config.middleware;
             const inputOverride = isSandbox ? { data: (_c = patch == null ? void 0 : patch.input) != null ? _c : "" } : void 0;
             if (allowWrite && isSandbox) {
               logger.warn(`[${maskedSessionId}] Agent is running in a sandbox environment, write will be disabled`);
@@ -7484,6 +7635,9 @@ async function connectToStudio(options) {
                 logger.warn(`[${maskedSessionId}] Failed to save studio config: ${err == null ? void 0 : err.message}`);
               });
             }
+            const generationHooks = new AsyncEventEmitter();
+            setupHookListener(generationHooks, root);
+            setupEventsStream(ws, generationHooks);
             await generate({
               config: {
                 ...config,
@@ -7493,12 +7647,15 @@ async function connectToStudio(options) {
                 output: {
                   ...config.output
                 },
-                plugins
+                plugins,
+                middleware,
+                // Studio may send an opaque adapter options blob; forward it unchanged to createKubb.
+                // The adapter factory is responsible for validating and merging its own options.
+                ...(patch == null ? void 0 : patch.adapter) != null && { adapter: patch.adapter }
               },
-              hooks
+              hooks: generationHooks
             });
             logger.success(`[${maskedSessionId}] Completed "${data.type}" from Studio`);
-            currentSource = void 0;
             return;
           }
           if (data.command === "connect") {
@@ -7510,8 +7667,7 @@ async function connectToStudio(options) {
                 configPath,
                 permissions: {
                   allowAll: effectiveAllowAll,
-                  allowWrite: effectiveWrite,
-                  allowPublish: effectivePublish
+                  allowWrite: effectiveWrite
                 },
                 config: {
                   plugins: config.plugins.map((plugin) => ({
@@ -7524,30 +7680,13 @@ async function connectToStudio(options) {
             logger.success(`[${maskedSessionId}] Completed "${data.type}" from Studio`);
             return;
           }
-          if (isPublishCommandMessage(data)) {
-            if (!effectivePublish) {
-              logger.warn(`[${maskedSessionId}] Publish command rejected \u2014 KUBB_AGENT_ALLOW_PUBLISH is not enabled`);
-              return;
-            }
-            currentSource = "publish";
-            const config = await loadConfig(resolvedConfigPath);
-            const resolvedCommand = (_e = (_d = data.payload.command) != null ? _d : process.env.KUBB_AGENT_PUBLISH_COMMAND) != null ? _e : "npm publish";
-            await publish({
-              command: resolvedCommand,
-              outputPath: config.output.path,
-              root,
-              hooks
-            });
-            logger.success(`[${maskedSessionId}] Completed "${data.command}" from Studio`);
-            currentSource = void 0;
-            return;
-          }
         }
         logger.warn(`[${maskedSessionId}] Unknown message type from Kubb Studio: ${message.data}`);
       } catch (error) {
-        logger.error(`[${maskedSessionId}] [unhandledRejection] ${(_f = error == null ? void 0 : error.message) != null ? _f : error}`);
+        logger.error(`[${maskedSessionId}] [unhandledRejection] ${(_d = error == null ? void 0 : error.message) != null ? _d : error}`);
       }
-    });
+    };
+    ws.addEventListener("message", onMessage);
   } catch (error) {
     throw new Error(`[unhandledRejection] ${(_a = error == null ? void 0 : error.message) != null ? _a : error}`, {
       cause: error
@@ -7577,7 +7716,6 @@ function resolveStudioRuntimeConfig(env = process$1.env, cwd = process$1.cwd())
     root,
     allowAll,
     allowWrite: allowAll || parseBooleanEnv(env.KUBB_AGENT_ALLOW_WRITE),
-    allowPublish: allowAll || parseBooleanEnv(env.KUBB_AGENT_ALLOW_PUBLISH),
     poolSize: parsePositiveIntegerEnv(env.KUBB_AGENT_POOL_SIZE, agentDefaults.poolSize),
     hasSecret: Boolean(env.KUBB_AGENT_SECRET)
   };
@@ -7587,7 +7725,7 @@ function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 const _zcw7I4pYH8OiCfaDcjy_x7I6IH1tLDQR3W_yRZgP6E = defineNitroPlugin(async (nitro) => {
-  const { studioUrl, token, configPath, resolvedConfigPath, retryInterval, heartbeatInterval, root, allowAll, allowWrite, allowPublish, poolSize, hasSecret } = resolveStudioRuntimeConfig(process$1.env);
+  const { studioUrl, token, configPath, resolvedConfigPath, retryInterval, heartbeatInterval, root, allowAll, allowWrite, poolSize, hasSecret } = resolveStudioRuntimeConfig(process$1.env);
   if (!token) {
     logger.warn("KUBB_AGENT_TOKEN not set", "cannot authenticate with studio");
     return null;
@@ -7597,6 +7735,7 @@ const _zcw7I4pYH8OiCfaDcjy_x7I6IH1tLDQR3W_yRZgP6E = defineNitroPlugin(async (nit
   }
   const maskedToken = maskString(token);
   try {
+    await checkPeerDependencies();
     await registerAgent({ token, studioUrl, poolSize });
     const baseOptions = {
       token,
@@ -7605,7 +7744,6 @@ const _zcw7I4pYH8OiCfaDcjy_x7I6IH1tLDQR3W_yRZgP6E = defineNitroPlugin(async (nit
       resolvedConfigPath,
       allowAll,
       allowWrite,
-      allowPublish,
       root,
       retryInterval,
       heartbeatInterval,