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

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

@@ -4713,6 +4713,14 @@ async function disconnect({ sessionId, token, studioUrl }) {
 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);
@@ -4727,210 +4735,131 @@ 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;
-  switch (node.kind) {
-    case "Input":
-      yield* node.schemas;
-      yield* node.operations;
-      break;
-    case "Output":
-      break;
-    case "Operation":
-      yield* node.parameters;
-      if ((_a = node.requestBody) == null ? void 0 : _a.content) {
-        for (const c of node.requestBody.content) if (c.schema) yield c.schema;
-      }
-      yield* node.responses;
-      break;
-    case "Schema":
-      if (!recurse) break;
-      if ("properties" in node && node.properties.length > 0) yield* node.properties;
-      if ("items" in node && node.items) yield* node.items;
-      if ("members" in node && node.members) yield* node.members;
-      if ("additionalProperties" in node && node.additionalProperties && node.additionalProperties !== true) yield node.additionalProperties;
-      break;
-    case "Property":
-      yield node.schema;
-      break;
-    case "Parameter":
-      yield node.schema;
-      break;
-    case "Response":
-      if (node.schema) yield node.schema;
-      break;
+  if (node.kind === "Input") {
+    yield* node.schemas;
+    yield* node.operations;
+    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;
+  if (node.kind === "Output") return;
+  if (node.kind === "Operation") {
+    yield* node.parameters;
+    if ((_a = node.requestBody) == null ? void 0 : _a.content) {
+      for (const c of node.requestBody.content) if (c.schema) yield c.schema;
+    }
+    yield* node.responses;
+    return;
+  }
+  if (node.kind === "Schema") {
+    if (!recurse) return;
+    if ("properties" in node && node.properties.length > 0) yield* node.properties;
+    if ("items" in node && node.items) yield* node.items;
+    if ("members" in node && node.members) yield* node.members;
+    if ("additionalProperties" in node && node.additionalProperties && node.additionalProperties !== true) yield node.additionalProperties;
+    return;
+  }
+  if (node.kind === "Property") {
+    yield node.schema;
+    return;
+  }
+  if (node.kind === "Parameter") {
+    yield node.schema;
+    return;
+  }
+  if (node.kind === "Response") {
+    if (node.schema) yield node.schema;
+    return;
   }
-  const children = getChildren(node, recurse);
-  for (const child of children) await _walk(child, visitor, recurse, limit, node);
 }
 function transform(node, options) {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
   const { depth, parent, ...visitor } = options;
   const recurse = (depth != null ? depth : visitorDepths.deep) === visitorDepths.deep;
-  switch (node.kind) {
-    case "Input": {
-      const input = (_b = (_a = visitor.input) == null ? void 0 : _a.call(visitor, node, { parent })) != null ? _b : node;
-      return {
-        ...input,
-        schemas: input.schemas.map((s) => transform(s, {
-          ...options,
-          parent: input
-        })),
-        operations: input.operations.map((op) => transform(op, {
-          ...options,
-          parent: input
-        }))
-      };
-    }
-    case "Output":
-      return (_d = (_c = visitor.output) == null ? void 0 : _c.call(visitor, node, { parent })) != null ? _d : node;
-    case "Operation": {
-      const op = (_f = (_e = visitor.operation) == null ? void 0 : _e.call(visitor, node, { parent })) != null ? _f : node;
-      return {
-        ...op,
-        parameters: op.parameters.map((p) => transform(p, {
-          ...options,
-          parent: op
-        })),
-        requestBody: op.requestBody ? {
-          ...op.requestBody,
-          content: (_g = op.requestBody.content) == null ? void 0 : _g.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
+  if (node.kind === "Input") {
+    const input = (_b = (_a = visitor.input) == null ? void 0 : _a.call(visitor, node, { parent })) != null ? _b : node;
+    return {
+      ...input,
+      schemas: input.schemas.map((s) => transform(s, {
+        ...options,
+        parent: input
+      })),
+      operations: input.operations.map((op) => transform(op, {
+        ...options,
+        parent: input
+      }))
+    };
+  }
+  if (node.kind === "Output") return (_d = (_c = visitor.output) == null ? void 0 : _c.call(visitor, node, { parent })) != null ? _d : node;
+  if (node.kind === "Operation") {
+    const op = (_f = (_e = visitor.operation) == null ? void 0 : _e.call(visitor, node, { parent })) != null ? _f : node;
+    return {
+      ...op,
+      parameters: op.parameters.map((p) => transform(p, {
+        ...options,
+        parent: op
+      })),
+      requestBody: op.requestBody ? {
+        ...op.requestBody,
+        content: (_g = op.requestBody.content) == null ? void 0 : _g.map((c) => ({
+          ...c,
+          schema: c.schema ? transform(c.schema, {
+            ...options,
+            parent: op
+          }) : void 0
         }))
-      };
-    }
-    case "Schema": {
-      const schema = (_i = (_h = visitor.schema) == null ? void 0 : _h.call(visitor, node, { parent })) != null ? _i : node;
-      const childOptions = {
+      } : void 0,
+      responses: op.responses.map((r) => transform(r, {
         ...options,
-        parent: schema
-      };
-      return {
-        ...schema,
-        ..."properties" in schema && recurse ? { properties: schema.properties.map((p) => transform(p, childOptions)) } : {},
-        ..."items" in schema && recurse ? { items: (_j = schema.items) == null ? void 0 : _j.map((i) => transform(i, childOptions)) } : {},
-        ..."members" in schema && recurse ? { members: (_k = schema.members) == null ? void 0 : _k.map((m) => transform(m, childOptions)) } : {},
-        ..."additionalProperties" in schema && recurse && schema.additionalProperties && schema.additionalProperties !== true ? { additionalProperties: transform(schema.additionalProperties, childOptions) } : {}
-      };
-    }
-    case "Property": {
-      const prop = (_m = (_l = visitor.property) == null ? void 0 : _l.call(visitor, node, { parent })) != null ? _m : node;
-      return createProperty({
-        ...prop,
-        schema: transform(prop.schema, {
-          ...options,
-          parent: prop
-        })
-      });
-    }
-    case "Parameter": {
-      const param = (_o = (_n = visitor.parameter) == null ? void 0 : _n.call(visitor, node, { parent })) != null ? _o : node;
-      return createParameter({
-        ...param,
-        schema: transform(param.schema, {
-          ...options,
-          parent: param
-        })
-      });
-    }
-    case "Response": {
-      const response = (_q = (_p = visitor.response) == null ? void 0 : _p.call(visitor, node, { parent })) != null ? _q : node;
-      return {
-        ...response,
-        schema: transform(response.schema, {
-          ...options,
-          parent: response
-        })
-      };
-    }
-    case "FunctionParameter":
-    case "ParameterGroup":
-    case "FunctionParameters":
-    case "Type":
-      return node;
-    default:
-      return node;
+        parent: op
+      }))
+    };
+  }
+  if (node.kind === "Schema") {
+    const schema = (_i = (_h = visitor.schema) == null ? void 0 : _h.call(visitor, node, { parent })) != null ? _i : node;
+    const childOptions = {
+      ...options,
+      parent: schema
+    };
+    return {
+      ...schema,
+      ..."properties" in schema && recurse ? { properties: schema.properties.map((p) => transform(p, childOptions)) } : {},
+      ..."items" in schema && recurse ? { items: (_j = schema.items) == null ? void 0 : _j.map((i) => transform(i, childOptions)) } : {},
+      ..."members" in schema && recurse ? { members: (_k = schema.members) == null ? void 0 : _k.map((m) => transform(m, childOptions)) } : {},
+      ..."additionalProperties" in schema && recurse && schema.additionalProperties && schema.additionalProperties !== true ? { additionalProperties: transform(schema.additionalProperties, childOptions) } : {}
+    };
+  }
+  if (node.kind === "Property") {
+    const prop = (_m = (_l = visitor.property) == null ? void 0 : _l.call(visitor, node, { parent })) != null ? _m : node;
+    return createProperty({
+      ...prop,
+      schema: transform(prop.schema, {
+        ...options,
+        parent: prop
+      })
+    });
+  }
+  if (node.kind === "Parameter") {
+    const param = (_o = (_n = visitor.parameter) == null ? void 0 : _n.call(visitor, node, { parent })) != null ? _o : node;
+    return createParameter({
+      ...param,
+      schema: transform(param.schema, {
+        ...options,
+        parent: param
+      })
+    });
+  }
+  if (node.kind === "Response") {
+    const response = (_q = (_p = visitor.response) == null ? void 0 : _p.call(visitor, node, { parent })) != null ? _q : node;
+    return {
+      ...response,
+      schema: transform(response.schema, {
+        ...options,
+        parent: response
+      })
+    };
   }
+  return node;
 }
 function* collectLazy(node, options) {
   var _a, _b, _c, _d, _e, _f, _g;
@@ -5112,10 +5041,7 @@ function resolveRefName(node) {
   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;
 }
-const schemaRefCache = /* @__PURE__ */ new WeakMap();
-function collectSchemaRefs(node) {
-  const cached = schemaRefCache.get(node);
-  if (cached) return cached;
+const collectSchemaRefs = memoize$1(/* @__PURE__ */ new WeakMap(), (node) => {
   const refs = /* @__PURE__ */ new Set();
   collect(node, { schema(child) {
     if (child.type === "ref") {
@@ -5123,23 +5049,15 @@ function collectSchemaRefs(node) {
       if (name) refs.add(name);
     }
   } });
-  schemaRefCache.set(node, refs);
   return refs;
-}
+});
 function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
   if (!node) return out;
   for (const name of collectSchemaRefs(node)) out.add(name);
   return out;
 }
-const usedSchemaNamesCache = /* @__PURE__ */ new WeakMap();
-function collectUsedSchemaNames(operations, schemas) {
-  let byOps = usedSchemaNamesCache.get(operations);
-  if (!byOps) {
-    byOps = /* @__PURE__ */ new WeakMap();
-    usedSchemaNamesCache.set(operations, byOps);
-  }
-  const cached = byOps.get(schemas);
-  if (cached) return cached;
+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();
@@ -5155,9 +5073,11 @@ function collectUsedSchemaNames(operations, schemas) {
     depth: "shallow",
     schema: (node) => node
   })) visitSchema(schema);
-  byOps.set(schemas, result);
   return result;
 }
+function collectUsedSchemaNames(operations, schemas) {
+  return collectUsedSchemaNamesMemo(operations)(schemas);
+}
 function syncOptionality(schema, required) {
   var _a;
   const nullable = (_a = schema.nullable) != null ? _a : false;
@@ -5167,6 +5087,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;
@@ -5220,9 +5148,9 @@ var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !==
 var __accessCheck$1 = (obj, member, msg) => member.has(obj) || __typeError$1("Cannot " + msg);
 var __privateGet$1 = (obj, member, getter) => (__accessCheck$1(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd$1 = (obj, member, value) => member.has(obj) ? __typeError$1("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet$1 = (obj, member, value, setter) => (__accessCheck$1(obj, member, "write to private field"), member.set(obj, value), value);
+var __privateSet = (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 _options, _URLPath_instances, transformParam_fn, eachParam_fn, _a$1, _cache, _filesCache, _FileManager_instances, store_fn, _b, _studio, _middlewareListeners, _eventGeneratorPlugins, _resolvers, _defaultResolvers, _hookListeners, _KubbDriver_instances, normalizePlugin_fn, registerAdapter_fn, registerMiddleware_fn, registerPlugin_fn, trackHookListener_fn, _getDefaultResolver, _c;
 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;
@@ -5248,154 +5176,411 @@ function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
   }) : camelCase(part));
   return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
-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* chunks(arr, size) {
+  for (let i = 0; i < arr.length; i += size) yield arr.slice(i, i + size);
 }
-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);
+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 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 matchesSchemaPattern(node, type, pattern) {
-  switch (type) {
-    case "schemaName":
-      return node.name ? testPattern(node.name, pattern) : false;
-    default:
-      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
-    };
+    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;
-}
-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);
+  if (batch.length > 0) {
+    await process2(batch.splice(0));
+    if (flush) await flush();
   }
-  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;
+async function withDrain(work, flush) {
+  await work(flush);
+  await flush();
 }
-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 isPromise(result) {
+  return result !== null && result !== void 0 && typeof result["then"] === "function";
 }
-function buildDefaultBanner({ title, description, version, config }) {
-  try {
-    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 "";
+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 arrayToAsyncIterable(arr) {
+  return { [Symbol.asyncIterator]() {
+    return (async function* () {
+      yield* arr;
     })();
-    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 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 URLPath = (_a$1 = class {
+  constructor(path2, options = {}) {
+    __privateAdd$1(this, _URLPath_instances);
+    /**
+    * The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
+    */
+    __publicField$1(this, "path");
+    __privateAdd$1(this, _options);
+    this.path = path2;
+    __privateSet(this, _options, options);
+  }
+  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').URL // '/pet/:petId'
+  * ```
+  */
+  get URL() {
+    return this.toURLPath();
+  }
+  /** 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;
+    }
+  }
+  /**
+  * Converts the OpenAPI path to a TypeScript template literal string.
+  *
+  * @example
+  * new URLPath('/pet/{petId}').template              // '`/pet/${petId}`'
+  * new URLPath('/account/monetary-accountID').template // '`/account/${monetaryAccountId}`'
+  */
+  get template() {
+    return this.toTemplateString();
+  }
+  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
+  *
+  * @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.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').params // { petId: 'petId' }
+  * new URLPath('/pet').params         // undefined
+  * ```
+  */
+  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;
+  }
+  /**
+  * Converts the OpenAPI path to a TypeScript template literal string.
+  * An optional `replacer` can transform each extracted parameter name before interpolation.
+  *
+  * @example
+  * new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
+  */
+  toTemplateString({ prefix = "", replacer } = {}) {
+    return `\`${prefix}${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("")}\``;
+  }
+  /**
+  * 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
+  * new URLPath('/pet/{petId}/tag/{tagId}').getParams()
+  * // { petId: 'petId', tagId: 'tagId' }
+  * ```
+  */
+  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;
+  }
+  /** Converts the OpenAPI path to Express-style colon syntax.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
+  * ```
+  */
+  toURLPath() {
+    return this.path.replace(/\{([^}]+)\}/g, ":$1");
+  }
+}, _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));
+  }
+}, _a$1);
+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";
+}
+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, _c2;
+  if (type === "tag") return node.tags.some((tag) => testPattern(tag, pattern));
+  if (type === "operationId") return testPattern(node.operationId, pattern);
+  if (type === "path") return testPattern(node.path, pattern);
+  if (type === "method") return 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 {
+    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}
 `;
@@ -5408,19 +5593,18 @@ function buildDefaultBanner({ title, description, version, config }) {
     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);
+function defaultResolveBanner(meta, { output, config }) {
+  if (typeof (output == null ? void 0 : output.banner) === "function") return output.banner(meta);
   if (typeof (output == null ? void 0 : output.banner) === "string") return output.banner;
   if (config.output.defaultBanner === false) return;
   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,
+    title: meta == null ? void 0 : meta.title,
+    version: meta == null ? void 0 : meta.version,
     config
   });
 }
-function defaultResolveFooter(node, { output }) {
-  if (typeof (output == null ? void 0 : output.footer) === "function") return node ? output.footer(node) : void 0;
+function defaultResolveFooter(meta, { output }) {
+  if (typeof (output == null ? void 0 : output.footer) === "function") return output.footer(meta);
   if (typeof (output == null ? void 0 : output.footer) === "string") return output.footer;
 }
 function defineResolver(build) {
@@ -5478,7 +5662,7 @@ function mergeFilesByPath(files) {
   }
   return merged;
 }
-var FileManager = (_a$1 = class {
+var FileManager = (_b = class {
   constructor() {
     __privateAdd$1(this, _FileManager_instances);
     __privateAdd$1(this, _cache, /* @__PURE__ */ new Map());
@@ -5506,11 +5690,11 @@ var FileManager = (_a$1 = class {
   }
   deleteByPath(path2) {
     __privateGet$1(this, _cache).delete(path2);
-    __privateSet$1(this, _filesCache, null);
+    __privateSet(this, _filesCache, null);
   }
   clear() {
     __privateGet$1(this, _cache).clear();
-    __privateSet$1(this, _filesCache, null);
+    __privateSet(this, _filesCache, null);
   }
   /**
   * Releases all stored files. Called by the core after `kubb:build:end` to
@@ -5527,7 +5711,7 @@ var FileManager = (_a$1 = class {
   */
   get files() {
     if (__privateGet$1(this, _filesCache)) return __privateGet$1(this, _filesCache);
-    __privateSet$1(this, _filesCache, [...__privateGet$1(this, _cache).values()].sort((a, b) => {
+    __privateSet(this, _filesCache, [...__privateGet$1(this, _cache).values()].sort((a, b) => {
       const lenDiff = a.path.length - b.path.length;
       if (lenDiff !== 0) return lenDiff;
       const aIsIndex = a.path.endsWith("/index.ts") || a.path === "index.ts";
@@ -5546,29 +5730,38 @@ var FileManager = (_a$1 = class {
     __privateGet$1(this, _cache).set(resolvedFile.path, resolvedFile);
     resolvedFiles.push(resolvedFile);
   }
-  __privateSet$1(this, _filesCache, null);
+  __privateSet(this, _filesCache, null);
   return resolvedFiles;
-}, _a$1);
+}, _b);
 function enforceOrder(enforce) {
   return enforce === "pre" ? -1 : enforce === "post" ? 1 : 0;
 }
-var PluginDriver = (_b$1 = class {
+var KubbDriver = (_c = class {
   constructor(config, options) {
-    __privateAdd$1(this, _PluginDriver_instances);
+    __privateAdd$1(this, _KubbDriver_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.
+    * The streaming `InputStreamNode` produced by the adapter.
+    * Always set after adapter setup — parse-only adapters are wrapped automatically.
     */
     __publicField$1(this, "inputNode");
+    __publicField$1(this, "adapter");
     /**
-    * Set when the adapter returns a streaming `InputStreamNode` (large specs).
-    * Mutually exclusive with `inputNode` — exactly one is set after adapter setup.
+    * 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.
     */
-    __publicField$1(this, "inputStreamNode");
-    __publicField$1(this, "adapter");
-    __privateAdd$1(this, _studioIsOpen, false);
+    __privateAdd$1(this, _studio, {
+      source: void 0,
+      isOpen: false,
+      inputNode: void 0
+    });
+    __privateAdd$1(this, _middlewareListeners, []);
     /**
     * Central file store for all generated files.
     * Plugins should use `this.addFile()` / `this.upsertFile()` (via their context) to
@@ -5580,97 +5773,50 @@ var PluginDriver = (_b$1 = class {
     * 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.
     */
-    __privateAdd$1(this, _pluginsWithEventGenerators, /* @__PURE__ */ new Set());
+    __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
+    }))));
     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);
-    });
+    this.adapter = config.adapter;
   }
   /**
   * Returns `'single'` when `fileOrFolder` has a file extension, `'split'` otherwise.
   *
   * @example
   * ```ts
-  * PluginDriver.getMode('src/gen/types.ts')  // 'single'
-  * PluginDriver.getMode('src/gen/types')     // 'split'
+  * KubbDriver.getMode('src/gen/types.ts')  // 'single'
+  * KubbDriver.getMode('src/gen/types')     // 'split'
   * ```
   */
   static getMode(fileOrFolder) {
     return getMode(fileOrFolder);
   }
+  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;
   }
   /**
-  * 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
-  */
-  registerPluginHooks(hookPlugin, normalizedPlugin) {
-    const { hooks } = hookPlugin;
-    if (!hooks) return;
-    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);
-    }
-  }
-  /**
   * Emits the `kubb:plugin:setup` event so that all registered hook-style plugin listeners
   * can configure generators, resolvers, transformers and renderers before `buildStart` runs.
   *
@@ -5721,7 +5867,7 @@ var PluginDriver = (_b$1 = class {
         });
       };
       this.hooks.on("kubb:generate:schema", schemaHandler);
-      __privateMethod$1(this, _PluginDriver_instances, trackHookListener_fn).call(this, "kubb:generate:schema", schemaHandler);
+      __privateMethod$1(this, _KubbDriver_instances, trackHookListener_fn).call(this, "kubb:generate:schema", schemaHandler);
     }
     if (gen.operation) {
       const operationHandler = async (node, ctx) => {
@@ -5733,7 +5879,7 @@ var PluginDriver = (_b$1 = class {
         });
       };
       this.hooks.on("kubb:generate:operation", operationHandler);
-      __privateMethod$1(this, _PluginDriver_instances, trackHookListener_fn).call(this, "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) => {
@@ -5745,9 +5891,9 @@ var PluginDriver = (_b$1 = class {
         });
       };
       this.hooks.on("kubb:generate:operations", operationsHandler);
-      __privateMethod$1(this, _PluginDriver_instances, trackHookListener_fn).call(this, "kubb:generate:operations", operationsHandler);
+      __privateMethod$1(this, _KubbDriver_instances, trackHookListener_fn).call(this, "kubb:generate:operations", operationsHandler);
     }
-    __privateGet$1(this, _pluginsWithEventGenerators).add(pluginName);
+    __privateGet$1(this, _eventGeneratorPlugins).add(pluginName);
   }
   /**
   * Returns `true` when at least one generator was registered for the given plugin
@@ -5756,8 +5902,8 @@ var PluginDriver = (_b$1 = class {
   * 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`.
   */
-  hasRegisteredGenerators(pluginName) {
-    return __privateGet$1(this, _pluginsWithEventGenerators).has(pluginName);
+  hasEventGenerators(pluginName) {
+    return __privateGet$1(this, _eventGeneratorPlugins).has(pluginName);
   }
   /**
   * Unregisters all plugin lifecycle listeners from the shared event emitter.
@@ -5768,12 +5914,17 @@ var PluginDriver = (_b$1 = class {
   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();
+    __privateGet$1(this, _eventGeneratorPlugins).clear();
     __privateGet$1(this, _resolvers).clear();
     __privateGet$1(this, _defaultResolvers).clear();
     this.fileManager.dispose();
     this.inputNode = void 0;
-    this.inputStreamNode = void 0;
+    __privateSet(this, _studio, {
+      source: void 0,
+      isOpen: false,
+      inputNode: void 0
+    });
+    for (const [event, handler] of __privateGet$1(this, _middlewareListeners)) this.hooks.off(event, handler);
   }
   [Symbol.dispose]() {
     this.dispose();
@@ -5785,7 +5936,7 @@ var PluginDriver = (_b$1 = class {
   */
   setPluginResolver(pluginName, partial) {
     const merged = {
-      ...__privateMethod$1(this, _PluginDriver_instances, createDefaultResolver_fn).call(this, pluginName),
+      ...__privateGet$1(this, _getDefaultResolver).call(this, pluginName),
       ...partial
     };
     __privateGet$1(this, _resolvers).set(pluginName, merged);
@@ -5793,8 +5944,8 @@ var PluginDriver = (_b$1 = class {
     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);
+    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);
   }
   getContext(plugin) {
     const driver = this;
@@ -5804,7 +5955,7 @@ var PluginDriver = (_b$1 = class {
         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));
+        return _c.getMode(resolve(driver.config.root, driver.config.output.path, output.path));
       },
       hooks: driver.hooks,
       plugin,
@@ -5818,14 +5969,11 @@ var PluginDriver = (_b$1 = class {
       upsertFile: async (...files) => {
         driver.fileManager.upsert(...files);
       },
-      get inputNode() {
-        var _a2;
-        if (driver.inputNode) return driver.inputNode;
-        return {
-          kind: "Input",
-          schemas: [],
-          operations: [],
-          meta: (_a2 = driver.inputStreamNode) == null ? void 0 : _a2.meta
+      get meta() {
+        var _a2, _b2;
+        return (_b2 = (_a2 = driver.inputNode) == null ? void 0 : _a2.meta) != null ? _b2 : {
+          circularNames: [],
+          enumNames: []
         };
       },
       get adapter() {
@@ -5846,14 +5994,15 @@ var PluginDriver = (_b$1 = class {
       info(message) {
         driver.hooks.emit("kubb:info", { message });
       },
-      openInStudio(options) {
-        var _a2, _b2;
-        if (!driver.config.devtools || __privateGet$1(driver, _studioIsOpen)) return;
+      async openInStudio(options) {
+        var _a2, _b2, _c2, _d;
+        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.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);
+        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";
-        return openInStudio(driver.inputNode, studioUrl, options);
+        (_d = (_c2 = __privateGet$1(driver, _studio)).inputNode) != null ? _d : _c2.inputNode = Promise.resolve(driver.adapter.parse(__privateGet$1(driver, _studio).source));
+        return openInStudio(await __privateGet$1(driver, _studio).inputNode, studioUrl, options);
       }
     };
   }
@@ -5865,23 +6014,107 @@ var PluginDriver = (_b$1 = class {
     if (!plugin) throw new Error(`[kubb] Plugin "${pluginName}" is required but not found. Make sure it is included in your Kubb config.`);
     return plugin;
   }
-}, _studioIsOpen = new WeakMap(), _pluginsWithEventGenerators = new WeakMap(), _resolvers = new WeakMap(), _defaultResolvers = new WeakMap(), _hookListeners = new WeakMap(), _PluginDriver_instances = new WeakSet(), /**
+}, _studio = new WeakMap(), _middlewareListeners = 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(hookPlugin) {
-  const normalizedPlugin = {
-    name: hookPlugin.name,
-    dependencies: hookPlugin.dependencies,
-    enforce: hookPlugin.enforce,
-    options: {
+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: []
     }
   };
-  this.registerPluginHooks(hookPlugin, normalizedPlugin);
-  return normalizedPlugin;
+  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}`
+      ]
+    });
+  }
+}, 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);
+  }
+  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);
+  }
 }, trackHookListener_fn = function(event, handler) {
   let handlers = __privateGet$1(this, _hookListeners).get(event);
   if (!handlers) {
@@ -5889,16 +6122,7 @@ normalizePlugin_fn = function(hookPlugin) {
     __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(() => ({
-    name: "default",
-    pluginName
-  }));
-  __privateGet$1(this, _defaultResolvers).set(pluginName, resolver);
-  return resolver;
-}, _b$1);
+}, _getDefaultResolver = new WeakMap(), _c);
 function applyHookResult({ result, driver, rendererFactory }) {
   if (!result) return;
   if (Array.isArray(result)) {
@@ -5923,6 +6147,22 @@ async function applyAsyncRender({ renderer, result, driver }) {
   driver.fileManager.upsert(...renderer.files);
   renderer.unmount();
 }
+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 __defProp = Object.defineProperty;
 var __typeError = (msg) => {
@@ -5933,9 +6173,8 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
 var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var _emitter, _AsyncEventEmitter_instances, emitAll_fn, _a, _options, _URLPath_instances, transformParam_fn, eachParam_fn, _b;
+var _emitter, _AsyncEventEmitter_instances, emitAll_fn, _a;
 var BuildError = class extends Error {
   constructor(message, options) {
     super(message, { cause: options.cause });
@@ -6043,283 +6282,58 @@ var AsyncEventEmitter = (_a = class {
     }
     throw new Error(`Error in async listener for "${eventName}" with eventArgs ${serializedArgs}`, { cause: toError(err) });
   }
-}, _a);
-function getElapsedMs(hrStart) {
-  const [seconds, nanoseconds] = process.hrtime(hrStart);
-  const ms = seconds * 1e3 + nanoseconds / 1e6;
-  return Math.round(ms * 100) / 100;
-}
-function formatMs(ms) {
-  if (ms >= 6e4) return `${Math.floor(ms / 6e4)}m ${(ms % 6e4 / 1e3).toFixed(1)}s`;
-  if (ms >= 1e3) return `${(ms / 1e3).toFixed(2)}s`;
-  return `${Math.round(ms)}ms`;
-}
-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;
-  }
-  try {
-    if (await readFile$1(resolved, { encoding: "utf-8" }) === trimmed) return null;
-  } catch {
-  }
-  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;
-  }
-  return trimmed;
-}
-async function clean(path) {
-  return rm(path, {
-    recursive: true,
-    force: true
-  });
-}
-function isPromise(result) {
-  return result !== null && result !== void 0 && typeof result["then"] === "function";
-}
-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 URLPath = (_b = class {
-  constructor(path, options = {}) {
-    __privateAdd(this, _URLPath_instances);
-    /**
-    * The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
-    */
-    __publicField(this, "path");
-    __privateAdd(this, _options);
-    this.path = path;
-    __privateSet(this, _options, options);
-  }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
-  *
-  * @example
-  * ```ts
-  * new URLPath('/pet/{petId}').URL // '/pet/:petId'
-  * ```
-  */
-  get URL() {
-    return this.toURLPath();
-  }
-  /** 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;
-    }
-  }
-  /**
-  * Converts the OpenAPI path to a TypeScript template literal string.
-  *
-  * @example
-  * new URLPath('/pet/{petId}').template              // '`/pet/${petId}`'
-  * new URLPath('/account/monetary-accountID').template // '`/account/${monetaryAccountId}`'
-  */
-  get template() {
-    return this.toTemplateString();
-  }
-  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
-  *
-  * @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.
-  *
-  * @example
-  * ```ts
-  * new URLPath('/pet/{petId}').params // { petId: 'petId' }
-  * new URLPath('/pet').params         // undefined
-  * ```
-  */
-  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;
-  }
-  /**
-  * Converts the OpenAPI path to a TypeScript template literal string.
-  * An optional `replacer` can transform each extracted parameter name before interpolation.
-  *
-  * @example
-  * new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
-  */
-  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("")}\``;
-  }
-  /**
-  * 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
-  * new URLPath('/pet/{petId}/tag/{tagId}').getParams()
-  * // { petId: 'petId', tagId: 'tagId' }
-  * ```
-  */
-  getParams(replacer) {
-    const params = {};
-    __privateMethod(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;
-  }
-  /** Converts the OpenAPI path to Express-style colon syntax.
-  *
-  * @example
-  * ```ts
-  * new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
-  * ```
-  */
-  toURLPath() {
-    return this.path.replace(/\{([^}]+)\}/g, ":$1");
+}, _a);
+function getElapsedMs(hrStart) {
+  const [seconds, nanoseconds] = process.hrtime(hrStart);
+  const ms = seconds * 1e3 + nanoseconds / 1e6;
+  return Math.round(ms * 100) / 100;
+}
+function formatMs(ms) {
+  if (ms >= 6e4) return `${Math.floor(ms / 6e4)}m ${(ms % 6e4 / 1e3).toFixed(1)}s`;
+  if (ms >= 1e3) return `${(ms / 1e3).toFixed(2)}s`;
+  return `${Math.round(ms)}ms`;
+}
+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;
   }
-}, _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));
+  try {
+    if (await readFile$1(resolved, { encoding: "utf-8" }) === trimmed) return null;
+  } catch {
   }
-}, _b);
-var version$1 = "5.0.0-beta.19";
+  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;
+  }
+  return trimmed;
+}
+async function clean(path) {
+  return rm(path, {
+    recursive: true,
+    force: true
+  });
+}
+var version$1 = "5.0.0-beta.20";
 function createStorage(build2) {
   return (options) => build2(options != null ? options : {});
 }
@@ -6398,7 +6412,7 @@ const fsStorage = createStorage(() => ({
   },
   async getKeys(base) {
     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 });
@@ -6407,12 +6421,12 @@ const fsStorage = createStorage(() => ({
       }
       for (const entry of entries) {
         const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-        if (entry.isDirectory()) yield* walk2(join(dir, entry.name), rel);
+        if (entry.isDirectory()) yield* walk(join(dir, entry.name), rel);
         else yield rel;
       }
     }
     const keys = [];
-    for await (const key of walk2(resolvedBase, "")) keys.push(key);
+    for await (const key of walk(resolvedBase, "")) keys.push(key);
     return keys;
   },
   async clear(base) {
@@ -6509,13 +6523,12 @@ function createSourcesView(storage) {
   }))();
 }
 async function setup(userConfig, options = {}) {
-  var _a2, _b2, _c, _d, _e, _f, _g, _h, _i;
+  var _a2, _b, _c, _d, _e, _f, _g, _h, _i;
   const hooks = (_a2 = options.hooks) != null ? _a2 : new AsyncEventEmitter();
   const config = {
     ...userConfig,
     root: userConfig.root || process.cwd(),
-    parsers: (_b2 = userConfig.parsers) != null ? _b2 : [],
-    adapter: userConfig.adapter,
+    parsers: (_b = userConfig.parsers) != null ? _b : [],
     output: {
       format: false,
       lint: false,
@@ -6530,7 +6543,7 @@ async function setup(userConfig, options = {}) {
     } : void 0,
     plugins: (_d = userConfig.plugins) != null ? _d : []
   };
-  const driver = new PluginDriver(config, { hooks });
+  const driver = new KubbDriver(config, { hooks });
   const storage = createSourcesView(config.storage);
   const diagnosticInfo = getDiagnosticInfo();
   await hooks.emit("kubb:debug", {
@@ -6545,6 +6558,7 @@ async function setup(userConfig, options = {}) {
       `  \u2022 Storage: ${config.storage.name}`,
       `  \u2022 Formatter: ${((_g = userConfig.output) == null ? void 0 : _g.format) || "none"}`,
       `  \u2022 Linter: ${((_h = userConfig.output) == null ? void 0 : _h.lint) || "none"}`,
+      `Running adapter: ${((_i = config.adapter) == null ? void 0 : _i.name) || "none"}`,
       "Environment:",
       Object.entries(diagnosticInfo).map(([key, value]) => `  \u2022 ${key}: ${value}`).join("\n")
     ]
@@ -6570,48 +6584,7 @@ async function setup(userConfig, options = {}) {
     });
     await config.storage.clear(resolve(config.root, config.output.path));
   }
-  const middlewareListeners = [];
-  function registerMiddlewareHook(event, middlewareHooks) {
-    const handler = middlewareHooks[event];
-    if (handler) {
-      hooks.on(event, handler);
-      middlewareListeners.push([event, handler]);
-    }
-  }
-  for (const middleware of (_i = config.middleware) != null ? _i : []) for (const event of Object.keys(middleware.hooks)) registerMiddlewareHook(event, middleware.hooks);
-  if (config.adapter) {
-    const source = inputToAdapterSource(config);
-    await hooks.emit("kubb:debug", {
-      date: /* @__PURE__ */ new Date(),
-      logs: [`Running adapter: ${config.adapter.name}`]
-    });
-    driver.adapter = config.adapter;
-    if (config.adapter.count && config.adapter.stream) {
-      const { schemas: schemaCount, operations: operationCount } = await config.adapter.count(source);
-      if (schemaCount > 100) {
-        driver.inputStreamNode = await config.adapter.stream(source);
-        await hooks.emit("kubb:debug", {
-          date: /* @__PURE__ */ new Date(),
-          logs: [
-            `\u2713 Adapter '${config.adapter.name}' streaming InputStreamNode`,
-            `  \u2022 Schemas: ${schemaCount} (threshold: 100)`,
-            `  \u2022 Operations: ${operationCount}`
-          ]
-        });
-      }
-    }
-    if (!driver.inputStreamNode) {
-      driver.inputNode = await config.adapter.parse(source);
-      await hooks.emit("kubb:debug", {
-        date: /* @__PURE__ */ new Date(),
-        logs: [
-          `\u2713 Adapter '${config.adapter.name}' resolved InputNode`,
-          `  \u2022 Schemas: ${driver.inputNode.schemas.length}`,
-          `  \u2022 Operations: ${driver.inputNode.operations.length}`
-        ]
-      });
-    }
-  }
+  await driver.setup();
   return {
     config,
     hooks,
@@ -6622,249 +6595,10 @@ async function setup(userConfig, options = {}) {
   };
   function dispose() {
     driver.dispose();
-    for (const [event, handler] of middlewareListeners) hooks.off(event, handler);
-  }
-}
-async function runPluginStreamHooks({ entries, driver, pluginTimings, failedPlugins }) {
-  const inputStreamNode = driver.inputStreamNode;
-  function resolveRendererFor(gen, state) {
-    var _a2, _b2;
-    return gen.renderer === null ? void 0 : (_b2 = (_a2 = gen.renderer) != null ? _a2 : state.plugin.renderer) != null ? _b2 : state.generatorContext.config.renderer;
-  }
-  const states = entries.map(({ plugin, context, hrStart }) => {
-    var _a2;
-    const { exclude, include, override } = plugin.options;
-    const hasExclude = Array.isArray(exclude) && exclude.length > 0;
-    const hasInclude = Array.isArray(include) && include.length > 0;
-    const hasOverride = Array.isArray(override) && override.length > 0;
-    return {
-      plugin,
-      generatorContext: {
-        ...context,
-        resolver: driver.getResolver(plugin.name)
-      },
-      generators: (_a2 = plugin.generators) != null ? _a2 : [],
-      hrStart,
-      failed: false,
-      error: void 0,
-      optionsAreStatic: !hasExclude && !hasInclude && !hasOverride
-    };
-  });
-  async function dispatchSchema(state, node) {
-    if (state.failed) return;
-    try {
-      const { plugin, generatorContext, generators } = state;
-      const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
-      const { exclude, include, override } = plugin.options;
-      const options = state.optionsAreStatic ? plugin.options : generatorContext.resolver.resolveOptions(transformedNode, {
-        options: plugin.options,
-        exclude,
-        include,
-        override
-      });
-      if (options === null) return;
-      const ctx = {
-        ...generatorContext,
-        options
-      };
-      for (const gen of generators) {
-        if (!gen.schema) continue;
-        const raw = gen.schema(transformedNode, ctx);
-        const applied = applyHookResult({
-          result: isPromise(raw) ? await raw : raw,
-          driver,
-          rendererFactory: resolveRendererFor(gen, state)
-        });
-        if (isPromise(applied)) await applied;
-      }
-      await driver.hooks.emit("kubb:generate:schema", transformedNode, ctx);
-    } catch (caughtError) {
-      state.failed = true;
-      state.error = caughtError;
-    }
-  }
-  async function dispatchOperation(state, node) {
-    if (state.failed) return;
-    try {
-      const { plugin, generatorContext, generators } = state;
-      const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
-      const { exclude, include, override } = plugin.options;
-      const options = state.optionsAreStatic ? plugin.options : generatorContext.resolver.resolveOptions(transformedNode, {
-        options: plugin.options,
-        exclude,
-        include,
-        override
-      });
-      if (options === null) return;
-      const ctx = {
-        ...generatorContext,
-        options
-      };
-      for (const gen of generators) {
-        if (!gen.operation) continue;
-        const raw = gen.operation(transformedNode, ctx);
-        const applied = applyHookResult({
-          result: isPromise(raw) ? await raw : raw,
-          driver,
-          rendererFactory: resolveRendererFor(gen, state)
-        });
-        if (isPromise(applied)) await applied;
-      }
-      await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
-    } catch (caughtError) {
-      state.failed = true;
-      state.error = caughtError;
-    }
-  }
-  for await (const node of inputStreamNode.schemas) await Promise.all(states.map((state) => dispatchSchema(state, node)));
-  const collectedOperations = [];
-  for await (const node of inputStreamNode.operations) {
-    collectedOperations.push(node);
-    await Promise.all(states.map((state) => dispatchOperation(state, node)));
-  }
-  for (const state of states) {
-    if (!state.failed) try {
-      const { plugin, generatorContext, generators } = state;
-      const ctx = {
-        ...generatorContext,
-        options: plugin.options
-      };
-      for (const gen of generators) {
-        if (!gen.operations) continue;
-        await applyHookResult({
-          result: await gen.operations(collectedOperations, ctx),
-          driver,
-          rendererFactory: resolveRendererFor(gen, state)
-        });
-      }
-      await driver.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
-    } catch (caughtError) {
-      state.failed = true;
-      state.error = caughtError;
-    }
-    const duration = getElapsedMs(state.hrStart);
-    pluginTimings.set(state.plugin.name, duration);
-    await driver.hooks.emit("kubb:plugin:end", {
-      plugin: state.plugin,
-      duration,
-      success: !state.failed,
-      ...state.failed && state.error ? { error: state.error } : {},
-      config: driver.config,
-      get files() {
-        return driver.fileManager.files;
-      },
-      upsertFile: (...files) => driver.fileManager.upsert(...files)
-    });
-    if (state.failed && state.error) failedPlugins.add({
-      plugin: state.plugin,
-      error: state.error
-    });
-    await driver.hooks.emit("kubb:debug", {
-      date: /* @__PURE__ */ new Date(),
-      logs: [state.failed ? "\u2717 Plugin start failed" : `\u2713 Plugin started successfully (${formatMs(duration)})`]
-    });
-  }
-}
-async function runPluginAstHooks(plugin, context) {
-  var _a2, _b2, _c;
-  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. adapterOas()) 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;
-  }
-  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 = (_c = include == null ? void 0 : include.some(({ type }) => type === "schemaName")) != null ? _c : false;
-  const allowedSchemaNames = (() => {
-    if (!hasOperationBasedIncludes || hasSchemaNameIncludes) return void 0;
-    return 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
-      };
-      await Promise.all(generators.filter((gen) => gen.schema).map(async (gen) => {
-        return applyHookResult({
-          result: await gen.schema(transformedNode, ctx),
-          driver,
-          rendererFactory: 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
-      });
-      if (options === null) return;
-      collectedOperations.push(transformedNode);
-      const ctx = {
-        ...generatorContext,
-        options
-      };
-      await Promise.all(generators.filter((gen) => gen.operation).map(async (gen) => {
-        return applyHookResult({
-          result: await gen.operation(transformedNode, ctx),
-          driver,
-          rendererFactory: resolveRenderer(gen)
-        });
-      }));
-      await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
-    }
-  });
-  if (collectedOperations.length > 0) {
-    const ctx = {
-      ...generatorContext,
-      options: plugin.options
-    };
-    for (const gen of generators) {
-      if (!gen.operations) continue;
-      await applyHookResult({
-        result: await gen.operations(collectedOperations, ctx),
-        driver,
-        rendererFactory: resolveRenderer(gen)
-      });
-    }
-    await driver.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
   }
 }
 async function safeBuild(setupResult) {
-  var _a2, _b2, _c, _d;
+  var _a2;
   try {
     var _usingCtx$1 = _usingCtx();
     _usingCtx$1.u(setupResult);
@@ -6874,8 +6608,8 @@ async function safeBuild(setupResult) {
     const config = driver.config;
     const writtenPaths = /* @__PURE__ */ new Set();
     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();
+    for (const parser of config.parsers) if (parser.extNames) for (const extname of parser.extNames) parsersMap.set(extname, parser);
     async function flushPendingFiles() {
       const files = driver.fileManager.files.filter((f) => !writtenPaths.has(f.path));
       if (files.length === 0) return;
@@ -6888,119 +6622,236 @@ async function safeBuild(setupResult) {
         parsers: parsersMap,
         extension: config.output.extension
       });
+      const queue = [];
       for (const { file, source, processed, total, percentage } of stream) {
-        await hooks.emit("kubb:file:processing:update", {
-          file,
-          source,
-          processed,
-          total,
-          percentage,
-          config
-        });
-        if (source) await storage.setItem(file.path, source);
         writtenPaths.add(file.path);
+        queue.push((async () => {
+          await hooks.emit("kubb:file:processing:update", {
+            file,
+            source,
+            processed,
+            total,
+            percentage,
+            config
+          });
+          if (source) await storage.setItem(file.path, source);
+        })());
+        if (queue.length >= 50) await Promise.all(queue.splice(0));
       }
+      await Promise.all(queue);
       await hooks.emit("kubb:files:processing:end", { files });
       await hooks.emit("kubb:debug", {
         date: /* @__PURE__ */ new Date(),
         logs: [`\u2713 File write process completed for ${files.length} files`]
       });
     }
+    async function dispatchOperationsToGenerators(generators, collectedOperations, ctx, rendererFor) {
+      for (const gen of generators) {
+        if (!gen.operations) continue;
+        await applyHookResult({
+          result: await gen.operations(collectedOperations, ctx),
+          driver,
+          rendererFactory: rendererFor(gen)
+        });
+      }
+      await driver.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
+    }
+    async function runPlugins(entries) {
+      var _a3, _b;
+      const { schemas, operations } = driver.inputNode;
+      const operationFilterTypes = /* @__PURE__ */ new Set([
+        "tag",
+        "operationId",
+        "path",
+        "method",
+        "contentType"
+      ]);
+      const states = entries.map(({ plugin, context, hrStart }) => {
+        var _a4;
+        const { exclude, include, override } = plugin.options;
+        const hasExclude = Array.isArray(exclude) && exclude.length > 0;
+        const hasInclude = Array.isArray(include) && include.length > 0;
+        const hasOverride = Array.isArray(override) && override.length > 0;
+        return {
+          plugin,
+          generatorContext: {
+            ...context,
+            resolver: driver.getResolver(plugin.name)
+          },
+          generators: (_a4 = plugin.generators) != null ? _a4 : [],
+          hrStart,
+          failed: false,
+          error: void 0,
+          optionsAreStatic: !hasExclude && !hasInclude && !hasOverride,
+          allowedSchemaNames: void 0
+        };
+      });
+      const pruningStates = states.filter(({ plugin }) => {
+        var _a4, _b2;
+        const { include } = plugin.options;
+        return ((_a4 = include == null ? void 0 : include.some(({ type }) => operationFilterTypes.has(type))) != null ? _a4 : false) && !((_b2 = include == null ? void 0 : include.some(({ type }) => type === "schemaName")) != null ? _b2 : false);
+      });
+      if (pruningStates.length > 0) {
+        const allSchemas = [];
+        for await (const schema of schemas) allSchemas.push(schema);
+        const includedOpsByState = new Map(pruningStates.map((s) => [s, []]));
+        for await (const operation of operations) for (const state of pruningStates) {
+          const { exclude, include, override } = state.plugin.options;
+          if (state.generatorContext.resolver.resolveOptions(operation, {
+            options: state.plugin.options,
+            exclude,
+            include,
+            override
+          }) !== null) (_a3 = includedOpsByState.get(state)) == null ? void 0 : _a3.push(operation);
+        }
+        for (const state of pruningStates) state.allowedSchemaNames = collectUsedSchemaNames((_b = includedOpsByState.get(state)) != null ? _b : [], allSchemas);
+      }
+      function resolveRendererFor(gen, state) {
+        var _a4, _b2;
+        return gen.renderer === null ? void 0 : (_b2 = (_a4 = gen.renderer) != null ? _a4 : state.plugin.renderer) != null ? _b2 : state.generatorContext.config.renderer;
+      }
+      async function dispatchSchema(state, node) {
+        if (state.failed) return;
+        try {
+          const { plugin, generatorContext, generators } = state;
+          const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
+          if (state.allowedSchemaNames !== void 0 && transformedNode.name && !state.allowedSchemaNames.has(transformedNode.name)) return;
+          const { exclude, include, override } = plugin.options;
+          const options = state.optionsAreStatic ? plugin.options : generatorContext.resolver.resolveOptions(transformedNode, {
+            options: plugin.options,
+            exclude,
+            include,
+            override
+          });
+          if (options === null) return;
+          const ctx = {
+            ...generatorContext,
+            options
+          };
+          for (const gen of generators) {
+            if (!gen.schema) continue;
+            const raw = gen.schema(transformedNode, ctx);
+            const applied = applyHookResult({
+              result: isPromise(raw) ? await raw : raw,
+              driver,
+              rendererFactory: resolveRendererFor(gen, state)
+            });
+            if (isPromise(applied)) await applied;
+          }
+          await driver.hooks.emit("kubb:generate:schema", transformedNode, ctx);
+        } catch (caughtError) {
+          state.failed = true;
+          state.error = caughtError;
+        }
+      }
+      async function dispatchOperation(state, node) {
+        if (state.failed) return;
+        try {
+          const { plugin, generatorContext, generators } = state;
+          const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
+          const { exclude, include, override } = plugin.options;
+          const options = state.optionsAreStatic ? plugin.options : generatorContext.resolver.resolveOptions(transformedNode, {
+            options: plugin.options,
+            exclude,
+            include,
+            override
+          });
+          if (options === null) return;
+          const ctx = {
+            ...generatorContext,
+            options
+          };
+          for (const gen of generators) {
+            if (!gen.operation) continue;
+            const raw = gen.operation(transformedNode, ctx);
+            const applied = applyHookResult({
+              result: isPromise(raw) ? await raw : raw,
+              driver,
+              rendererFactory: resolveRendererFor(gen, state)
+            });
+            if (isPromise(applied)) await applied;
+          }
+          await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
+        } catch (caughtError) {
+          state.failed = true;
+          state.error = caughtError;
+        }
+      }
+      await forBatches(schemas, (nodes) => Promise.all(nodes.flatMap((n) => states.map((state) => dispatchSchema(state, n)))), {
+        concurrency: 8,
+        flush: flushPendingFiles
+      });
+      const collectedOperations = [];
+      await forBatches(operations, (nodes) => {
+        collectedOperations.push(...nodes);
+        return Promise.all(nodes.flatMap((n) => states.map((state) => dispatchOperation(state, n))));
+      }, {
+        concurrency: 8,
+        flush: flushPendingFiles
+      });
+      for (const state of states) {
+        if (!state.failed) try {
+          const { plugin, generatorContext, generators } = state;
+          await dispatchOperationsToGenerators(generators, collectedOperations, {
+            ...generatorContext,
+            options: plugin.options
+          }, (gen) => resolveRendererFor(gen, state));
+        } catch (caughtError) {
+          state.failed = true;
+          state.error = caughtError;
+        }
+        const duration = getElapsedMs(state.hrStart);
+        pluginTimings.set(state.plugin.name, duration);
+        await driver.hooks.emit("kubb:plugin:end", {
+          plugin: state.plugin,
+          duration,
+          success: !state.failed,
+          ...state.failed && state.error ? { error: state.error } : {},
+          config: driver.config,
+          get files() {
+            return driver.fileManager.files;
+          },
+          upsertFile: (...files) => driver.fileManager.upsert(...files)
+        });
+        if (state.failed && state.error) failedPlugins.add({
+          plugin: state.plugin,
+          error: state.error
+        });
+        await driver.hooks.emit("kubb:debug", {
+          date: /* @__PURE__ */ new Date(),
+          logs: [state.failed ? "\u2717 Plugin start failed" : `\u2713 Plugin started successfully (${formatMs(duration)})`]
+        });
+      }
+    }
     try {
       await driver.emitSetupHooks();
-      if (driver.adapter && (driver.inputNode || driver.inputStreamNode)) await hooks.emit("kubb:build:start", {
+      if (driver.adapter && driver.inputNode) await hooks.emit("kubb:build:start", {
         config,
         adapter: driver.adapter,
-        inputNode: (_b2 = driver.inputNode) != null ? _b2 : {
-          kind: "Input",
-          schemas: [],
-          operations: [],
-          meta: (_a2 = driver.inputStreamNode) == null ? void 0 : _a2.meta
-        },
+        meta: driver.inputNode.meta,
         getPlugin: driver.getPlugin.bind(driver),
         get files() {
           return driver.fileManager.files;
         },
         upsertFile: (...files2) => driver.fileManager.upsert(...files2)
       });
-      if (driver.inputStreamNode) {
-        const streamPluginEntries = [];
-        for (const plugin of driver.plugins.values()) {
-          const context = driver.getContext(plugin);
-          const hrStart = process.hrtime();
-          await hooks.emit("kubb:plugin:start", { plugin });
-          await hooks.emit("kubb:debug", {
-            date: /* @__PURE__ */ new Date(),
-            logs: ["Starting plugin...", `  \u2022 Plugin Name: ${plugin.name}`]
-          });
-          if (((_c = plugin.generators) == null ? void 0 : _c.length) || driver.hasRegisteredGenerators(plugin.name)) {
-            streamPluginEntries.push({
-              plugin,
-              context,
-              hrStart
-            });
-            continue;
-          }
-          const duration = getElapsedMs(hrStart);
-          pluginTimings.set(plugin.name, duration);
-          await hooks.emit("kubb:plugin:end", {
-            plugin,
-            duration,
-            success: true,
-            config,
-            get files() {
-              return driver.fileManager.files;
-            },
-            upsertFile: (...files2) => driver.fileManager.upsert(...files2)
-          });
-          await hooks.emit("kubb:debug", {
-            date: /* @__PURE__ */ new Date(),
-            logs: [`\u2713 Plugin started successfully (${formatMs(duration)})`]
-          });
-        }
-        if (streamPluginEntries.length > 0) {
-          await runPluginStreamHooks({
-            entries: streamPluginEntries,
-            driver,
-            pluginTimings,
-            failedPlugins
-          });
-          await flushPendingFiles();
-        }
-      } else for (const plugin of driver.plugins.values()) {
+      const generatorPlugins = [];
+      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 (((_d = plugin.generators) == null ? void 0 : _d.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)})`]
+            logs: ["Starting plugin...", `  \u2022 Plugin Name: ${plugin.name}`]
           });
         } catch (caughtError) {
           const error = caughtError;
-          const errorTimestamp = /* @__PURE__ */ new Date();
-          const duration = getElapsedMs(hrStart);
+          const duration2 = getElapsedMs(hrStart);
+          pluginTimings.set(plugin.name, duration2);
           await hooks.emit("kubb:plugin:end", {
             plugin,
-            duration,
+            duration: duration2,
             success: false,
             error,
             config,
@@ -7009,22 +6860,51 @@ async function safeBuild(setupResult) {
             },
             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
           });
+          continue;
+        }
+        if (((_a2 = plugin.generators) == null ? void 0 : _a2.length) || driver.hasEventGenerators(plugin.name)) {
+          generatorPlugins.push({
+            plugin,
+            context,
+            hrStart
+          });
+          continue;
         }
-        await flushPendingFiles();
+        const duration = getElapsedMs(hrStart);
+        pluginTimings.set(plugin.name, duration);
+        await hooks.emit("kubb:plugin:end", {
+          plugin,
+          duration,
+          success: true,
+          config,
+          get files() {
+            return driver.fileManager.files;
+          },
+          upsertFile: (...files2) => driver.fileManager.upsert(...files2)
+        });
+        await hooks.emit("kubb:debug", {
+          date: /* @__PURE__ */ new Date(),
+          logs: [`\u2713 Plugin started successfully (${formatMs(duration)})`]
+        });
+      }
+      if (generatorPlugins.length > 0) if (driver.inputNode) await withDrain(() => runPlugins(generatorPlugins), flushPendingFiles);
+      else for (const { plugin, hrStart } of generatorPlugins) {
+        const duration = getElapsedMs(hrStart);
+        pluginTimings.set(plugin.name, duration);
+        await hooks.emit("kubb:plugin:end", {
+          plugin,
+          duration,
+          success: true,
+          config,
+          get files() {
+            return driver.fileManager.files;
+          },
+          upsertFile: (...files2) => driver.fileManager.upsert(...files2)
+        });
       }
       await hooks.emit("kubb:plugins:end", {
         config,
@@ -7091,22 +6971,6 @@ function getDiagnosticInfo() {
 function isInputPath(config) {
   return typeof (config == null ? void 0 : config.input) === "object" && config.input !== null && "path" in config.input;
 }
-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)
-  };
-}
 function createKubb(userConfig, options = {}) {
   var _a2;
   const hooks = (_a2 = options.hooks) != null ? _a2 : new AsyncEventEmitter();
@@ -7172,7 +7036,7 @@ const memoryStorage = createStorage(() => {
   };
 });
 
-var version = "5.0.0-beta.19";
+var version = "5.0.0-beta.20";
 
 function isCommandMessage(msg) {
   return msg.type === "command";