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

package/dist/{PluginDriver-BXibeQk-.cjs → KubbDriver-BXSnJ3qM.cjs}

@@ -93,11 +93,386 @@ function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
 //#endregion
+//#region ../../internals/utils/src/promise.ts
+function* chunks(arr, size) {
+	for (let i = 0; i < arr.length; i += size) yield arr.slice(i, i + size);
+}
+/**
+* Slices `source` into batches of `concurrency` items and awaits `process` for each batch.
+* Accepts both plain arrays (sync) and `AsyncIterable` (streaming).
+*
+* `process` controls whether items inside a batch run in parallel; this helper only
+* controls batch size and per-batch flushing.
+*
+* @example
+* ```ts
+* // parallel dispatch inside each batch
+* await forBatches(schemas, (batch) => Promise.all(batch.map(process)), { concurrency: 8 })
+*
+* // async iterable with a flush after every batch
+* await forBatches(stream.schemas, (batch) => dispatch(batch), { concurrency: 8, flush })
+* ```
+*/
+async function forBatches(source, process, options) {
+	const { concurrency, flush } = options;
+	if (Array.isArray(source)) {
+		for (const batch of chunks(source, concurrency)) {
+			await process(batch);
+			if (flush) await flush();
+		}
+		return;
+	}
+	const batch = [];
+	for await (const item of source) {
+		batch.push(item);
+		if (batch.length >= concurrency) {
+			await process(batch.splice(0));
+			if (flush) await flush();
+		}
+	}
+	if (batch.length > 0) {
+		await process(batch.splice(0));
+		if (flush) await flush();
+	}
+}
+/**
+* Runs `work`, passing `flush` as its periodic-flush callback, then calls
+* `flush` once more to drain any items that did not cross a flush boundary.
+*
+* @example
+* ```ts
+* await withDrain(
+*   (flush) => processItems(items, { flush }),
+*   () => writeRemainingFiles(),
+* )
+* ```
+*/
+async function withDrain(work, flush) {
+	await work(flush);
+	await flush();
+}
+/** Returns `true` when `result` is a thenable `Promise`.
+*
+* @example
+* ```ts
+* isPromise(Promise.resolve(1)) // true
+* isPromise(42)                 // false
+* ```
+*/
+function isPromise(result) {
+	return result !== null && result !== void 0 && typeof result["then"] === "function";
+}
+/**
+* Wraps `factory` with a keyed cache backed by the provided store.
+*
+* Pass a `WeakMap` for object keys (results are GC-eligible when the key is
+* collected) or a `Map` for primitive keys. For multi-argument functions,
+* nest two `memoize` calls — the outer keyed by the first argument, the
+* inner (created once per outer miss) keyed by the second.
+*
+* Because the cache is owned by the caller, it can be shared, inspected, or
+* cleared independently of the memoized function.
+*
+* @example Single WeakMap key
+* ```ts
+* const cache = new WeakMap<SchemaNode, Set<string>>()
+* const getRefs = memoize(cache, (node) => collectRefs(node))
+* ```
+*
+* @example Single Map key (primitive)
+* ```ts
+* const cache = new Map<string, Resolver>()
+* const getResolver = memoize(cache, (name) => buildResolver(name))
+* ```
+*
+* @example Two-level (object + primitive)
+* ```ts
+* const outer = new WeakMap<Params[], Map<string, Params[]>>()
+* const fn = memoize(outer, (params) => memoize(new Map(), (key) => transform(params, key)))
+* fn(params)('camelcase')
+* ```
+*/
+function memoize(store, factory) {
+	return (key) => {
+		if (store.has(key)) return store.get(key);
+		const value = factory(key);
+		store.set(key, value);
+		return value;
+	};
+}
+/**
+* Wraps a plain array in a reusable `AsyncIterable`.
+* Each `[Symbol.asyncIterator]()` call returns a fresh generator so the
+* iterable can be consumed multiple times (e.g. once per plugin pre-scan).
+*
+* @example
+* ```ts
+* const stream = arrayToAsyncIterable([1, 2, 3])
+* for await (const n of stream) console.log(n) // 1, 2, 3
+* ```
+*/
+function arrayToAsyncIterable(arr) {
+	return { [Symbol.asyncIterator]() {
+		return (async function* () {
+			yield* arr;
+		})();
+	} };
+}
+//#endregion
+//#region ../../internals/utils/src/reserved.ts
+/**
+* JavaScript and Java reserved words.
+* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+*/
+const reservedWords = 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"
+]);
+/**
+* Returns `true` when `name` is a syntactically valid JavaScript variable name.
+*
+* @example
+* ```ts
+* isValidVarName('status')  // true
+* isValidVarName('class')   // false (reserved word)
+* isValidVarName('42foo')   // false (starts with digit)
+* ```
+*/
+function isValidVarName(name) {
+	if (!name || reservedWords.has(name)) return false;
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+//#endregion
+//#region ../../internals/utils/src/urlPath.ts
+/**
+* Parses and transforms an OpenAPI/Swagger path string into various URL formats.
+*
+* @example
+* const p = new URLPath('/pet/{petId}')
+* p.URL      // '/pet/:petId'
+* p.template // '`/pet/${petId}`'
+*/
+var URLPath = class {
+	/**
+	* The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
+	*/
+	path;
+	#options;
+	constructor(path, options = {}) {
+		this.path = path;
+		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();
+	}
+	#transformParam(raw) {
+		const param = isValidVarName(raw) ? raw : camelCase(raw);
+		return 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) {
+		for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
+			const raw = match[1];
+			fn(raw, this.#transformParam(raw));
+		}
+	}
+	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 = this.#transformParam(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 = {};
+		this.#eachParam((_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");
+	}
+};
+//#endregion
 //#region src/constants.ts
 /**
 * Base URL for the Kubb Studio web app.
 */
-const DEFAULT_STUDIO_URL = "https://studio.kubb.dev";
+const DEFAULT_STUDIO_URL = "https://kubb.studio";
 /**
 * Default banner style written at the top of every generated file.
 */
@@ -120,6 +495,42 @@ const logLevel = {
 	debug: 5
 };
 //#endregion
+//#region src/definePlugin.ts
+/**
+* Wraps a factory function and returns a typed `Plugin` with lifecycle handlers grouped under `hooks`.
+*
+* Handlers live in a single `hooks` object (inspired by Astro integrations).
+* All lifecycle events from `KubbHooks` are available for subscription.
+*
+* @note For real plugins, use a `PluginFactoryOptions` type parameter to get type-safe context in `kubb:plugin:setup`.
+* Plugin names should follow the convention `plugin-<feature>` (e.g., `plugin-react-query`, `plugin-zod`).
+*
+* @example
+* ```ts
+* import { definePlugin } from '@kubb/core'
+*
+* export const pluginTs = definePlugin((options: { prefix?: string } = {}) => ({
+*   name: 'plugin-ts',
+*   hooks: {
+*     'kubb:plugin:setup'(ctx) {
+*       ctx.setResolver(resolverTs)
+*     },
+*   },
+* }))
+* ```
+*/
+function definePlugin(factory) {
+	return (options) => factory(options ?? {});
+}
+/**
+* Returns `'single'` when `fileOrFolder` has a file extension, `'split'` otherwise.
+* Used to determine whether an output path targets a single file or a directory.
+*/
+function getMode(fileOrFolder) {
+	if (!fileOrFolder) return "split";
+	return (0, node_path.extname)(fileOrFolder) ? "single" : "split";
+}
+//#endregion
 //#region src/defineResolver.ts
 const stringPatternCache = /* @__PURE__ */ new Map();
 function testPattern(value, pattern) {
@@ -137,14 +548,12 @@ function testPattern(value, pattern) {
 * Checks if an operation matches a pattern for a given filter type (`tag`, `operationId`, `path`, `method`).
 */
 function matchesOperationPattern(node, type, pattern) {
-	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 node.requestBody?.content?.some((c) => testPattern(c.contentType, pattern)) ?? false;
-		default: return false;
-	}
+	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 node.requestBody?.content?.some((c) => testPattern(c.contentType, pattern)) ?? false;
+	return false;
 }
 /**
 * Checks if a schema matches a pattern for a given filter type (`schemaName`).
@@ -152,10 +561,8 @@ function matchesOperationPattern(node, type, pattern) {
 * Returns `null` when the filter type doesn't apply to schemas.
 */
 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;
 }
 /**
 * Default name resolver used by `defineResolver`.
@@ -165,10 +572,9 @@ function matchesSchemaPattern(node, type, pattern) {
 * - `camelCase` for everything else.
 */
 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);
 }
 /**
 * Default option resolver — applies include/exclude filters and merges matching override options.
@@ -193,7 +599,8 @@ function defaultResolver(name, type) {
 * // → { enumType: 'enum' } when operationId matches
 * ```
 */
-function defaultResolveOptions(node, { options, exclude = [], include, override = [] }) {
+const resolveOptionsCache = /* @__PURE__ */ new WeakMap();
+function computeOptions(node, options, exclude, include, override) {
 	if ((0, _kubb_ast.isOperationNode)(node)) {
 		if (exclude.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) return null;
 		if (include && !include.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) return null;
@@ -217,6 +624,19 @@ 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;
+}
 /**
 * Default path resolver used by `defineResolver`.
 *
@@ -262,17 +682,19 @@ function defaultResolveOptions(node, { options, exclude = [], include, override
 * ```
 */
 function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }, { root, output, group }) {
-	if ((pathMode ?? PluginDriver.getMode(node_path.default.resolve(root, output.path))) === "single") return node_path.default.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 = group.name ?? defaultName;
-		result = node_path.default.resolve(root, output.path, resolveName({ group: groupValue }), baseName);
-	} else result = node_path.default.resolve(root, output.path, baseName);
+	if ((pathMode ?? getMode(node_path.default.resolve(root, output.path))) === "single") return node_path.default.resolve(root, output.path);
+	const 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 = group.name ?? defaultName;
+			return node_path.default.resolve(root, output.path, resolveName({ group: groupValue }), baseName);
+		}
+		return node_path.default.resolve(root, output.path, baseName);
+	})();
 	const outputDir = node_path.default.resolve(root, output.path);
 	const outputDirWithSep = outputDir.endsWith(node_path.default.sep) ? outputDir : `${outputDir}${node_path.default.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.`);
@@ -289,28 +711,28 @@ function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }, { root
 *
 * @example Resolve a schema file
 * ```ts
-* const file = defaultResolveFile(
+* const file = defaultResolveFile.call(
+*   resolver,
 *   { name: 'pet', extname: '.ts' },
 *   { root: '/src', output: { path: 'types' } },
-*   resolver,
 * )
 * // → { baseName: 'pet.ts', path: '/src/types/pet.ts', sources: [], ... }
 * ```
 *
 * @example Resolve an operation file with tag grouping
 * ```ts
-* const file = defaultResolveFile(
+* const file = defaultResolveFile.call(
+*   resolver,
 *   { name: 'listPets', extname: '.ts', tag: 'pets' },
 *   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
-*   resolver,
 * )
 * // → { baseName: 'listPets.ts', path: '/src/types/petsController/listPets.ts', ... }
 * ```
 */
-function defaultResolveFile({ name, extname, tag, path: groupPath }, context, ctx) {
-	const pathMode = PluginDriver.getMode(node_path.default.resolve(context.root, context.output.path));
-	const baseName = `${pathMode === "single" ? "" : ctx.default(name, "file")}${extname}`;
-	const filePath = ctx.resolvePath({
+function defaultResolveFile({ name, extname, tag, path: groupPath }, context) {
+	const pathMode = getMode(node_path.default.resolve(context.root, context.output.path));
+	const baseName = `${pathMode === "single" ? "" : this.default(name, "file")}${extname}`;
+	const filePath = this.resolvePath({
 		baseName,
 		pathMode,
 		tag,
@@ -319,7 +741,7 @@ function defaultResolveFile({ name, extname, tag, path: groupPath }, context, ct
 	return (0, _kubb_ast.createFile)({
 		path: filePath,
 		baseName: node_path.default.basename(filePath),
-		meta: { pluginName: ctx.pluginName },
+		meta: { pluginName: this.pluginName },
 		sources: [],
 		imports: [],
 		exports: []
@@ -330,12 +752,16 @@ function defaultResolveFile({ name, extname, tag, path: groupPath }, context, ct
 */
 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 = node_path.default.basename(first.path);
-		} else if ("path" in config.input) source = node_path.default.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 node_path.default.basename(first.path);
+				return "";
+			}
+			if (config.input && "path" in config.input) return node_path.default.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";
@@ -359,10 +785,9 @@ function buildDefaultBanner({ title, description, version, config }) {
 *
 * A user-supplied `output.banner` overrides the default Kubb "Generated by Kubb" notice.
 * When no `output.banner` is set, the Kubb notice is used (including `title` and `version`
-* from the OAS spec when a `node` is provided).
+* from the document metadata when `meta` is provided).
 *
-* - When `output.banner` is a function and `node` is provided, returns `output.banner(node)`.
-* - When `output.banner` is a function and `node` is absent, falls back to the Kubb notice.
+* - When `output.banner` is a function, calls it with `meta` and returns the result.
 * - When `output.banner` is a string, returns it directly.
 * - When `config.output.defaultBanner` is `false`, returns `undefined`.
 * - Otherwise returns the Kubb "Generated by Kubb" notice.
@@ -373,15 +798,15 @@ function buildDefaultBanner({ title, description, version, config }) {
 * // → '// my banner'
 * ```
 *
-* @example Function banner with node
+* @example Function banner with metadata
 * ```ts
-* defaultResolveBanner(inputNode, { output: { banner: (node) => `// v${node.version}` }, config })
+* defaultResolveBanner(meta, { output: { banner: (m) => `// v${m?.version}` }, config })
 * // → '// v3.0.0'
 * ```
 *
 * @example No user banner — Kubb notice with OAS metadata
 * ```ts
-* defaultResolveBanner(inputNode, { config })
+* defaultResolveBanner(meta, { config })
 * // → '/** Generated by Kubb ... Title: Pet Store ... *\/'
 * ```
 *
@@ -391,21 +816,20 @@ function buildDefaultBanner({ title, description, version, config }) {
 * // → undefined
 * ```
 */
-function defaultResolveBanner(node, { output, config }) {
-	if (typeof output?.banner === "function") return output.banner(node);
+function defaultResolveBanner(meta, { output, config }) {
+	if (typeof output?.banner === "function") return output.banner(meta);
 	if (typeof output?.banner === "string") return output.banner;
 	if (config.output.defaultBanner === false) return;
 	return buildDefaultBanner({
-		title: node?.meta?.title,
-		version: node?.meta?.version,
+		title: meta?.title,
+		version: meta?.version,
 		config
 	});
 }
 /**
 * Default footer resolver — returns the footer string for a generated file.
 *
-* - When `output.footer` is a function and `node` is provided, calls it with the node.
-* - When `output.footer` is a function and `node` is absent, returns `undefined`.
+* - When `output.footer` is a function, calls it with `meta` and returns the result.
 * - When `output.footer` is a string, returns it directly.
 * - Otherwise returns `undefined`.
 *
@@ -415,14 +839,14 @@ function defaultResolveBanner(node, { output, config }) {
 * // → '// end of file'
 * ```
 *
-* @example Function footer with node
+* @example Function footer with metadata
 * ```ts
-* defaultResolveFooter(inputNode, { output: { footer: (node) => `// ${node.title}` }, config })
+* defaultResolveFooter(meta, { output: { footer: (m) => `// ${m?.title}` }, config })
 * // → '// Pet Store'
 * ```
 */
-function defaultResolveFooter(node, { output }) {
-	if (typeof output?.footer === "function") return node ? output.footer(node) : void 0;
+function defaultResolveFooter(meta, { output }) {
+	if (typeof output?.footer === "function") return output.footer(meta);
 	if (typeof output?.footer === "string") return output.footer;
 }
 /**
@@ -435,25 +859,24 @@ function defaultResolveFooter(node, { output }) {
 * - `resolvePath` — output path computation
 * - `resolveFile` — full `FileNode` construction
 *
-* The builder receives `ctx` — a reference to the assembled resolver — so methods can
-* call sibling resolver methods using `ctx` instead of `this`.
+* Methods in the returned object can call sibling resolver methods via `this`.
 *
 * @example Basic resolver with naming helpers
 * ```ts
-* export const resolver = defineResolver<PluginTs>((ctx) => ({
+* export const resolver = defineResolver<PluginTs>(() => ({
 *   name: 'default',
 *   resolveName(node) {
-*     return ctx.default(node.name, 'function')
+*     return this.default(node.name, 'function')
 *   },
 *   resolveTypedName(node) {
-*     return ctx.default(node.name, 'type')
+*     return this.default(node.name, 'type')
 *   },
 * }))
 * ```
 *
 * @example Override resolvePath for a custom output structure
 * ```ts
-* export const resolver = defineResolver<PluginTs>((_ctx) => ({
+* export const resolver = defineResolver<PluginTs>(() => ({
 *   name: 'custom',
 *   resolvePath({ baseName }, { root, output }) {
 *     return path.resolve(root, output.path, 'generated', baseName)
@@ -461,27 +884,27 @@ function defaultResolveFooter(node, { output }) {
 * }))
 * ```
 *
-* @example Use ctx.default inside a helper
+* @example Use this.default inside a helper
 * ```ts
-* export const resolver = defineResolver<PluginTs>((ctx) => ({
+* export const resolver = defineResolver<PluginTs>(() => ({
 *   name: 'default',
 *   resolveParamName(node, param) {
-*     return ctx.default(`${node.operationId} ${param.in} ${param.name}`, 'type')
+*     return this.default(`${node.operationId} ${param.in} ${param.name}`, 'type')
 *   },
 * }))
 * ```
 */
 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;
 }
 //#endregion
@@ -609,6 +1032,16 @@ var FileManager = class {
 		this.#filesCache = null;
 	}
 	/**
+	* Releases all stored files. Called by the core after `kubb:build:end` to
+	* free the per-plugin FileNode caches for the rest of the process lifetime.
+	*/
+	dispose() {
+		this.clear();
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+	/**
 	* All stored files, sorted by path length (shorter paths first).
 	*/
 	get files() {
@@ -626,35 +1059,11 @@ var FileManager = class {
 	}
 };
 //#endregion
-//#region src/renderNode.ts
-/**
-* Handles the return value of a plugin AST hook or generator method.
-*
-* - Renderer output → rendered via the provided `rendererFactory` (e.g. JSX), files stored in `driver.fileManager`
-* - `Array<FileNode>` → added directly into `driver.fileManager`
-* - `void` / `null` / `undefined` → no-op (plugin handled it via `this.upsertFile`)
-*
-* Pass a `rendererFactory` (e.g. `jsxRenderer` from `@kubb/renderer-jsx`) when the result
-* may be a renderer element. Generators that only return `Array<FileNode>` do not need one.
-*/
-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();
-}
-//#endregion
-//#region src/PluginDriver.ts
+//#region src/KubbDriver.ts
 function enforceOrder(enforce) {
 	return enforce === "pre" ? -1 : enforce === "post" ? 1 : 0;
 }
-var PluginDriver = class PluginDriver {
+var KubbDriver = class KubbDriver {
 	config;
 	options;
 	/**
@@ -662,21 +1071,34 @@ var PluginDriver = class PluginDriver {
 	*
 	* @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 (0, node_path.extname)(fileOrFolder) ? "single" : "split";
+		return getMode(fileOrFolder);
 	}
 	/**
-	* 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.
 	*/
 	inputNode = void 0;
 	adapter = void 0;
-	#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.
+	*/
+	#studio = {
+		source: void 0,
+		isOpen: false,
+		inputNode: void 0
+	};
+	#middlewareListeners = [];
 	/**
 	* Central file store for all generated files.
 	* Plugins should use `this.addFile()` / `this.upsertFile()` (via their context) to
@@ -688,23 +1110,29 @@ var PluginDriver = class PluginDriver {
 	* 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.
 	*/
-	#pluginsWithEventGenerators = /* @__PURE__ */ new Set();
+	#eventGeneratorPlugins = /* @__PURE__ */ new Set();
 	#resolvers = /* @__PURE__ */ new Map();
 	#defaultResolvers = /* @__PURE__ */ new Map();
 	#hookListeners = /* @__PURE__ */ new Map();
 	constructor(config, options) {
 		this.config = config;
 		this.options = options;
-		config.plugins.map((rawPlugin) => this.#normalizePlugin(rawPlugin)).filter((plugin) => {
-			if (typeof plugin.apply === "function") return plugin.apply(config);
-			return true;
-		}).sort((a, b) => {
+		this.adapter = config.adapter;
+	}
+	async setup() {
+		const normalized = this.config.plugins.map((rawPlugin) => this.#normalizePlugin(rawPlugin));
+		normalized.sort((a, b) => {
 			if (b.dependencies?.includes(a.name)) return -1;
 			if (a.dependencies?.includes(b.name)) return 1;
 			return enforceOrder(a.enforce) - enforceOrder(b.enforce);
-		}).forEach((plugin) => {
-			this.plugins.set(plugin.name, plugin);
 		});
+		for (const plugin of normalized) {
+			if (plugin.apply) plugin.apply(this.config);
+			this.#registerPlugin(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)) this.#registerMiddleware(event, middleware.hooks);
+		if (this.config.adapter) await this.#registerAdapter(this.config.adapter);
 	}
 	get hooks() {
 		return this.options.hooks;
@@ -713,19 +1141,48 @@ var PluginDriver = class PluginDriver {
 	* Creates an `NormalizedPlugin` from a hook-style plugin and registers
 	* its lifecycle handlers on the `AsyncEventEmitter`.
 	*/
-	#normalizePlugin(hookPlugin) {
-		const normalizedPlugin = {
-			name: hookPlugin.name,
-			dependencies: hookPlugin.dependencies,
-			enforce: hookPlugin.enforce,
-			options: {
+	#normalizePlugin(plugin) {
+		const normalized = {
+			name: plugin.name,
+			dependencies: plugin.dependencies,
+			enforce: plugin.enforce,
+			hooks: plugin.hooks,
+			options: plugin.options ?? {
 				output: { path: "." },
 				exclude: [],
 				override: []
 			}
 		};
-		this.registerPluginHooks(hookPlugin, normalizedPlugin);
-		return normalizedPlugin;
+		if ("apply" in plugin && typeof plugin.apply === "function") normalized.apply = plugin.apply;
+		return normalized;
+	}
+	async #registerAdapter(adapter) {
+		const source = inputToAdapterSource(this.config);
+		this.#studio.source = source;
+		if (adapter.stream) {
+			this.inputNode = await adapter.stream(source);
+			await this.hooks.emit("kubb:debug", {
+				date: /* @__PURE__ */ new Date(),
+				logs: [`✓ Adapter '${adapter.name}' producing input stream`]
+			});
+		} else {
+			const inputNode = await adapter.parse(source);
+			this.inputNode = (0, _kubb_ast.createStreamInput)(arrayToAsyncIterable(inputNode.schemas), arrayToAsyncIterable(inputNode.operations), inputNode.meta);
+			await this.hooks.emit("kubb:debug", {
+				date: /* @__PURE__ */ new Date(),
+				logs: [
+					`✓ Adapter '${adapter.name}' resolved InputNode (wrapped as stream)`,
+					`  • Schemas: ${inputNode.schemas.length}`,
+					`  • Operations: ${inputNode.operations.length}`
+				]
+			});
+		}
+	}
+	#registerMiddleware(event, middlewareHooks) {
+		const handler = middlewareHooks[event];
+		if (!handler) return;
+		this.hooks.on(event, handler);
+		this.#middlewareListeners.push([event, handler]);
 	}
 	/**
 	* Registers a hook-style plugin's lifecycle handlers on the shared `AsyncEventEmitter`.
@@ -742,28 +1199,29 @@ var PluginDriver = class PluginDriver {
 	*
 	* @internal
 	*/
-	registerPluginHooks(hookPlugin, normalizedPlugin) {
-		const { hooks } = hookPlugin;
+	#registerPlugin(plugin) {
+		const { hooks } = plugin;
+		if (!hooks) return;
 		if (hooks["kubb:plugin:setup"]) {
 			const setupHandler = (globalCtx) => {
 				const pluginCtx = {
 					...globalCtx,
-					options: hookPlugin.options ?? {},
+					options: plugin.options ?? {},
 					addGenerator: (gen) => {
-						this.registerGenerator(normalizedPlugin.name, gen);
+						this.registerGenerator(plugin.name, gen);
 					},
 					setResolver: (resolver) => {
-						this.setPluginResolver(normalizedPlugin.name, resolver);
+						this.setPluginResolver(plugin.name, resolver);
 					},
 					setTransformer: (visitor) => {
-						normalizedPlugin.transformer = visitor;
+						plugin.transformer = visitor;
 					},
 					setRenderer: (renderer) => {
-						normalizedPlugin.renderer = renderer;
+						plugin.renderer = renderer;
 					},
 					setOptions: (opts) => {
-						normalizedPlugin.options = {
-							...normalizedPlugin.options,
+						plugin.options = {
+							...plugin.options,
 							...opts
 						};
 					},
@@ -824,7 +1282,11 @@ var PluginDriver = class PluginDriver {
 		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);
 			this.#trackHookListener("kubb:generate:schema", schemaHandler);
@@ -832,7 +1294,11 @@ var PluginDriver = class PluginDriver {
 		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);
 			this.#trackHookListener("kubb:generate:operation", operationHandler);
@@ -840,12 +1306,16 @@ var PluginDriver = class PluginDriver {
 		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);
 			this.#trackHookListener("kubb:generate:operations", operationsHandler);
 		}
-		this.#pluginsWithEventGenerators.add(pluginName);
+		this.#eventGeneratorPlugins.add(pluginName);
 	}
 	/**
 	* Returns `true` when at least one generator was registered for the given plugin
@@ -854,8 +1324,8 @@ var PluginDriver = class PluginDriver {
 	* 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 this.#pluginsWithEventGenerators.has(pluginName);
+	hasEventGenerators(pluginName) {
+		return this.#eventGeneratorPlugins.has(pluginName);
 	}
 	/**
 	* Unregisters all plugin lifecycle listeners from the shared event emitter.
@@ -866,7 +1336,20 @@ var PluginDriver = class PluginDriver {
 	dispose() {
 		for (const [event, handlers] of this.#hookListeners) for (const handler of handlers) this.hooks.off(event, handler);
 		this.#hookListeners.clear();
-		this.#pluginsWithEventGenerators.clear();
+		this.#eventGeneratorPlugins.clear();
+		this.#resolvers.clear();
+		this.#defaultResolvers.clear();
+		this.fileManager.dispose();
+		this.inputNode = void 0;
+		this.#studio = {
+			source: void 0,
+			isOpen: false,
+			inputNode: void 0
+		};
+		for (const [event, handler] of this.#middlewareListeners) this.hooks.off(event, handler);
+	}
+	[Symbol.dispose]() {
+		this.dispose();
 	}
 	#trackHookListener(event, handler) {
 		let handlers = this.#hookListeners.get(event);
@@ -876,16 +1359,10 @@ var PluginDriver = class PluginDriver {
 		}
 		handlers.add(handler);
 	}
-	#createDefaultResolver(pluginName) {
-		const existingResolver = this.#defaultResolvers.get(pluginName);
-		if (existingResolver) return existingResolver;
-		const resolver = defineResolver((_ctx) => ({
-			name: "default",
-			pluginName
-		}));
-		this.#defaultResolvers.set(pluginName, resolver);
-		return resolver;
-	}
+	#getDefaultResolver = memoize(this.#defaultResolvers, (pluginName) => defineResolver(() => ({
+		name: "default",
+		pluginName
+	})));
 	/**
 	* Merges `partial` with the plugin's default resolver and stores the result.
 	* Also mirrors it onto `plugin.resolver` so callers using `getPlugin(name).resolver`
@@ -893,7 +1370,7 @@ var PluginDriver = class PluginDriver {
 	*/
 	setPluginResolver(pluginName, partial) {
 		const merged = {
-			...this.#createDefaultResolver(pluginName),
+			...this.#getDefaultResolver(pluginName),
 			...partial
 		};
 		this.#resolvers.set(pluginName, merged);
@@ -901,7 +1378,7 @@ var PluginDriver = class PluginDriver {
 		if (plugin) plugin.resolver = merged;
 	}
 	getResolver(pluginName) {
-		return this.#resolvers.get(pluginName) ?? this.plugins.get(pluginName)?.resolver ?? this.#createDefaultResolver(pluginName);
+		return this.#resolvers.get(pluginName) ?? this.plugins.get(pluginName)?.resolver ?? this.#getDefaultResolver(pluginName);
 	}
 	getContext(plugin) {
 		const driver = this;
@@ -911,7 +1388,7 @@ var PluginDriver = class PluginDriver {
 				return (0, node_path.resolve)(driver.config.root, driver.config.output.path);
 			},
 			getMode(output) {
-				return PluginDriver.getMode((0, node_path.resolve)(driver.config.root, driver.config.output.path, output.path));
+				return KubbDriver.getMode((0, node_path.resolve)(driver.config.root, driver.config.output.path, output.path));
 			},
 			hooks: driver.hooks,
 			plugin,
@@ -925,8 +1402,11 @@ var PluginDriver = class PluginDriver {
 			upsertFile: async (...files) => {
 				driver.fileManager.upsert(...files);
 			},
-			get inputNode() {
-				return driver.inputNode;
+			get meta() {
+				return driver.inputNode?.meta ?? {
+					circularNames: [],
+					enumNames: []
+				};
 			},
 			get adapter() {
 				return driver.adapter;
@@ -946,13 +1426,14 @@ var PluginDriver = class PluginDriver {
 			info(message) {
 				driver.hooks.emit("kubb:info", { message });
 			},
-			openInStudio(options) {
-				if (!driver.config.devtools || driver.#studioIsOpen) return;
+			async openInStudio(options) {
+				if (!driver.config.devtools || 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");
-				driver.#studioIsOpen = true;
-				const studioUrl = driver.config.devtools?.studioUrl ?? "https://studio.kubb.dev";
-				return openInStudio(driver.inputNode, studioUrl, options);
+				if (!driver.adapter || !driver.#studio.source) throw new Error("adapter is not defined, make sure you have set the parser in kubb.config.ts");
+				driver.#studio.isOpen = true;
+				const studioUrl = driver.config.devtools?.studioUrl ?? "https://kubb.studio";
+				driver.#studio.inputNode ??= Promise.resolve(driver.adapter.parse(driver.#studio.source));
+				return openInStudio(await driver.#studio.inputNode, studioUrl, options);
 			}
 		};
 	}
@@ -965,6 +1446,56 @@ var PluginDriver = class PluginDriver {
 		return plugin;
 	}
 };
+/**
+* Handles the return value of a plugin AST hook or generator method.
+*
+* - Renderer output → rendered via the provided `rendererFactory` (e.g. JSX), files stored in `driver.fileManager`
+* - `Array<FileNode>` → added directly into `driver.fileManager`
+* - `void` / `null` / `undefined` → no-op (plugin handled it via `this.upsertFile`)
+*
+* Pass a `rendererFactory` (e.g. `jsxRenderer` from `@kubb/renderer-jsx`) when the result
+* may be a renderer element. Generators that only return `Array<FileNode>` do not need one.
+*/
+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: (0, node_path.resolve)(config.root, input.path)
+	};
+}
 //#endregion
 Object.defineProperty(exports, "DEFAULT_BANNER", {
 	enumerable: true,
@@ -990,10 +1521,16 @@ Object.defineProperty(exports, "FileManager", {
 		return FileManager;
 	}
 });
-Object.defineProperty(exports, "PluginDriver", {
+Object.defineProperty(exports, "KubbDriver", {
 	enumerable: true,
 	get: function() {
-		return PluginDriver;
+		return KubbDriver;
+	}
+});
+Object.defineProperty(exports, "URLPath", {
+	enumerable: true,
+	get: function() {
+		return URLPath;
 	}
 });
 Object.defineProperty(exports, "__name", {
@@ -1014,10 +1551,10 @@ Object.defineProperty(exports, "applyHookResult", {
 		return applyHookResult;
 	}
 });
-Object.defineProperty(exports, "camelCase", {
+Object.defineProperty(exports, "definePlugin", {
 	enumerable: true,
 	get: function() {
-		return camelCase;
+		return definePlugin;
 	}
 });
 Object.defineProperty(exports, "defineResolver", {
@@ -1026,11 +1563,29 @@ Object.defineProperty(exports, "defineResolver", {
 		return defineResolver;
 	}
 });
+Object.defineProperty(exports, "forBatches", {
+	enumerable: true,
+	get: function() {
+		return forBatches;
+	}
+});
+Object.defineProperty(exports, "isPromise", {
+	enumerable: true,
+	get: function() {
+		return isPromise;
+	}
+});
 Object.defineProperty(exports, "logLevel", {
 	enumerable: true,
 	get: function() {
 		return logLevel;
 	}
 });
+Object.defineProperty(exports, "withDrain", {
+	enumerable: true,
+	get: function() {
+		return withDrain;
+	}
+});
 
-//# sourceMappingURL=PluginDriver-BXibeQk-.cjs.map
+//# sourceMappingURL=KubbDriver-BXSnJ3qM.cjs.map