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

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

@@ -18,7 +18,7 @@ import { deflateSync } from 'fflate';
 import { x } from 'tinyexec';
 import { access, rm, readFile as readFile$1, readdir as readdir$1, mkdir, writeFile as writeFile$1 } from 'node:fs/promises';
 import { styleText } from 'node:util';
-import { unrun } from 'unrun';
+import { createJiti } from 'jiti';
 import { mergeDeep } from 'remeda';
 import WebSocket from 'ws';
 
@@ -90,26 +90,26 @@ function destr(value, options = {}) {
   }
 }
 
-const HASH_RE$1 = /#/g;
-const AMPERSAND_RE$1 = /&/g;
-const SLASH_RE$1 = /\//g;
-const EQUAL_RE$1 = /=/g;
-const PLUS_RE$1 = /\+/g;
-const ENC_CARET_RE$1 = /%5e/gi;
-const ENC_BACKTICK_RE$1 = /%60/gi;
-const ENC_PIPE_RE$1 = /%7c/gi;
-const ENC_SPACE_RE$1 = /%20/gi;
+const HASH_RE = /#/g;
+const AMPERSAND_RE = /&/g;
+const SLASH_RE = /\//g;
+const EQUAL_RE = /=/g;
+const PLUS_RE = /\+/g;
+const ENC_CARET_RE = /%5e/gi;
+const ENC_BACKTICK_RE = /%60/gi;
+const ENC_PIPE_RE = /%7c/gi;
+const ENC_SPACE_RE = /%20/gi;
 const ENC_SLASH_RE = /%2f/gi;
-function encode$1(text) {
-  return encodeURI("" + text).replace(ENC_PIPE_RE$1, "|");
+function encode(text) {
+  return encodeURI("" + text).replace(ENC_PIPE_RE, "|");
 }
-function encodeQueryValue$1(input) {
-  return encode$1(typeof input === "string" ? input : JSON.stringify(input)).replace(PLUS_RE$1, "%2B").replace(ENC_SPACE_RE$1, "+").replace(HASH_RE$1, "%23").replace(AMPERSAND_RE$1, "%26").replace(ENC_BACKTICK_RE$1, "`").replace(ENC_CARET_RE$1, "^").replace(SLASH_RE$1, "%2F");
+function encodeQueryValue(input) {
+  return encode(typeof input === "string" ? input : JSON.stringify(input)).replace(PLUS_RE, "%2B").replace(ENC_SPACE_RE, "+").replace(HASH_RE, "%23").replace(AMPERSAND_RE, "%26").replace(ENC_BACKTICK_RE, "`").replace(ENC_CARET_RE, "^").replace(SLASH_RE, "%2F");
 }
-function encodeQueryKey$1(text) {
-  return encodeQueryValue$1(text).replace(EQUAL_RE$1, "%3D");
+function encodeQueryKey(text) {
+  return encodeQueryValue(text).replace(EQUAL_RE, "%3D");
 }
-function decode$1(text = "") {
+function decode(text = "") {
   try {
     return decodeURIComponent("" + text);
   } catch {
@@ -117,16 +117,16 @@ function decode$1(text = "") {
   }
 }
 function decodePath(text) {
-  return decode$1(text.replace(ENC_SLASH_RE, "%252F"));
+  return decode(text.replace(ENC_SLASH_RE, "%252F"));
 }
-function decodeQueryKey$1(text) {
-  return decode$1(text.replace(PLUS_RE$1, " "));
+function decodeQueryKey(text) {
+  return decode(text.replace(PLUS_RE, " "));
 }
-function decodeQueryValue$1(text) {
-  return decode$1(text.replace(PLUS_RE$1, " "));
+function decodeQueryValue(text) {
+  return decode(text.replace(PLUS_RE, " "));
 }
 
-function parseQuery$1(parametersString = "") {
+function parseQuery(parametersString = "") {
   const object = /* @__PURE__ */ Object.create(null);
   if (parametersString[0] === "?") {
     parametersString = parametersString.slice(1);
@@ -136,11 +136,11 @@ function parseQuery$1(parametersString = "") {
     if (s.length < 2) {
       continue;
     }
-    const key = decodeQueryKey$1(s[1]);
+    const key = decodeQueryKey(s[1]);
     if (key === "__proto__" || key === "constructor") {
       continue;
     }
-    const value = decodeQueryValue$1(s[2] || "");
+    const value = decodeQueryValue(s[2] || "");
     if (object[key] === void 0) {
       object[key] = value;
     } else if (Array.isArray(object[key])) {
@@ -151,48 +151,48 @@ function parseQuery$1(parametersString = "") {
   }
   return object;
 }
-function encodeQueryItem$1(key, value) {
+function encodeQueryItem(key, value) {
   if (typeof value === "number" || typeof value === "boolean") {
     value = String(value);
   }
   if (!value) {
-    return encodeQueryKey$1(key);
+    return encodeQueryKey(key);
   }
   if (Array.isArray(value)) {
     return value.map(
-      (_value) => `${encodeQueryKey$1(key)}=${encodeQueryValue$1(_value)}`
+      (_value) => `${encodeQueryKey(key)}=${encodeQueryValue(_value)}`
     ).join("&");
   }
-  return `${encodeQueryKey$1(key)}=${encodeQueryValue$1(value)}`;
+  return `${encodeQueryKey(key)}=${encodeQueryValue(value)}`;
 }
-function stringifyQuery$1(query) {
-  return Object.keys(query).filter((k) => query[k] !== void 0).map((k) => encodeQueryItem$1(k, query[k])).filter(Boolean).join("&");
+function stringifyQuery(query) {
+  return Object.keys(query).filter((k) => query[k] !== void 0).map((k) => encodeQueryItem(k, query[k])).filter(Boolean).join("&");
 }
 
-const PROTOCOL_STRICT_REGEX$1 = /^[\s\w\0+.-]{2,}:([/\\]{1,2})/;
-const PROTOCOL_REGEX$1 = /^[\s\w\0+.-]{2,}:([/\\]{2})?/;
-const PROTOCOL_RELATIVE_REGEX$1 = /^([/\\]\s*){2,}[^/\\]/;
-const JOIN_LEADING_SLASH_RE$1 = /^\.?\//;
-function hasProtocol$1(inputString, opts = {}) {
+const PROTOCOL_STRICT_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{1,2})/;
+const PROTOCOL_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{2})?/;
+const PROTOCOL_RELATIVE_REGEX = /^([/\\]\s*){2,}[^/\\]/;
+const JOIN_LEADING_SLASH_RE = /^\.?\//;
+function hasProtocol(inputString, opts = {}) {
   if (typeof opts === "boolean") {
     opts = { acceptRelative: opts };
   }
   if (opts.strict) {
-    return PROTOCOL_STRICT_REGEX$1.test(inputString);
+    return PROTOCOL_STRICT_REGEX.test(inputString);
   }
-  return PROTOCOL_REGEX$1.test(inputString) || (opts.acceptRelative ? PROTOCOL_RELATIVE_REGEX$1.test(inputString) : false);
+  return PROTOCOL_REGEX.test(inputString) || (opts.acceptRelative ? PROTOCOL_RELATIVE_REGEX.test(inputString) : false);
 }
-function hasTrailingSlash$1(input = "", respectQueryAndFragment) {
+function hasTrailingSlash(input = "", respectQueryAndFragment) {
   {
     return input.endsWith("/");
   }
 }
-function withoutTrailingSlash$1(input = "", respectQueryAndFragment) {
+function withoutTrailingSlash(input = "", respectQueryAndFragment) {
   {
-    return (hasTrailingSlash$1(input) ? input.slice(0, -1) : input) || "/";
+    return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || "/";
   }
 }
-function withTrailingSlash$1(input = "", respectQueryAndFragment) {
+function withTrailingSlash(input = "", respectQueryAndFragment) {
   {
     return input.endsWith("/") ? input : input + "/";
   }
@@ -204,36 +204,54 @@ function withLeadingSlash(input = "") {
   return hasLeadingSlash(input) ? input : "/" + input;
 }
 function withBase(input, base) {
-  if (isEmptyURL$1(base) || hasProtocol$1(input)) {
+  if (isEmptyURL(base) || hasProtocol(input)) {
     return input;
   }
-  const _base = withoutTrailingSlash$1(base);
+  const _base = withoutTrailingSlash(base);
   if (input.startsWith(_base)) {
     const nextChar = input[_base.length];
     if (!nextChar || nextChar === "/" || nextChar === "?") {
       return input;
     }
   }
-  return joinURL$1(_base, input);
+  return joinURL(_base, input);
+}
+function withoutBase(input, base) {
+  if (isEmptyURL(base)) {
+    return input;
+  }
+  const _base = withoutTrailingSlash(base);
+  if (!input.startsWith(_base)) {
+    return input;
+  }
+  const nextChar = input[_base.length];
+  if (nextChar && nextChar !== "/" && nextChar !== "?") {
+    return input;
+  }
+  const trimmed = input.slice(_base.length).replace(/^\/+/, "");
+  return "/" + trimmed;
 }
-function withQuery$1(input, query) {
-  const parsed = parseURL$1(input);
-  const mergedQuery = { ...parseQuery$1(parsed.search), ...query };
-  parsed.search = stringifyQuery$1(mergedQuery);
-  return stringifyParsedURL$1(parsed);
+function withQuery(input, query) {
+  const parsed = parseURL(input);
+  const mergedQuery = { ...parseQuery(parsed.search), ...query };
+  parsed.search = stringifyQuery(mergedQuery);
+  return stringifyParsedURL(parsed);
+}
+function getQuery(input) {
+  return parseQuery(parseURL(input).search);
 }
-function isEmptyURL$1(url) {
+function isEmptyURL(url) {
   return !url || url === "/";
 }
-function isNonEmptyURL$1(url) {
+function isNonEmptyURL(url) {
   return url && url !== "/";
 }
-function joinURL$1(base, ...input) {
+function joinURL(base, ...input) {
   let url = base || "";
-  for (const segment of input.filter((url2) => isNonEmptyURL$1(url2))) {
+  for (const segment of input.filter((url2) => isNonEmptyURL(url2))) {
     if (url) {
-      const _segment = segment.replace(JOIN_LEADING_SLASH_RE$1, "");
-      url = withTrailingSlash$1(url) + _segment;
+      const _segment = segment.replace(JOIN_LEADING_SLASH_RE, "");
+      url = withTrailingSlash(url) + _segment;
     } else {
       url = segment;
     }
@@ -241,8 +259,8 @@ function joinURL$1(base, ...input) {
   return url;
 }
 
-const protocolRelative$1 = Symbol.for("ufo:protocolRelative");
-function parseURL$1(input = "", defaultProto) {
+const protocolRelative = Symbol.for("ufo:protocolRelative");
+function parseURL(input = "", defaultProto) {
   const _specialProtoMatch = input.match(
     /^[\s\0]*(blob:|data:|javascript:|vbscript:)(.*)/i
   );
@@ -258,15 +276,15 @@ function parseURL$1(input = "", defaultProto) {
       hash: ""
     };
   }
-  if (!hasProtocol$1(input, { acceptRelative: true })) {
-    return parsePath$1(input);
+  if (!hasProtocol(input, { acceptRelative: true })) {
+    return parsePath(input);
   }
   const [, protocol = "", auth, hostAndPath = ""] = input.replace(/\\/g, "/").match(/^[\s\0]*([\w+.-]{2,}:)?\/\/([^/@]+@)?(.*)/) || [];
   let [, host = "", path = ""] = hostAndPath.match(/([^#/?]*)(.*)?/) || [];
   if (protocol === "file:") {
     path = path.replace(/\/(?=[A-Za-z]:)/, "");
   }
-  const { pathname, search, hash } = parsePath$1(path);
+  const { pathname, search, hash } = parsePath(path);
   return {
     protocol: protocol.toLowerCase(),
     auth: auth ? auth.slice(0, Math.max(0, auth.length - 1)) : "",
@@ -274,10 +292,10 @@ function parseURL$1(input = "", defaultProto) {
     pathname,
     search,
     hash,
-    [protocolRelative$1]: !protocol
+    [protocolRelative]: !protocol
   };
 }
-function parsePath$1(input = "") {
+function parsePath(input = "") {
   const [pathname = "", search = "", hash = ""] = (input.match(/([^#?]*)(\?[^#]*)?(#.*)?/) || []).splice(1);
   return {
     pathname,
@@ -285,13 +303,13 @@ function parsePath$1(input = "") {
     hash
   };
 }
-function stringifyParsedURL$1(parsed) {
+function stringifyParsedURL(parsed) {
   const pathname = parsed.pathname || "";
   const search = parsed.search ? (parsed.search.startsWith("?") ? "" : "?") + parsed.search : "";
   const hash = parsed.hash || "";
   const auth = parsed.auth ? parsed.auth + "@" : "";
   const host = parsed.host || "";
-  const proto = parsed.protocol || parsed[protocolRelative$1] ? (parsed.protocol || "") + "//" : "";
+  const proto = parsed.protocol || parsed[protocolRelative] ? (parsed.protocol || "") + "//" : "";
   return proto + auth + host + pathname + search + hash;
 }
 
@@ -1591,7 +1609,7 @@ function createResolver(stack) {
         res = {
           ...res,
           ..._res,
-          route: joinURL$1(res.route || "/", _res.route || "/")
+          route: joinURL(res.route || "/", _res.route || "/")
         };
       }
       return res;
@@ -1609,7 +1627,7 @@ function normalizeLayer(input) {
     handler = toEventHandler(handler, void 0, input.route);
   }
   return {
-    route: withoutTrailingSlash$1(input.route),
+    route: withoutTrailingSlash(input.route),
     match: input.match,
     handler
   };
@@ -1676,7 +1694,7 @@ function websocketOptions(evResolver, appOptions) {
     ...appOptions.websocket,
     async resolve(info) {
       const url = info.request?.url || info.url || "/";
-      const { pathname } = typeof url === "string" ? parseURL$1(url) : url;
+      const { pathname } = typeof url === "string" ? parseURL(url) : url;
       const resolved = await evResolver(pathname);
       return resolved?.handler?.__websocket__ || {};
     }
@@ -2268,7 +2286,7 @@ function createFetch(globalOptions = {}) {
         context.request = withBase(context.request, context.options.baseURL);
       }
       if (context.options.query) {
-        context.request = withQuery$1(context.request, context.options.query);
+        context.request = withQuery(context.request, context.options.query);
         delete context.options.query;
       }
       if ("query" in context.options) {
@@ -2413,269 +2431,69 @@ const Headers$1 = globalThis.Headers || s$1;
 const AbortController = globalThis.AbortController || i;
 createFetch({ fetch, Headers: Headers$1, AbortController });
 
-const HASH_RE = /#/g;
-const AMPERSAND_RE = /&/g;
-const SLASH_RE = /\//g;
-const EQUAL_RE = /=/g;
-const PLUS_RE = /\+/g;
-const ENC_CARET_RE = /%5e/gi;
-const ENC_BACKTICK_RE = /%60/gi;
-const ENC_PIPE_RE = /%7c/gi;
-const ENC_SPACE_RE = /%20/gi;
-function encode(text) {
-  return encodeURI("" + text).replace(ENC_PIPE_RE, "|");
-}
-function encodeQueryValue(input) {
-  return encode(typeof input === "string" ? input : JSON.stringify(input)).replace(PLUS_RE, "%2B").replace(ENC_SPACE_RE, "+").replace(HASH_RE, "%23").replace(AMPERSAND_RE, "%26").replace(ENC_BACKTICK_RE, "`").replace(ENC_CARET_RE, "^").replace(SLASH_RE, "%2F");
-}
-function encodeQueryKey(text) {
-  return encodeQueryValue(text).replace(EQUAL_RE, "%3D");
+function wrapToPromise(value) {
+  if (!value || typeof value.then !== "function") {
+    return Promise.resolve(value);
+  }
+  return value;
 }
-function decode(text = "") {
+function asyncCall(function_, ...arguments_) {
   try {
-    return decodeURIComponent("" + text);
-  } catch {
-    return "" + text;
+    return wrapToPromise(function_(...arguments_));
+  } catch (error) {
+    return Promise.reject(error);
   }
 }
-function decodeQueryKey(text) {
-  return decode(text.replace(PLUS_RE, " "));
-}
-function decodeQueryValue(text) {
-  return decode(text.replace(PLUS_RE, " "));
+function isPrimitive(value) {
+  const type = typeof value;
+  return value === null || type !== "object" && type !== "function";
 }
-
-function parseQuery(parametersString = "") {
-  const object = /* @__PURE__ */ Object.create(null);
-  if (parametersString[0] === "?") {
-    parametersString = parametersString.slice(1);
-  }
-  for (const parameter of parametersString.split("&")) {
-    const s = parameter.match(/([^=]+)=?(.*)/) || [];
-    if (s.length < 2) {
-      continue;
-    }
-    const key = decodeQueryKey(s[1]);
-    if (key === "__proto__" || key === "constructor") {
-      continue;
-    }
-    const value = decodeQueryValue(s[2] || "");
-    if (object[key] === void 0) {
-      object[key] = value;
-    } else if (Array.isArray(object[key])) {
-      object[key].push(value);
-    } else {
-      object[key] = [object[key], value];
-    }
-  }
-  return object;
+function isPureObject(value) {
+  const proto = Object.getPrototypeOf(value);
+  return !proto || proto.isPrototypeOf(Object);
 }
-function encodeQueryItem(key, value) {
-  if (typeof value === "number" || typeof value === "boolean") {
-    value = String(value);
-  }
-  if (!value) {
-    return encodeQueryKey(key);
-  }
-  if (Array.isArray(value)) {
-    return value.map(
-      (_value) => `${encodeQueryKey(key)}=${encodeQueryValue(_value)}`
-    ).join("&");
+function stringify(value) {
+  if (isPrimitive(value)) {
+    return String(value);
   }
-  return `${encodeQueryKey(key)}=${encodeQueryValue(value)}`;
-}
-function stringifyQuery(query) {
-  return Object.keys(query).filter((k) => query[k] !== void 0).map((k) => encodeQueryItem(k, query[k])).filter(Boolean).join("&");
-}
-
-const PROTOCOL_STRICT_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{1,2})/;
-const PROTOCOL_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{2})?/;
-const PROTOCOL_RELATIVE_REGEX = /^([/\\]\s*){2,}[^/\\]/;
-const JOIN_LEADING_SLASH_RE = /^\.?\//;
-function hasProtocol(inputString, opts = {}) {
-  if (typeof opts === "boolean") {
-    opts = { acceptRelative: opts };
+  if (isPureObject(value) || Array.isArray(value)) {
+    return JSON.stringify(value);
   }
-  if (opts.strict) {
-    return PROTOCOL_STRICT_REGEX.test(inputString);
+  if (typeof value.toJSON === "function") {
+    return stringify(value.toJSON());
   }
-  return PROTOCOL_REGEX.test(inputString) || (opts.acceptRelative ? PROTOCOL_RELATIVE_REGEX.test(inputString) : false);
+  throw new Error("[unstorage] Cannot stringify value!");
 }
-function hasTrailingSlash(input = "", respectQueryAndFragment) {
-  {
-    return input.endsWith("/");
+const BASE64_PREFIX = "base64:";
+function serializeRaw(value) {
+  if (typeof value === "string") {
+    return value;
   }
+  return BASE64_PREFIX + base64Encode(value);
 }
-function withoutTrailingSlash(input = "", respectQueryAndFragment) {
-  {
-    return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || "/";
+function deserializeRaw(value) {
+  if (typeof value !== "string") {
+    return value;
   }
-}
-function withTrailingSlash(input = "", respectQueryAndFragment) {
-  {
-    return input.endsWith("/") ? input : input + "/";
+  if (!value.startsWith(BASE64_PREFIX)) {
+    return value;
   }
+  return base64Decode(value.slice(BASE64_PREFIX.length));
 }
-function withoutBase(input, base) {
-  if (isEmptyURL(base)) {
-    return input;
-  }
-  const _base = withoutTrailingSlash(base);
-  if (!input.startsWith(_base)) {
-    return input;
-  }
-  const nextChar = input[_base.length];
-  if (nextChar && nextChar !== "/" && nextChar !== "?") {
-    return input;
+function base64Decode(input) {
+  if (globalThis.Buffer) {
+    return Buffer.from(input, "base64");
   }
-  const trimmed = input.slice(_base.length).replace(/^\/+/, "");
-  return "/" + trimmed;
-}
-function withQuery(input, query) {
-  const parsed = parseURL(input);
-  const mergedQuery = { ...parseQuery(parsed.search), ...query };
-  parsed.search = stringifyQuery(mergedQuery);
-  return stringifyParsedURL(parsed);
-}
-function getQuery(input) {
-  return parseQuery(parseURL(input).search);
-}
-function isEmptyURL(url) {
-  return !url || url === "/";
-}
-function isNonEmptyURL(url) {
-  return url && url !== "/";
+  return Uint8Array.from(
+    globalThis.atob(input),
+    (c) => c.codePointAt(0)
+  );
 }
-function joinURL(base, ...input) {
-  let url = base || "";
-  for (const segment of input.filter((url2) => isNonEmptyURL(url2))) {
-    if (url) {
-      const _segment = segment.replace(JOIN_LEADING_SLASH_RE, "");
-      url = withTrailingSlash(url) + _segment;
-    } else {
-      url = segment;
-    }
+function base64Encode(input) {
+  if (globalThis.Buffer) {
+    return Buffer.from(input).toString("base64");
   }
-  return url;
-}
-
-const protocolRelative = Symbol.for("ufo:protocolRelative");
-function parseURL(input = "", defaultProto) {
-  const _specialProtoMatch = input.match(
-    /^[\s\0]*(blob:|data:|javascript:|vbscript:)(.*)/i
-  );
-  if (_specialProtoMatch) {
-    const [, _proto, _pathname = ""] = _specialProtoMatch;
-    return {
-      protocol: _proto.toLowerCase(),
-      pathname: _pathname,
-      href: _proto + _pathname,
-      auth: "",
-      host: "",
-      search: "",
-      hash: ""
-    };
-  }
-  if (!hasProtocol(input, { acceptRelative: true })) {
-    return defaultProto ? parseURL(defaultProto + input) : parsePath(input);
-  }
-  const [, protocol = "", auth, hostAndPath = ""] = input.replace(/\\/g, "/").match(/^[\s\0]*([\w+.-]{2,}:)?\/\/([^/@]+@)?(.*)/) || [];
-  let [, host = "", path = ""] = hostAndPath.match(/([^#/?]*)(.*)?/) || [];
-  if (protocol === "file:") {
-    path = path.replace(/\/(?=[A-Za-z]:)/, "");
-  }
-  const { pathname, search, hash } = parsePath(path);
-  return {
-    protocol: protocol.toLowerCase(),
-    auth: auth ? auth.slice(0, Math.max(0, auth.length - 1)) : "",
-    host,
-    pathname,
-    search,
-    hash,
-    [protocolRelative]: !protocol
-  };
-}
-function parsePath(input = "") {
-  const [pathname = "", search = "", hash = ""] = (input.match(/([^#?]*)(\?[^#]*)?(#.*)?/) || []).splice(1);
-  return {
-    pathname,
-    search,
-    hash
-  };
-}
-function stringifyParsedURL(parsed) {
-  const pathname = parsed.pathname || "";
-  const search = parsed.search ? (parsed.search.startsWith("?") ? "" : "?") + parsed.search : "";
-  const hash = parsed.hash || "";
-  const auth = parsed.auth ? parsed.auth + "@" : "";
-  const host = parsed.host || "";
-  const proto = parsed.protocol || parsed[protocolRelative] ? (parsed.protocol || "") + "//" : "";
-  return proto + auth + host + pathname + search + hash;
-}
-
-function wrapToPromise(value) {
-  if (!value || typeof value.then !== "function") {
-    return Promise.resolve(value);
-  }
-  return value;
-}
-function asyncCall(function_, ...arguments_) {
-  try {
-    return wrapToPromise(function_(...arguments_));
-  } catch (error) {
-    return Promise.reject(error);
-  }
-}
-function isPrimitive(value) {
-  const type = typeof value;
-  return value === null || type !== "object" && type !== "function";
-}
-function isPureObject(value) {
-  const proto = Object.getPrototypeOf(value);
-  return !proto || proto.isPrototypeOf(Object);
-}
-function stringify(value) {
-  if (isPrimitive(value)) {
-    return String(value);
-  }
-  if (isPureObject(value) || Array.isArray(value)) {
-    return JSON.stringify(value);
-  }
-  if (typeof value.toJSON === "function") {
-    return stringify(value.toJSON());
-  }
-  throw new Error("[unstorage] Cannot stringify value!");
-}
-const BASE64_PREFIX = "base64:";
-function serializeRaw(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  return BASE64_PREFIX + base64Encode(value);
-}
-function deserializeRaw(value) {
-  if (typeof value !== "string") {
-    return value;
-  }
-  if (!value.startsWith(BASE64_PREFIX)) {
-    return value;
-  }
-  return base64Decode(value.slice(BASE64_PREFIX.length));
-}
-function base64Decode(input) {
-  if (globalThis.Buffer) {
-    return Buffer.from(input, "base64");
-  }
-  return Uint8Array.from(
-    globalThis.atob(input),
-    (c) => c.codePointAt(0)
-  );
-}
-function base64Encode(input) {
-  if (globalThis.Buffer) {
-    return Buffer.from(input).toString("base64");
-  }
-  return globalThis.btoa(String.fromCodePoint(...input));
+  return globalThis.btoa(String.fromCodePoint(...input));
 }
 
 const storageKeyProperties = [
@@ -4608,12 +4426,17 @@ function sendToBetterStack(level, tag, message, ctx) {
     const fullMessage = message !== void 0 ? `[${tag}] ${message}` : tag;
     const context = toBetterStackContext(ctx);
     if (level === "error") {
-      client.error(fullMessage, context).then(() => client.flush());
-    } else if (level === "warn") {
-      client.warn(fullMessage, context).then(() => client.flush());
-    } else {
-      client.info(fullMessage, context).then(() => client.flush());
+      client.error(fullMessage, context).then(() => client.flush()).catch(() => {
+      });
+      return;
+    }
+    if (level === "warn") {
+      client.warn(fullMessage, context).then(() => client.flush()).catch(() => {
+      });
+      return;
     }
+    client.info(fullMessage, context).then(() => client.flush()).catch(() => {
+    });
   } catch (_e) {
   }
 }
@@ -4887,15 +4710,17 @@ async function disconnect({ sessionId, token, studioUrl }) {
   }
 }
 
-var __defProp$2 = Object.defineProperty;
-var __name = (target, value) => __defProp$2(target, "name", {
-  value,
-  configurable: true
-});
-
 const visitorDepths = {
   deep: "deep"
 };
+function memoize$1(store, factory) {
+  return (key) => {
+    if (store.has(key)) return store.get(key);
+    const value = factory(key);
+    store.set(key, value);
+    return value;
+  };
+}
 function trimExtName(text) {
   const dotIndex = text.lastIndexOf(".");
   if (dotIndex > 0 && !text.includes("/", dotIndex)) return text.slice(0, dotIndex);
@@ -4910,235 +4735,136 @@ 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()();
-    }
+function* getChildren(node, recurse) {
+  var _a;
+  if (node.kind === "Input") {
+    yield* node.schemas;
+    yield* node.operations;
+    return;
   }
-  return function limit(fn) {
-    return new Promise((resolve, reject) => {
-      queue.push(() => {
-        Promise.resolve(fn()).then(resolve, reject).finally(() => {
-          active--;
-          next();
-        });
-      });
-      next();
-    });
-  };
-}
-function getChildren(node, recurse) {
-  var _a, _b, _c;
-  switch (node.kind) {
-    case "Input":
-      return [...node.schemas, ...node.operations];
-    case "Output":
-      return [];
-    case "Operation":
-      return [
-        ...node.parameters,
-        ...(_c = (_b = (_a = node.requestBody) == null ? void 0 : _a.content) == null ? void 0 : _b.flatMap((c) => c.schema ? [c.schema] : [])) != null ? _c : [],
-        ...node.responses
-      ];
-    case "Schema": {
-      const children = [];
-      if (!recurse) return [];
-      if ("properties" in node && node.properties.length > 0) children.push(...node.properties);
-      if ("items" in node && node.items) children.push(...node.items);
-      if ("members" in node && node.members) children.push(...node.members);
-      if ("additionalProperties" in node && node.additionalProperties && node.additionalProperties !== true) children.push(node.additionalProperties);
-      return children;
+  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;
     }
-    case "Property":
-      return [node.schema];
-    case "Parameter":
-      return [node.schema];
-    case "Response":
-      return node.schema ? [node.schema] : [];
-    case "FunctionParameter":
-    case "ParameterGroup":
-    case "FunctionParameters":
-    case "Type":
-      return [];
-    default:
-      return [];
+    yield* node.responses;
+    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 === "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;
+  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": {
-      let input = node;
-      const replaced = (_a = visitor.input) == null ? void 0 : _a.call(visitor, input, { parent });
-      if (replaced) input = replaced;
-      return {
-        ...input,
-        schemas: input.schemas.map((s) => transform(s, {
-          ...options,
-          parent: input
-        })),
-        operations: input.operations.map((op) => transform(op, {
-          ...options,
-          parent: input
-        }))
-      };
-    }
-    case "Output": {
-      let output = node;
-      const replaced = (_b = visitor.output) == null ? void 0 : _b.call(visitor, output, { parent });
-      if (replaced) output = replaced;
-      return output;
-    }
-    case "Operation": {
-      let op = node;
-      const replaced = (_c = visitor.operation) == null ? void 0 : _c.call(visitor, op, { parent });
-      if (replaced) op = replaced;
-      return {
-        ...op,
-        parameters: op.parameters.map((p) => transform(p, {
-          ...options,
-          parent: op
-        })),
-        requestBody: op.requestBody ? {
-          ...op.requestBody,
-          content: (_d = op.requestBody.content) == null ? void 0 : _d.map((c) => ({
-            ...c,
-            schema: c.schema ? transform(c.schema, {
-              ...options,
-              parent: op
-            }) : void 0
-          }))
-        } : void 0,
-        responses: op.responses.map((r) => transform(r, {
-          ...options,
-          parent: op
+  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": {
-      let schema = node;
-      const replaced = (_e = visitor.schema) == null ? void 0 : _e.call(visitor, schema, { parent });
-      if (replaced) schema = replaced;
-      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: (_f = schema.items) == null ? void 0 : _f.map((i) => transform(i, childOptions)) } : {},
-        ..."members" in schema && recurse ? { members: (_g = schema.members) == null ? void 0 : _g.map((m) => transform(m, childOptions)) } : {},
-        ..."additionalProperties" in schema && recurse && schema.additionalProperties && schema.additionalProperties !== true ? { additionalProperties: transform(schema.additionalProperties, childOptions) } : {}
-      };
-    }
-    case "Property": {
-      let prop = node;
-      const replaced = (_h = visitor.property) == null ? void 0 : _h.call(visitor, prop, { parent });
-      if (replaced) prop = replaced;
-      return createProperty({
-        ...prop,
-        schema: transform(prop.schema, {
-          ...options,
-          parent: prop
-        })
-      });
-    }
-    case "Parameter": {
-      let param = node;
-      const replaced = (_i = visitor.parameter) == null ? void 0 : _i.call(visitor, param, { parent });
-      if (replaced) param = replaced;
-      return createParameter({
-        ...param,
-        schema: transform(param.schema, {
-          ...options,
-          parent: param
-        })
-      });
-    }
-    case "Response": {
-      let response = node;
-      const replaced = (_j = visitor.response) == null ? void 0 : _j.call(visitor, response, { parent });
-      if (replaced) response = replaced;
-      return {
-        ...response,
-        schema: transform(response.schema, {
-          ...options,
-          parent: response
-        })
-      };
-    }
-    case "FunctionParameter":
-    case "ParameterGroup":
-    case "FunctionParameters":
-    case "Type":
-      return node;
-    default:
-      return node;
+        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 collect(node, options) {
+function* collectLazy(node, options) {
   var _a, _b, _c, _d, _e, _f, _g;
   const { depth, parent, ...visitor } = options;
   const recurse = (depth != null ? depth : visitorDepths.deep) === visitorDepths.deep;
-  const results = [];
   let v;
   switch (node.kind) {
     case "Input":
@@ -5163,12 +4889,14 @@ function collect(node, options) {
       v = (_g = visitor.response) == null ? void 0 : _g.call(visitor, node, { parent });
       break;
   }
-  if (v !== void 0) results.push(v);
-  for (const child of getChildren(node, recurse)) for (const item of collect(child, {
+  if (v !== void 0) yield v;
+  for (const child of getChildren(node, recurse)) yield* collectLazy(child, {
     ...options,
     parent: node
-  })) results.push(item);
-  return results;
+  });
+}
+function collect(node, options) {
+  return Array.from(collectLazy(node, options));
 }
 function sourceKey(source) {
   var _a, _b, _c;
@@ -5199,11 +4927,11 @@ function combineSources(sources) {
   }
   return [...seen.values()];
 }
-function combineExports(exports$1) {
+function combineExports(exports) {
   const result = [];
   const namedByPath = /* @__PURE__ */ new Map();
   const seen = /* @__PURE__ */ new Set();
-  const keyed = exports$1.map((node) => ({
+  const keyed = exports.map((node) => ({
     node,
     key: sortKey(node)
   }));
@@ -5236,9 +4964,17 @@ function combineExports(exports$1) {
   }
   return result;
 }
-function combineImports(imports, exports$1, source) {
-  const exportedNames = new Set(exports$1.flatMap((e) => Array.isArray(e.name) ? e.name : e.name ? [e.name] : []));
+function combineImports(imports, exports, source) {
+  const exportedNames = new Set(exports.flatMap((e) => Array.isArray(e.name) ? e.name : e.name ? [e.name] : []));
   const isUsed = (importName) => !source || source.includes(importName) || exportedNames.has(importName);
+  const importNameMemo = /* @__PURE__ */ new Map();
+  const canonicalizeName = (n) => {
+    var _a;
+    if (typeof n === "string") return n;
+    const key = `${n.propertyName}:${(_a = n.name) != null ? _a : ""}`;
+    if (!importNameMemo.has(key)) importNameMemo.set(key, n);
+    return importNameMemo.get(key);
+  };
   const result = [];
   const namedByPath = /* @__PURE__ */ new Map();
   const seen = /* @__PURE__ */ new Set();
@@ -5252,7 +4988,7 @@ function combineImports(imports, exports$1, source) {
     const { path: path2, isTypeOnly } = curr;
     let { name } = curr;
     if (Array.isArray(name)) {
-      name = [...new Set(name)].filter((item) => {
+      name = [...new Set(name.map(canonicalizeName))].filter((item) => {
         var _a;
         return typeof item === "string" ? isUsed(item) : isUsed((_a = item.name) != null ? _a : item.propertyName);
       });
@@ -5305,17 +5041,23 @@ 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;
 }
-function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
-  if (!node) return out;
+const collectSchemaRefs = memoize$1(/* @__PURE__ */ new WeakMap(), (node) => {
+  const refs = /* @__PURE__ */ new Set();
   collect(node, { schema(child) {
     if (child.type === "ref") {
       const name = resolveRefName(child);
-      if (name) out.add(name);
+      if (name) refs.add(name);
     }
   } });
+  return refs;
+});
+function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
+  if (!node) return out;
+  for (const name of collectSchemaRefs(node)) out.add(name);
   return out;
 }
-function collectUsedSchemaNames(operations, schemas) {
+const collectUsedSchemaNamesMemo = memoize$1(/* @__PURE__ */ new WeakMap(), (ops) => memoize$1(/* @__PURE__ */ new WeakMap(), (schemas) => computeUsedSchemaNames(ops, schemas)));
+function computeUsedSchemaNames(operations, schemas) {
   const schemaMap = /* @__PURE__ */ new Map();
   for (const schema of schemas) if (schema.name) schemaMap.set(schema.name, schema);
   const result = /* @__PURE__ */ new Set();
@@ -5327,12 +5069,15 @@ function collectUsedSchemaNames(operations, schemas) {
       if (namedSchema) visitSchema(namedSchema);
     }
   }
-  for (const op of operations) for (const schema of collect(op, {
+  for (const op of operations) for (const schema of collectLazy(op, {
     depth: "shallow",
     schema: (node) => node
   })) visitSchema(schema);
   return result;
 }
+function collectUsedSchemaNames(operations, schemas) {
+  return collectUsedSchemaNamesMemo(operations)(schemas);
+}
 function syncOptionality(schema, required) {
   var _a;
   const nullable = (_a = schema.nullable) != null ? _a : false;
@@ -5342,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;
@@ -5395,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;
@@ -5423,53 +5176,314 @@ function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
   }) : camelCase(part));
   return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
-const DEFAULT_STUDIO_URL = "https://studio.kubb.dev";
-const DEFAULT_BANNER = "simple";
-const DEFAULT_EXTENSION = { ".ts": ".ts" };
-const stringPatternCache = /* @__PURE__ */ new Map();
-function testPattern(value, pattern) {
-  if (typeof pattern === "string") {
-    let regex = stringPatternCache.get(pattern);
-    if (!regex) {
-      regex = new RegExp(pattern);
-      stringPatternCache.set(pattern, regex);
+function* chunks(arr, size) {
+  for (let i = 0; i < arr.length; i += size) yield arr.slice(i, i + size);
+}
+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;
+  }
+  const batch = [];
+  for await (const item of source) {
+    batch.push(item);
+    if (batch.length >= concurrency) {
+      await process2(batch.splice(0));
+      if (flush) await flush();
+    }
+  }
+  if (batch.length > 0) {
+    await process2(batch.splice(0));
+    if (flush) await flush();
+  }
+}
+async function withDrain(work, flush) {
+  await work(flush);
+  await flush();
+}
+function isPromise(result) {
+  return result !== null && result !== void 0 && typeof result["then"] === "function";
+}
+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;
+    })();
+  } };
+}
+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, _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;
-  }
+  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) {
-  switch (type) {
-    case "schemaName":
-      return node.name ? testPattern(node.name, pattern) : false;
-    default:
-      return null;
-  }
+  if (type === "schemaName") return node.name ? testPattern(node.name, pattern) : false;
+  return null;
 }
 function defaultResolver(name, type) {
-  let resolvedName = camelCase(name);
-  if (type === "file" || type === "function") resolvedName = camelCase(name, { isFile: type === "file" });
-  if (type === "type") resolvedName = pascalCase(name);
-  return resolvedName;
+  if (type === "file" || type === "function") return camelCase(name, { isFile: type === "file" });
+  if (type === "type") return pascalCase(name);
+  return camelCase(name);
 }
-function defaultResolveOptions(node, { options, exclude = [], include, override = [] }) {
+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;
@@ -5494,28 +5508,43 @@ function defaultResolveOptions(node, { options, exclude = [], include, override
   }
   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 }) {
-  var _a2;
-  if ((pathMode != null ? pathMode : PluginDriver.getMode(path$1.resolve(root, output.path))) === "single") return path$1.resolve(root, output.path);
-  let result;
-  if (group && (groupPath || tag)) {
-    const groupValue = group.type === "path" ? groupPath : tag;
-    const defaultName = group.type === "tag" ? ({ group: g }) => `${camelCase(g)}Controller` : ({ group: g }) => {
-      const segment = g.split("/").filter((s) => s !== "" && s !== "." && s !== "..")[0];
-      return segment ? camelCase(segment) : "";
-    };
-    const resolveName = (_a2 = group.name) != null ? _a2 : defaultName;
-    result = path$1.resolve(root, output.path, resolveName({ group: groupValue }), baseName);
-  } else result = path$1.resolve(root, output.path, baseName);
+  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, ctx) {
-  const pathMode = PluginDriver.getMode(path$1.resolve(context.root, context.output.path));
-  const baseName = `${pathMode === "single" ? "" : ctx.default(name, "file")}${extname2}`;
-  const filePath = ctx.resolvePath({
+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,
@@ -5524,7 +5553,7 @@ function defaultResolveFile({ name, extname: extname2, tag, path: groupPath }, c
   return createFile({
     path: filePath,
     baseName: path$1.basename(filePath),
-    meta: { pluginName: ctx.pluginName },
+    meta: { pluginName: this.pluginName },
     sources: [],
     imports: [],
     exports: []
@@ -5532,12 +5561,16 @@ function defaultResolveFile({ name, extname: extname2, tag, path: groupPath }, c
 }
 function buildDefaultBanner({ title, description, version, config }) {
   try {
-    let source = "";
-    if (Array.isArray(config.input)) {
-      const first = config.input[0];
-      if (first && "path" in first) source = path$1.basename(first.path);
-    } else if ("path" in config.input) source = path$1.basename(config.input.path);
-    else if ("data" in config.input) source = "text content";
+    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";
@@ -5560,32 +5593,31 @@ 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) {
-  const resolver = {};
-  Object.assign(resolver, {
+  let resolver;
+  resolver = {
     default: defaultResolver,
     resolveOptions: defaultResolveOptions,
     resolvePath: defaultResolvePath,
-    resolveFile: (params, context) => defaultResolveFile(params, context, resolver),
+    resolveFile: (params, context) => defaultResolveFile.call(resolver, params, context),
     resolveBanner: defaultResolveBanner,
     resolveFooter: defaultResolveFooter,
-    ...build(resolver)
-  });
+    ...build()
+  };
   return resolver;
 }
 function encodeAst(input) {
@@ -5630,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());
@@ -5658,18 +5690,28 @@ 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);
   }
   /**
-  * All stored files, sorted by path length (shorter paths first).
+  * Releases all stored files. Called by the core after `kubb:build:end` to
+  * free the per-plugin FileNode caches for the rest of the process lifetime.
+  */
+  dispose() {
+    this.clear();
+  }
+  [Symbol.dispose]() {
+    this.dispose();
+  }
+  /**
+  * All stored files, sorted by path length (shorter paths first).
   */
   get files() {
     if (__privateGet$1(this, _filesCache)) return __privateGet$1(this, _filesCache);
-    __privateSet$1(this, _filesCache, [...__privateGet$1(this, _cache).values()].sort((a, b) => {
+    __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";
@@ -5688,36 +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);
-async function applyHookResult(result, driver, rendererFactory) {
-  if (!result) return;
-  if (Array.isArray(result)) {
-    driver.fileManager.upsert(...result);
-    return;
-  }
-  if (!rendererFactory) return;
-  const renderer = rendererFactory();
-  await renderer.render(result);
-  driver.fileManager.upsert(...renderer.files);
-  renderer.unmount();
-}
+}, _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");
-    __privateAdd$1(this, _studioIsOpen, false);
+    /**
+    * Studio session state, kept together so `dispose()` can reset it atomically.
+    *
+    * - `source` holds the raw adapter source so `adapter.parse()` can be called lazily.
+    *   Intentionally outlives the build; cleared by `dispose()`.
+    * - `isOpen` prevents opening the studio more than once per build.
+    * - `inputNode` caches the parse promise so `adapter.parse()` is called at most once
+    *   per studio session, even when `openInStudio()` is called multiple times.
+    */
+    __privateAdd$1(this, _studio, {
+      source: 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
@@ -5729,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) {
-    if (!fileOrFolder) return "split";
-    return extname(fileOrFolder) ? "single" : "split";
+    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["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.
   *
@@ -5863,28 +5860,40 @@ var PluginDriver = (_b$1 = class {
     if (gen.schema) {
       const schemaHandler = async (node, ctx) => {
         if (ctx.plugin.name !== pluginName) return;
-        await applyHookResult(await gen.schema(node, ctx), this, resolveRenderer());
+        await applyHookResult({
+          result: await gen.schema(node, ctx),
+          driver: this,
+          rendererFactory: resolveRenderer()
+        });
       };
       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) => {
         if (ctx.plugin.name !== pluginName) return;
-        await applyHookResult(await gen.operation(node, ctx), this, resolveRenderer());
+        await applyHookResult({
+          result: await gen.operation(node, ctx),
+          driver: this,
+          rendererFactory: resolveRenderer()
+        });
       };
       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) => {
         if (ctx.plugin.name !== pluginName) return;
-        await applyHookResult(await gen.operations(nodes, ctx), this, resolveRenderer());
+        await applyHookResult({
+          result: await gen.operations(nodes, ctx),
+          driver: this,
+          rendererFactory: resolveRenderer()
+        });
       };
       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
@@ -5893,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.
@@ -5905,7 +5914,20 @@ 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;
+    __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();
   }
   /**
   * Merges `partial` with the plugin's default resolver and stores the result.
@@ -5914,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);
@@ -5922,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;
@@ -5933,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,
@@ -5947,8 +5969,12 @@ var PluginDriver = (_b$1 = class {
       upsertFile: async (...files) => {
         driver.fileManager.upsert(...files);
       },
-      get inputNode() {
-        return driver.inputNode;
+      get meta() {
+        var _a2, _b2;
+        return (_b2 = (_a2 = driver.inputNode) == null ? void 0 : _a2.meta) != null ? _b2 : {
+          circularNames: [],
+          enumNames: []
+        };
       },
       get adapter() {
         return driver.adapter;
@@ -5968,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);
-        const studioUrl = (_b2 = (_a2 = driver.config.devtools) == null ? void 0 : _a2.studioUrl) != null ? _b2 : "https://studio.kubb.dev";
-        return openInStudio(driver.inputNode, studioUrl, options);
+        if (!driver.adapter || !__privateGet$1(driver, _studio).source) throw new Error("adapter is not defined, make sure you have set the parser in kubb.config.ts");
+        __privateGet$1(driver, _studio).isOpen = true;
+        const studioUrl = (_b2 = (_a2 = driver.config.devtools) == null ? void 0 : _a2.studioUrl) != null ? _b2 : "https://kubb.studio";
+        (_d = (_c2 = __privateGet$1(driver, _studio)).inputNode) != null ? _d : _c2.inputNode = Promise.resolve(driver.adapter.parse(__privateGet$1(driver, _studio).source));
+        return openInStudio(await __privateGet$1(driver, _studio).inputNode, studioUrl, options);
       }
     };
   }
@@ -5987,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) {
@@ -6011,16 +6122,47 @@ 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((_ctx) => ({
-    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)) {
+    driver.fileManager.upsert(...result);
+    return;
+  }
+  if (!rendererFactory) return;
+  const renderer = rendererFactory();
+  if (renderer.stream) {
+    for (const file of renderer.stream(result)) driver.fileManager.upsert(file);
+    renderer.unmount();
+    return;
+  }
+  return applyAsyncRender({
+    renderer,
+    result,
+    driver
+  });
+}
+async function applyAsyncRender({ renderer, result, driver }) {
+  await renderer.render(result);
+  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) => {
@@ -6031,17 +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 __privateWrapper = (obj, member, setter, getter) => ({
-  set _(value) {
-    __privateSet(obj, member, value);
-  },
-  get _() {
-    return __privateGet(obj, member, getter);
-  }
-});
-var _emitter, _a, _options, _URLPath_instances, transformParam_fn, eachParam_fn, _b, _c, _head, _tail, _size, _d, _limit, _e;
+var _emitter, _AsyncEventEmitter_instances, emitAll_fn, _a;
 var BuildError = class extends Error {
   constructor(message, options) {
     super(message, { cause: options.cause });
@@ -6059,6 +6192,7 @@ var AsyncEventEmitter = (_a = class {
   * @default 10
   */
   constructor(maxListener = 10) {
+    __privateAdd(this, _AsyncEventEmitter_instances);
     __privateAdd(this, _emitter, new EventEmitter());
     __privateGet(this, _emitter).setMaxListeners(maxListener);
   }
@@ -6071,20 +6205,10 @@ var AsyncEventEmitter = (_a = class {
   * await emitter.emit('build', 'petstore')
   * ```
   */
-  async emit(eventName, ...eventArgs) {
+  emit(eventName, ...eventArgs) {
     const listeners = __privateGet(this, _emitter).listeners(eventName);
     if (listeners.length === 0) return;
-    for (const listener of listeners) try {
-      await listener(...eventArgs);
-    } catch (err) {
-      let serializedArgs;
-      try {
-        serializedArgs = JSON.stringify(eventArgs);
-      } catch {
-        serializedArgs = String(eventArgs);
-      }
-      throw new Error(`Error in async listener for "${eventName}" with eventArgs ${serializedArgs}`, { cause: toError(err) });
-    }
+    return __privateMethod(this, _AsyncEventEmitter_instances, emitAll_fn).call(this, eventName, listeners, eventArgs);
   }
   /**
   * Registers a persistent listener for `eventName`.
@@ -6146,7 +6270,19 @@ var AsyncEventEmitter = (_a = class {
   removeAll() {
     __privateGet(this, _emitter).removeAllListeners();
   }
-}, _emitter = new WeakMap(), _a);
+}, _emitter = new WeakMap(), _AsyncEventEmitter_instances = new WeakSet(), emitAll_fn = async function(eventName, listeners, eventArgs) {
+  for (const listener of listeners) try {
+    await listener(...eventArgs);
+  } catch (err) {
+    let serializedArgs;
+    try {
+      serializedArgs = JSON.stringify(eventArgs);
+    } catch {
+      serializedArgs = String(eventArgs);
+    }
+    throw new Error(`Error in async listener for "${eventName}" with eventArgs ${serializedArgs}`, { cause: toError(err) });
+  }
+}, _a);
 function getElapsedMs(hrStart) {
   const [seconds, nanoseconds] = process.hrtime(hrStart);
   const ms = seconds * 1e3 + nanoseconds / 1e6;
@@ -6197,414 +6333,75 @@ async function clean(path) {
     force: true
   });
 }
-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");
-  }
-}, _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));
-  }
-}, _b);
-var Node$1 = (_c = class {
-  constructor(value) {
-    __publicField(this, "value");
-    __publicField(this, "next");
-    this.value = value;
-  }
-}, __name(_c, "Node"), _c);
-var Queue = (_d = class {
-  constructor() {
-    __privateAdd(this, _head);
-    __privateAdd(this, _tail);
-    __privateAdd(this, _size);
-    this.clear();
-  }
-  enqueue(value) {
-    const node = new Node$1(value);
-    if (__privateGet(this, _head)) {
-      __privateGet(this, _tail).next = node;
-      __privateSet(this, _tail, node);
-    } else {
-      __privateSet(this, _head, node);
-      __privateSet(this, _tail, node);
-    }
-    __privateWrapper(this, _size)._++;
-  }
-  dequeue() {
-    const current = __privateGet(this, _head);
-    if (!current) return;
-    __privateSet(this, _head, __privateGet(this, _head).next);
-    __privateWrapper(this, _size)._--;
-    if (!__privateGet(this, _head)) __privateSet(this, _tail, void 0);
-    return current.value;
-  }
-  peek() {
-    if (!__privateGet(this, _head)) return;
-    return __privateGet(this, _head).value;
-  }
-  clear() {
-    __privateSet(this, _head, void 0);
-    __privateSet(this, _tail, void 0);
-    __privateSet(this, _size, 0);
-  }
-  get size() {
-    return __privateGet(this, _size);
-  }
-  *[Symbol.iterator]() {
-    let current = __privateGet(this, _head);
-    while (current) {
-      yield current.value;
-      current = current.next;
-    }
-  }
-  *drain() {
-    while (__privateGet(this, _head)) yield this.dequeue();
-  }
-}, _head = new WeakMap(), _tail = new WeakMap(), _size = new WeakMap(), _d);
-function pLimit(concurrency) {
-  let rejectOnClear = false;
-  if (typeof concurrency === "object") ({ concurrency, rejectOnClear = false } = concurrency);
-  validateConcurrency(concurrency);
-  if (typeof rejectOnClear !== "boolean") throw new TypeError("Expected `rejectOnClear` to be a boolean");
-  const queue = new Queue();
-  let activeCount = 0;
-  const resumeNext = () => {
-    if (activeCount < concurrency && queue.size > 0) {
-      activeCount++;
-      queue.dequeue().run();
-    }
-  };
-  const next = () => {
-    activeCount--;
-    resumeNext();
-  };
-  const run = async (function_, resolve2, arguments_) => {
-    const result = (async () => function_(...arguments_))();
-    resolve2(result);
-    try {
-      await result;
-    } catch {
-    }
-    next();
-  };
-  const enqueue = (function_, resolve2, reject, arguments_) => {
-    const queueItem = { reject };
-    new Promise((internalResolve) => {
-      queueItem.run = internalResolve;
-      queue.enqueue(queueItem);
-    }).then(run.bind(void 0, function_, resolve2, arguments_));
-    if (activeCount < concurrency) resumeNext();
-  };
-  const generator = (function_, ...arguments_) => new Promise((resolve2, reject) => {
-    enqueue(function_, resolve2, reject, arguments_);
-  });
-  Object.defineProperties(generator, {
-    activeCount: { get: () => activeCount },
-    pendingCount: { get: () => queue.size },
-    clearQueue: { value() {
-      if (!rejectOnClear) {
-        queue.clear();
-        return;
-      }
-      const abortError = AbortSignal.abort().reason;
-      while (queue.size > 0) queue.dequeue().reject(abortError);
-    } },
-    concurrency: {
-      get: () => concurrency,
-      set(newConcurrency) {
-        validateConcurrency(newConcurrency);
-        concurrency = newConcurrency;
-        queueMicrotask(() => {
-          while (activeCount < concurrency && queue.size > 0) resumeNext();
-        });
-      }
-    },
-    map: { async value(iterable, function_) {
-      const promises = Array.from(iterable, (value, index) => this(function_, value, index));
-      return Promise.all(promises);
-    } }
-  });
-  return generator;
-}
-function validateConcurrency(concurrency) {
-  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+var version$1 = "5.0.0-beta.20";
+function createStorage(build2) {
+  return (options) => build2(options != null ? options : {});
 }
 function joinSources(file) {
-  return file.sources.map((item) => extractStringsFromNodes(item.nodes)).filter(Boolean).join("\n\n");
+  const sources = file.sources;
+  if (sources.length === 0) return "";
+  const parts = [];
+  for (const source of sources) {
+    const s = extractStringsFromNodes(source.nodes);
+    if (s) parts.push(s);
+  }
+  return parts.join("\n\n");
 }
-var FileProcessor = (_e = class {
+var FileProcessor = class {
   constructor() {
-    __privateAdd(this, _limit, pLimit(100));
+    __publicField(this, "events", new AsyncEventEmitter());
   }
-  async parse(file, { parsers, extension } = {}) {
+  parse(file, { parsers, extension } = {}) {
     const parseExtName = (extension == null ? void 0 : extension[file.extname]) || void 0;
     if (!parsers || !file.extname) return joinSources(file);
     const parser = parsers.get(file.extname);
     if (!parser) return joinSources(file);
     return parser.parse(file, { extname: parseExtName });
   }
-  async run(files, { parsers, mode = "sequential", extension, onStart, onEnd, onUpdate } = {}) {
-    await (onStart == null ? void 0 : onStart(files));
+  *stream(files, options = {}) {
     const total = files.length;
+    if (total === 0) return;
     let processed = 0;
-    const processOne = async (file) => {
-      const source = await this.parse(file, {
-        extension,
-        parsers
-      });
-      const currentProcessed = ++processed;
-      const percentage = currentProcessed / total * 100;
-      await (onUpdate == null ? void 0 : onUpdate({
+    for (const file of files) {
+      const source = this.parse(file, options);
+      processed++;
+      yield {
         file,
         source,
-        processed: currentProcessed,
-        percentage,
-        total
-      }));
-    };
-    if (mode === "sequential") for (const file of files) await processOne(file);
-    else await Promise.all(files.map((file) => __privateGet(this, _limit).call(this, () => processOne(file))));
-    await (onEnd == null ? void 0 : onEnd(files));
-    return files;
+        processed,
+        total,
+        percentage: processed / total * 100
+      };
+    }
   }
-}, _limit = new WeakMap(), _e);
-function createStorage(build2) {
-  return (options) => build2(options != null ? options : {});
-}
-function isMissingPathError(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
+  async run(files, options = {}) {
+    await this.events.emit("start", files);
+    for (const { file, source, processed, total, percentage } of this.stream(files, options)) await this.events.emit("update", {
+      file,
+      source,
+      processed,
+      percentage,
+      total
+    });
+    await this.events.emit("end", files);
+    return files;
+  }
+};
 const fsStorage = createStorage(() => ({
   name: "fs",
   async hasItem(key) {
     try {
       await access(resolve(key));
       return true;
-    } catch (error) {
-      if (isMissingPathError(error)) return false;
-      throw new Error(`Failed to access storage item "${key}"`, { cause: error });
+    } catch (_error) {
+      return false;
     }
   },
   async getItem(key) {
     try {
       return await readFile$1(resolve(key), "utf8");
-    } catch (error) {
-      if (isMissingPathError(error)) return null;
-      throw new Error(`Failed to read storage item "${key}"`, { cause: error });
+    } catch (_error) {
+      return null;
     }
   },
   async setItem(key, value) {
@@ -6614,23 +6411,22 @@ const fsStorage = createStorage(() => ({
     await rm(resolve(key), { force: true });
   },
   async getKeys(base) {
-    const keys = [];
     const resolvedBase = resolve(base != null ? base : process.cwd());
-    async function walk2(dir, prefix) {
+    async function* walk(dir, prefix) {
       let entries;
       try {
         entries = await readdir$1(dir, { withFileTypes: true });
-      } catch (error) {
-        if (isMissingPathError(error)) return;
-        throw new Error(`Failed to list storage keys under "${resolvedBase}"`, { cause: error });
+      } catch (_error) {
+        return;
       }
       for (const entry of entries) {
         const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-        if (entry.isDirectory()) await walk2(join(dir, entry.name), rel);
-        else keys.push(rel);
+        if (entry.isDirectory()) yield* walk(join(dir, entry.name), rel);
+        else yield rel;
       }
     }
-    await walk2(resolvedBase, "");
+    const keys = [];
+    for await (const key of walk(resolvedBase, "")) keys.push(key);
     return keys;
   },
   async clear(base) {
@@ -6638,37 +6434,131 @@ const fsStorage = createStorage(() => ({
     await clean(resolve(base));
   }
 }));
-var version$1 = "5.0.0-beta.2";
-function getDiagnosticInfo() {
+function _usingCtx() {
+  var r = "function" == typeof SuppressedError ? SuppressedError : function(r2, e2) {
+    var n2 = Error();
+    return n2.name = "SuppressedError", n2.error = r2, n2.suppressed = e2, n2;
+  };
+  var e = {};
+  var n = [];
+  function using(r2, e2) {
+    if (null != e2) {
+      if (Object(e2) !== e2) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+      if (r2) var o = e2[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+      if (void 0 === o && (o = e2[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r2)) var t = o;
+      if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+      t && (o = function o2() {
+        try {
+          t.call(e2);
+        } catch (r3) {
+          return Promise.reject(r3);
+        }
+      }), n.push({
+        v: e2,
+        d: o,
+        a: r2
+      });
+    } else r2 && n.push({
+      d: e2,
+      a: r2
+    });
+    return e2;
+  }
   return {
-    nodeVersion: version$2,
-    KubbVersion: version$1,
-    platform: process.platform,
-    arch: process.arch,
-    cwd: process.cwd()
+    e,
+    u: using.bind(null, false),
+    a: using.bind(null, true),
+    d: function d() {
+      var o;
+      var t = this.e;
+      var s = 0;
+      function next() {
+        for (; o = n.pop(); ) try {
+          if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+          if (o.d) {
+            var r2 = o.d.call(o.v);
+            if (o.a) return s |= 2, Promise.resolve(r2).then(next, err);
+          } else s |= 1;
+        } catch (r3) {
+          return err(r3);
+        }
+        if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+        if (t !== e) throw t;
+      }
+      function err(n2) {
+        return t = t !== e ? new r(n2, t) : n2, next();
+      }
+      return next();
+    }
   };
 }
-function isInputPath(config) {
-  return typeof (config == null ? void 0 : config.input) === "object" && config.input !== null && "path" in config.input;
+function createSourcesView(storage) {
+  const paths = /* @__PURE__ */ new Set();
+  return createStorage(() => ({
+    name: `${storage.name}:sources`,
+    async hasItem(key) {
+      return paths.has(key) && await storage.hasItem(key);
+    },
+    async getItem(key) {
+      return paths.has(key) ? storage.getItem(key) : null;
+    },
+    async setItem(key, value) {
+      paths.add(key);
+      await storage.setItem(key, value);
+    },
+    async removeItem(key) {
+      paths.delete(key);
+      await storage.removeItem(key);
+    },
+    async getKeys(base) {
+      if (!base) return [...paths];
+      const result = [];
+      for (const key of paths) if (key.startsWith(base)) result.push(key);
+      return result;
+    },
+    async clear() {
+      paths.clear();
+      await storage.clear();
+    }
+  }))();
 }
 async function setup(userConfig, options = {}) {
-  var _a2, _b2, _c2, _d2, _e2, _f, _g, _h, _i;
+  var _a2, _b, _c, _d, _e, _f, _g, _h, _i;
   const hooks = (_a2 = options.hooks) != null ? _a2 : new AsyncEventEmitter();
-  const sources = /* @__PURE__ */ new Map();
+  const config = {
+    ...userConfig,
+    root: userConfig.root || process.cwd(),
+    parsers: (_b = userConfig.parsers) != null ? _b : [],
+    output: {
+      format: false,
+      lint: false,
+      extension: DEFAULT_EXTENSION,
+      defaultBanner: DEFAULT_BANNER,
+      ...userConfig.output
+    },
+    storage: (_c = userConfig.storage) != null ? _c : fsStorage(),
+    devtools: userConfig.devtools ? {
+      studioUrl: DEFAULT_STUDIO_URL,
+      ...typeof userConfig.devtools === "boolean" ? {} : userConfig.devtools
+    } : void 0,
+    plugins: (_d = userConfig.plugins) != null ? _d : []
+  };
+  const driver = new KubbDriver(config, { hooks });
+  const storage = createSourcesView(config.storage);
   const diagnosticInfo = getDiagnosticInfo();
-  if (Array.isArray(userConfig.input)) await hooks.emit("kubb:warn", { message: "This feature is still under development \u2014 use with caution" });
   await hooks.emit("kubb:debug", {
     date: /* @__PURE__ */ new Date(),
     logs: [
       "Configuration:",
       `  \u2022 Name: ${userConfig.name || "unnamed"}`,
       `  \u2022 Root: ${userConfig.root || process.cwd()}`,
-      `  \u2022 Output: ${((_b2 = userConfig.output) == null ? void 0 : _b2.path) || "not specified"}`,
-      `  \u2022 Plugins: ${((_c2 = userConfig.plugins) == null ? void 0 : _c2.length) || 0}`,
+      `  \u2022 Output: ${((_e = userConfig.output) == null ? void 0 : _e.path) || "not specified"}`,
+      `  \u2022 Plugins: ${((_f = userConfig.plugins) == null ? void 0 : _f.length) || 0}`,
       "Output Settings:",
-      `  \u2022 Storage: ${userConfig.storage ? `custom(${userConfig.storage.name})` : ((_d2 = userConfig.output) == null ? void 0 : _d2.write) === false ? "disabled" : "filesystem (default)"}`,
-      `  \u2022 Formatter: ${((_e2 = userConfig.output) == null ? void 0 : _e2.format) || "none"}`,
-      `  \u2022 Linter: ${((_f = userConfig.output) == null ? void 0 : _f.lint) || "none"}`,
+      `  \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")
     ]
@@ -6687,181 +6577,303 @@ async function setup(userConfig, options = {}) {
       throw new Error(`Cannot read file/URL defined in \`input.path\` or set with \`kubb generate PATH\` in the CLI of your Kubb config ${userConfig.input.path}`, { cause: error });
     }
   }
-  if (!userConfig.adapter) throw new Error("Adapter should be defined");
-  const config = {
-    ...userConfig,
-    root: userConfig.root || process.cwd(),
-    parsers: (_g = userConfig.parsers) != null ? _g : [],
-    adapter: userConfig.adapter,
-    output: {
-      format: false,
-      lint: false,
-      write: true,
-      extension: DEFAULT_EXTENSION,
-      defaultBanner: DEFAULT_BANNER,
-      ...userConfig.output
-    },
-    devtools: userConfig.devtools ? {
-      studioUrl: DEFAULT_STUDIO_URL,
-      ...typeof userConfig.devtools === "boolean" ? {} : userConfig.devtools
-    } : void 0,
-    plugins: userConfig.plugins
-  };
-  const storage = config.output.write === false ? null : (_h = config.storage) != null ? _h : fsStorage();
   if (config.output.clean) {
     await hooks.emit("kubb:debug", {
       date: /* @__PURE__ */ new Date(),
       logs: ["Cleaning output directories", `  \u2022 Output: ${config.output.path}`]
     });
-    await (storage == null ? void 0 : storage.clear(resolve(config.root, config.output.path)));
+    await config.storage.clear(resolve(config.root, config.output.path));
   }
-  const driver = new PluginDriver(config, { hooks });
-  function registerMiddlewareHook(event, middlewareHooks) {
-    const handler = middlewareHooks[event];
-    if (handler) hooks.on(event, handler);
-  }
-  for (const middleware of (_i = config.middleware) != null ? _i : []) for (const event of Object.keys(middleware.hooks)) registerMiddlewareHook(event, middleware.hooks);
-  const adapter = config.adapter;
-  if (!adapter) throw new Error("No adapter configured. Please provide an adapter in your kubb.config.ts.");
-  const source = inputToAdapterSource(config);
-  await hooks.emit("kubb:debug", {
-    date: /* @__PURE__ */ new Date(),
-    logs: [`Running adapter: ${adapter.name}`]
-  });
-  driver.adapter = adapter;
-  driver.inputNode = await adapter.parse(source);
-  await hooks.emit("kubb:debug", {
-    date: /* @__PURE__ */ new Date(),
-    logs: [
-      `\u2713 Adapter '${adapter.name}' resolved InputNode`,
-      `  \u2022 Schemas: ${driver.inputNode.schemas.length}`,
-      `  \u2022 Operations: ${driver.inputNode.operations.length}`
-    ]
-  });
+  await driver.setup();
   return {
     config,
     hooks,
     driver,
-    sources,
-    storage
+    storage,
+    dispose,
+    [Symbol.dispose]: dispose
   };
+  function dispose() {
+    driver.dispose();
+  }
 }
-async function runPluginAstHooks(plugin, context) {
-  var _a2, _b2, _c2;
-  const { adapter, inputNode, resolver, driver } = context;
-  const { exclude, include, override } = plugin.options;
-  if (!adapter || !inputNode) throw new Error(`[${plugin.name}] No adapter found. Add an OAS adapter (e.g. pluginOas()) before this plugin in your Kubb config.`);
-  function resolveRenderer(gen) {
-    var _a3, _b3;
-    return gen.renderer === null ? void 0 : (_b3 = (_a3 = gen.renderer) != null ? _a3 : plugin.renderer) != null ? _b3 : context.config.renderer;
-  }
-  const generators = (_a2 = plugin.generators) != null ? _a2 : [];
-  const collectedOperations = [];
-  const generatorContext = {
-    ...context,
-    resolver: driver.getResolver(plugin.name)
-  };
-  const operationFilterTypes = /* @__PURE__ */ new Set([
-    "tag",
-    "operationId",
-    "path",
-    "method",
-    "contentType"
-  ]);
-  const hasOperationBasedIncludes = (_b2 = include == null ? void 0 : include.some(({ type }) => operationFilterTypes.has(type))) != null ? _b2 : false;
-  const hasSchemaNameIncludes = (_c2 = include == null ? void 0 : include.some(({ type }) => type === "schemaName")) != null ? _c2 : false;
-  let allowedSchemaNames;
-  if (hasOperationBasedIncludes && !hasSchemaNameIncludes) allowedSchemaNames = collectUsedSchemaNames(inputNode.operations.filter((op) => resolver.resolveOptions(op, {
-    options: plugin.options,
-    exclude,
-    include,
-    override
-  }) !== null), inputNode.schemas);
-  await walk(inputNode, {
-    depth: "shallow",
-    async schema(node) {
-      const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
-      if (allowedSchemaNames !== void 0 && transformedNode.name && !allowedSchemaNames.has(transformedNode.name)) return;
-      const options = resolver.resolveOptions(transformedNode, {
-        options: plugin.options,
-        exclude,
-        include,
-        override
+async function safeBuild(setupResult) {
+  var _a2;
+  try {
+    var _usingCtx$1 = _usingCtx();
+    _usingCtx$1.u(setupResult);
+    const { driver, hooks, storage } = setupResult;
+    const failedPlugins = /* @__PURE__ */ new Set();
+    const pluginTimings = /* @__PURE__ */ new Map();
+    const config = driver.config;
+    const writtenPaths = /* @__PURE__ */ new Set();
+    const parsersMap = /* @__PURE__ */ new Map();
+    const fileProcessor = new FileProcessor();
+    for (const parser of config.parsers) if (parser.extNames) for (const extname of parser.extNames) parsersMap.set(extname, parser);
+    async function flushPendingFiles() {
+      const files = driver.fileManager.files.filter((f) => !writtenPaths.has(f.path));
+      if (files.length === 0) return;
+      await hooks.emit("kubb:debug", {
+        date: /* @__PURE__ */ new Date(),
+        logs: [`Writing ${files.length} files...`]
       });
-      if (options === null) return;
-      const ctx = {
-        ...generatorContext,
-        options
-      };
-      for (const gen of generators) {
-        if (!gen.schema) continue;
-        await applyHookResult(await gen.schema(transformedNode, ctx), driver, resolveRenderer(gen));
+      await hooks.emit("kubb:files:processing:start", { files });
+      const stream = fileProcessor.stream(files, {
+        parsers: parsersMap,
+        extension: config.output.extension
+      });
+      const queue = [];
+      for (const { file, source, processed, total, percentage } of stream) {
+        writtenPaths.add(file.path);
+        queue.push((async () => {
+          await hooks.emit("kubb:file:processing:update", {
+            file,
+            source,
+            processed,
+            total,
+            percentage,
+            config
+          });
+          if (source) await storage.setItem(file.path, source);
+        })());
+        if (queue.length >= 50) await Promise.all(queue.splice(0));
       }
-      await 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
+      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`]
       });
-      if (options !== null) {
-        collectedOperations.push(transformedNode);
-        const ctx = {
-          ...generatorContext,
-          options
+    }
+    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
         };
-        for (const gen of generators) {
-          if (!gen.operation) continue;
-          await applyHookResult(await gen.operation(transformedNode, ctx), driver, resolveRenderer(gen));
+      });
+      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;
         }
-        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(await gen.operations(collectedOperations, ctx), driver, resolveRenderer(gen));
-    }
-    await driver.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
-  }
-}
-async function safeBuild(setupResult) {
-  var _a2;
-  const { driver, hooks, sources, storage } = setupResult;
-  const failedPlugins = /* @__PURE__ */ new Set();
-  const pluginTimings = /* @__PURE__ */ new Map();
-  const config = driver.config;
-  try {
-    await driver.emitSetupHooks();
-    if (driver.adapter && driver.inputNode) await hooks.emit("kubb:build:start", {
-      config,
-      adapter: driver.adapter,
-      inputNode: driver.inputNode,
-      getPlugin: driver.getPlugin.bind(driver),
-      get files() {
-        return driver.fileManager.files;
-      },
-      upsertFile: (...files2) => driver.fileManager.upsert(...files2)
-    });
-    for (const plugin of driver.plugins.values()) {
-      const context = driver.getContext(plugin);
-      const hrStart = process.hrtime();
-      try {
-        const timestamp = /* @__PURE__ */ new Date();
-        await hooks.emit("kubb:plugin:start", { plugin });
-        await hooks.emit("kubb:debug", {
-          date: timestamp,
-          logs: ["Starting plugin...", `  \u2022 Plugin Name: ${plugin.name}`]
+      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)})`]
         });
-        if (((_a2 = plugin.generators) == null ? void 0 : _a2.length) || driver.hasRegisteredGenerators(plugin.name)) await runPluginAstHooks(plugin, context);
+      }
+    }
+    try {
+      await driver.emitSetupHooks();
+      if (driver.adapter && driver.inputNode) await hooks.emit("kubb:build:start", {
+        config,
+        adapter: driver.adapter,
+        meta: driver.inputNode.meta,
+        getPlugin: driver.getPlugin.bind(driver),
+        get files() {
+          return driver.fileManager.files;
+        },
+        upsertFile: (...files2) => driver.fileManager.upsert(...files2)
+      });
+      const generatorPlugins = [];
+      for (const plugin of driver.plugins.values()) {
+        const context = driver.getContext(plugin);
+        const hrStart = process.hrtime();
+        try {
+          await hooks.emit("kubb:plugin:start", { plugin });
+          await hooks.emit("kubb:debug", {
+            date: /* @__PURE__ */ new Date(),
+            logs: ["Starting plugin...", `  \u2022 Plugin Name: ${plugin.name}`]
+          });
+        } catch (caughtError) {
+          const error = caughtError;
+          const duration2 = getElapsedMs(hrStart);
+          pluginTimings.set(plugin.name, duration2);
+          await hooks.emit("kubb:plugin:end", {
+            plugin,
+            duration: duration2,
+            success: false,
+            error,
+            config,
+            get files() {
+              return driver.fileManager.files;
+            },
+            upsertFile: (...files2) => driver.fileManager.upsert(...files2)
+          });
+          failedPlugins.add({
+            plugin,
+            error
+          });
+          continue;
+        }
+        if (((_a2 = plugin.generators) == null ? void 0 : _a2.length) || driver.hasEventGenerators(plugin.name)) {
+          generatorPlugins.push({
+            plugin,
+            context,
+            hrStart
+          });
+          continue;
+        }
         const duration = getElapsedMs(hrStart);
         pluginTimings.set(plugin.name, duration);
         await hooks.emit("kubb:plugin:end", {
@@ -6878,107 +6890,61 @@ async function safeBuild(setupResult) {
           date: /* @__PURE__ */ new Date(),
           logs: [`\u2713 Plugin started successfully (${formatMs(duration)})`]
         });
-      } catch (caughtError) {
-        const error = caughtError;
-        const errorTimestamp = /* @__PURE__ */ new Date();
+      }
+      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: false,
-          error,
+          success: true,
           config,
           get files() {
             return driver.fileManager.files;
           },
           upsertFile: (...files2) => driver.fileManager.upsert(...files2)
         });
-        await hooks.emit("kubb:debug", {
-          date: errorTimestamp,
-          logs: [
-            "\u2717 Plugin start failed",
-            `  \u2022 Plugin Name: ${plugin.name}`,
-            `  \u2022 Error: ${error.constructor.name} - ${error.message}`,
-            "  \u2022 Stack Trace:",
-            error.stack || "No stack trace available"
-          ]
-        });
-        failedPlugins.add({
-          plugin,
-          error
-        });
       }
+      await hooks.emit("kubb:plugins:end", {
+        config,
+        get files() {
+          return driver.fileManager.files;
+        },
+        upsertFile: (...files2) => driver.fileManager.upsert(...files2)
+      });
+      await flushPendingFiles();
+      const files = driver.fileManager.files;
+      await hooks.emit("kubb:build:end", {
+        files,
+        config,
+        outputDir: resolve(config.root, config.output.path)
+      });
+      return {
+        failedPlugins,
+        files,
+        driver,
+        pluginTimings,
+        storage
+      };
+    } catch (error) {
+      return {
+        failedPlugins,
+        files: [],
+        driver,
+        pluginTimings,
+        error,
+        storage
+      };
     }
-    await hooks.emit("kubb:plugins:end", {
-      config,
-      get files() {
-        return driver.fileManager.files;
-      },
-      upsertFile: (...files2) => driver.fileManager.upsert(...files2)
-    });
-    const files = driver.fileManager.files;
-    const parsersMap = /* @__PURE__ */ new Map();
-    for (const parser of config.parsers) if (parser.extNames) for (const extname of parser.extNames) parsersMap.set(extname, parser);
-    const fileProcessor = new FileProcessor();
-    await hooks.emit("kubb:debug", {
-      date: /* @__PURE__ */ new Date(),
-      logs: [`Writing ${files.length} files...`]
-    });
-    await fileProcessor.run(files, {
-      parsers: parsersMap,
-      extension: config.output.extension,
-      onStart: async (processingFiles) => {
-        await hooks.emit("kubb:files:processing:start", { files: processingFiles });
-      },
-      onUpdate: async ({ file, source, processed, total, percentage }) => {
-        await hooks.emit("kubb:file:processing:update", {
-          file,
-          source,
-          processed,
-          total,
-          percentage,
-          config
-        });
-        if (source) {
-          await (storage == null ? void 0 : storage.setItem(file.path, source));
-          sources.set(file.path, source);
-        }
-      },
-      onEnd: async (processedFiles) => {
-        await hooks.emit("kubb:files:processing:end", { files: processedFiles });
-        await hooks.emit("kubb:debug", {
-          date: /* @__PURE__ */ new Date(),
-          logs: [`\u2713 File write process completed for ${processedFiles.length} files`]
-        });
-      }
-    });
-    await hooks.emit("kubb:build:end", {
-      files,
-      config,
-      outputDir: resolve(config.root, config.output.path)
-    });
-    return {
-      failedPlugins,
-      files,
-      driver,
-      pluginTimings,
-      sources
-    };
-  } catch (error) {
-    return {
-      failedPlugins,
-      files: [],
-      driver,
-      pluginTimings,
-      error,
-      sources
-    };
+  } catch (_) {
+    _usingCtx$1.e = _;
   } finally {
-    driver.dispose();
+    _usingCtx$1.d();
   }
 }
 async function build(setupResult) {
-  const { files, driver, failedPlugins, pluginTimings, error, sources } = await safeBuild(setupResult);
+  const { files, driver, failedPlugins, pluginTimings, error, storage } = await safeBuild(setupResult);
   if (error) throw error;
   if (failedPlugins.size > 0) {
     const errors = [...failedPlugins].map(({ error: error2 }) => error2);
@@ -6990,27 +6956,21 @@ async function build(setupResult) {
     driver,
     pluginTimings,
     error: void 0,
-    sources
+    storage
   };
 }
-function inputToAdapterSource(config) {
-  if (Array.isArray(config.input)) return {
-    type: "paths",
-    paths: config.input.map((i) => new URLPath(i.path).isURL ? i.path : resolve(config.root, i.path))
-  };
-  if ("data" in config.input) return {
-    type: "data",
-    data: config.input.data
-  };
-  if (new URLPath(config.input.path).isURL) return {
-    type: "path",
-    path: config.input.path
-  };
+function getDiagnosticInfo() {
   return {
-    type: "path",
-    path: resolve(config.root, config.input.path)
+    nodeVersion: version$2,
+    KubbVersion: version$1,
+    platform: process.platform,
+    arch: process.arch,
+    cwd: process.cwd()
   };
 }
+function isInputPath(config) {
+  return typeof (config == null ? void 0 : config.input) === "object" && config.input !== null && "path" in config.input;
+}
 function createKubb(userConfig, options = {}) {
   var _a2;
   const hooks = (_a2 = options.hooks) != null ? _a2 : new AsyncEventEmitter();
@@ -7019,15 +6979,17 @@ function createKubb(userConfig, options = {}) {
     get hooks() {
       return hooks;
     },
-    get sources() {
-      var _a3;
-      return (_a3 = setupResult == null ? void 0 : setupResult.sources) != null ? _a3 : /* @__PURE__ */ new Map();
+    get storage() {
+      if (!setupResult) throw new Error("[kubb] setup() must be called before accessing storage");
+      return setupResult.storage;
     },
     get driver() {
-      return setupResult == null ? void 0 : setupResult.driver;
+      if (!setupResult) throw new Error("[kubb] setup() must be called before accessing driver");
+      return setupResult.driver;
     },
     get config() {
-      return setupResult == null ? void 0 : setupResult.config;
+      if (!setupResult) throw new Error("[kubb] setup() must be called before accessing config");
+      return setupResult.config;
     },
     async setup() {
       setupResult = await setup(userConfig, { hooks });
@@ -7074,7 +7036,7 @@ const memoryStorage = createStorage(() => {
   };
 });
 
-var version = "5.0.0-beta.2";
+var version = "5.0.0-beta.20";
 
 function isCommandMessage(msg) {
   return msg.type === "command";
@@ -7085,9 +7047,6 @@ function isPongMessage(msg) {
 function isDisconnectMessage(msg) {
   return msg.type === "disconnect";
 }
-function isPublishCommandMessage(msg) {
-  return msg.type === "command" && msg.command === "publish";
-}
 
 function getStorage() {
   return useStorage("kubb");
@@ -7131,7 +7090,7 @@ async function generate({ config, hooks }) {
   const kubb = createKubb(config, { hooks });
   await kubb.setup();
   await hooks.emit("kubb:info", { message: config.name ? `Build generation ${config.name}` : "Build generation" });
-  const { files, failedPlugins, error } = await kubb.safeBuild();
+  const { failedPlugins, error } = await kubb.safeBuild();
   await hooks.emit("kubb:info", { message: "Load summary" });
   const hasFailures = failedPlugins.size > 0 || error;
   if (hasFailures) {
@@ -7142,11 +7101,11 @@ async function generate({ config, hooks }) {
     allErrors.forEach((err) => {
       hooks.emit("kubb:error", { error: err });
     });
-    await hooks.emit("kubb:generation:end", { config, files, sources: kubb.sources });
+    await hooks.emit("kubb:generation:end", { config, storage: kubb.storage });
     throw new Error("Generation failed");
   }
   await hooks.emit("kubb:success", { message: "Generation successfully" });
-  await hooks.emit("kubb:generation:end", { config, files, sources: kubb.sources });
+  await hooks.emit("kubb:generation:end", { config, storage: kubb.storage });
   if (config.output.format) {
     await hooks.emit("kubb:format:start");
     let formatter = config.output.format;
@@ -7221,20 +7180,15 @@ async function generate({ config, hooks }) {
   }
 }
 
-const unrunInputOptions = {
-  transform: {
-    jsx: {
-      runtime: "automatic",
-      importSource: "@kubb/renderer-jsx"
-    }
-  }
-};
+const jiti = createJiti(globalThis._importMeta_.url, {
+  jsx: {
+    runtime: "automatic",
+    importSource: "@kubb/renderer-jsx"
+  },
+  moduleCache: false
+});
 const tsLoader = async (configFile) => {
-  const { module } = await unrun({
-    path: configFile,
-    inputOptions: unrunInputOptions
-  });
-  return module;
+  return jiti.import(configFile, { default: true });
 };
 async function getCosmiConfig(configPath) {
   var _a;
@@ -7295,6 +7249,21 @@ async function resolvePlugins(plugins) {
     })
   );
 }
+async function resolveMiddlewares(middlewares) {
+  return Promise.all(
+    middlewares.map(async ({ name, options }) => {
+      const factory = await loadPluginFactory(name);
+      return factory(options != null ? options : {});
+    })
+  );
+}
+async function checkPeerDependencies() {
+  try {
+    await import('@kubb/renderer-jsx');
+  } catch {
+    logger.warn("Missing peer dependency @kubb/renderer-jsx. Install it alongside kubb plugins.");
+  }
+}
 
 async function mergePlugins(diskPlugins, studioPlugins) {
   if (!diskPlugins && !studioPlugins) return void 0;
@@ -7323,44 +7292,6 @@ async function mergePlugins(diskPlugins, studioPlugins) {
   return [...mergedDisk, ...studioOnly];
 }
 
-async function publish({ command, outputPath, root, hooks }) {
-  var _a, _b, _c, _d;
-  const resolvedOutputPath = path$1.isAbsolute(outputPath) ? outputPath : path$1.resolve(root, outputPath);
-  const [cmd, ...args] = tokenize(command);
-  if (!cmd) {
-    throw new Error(`[plugin-publish] Invalid publish command: "${command}"`);
-  }
-  const commandWithArgs = args.length ? `${cmd} ${args.join(" ")}` : cmd;
-  await hooks.emit("kubb:info", { message: `[publish] Running "${commandWithArgs}" in "${resolvedOutputPath}"` });
-  const startTime = Date.now();
-  let exitCode = null;
-  try {
-    const proc = x(cmd, args, {
-      nodeOptions: { cwd: resolvedOutputPath }
-    });
-    for await (const line of proc) {
-      if (line.trim()) {
-        await hooks.emit("kubb:info", { message: line.trim() });
-      }
-    }
-    const result = await proc;
-    exitCode = (_a = result.exitCode) != null ? _a : null;
-  } catch (err) {
-    const message = (_d = (_c = (_b = err == null ? void 0 : err.stderr) == null ? void 0 : _b.trim()) != null ? _c : err == null ? void 0 : err.message) != null ? _d : String(err);
-    const error = new Error(`[publish] Failed to run "${commandWithArgs}": ${message}`);
-    error.cause = err;
-    await hooks.emit("kubb:error", { error });
-    throw error;
-  }
-  if (exitCode !== 0) {
-    const error = new Error(`[publish] "${commandWithArgs}" exited with code ${exitCode}`);
-    await hooks.emit("kubb:error", { error });
-    throw error;
-  }
-  const duration = Date.now() - startTime;
-  await hooks.emit("kubb:success", { message: `[publish] Published successfully in ${duration}ms` });
-}
-
 function setupHookListener(hooks, root) {
   hooks.on("kubb:hook:start", async (ctx) => {
     const { id, command, args } = ctx;
@@ -7396,7 +7327,7 @@ function setupHookListener(hooks, root) {
 }
 
 const agentDefaults = {
-  studioUrl: "https://studio.kubb.dev",
+  studioUrl: "https://kubb.studio",
   configPath: "kubb.config.ts",
   retryIntervalMs: 3e4,
   heartbeatIntervalMs: 3e4,
@@ -7431,24 +7362,24 @@ function sendAgentMessage(ws, message) {
     throw new Error("Failed to send message to Kubb Studio", { cause: error });
   }
 }
-function setupEventsStream(ws, hooks, getSource) {
+function setupEventsStream(ws, hooks) {
   function sendDataMessage(payload) {
     sendAgentMessage(ws, {
       type: "data",
-      payload: { ...payload, source: getSource == null ? void 0 : getSource() }
+      payload
     });
   }
   hooks.on("kubb:plugin:start", (ctx) => {
     sendDataMessage({
       type: "kubb:plugin:start",
-      data: [ctx.plugin],
+      data: [{ plugin: ctx.plugin }],
       timestamp: Date.now()
     });
   });
   hooks.on("kubb:plugin:end", (ctx) => {
     sendDataMessage({
       type: "kubb:plugin:end",
-      data: [ctx.plugin, { duration: ctx.duration, success: ctx.success }],
+      data: [{ plugin: ctx.plugin, duration: ctx.duration, success: ctx.success }],
       timestamp: Date.now()
     });
   });
@@ -7483,21 +7414,21 @@ function setupEventsStream(ws, hooks, getSource) {
   hooks.on("kubb:info", ({ message, info }) => {
     sendDataMessage({
       type: "kubb:info",
-      data: [message, info],
+      data: [{ message, info }],
       timestamp: Date.now()
     });
   });
   hooks.on("kubb:success", ({ message, info }) => {
     sendDataMessage({
       type: "kubb:success",
-      data: [message, info],
+      data: [{ message, info }],
       timestamp: Date.now()
     });
   });
   hooks.on("kubb:warn", ({ message, info }) => {
     sendDataMessage({
       type: "kubb:warn",
-      data: [message, info],
+      data: [{ message, info }],
       timestamp: Date.now()
     });
   });
@@ -7513,14 +7444,17 @@ function setupEventsStream(ws, hooks, getSource) {
       timestamp: Date.now()
     });
   });
-  hooks.on("kubb:generation:end", ({ config, files, sources }) => {
+  hooks.on("kubb:generation:end", async ({ config, storage }) => {
     const sourcesRecord = {};
-    sources.forEach((value, key) => {
-      sourcesRecord[key] = value;
-    });
+    for (const key of await storage.getKeys()) {
+      const value = await storage.getItem(key);
+      if (value !== null) {
+        sourcesRecord[key] = value;
+      }
+    }
     sendDataMessage({
       type: "kubb:generation:end",
-      data: [config, files, sourcesRecord],
+      data: [{ config, storage: sourcesRecord }],
       timestamp: Date.now()
     });
   });
@@ -7547,7 +7481,6 @@ async function connectToStudio(options) {
     resolvedConfigPath,
     allowAll,
     allowWrite,
-    allowPublish,
     root,
     retryInterval,
     heartbeatInterval = 3e4,
@@ -7555,7 +7488,6 @@ async function connectToStudio(options) {
     nitro
   } = options;
   const hooks = new AsyncEventEmitter();
-  let currentSource;
   async function reconnect() {
     logger.info(`Retrying connection in ${formatMs$1(retryInterval)} to Kubb Studio ...`);
     setTimeout(() => connectToStudio({ ...options, initialSession: void 0 }), retryInterval);
@@ -7570,7 +7502,6 @@ async function connectToStudio(options) {
     const maskedSessionId = maskString(sessionId);
     const effectiveAllowAll = isSandbox ? false : allowAll;
     const effectiveWrite = isSandbox ? false : allowWrite;
-    const effectivePublish = isSandbox ? false : allowPublish;
     let serverDisconnected = false;
     let heartbeatTimer;
     async function cleanup(reason = "cleanup") {
@@ -7582,6 +7513,7 @@ async function connectToStudio(options) {
         ws.removeEventListener("open", onOpen);
         ws.removeEventListener("close", onClose);
         ws.removeEventListener("error", onError);
+        ws.removeEventListener("message", onMessage);
       } catch (_error) {
       }
     }
@@ -7614,9 +7546,9 @@ async function connectToStudio(options) {
       });
     });
     heartbeatTimer = setInterval(() => sendAgentMessage(ws, { type: "ping" }), heartbeatInterval);
-    setupEventsStream(ws, hooks, () => currentSource);
-    ws.addEventListener("message", async (message) => {
-      var _a2, _b, _c, _d, _e, _f;
+    setupEventsStream(ws, hooks);
+    const onMessage = async (message) => {
+      var _a2, _b, _c, _d;
       try {
         const data = JSON.parse(message.data);
         logger.info(`[${maskedSessionId}] Received "${data.type}" from Studio`);
@@ -7638,11 +7570,11 @@ async function connectToStudio(options) {
         }
         if (isCommandMessage(data)) {
           if (data.command === "generate") {
-            currentSource = "generate";
             const config = await loadConfig(resolvedConfigPath);
             const storedConfig = data.payload ? null : await getLatestStudioConfigFromStorage({ sessionId }).catch(() => null);
             const patch = (_b = (_a2 = data.payload) != null ? _a2 : storedConfig) != null ? _b : void 0;
             const plugins = await mergePlugins(config.plugins, patch == null ? void 0 : patch.plugins);
+            const middleware = (patch == null ? void 0 : patch.middleware) ? await resolveMiddlewares(patch.middleware) : config.middleware;
             const inputOverride = isSandbox ? { data: (_c = patch == null ? void 0 : patch.input) != null ? _c : "" } : void 0;
             if (allowWrite && isSandbox) {
               logger.warn(`[${maskedSessionId}] Agent is running in a sandbox environment, write will be disabled`);
@@ -7658,6 +7590,9 @@ async function connectToStudio(options) {
                 logger.warn(`[${maskedSessionId}] Failed to save studio config: ${err == null ? void 0 : err.message}`);
               });
             }
+            const generationHooks = new AsyncEventEmitter();
+            setupHookListener(generationHooks, root);
+            setupEventsStream(ws, generationHooks);
             await generate({
               config: {
                 ...config,
@@ -7667,12 +7602,15 @@ async function connectToStudio(options) {
                 output: {
                   ...config.output
                 },
-                plugins
+                plugins,
+                middleware,
+                // Studio may send an opaque adapter options blob; forward it unchanged to createKubb.
+                // The adapter factory is responsible for validating and merging its own options.
+                ...(patch == null ? void 0 : patch.adapter) != null && { adapter: patch.adapter }
               },
-              hooks
+              hooks: generationHooks
             });
             logger.success(`[${maskedSessionId}] Completed "${data.type}" from Studio`);
-            currentSource = void 0;
             return;
           }
           if (data.command === "connect") {
@@ -7684,8 +7622,7 @@ async function connectToStudio(options) {
                 configPath,
                 permissions: {
                   allowAll: effectiveAllowAll,
-                  allowWrite: effectiveWrite,
-                  allowPublish: effectivePublish
+                  allowWrite: effectiveWrite
                 },
                 config: {
                   plugins: config.plugins.map((plugin) => ({
@@ -7698,30 +7635,13 @@ async function connectToStudio(options) {
             logger.success(`[${maskedSessionId}] Completed "${data.type}" from Studio`);
             return;
           }
-          if (isPublishCommandMessage(data)) {
-            if (!effectivePublish) {
-              logger.warn(`[${maskedSessionId}] Publish command rejected \u2014 KUBB_AGENT_ALLOW_PUBLISH is not enabled`);
-              return;
-            }
-            currentSource = "publish";
-            const config = await loadConfig(resolvedConfigPath);
-            const resolvedCommand = (_e = (_d = data.payload.command) != null ? _d : process.env.KUBB_AGENT_PUBLISH_COMMAND) != null ? _e : "npm publish";
-            await publish({
-              command: resolvedCommand,
-              outputPath: config.output.path,
-              root,
-              hooks
-            });
-            logger.success(`[${maskedSessionId}] Completed "${data.command}" from Studio`);
-            currentSource = void 0;
-            return;
-          }
         }
         logger.warn(`[${maskedSessionId}] Unknown message type from Kubb Studio: ${message.data}`);
       } catch (error) {
-        logger.error(`[${maskedSessionId}] [unhandledRejection] ${(_f = error == null ? void 0 : error.message) != null ? _f : error}`);
+        logger.error(`[${maskedSessionId}] [unhandledRejection] ${(_d = error == null ? void 0 : error.message) != null ? _d : error}`);
       }
-    });
+    };
+    ws.addEventListener("message", onMessage);
   } catch (error) {
     throw new Error(`[unhandledRejection] ${(_a = error == null ? void 0 : error.message) != null ? _a : error}`, {
       cause: error
@@ -7751,7 +7671,6 @@ function resolveStudioRuntimeConfig(env = process$1.env, cwd = process$1.cwd())
     root,
     allowAll,
     allowWrite: allowAll || parseBooleanEnv(env.KUBB_AGENT_ALLOW_WRITE),
-    allowPublish: allowAll || parseBooleanEnv(env.KUBB_AGENT_ALLOW_PUBLISH),
     poolSize: parsePositiveIntegerEnv(env.KUBB_AGENT_POOL_SIZE, agentDefaults.poolSize),
     hasSecret: Boolean(env.KUBB_AGENT_SECRET)
   };
@@ -7761,7 +7680,7 @@ function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 const _zcw7I4pYH8OiCfaDcjy_x7I6IH1tLDQR3W_yRZgP6E = defineNitroPlugin(async (nitro) => {
-  const { studioUrl, token, configPath, resolvedConfigPath, retryInterval, heartbeatInterval, root, allowAll, allowWrite, allowPublish, poolSize, hasSecret } = resolveStudioRuntimeConfig(process$1.env);
+  const { studioUrl, token, configPath, resolvedConfigPath, retryInterval, heartbeatInterval, root, allowAll, allowWrite, poolSize, hasSecret } = resolveStudioRuntimeConfig(process$1.env);
   if (!token) {
     logger.warn("KUBB_AGENT_TOKEN not set", "cannot authenticate with studio");
     return null;
@@ -7771,6 +7690,7 @@ const _zcw7I4pYH8OiCfaDcjy_x7I6IH1tLDQR3W_yRZgP6E = defineNitroPlugin(async (nit
   }
   const maskedToken = maskString(token);
   try {
+    await checkPeerDependencies();
     await registerAgent({ token, studioUrl, poolSize });
     const baseOptions = {
       token,
@@ -7779,7 +7699,6 @@ const _zcw7I4pYH8OiCfaDcjy_x7I6IH1tLDQR3W_yRZgP6E = defineNitroPlugin(async (nit
       resolvedConfigPath,
       allowAll,
       allowWrite,
-      allowPublish,
       root,
       retryInterval,
       heartbeatInterval,