@kubb/core 5.0.0-beta.4 → 5.0.0-beta.40

package/dist/memoryStorage-Dkxnid2K.cjs

@@ -0,0 +1,2985 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_events = require("node:events");
+let node_util = require("node:util");
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let _kubb_ast = require("@kubb/ast");
+let node_async_hooks = require("node:async_hooks");
+//#region ../../internals/utils/src/errors.ts
+/**
+* Thrown when one or more errors occur during a Kubb build.
+* Carries the full list of underlying errors on `errors`.
+*
+* @example
+* ```ts
+* throw new BuildError('Build failed', { errors: [err1, err2] })
+* ```
+*/
+var BuildError = class extends Error {
+	errors;
+	constructor(message, options) {
+		super(message, { cause: options.cause });
+		this.name = "BuildError";
+		this.errors = options.errors;
+	}
+};
+/**
+* Coerces an unknown thrown value to an `Error` instance.
+* Returns the value as-is when it is already an `Error`; otherwise wraps it with `String(value)`.
+*
+* @example
+* ```ts
+* try { ... } catch(err) {
+*   throw new BuildError('Build failed', { cause: toError(err), errors: [] })
+* }
+* ```
+*/
+function toError(value) {
+	return value instanceof Error ? value : new Error(String(value));
+}
+/**
+* Extracts a human-readable message from any thrown value.
+*
+* @example
+* ```ts
+* getErrorMessage(new Error('oops')) // 'oops'
+* getErrorMessage('plain string')    // 'plain string'
+* ```
+*/
+function getErrorMessage(value) {
+	return value instanceof Error ? value.message : String(value);
+}
+//#endregion
+//#region ../../internals/utils/src/asyncEventEmitter.ts
+/**
+* Typed `EventEmitter` that awaits all async listeners before resolving.
+* Wraps Node's `EventEmitter` with full TypeScript event-map inference.
+*
+* @example
+* ```ts
+* const emitter = new AsyncEventEmitter<{ build: [name: string] }>()
+* emitter.on('build', async (name) => { console.log(name) })
+* await emitter.emit('build', 'petstore') // all listeners awaited
+* ```
+*/
+var AsyncEventEmitter = class {
+	/**
+	* Maximum number of listeners per event before Node emits a memory-leak warning.
+	* @default 10
+	*/
+	constructor(maxListener = 10) {
+		this.#emitter.setMaxListeners(maxListener);
+	}
+	#emitter = new node_events.EventEmitter();
+	/**
+	* Emits `eventName` and awaits all registered listeners sequentially.
+	* Throws if any listener rejects, wrapping the cause with the event name and serialized arguments.
+	*
+	* @example
+	* ```ts
+	* await emitter.emit('build', 'petstore')
+	* ```
+	*/
+	emit(eventName, ...eventArgs) {
+		const listeners = this.#emitter.listeners(eventName);
+		if (listeners.length === 0) return;
+		return this.#emitAll(eventName, listeners, eventArgs);
+	}
+	async #emitAll(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) });
+		}
+	}
+	/**
+	* Registers a persistent listener for `eventName`.
+	*
+	* @example
+	* ```ts
+	* emitter.on('build', async (name) => { console.log(name) })
+	* ```
+	*/
+	on(eventName, handler) {
+		this.#emitter.on(eventName, handler);
+	}
+	/**
+	* Registers a one-shot listener that removes itself after the first invocation.
+	*
+	* @example
+	* ```ts
+	* emitter.onOnce('build', async (name) => { console.log(name) })
+	* ```
+	*/
+	onOnce(eventName, handler) {
+		const wrapper = (...args) => {
+			this.off(eventName, wrapper);
+			return handler(...args);
+		};
+		this.on(eventName, wrapper);
+	}
+	/**
+	* Removes a previously registered listener.
+	*
+	* @example
+	* ```ts
+	* emitter.off('build', handler)
+	* ```
+	*/
+	off(eventName, handler) {
+		this.#emitter.off(eventName, handler);
+	}
+	/**
+	* Returns the number of listeners registered for `eventName`.
+	*
+	* @example
+	* ```ts
+	* emitter.on('build', handler)
+	* emitter.listenerCount('build') // 1
+	* ```
+	*/
+	listenerCount(eventName) {
+		return this.#emitter.listenerCount(eventName);
+	}
+	/**
+	* Raises or lowers the per-event listener ceiling before Node warns about a memory leak.
+	* Set this above the expected listener count when many listeners attach by design.
+	*
+	* @example
+	* ```ts
+	* emitter.setMaxListeners(40)
+	* ```
+	*/
+	setMaxListeners(max) {
+		this.#emitter.setMaxListeners(max);
+	}
+	/**
+	* Returns the current per-event listener ceiling.
+	*/
+	getMaxListeners() {
+		return this.#emitter.getMaxListeners();
+	}
+	/**
+	* Removes all listeners from every event channel.
+	*
+	* @example
+	* ```ts
+	* emitter.removeAll()
+	* ```
+	*/
+	removeAll() {
+		this.#emitter.removeAllListeners();
+	}
+};
+//#endregion
+//#region ../../internals/utils/src/casing.ts
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+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;
+		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
+		return word.charAt(0).toUpperCase() + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Splits `text` on `.` and applies `transformPart` to each segment.
+* The last segment receives `isLast = true`, all earlier segments receive `false`.
+* Segments are joined with `/` to form a file path.
+*
+* Only splits on dots followed by a letter so that version numbers
+* embedded in operationIds (e.g. `v2025.0`) are kept intact.
+*
+* Empty segments are filtered before joining. They arise when the text starts with
+* a dot followed immediately by a letter (e.g. `..Schema` splits into `['..', 'Schema']`
+* and `'..'` transforms to an empty string). Without this filter the join would produce
+* a leading `/`, which `path.resolve` would interpret as an absolute path, allowing
+* generated files to escape the configured output directory.
+*/
+function applyToFileParts(text, transformPart) {
+	const parts = text.split(/\.(?=[a-zA-Z])/);
+	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).filter(Boolean).join("/");
+}
+/**
+* Converts `text` to camelCase.
+* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
+*
+* @example
+* camelCase('hello-world')                   // 'helloWorld'
+* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+*/
+function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
+		prefix,
+		suffix
+	} : {}));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+/**
+* Converts `text` to PascalCase.
+* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
+*
+* @example
+* pascalCase('hello-world')                  // 'HelloWorld'
+* pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'
+*/
+function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => isLast ? pascalCase(part, {
+		prefix,
+		suffix
+	}) : camelCase(part));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
+}
+//#endregion
+//#region ../../internals/utils/src/time.ts
+/**
+* Calculates elapsed time in milliseconds from a high-resolution `process.hrtime` start time.
+* Rounds to 2 decimal places for sub-millisecond precision without noise.
+*
+* @example
+* ```ts
+* const start = process.hrtime()
+* doWork()
+* getElapsedMs(start) // 42.35
+* ```
+*/
+function getElapsedMs(hrStart) {
+	const [seconds, nanoseconds] = process.hrtime(hrStart);
+	const ms = seconds * 1e3 + nanoseconds / 1e6;
+	return Math.round(ms * 100) / 100;
+}
+/**
+* Converts a millisecond duration into a human-readable string (`ms`, `s`, or `m s`).
+*
+* @example
+* ```ts
+* formatMs(250)   // '250ms'
+* formatMs(1500)  // '1.50s'
+* formatMs(90000) // '1m 30.0s'
+* ```
+*/
+function formatMs(ms) {
+	if (ms >= 6e4) return `${Math.floor(ms / 6e4)}m ${(ms % 6e4 / 1e3).toFixed(1)}s`;
+	if (ms >= 1e3) return `${(ms / 1e3).toFixed(2)}s`;
+	return `${Math.round(ms)}ms`;
+}
+//#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();
+	}
+}
+/** 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 } = {}) {
+		const result = this.path.split(/\{([^}]+)\}/).map((part, i) => {
+			if (i % 2 === 0) return part;
+			const param = this.#transformParam(part);
+			return `\${${replacer ? replacer(param) : param}}`;
+		}).join("");
+		return `\`${prefix ?? ""}${result}\``;
+	}
+	/**
+	* 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 package.json
+var version = "5.0.0-beta.40";
+//#endregion
+//#region src/constants.ts
+/**
+* OpenTelemetry ingestion endpoint for anonymous usage telemetry.
+*/
+const OTLP_ENDPOINT = "https://otlp.kubb.dev";
+/**
+* Plugin `include` filter types that select operations directly. When one of these is set
+* without a `schemaName` include, the generate phase pre-scans operations to compute the set
+* of schemas they reach, so unreachable schemas can be pruned for that plugin.
+*/
+const OPERATION_FILTER_TYPES = new Set([
+	"tag",
+	"operationId",
+	"path",
+	"method",
+	"contentType"
+]);
+/**
+* Stable codes Kubb attaches to a `Diagnostic`. Each maps to a known failure mode
+* and stays stable so it can be referenced in tooling and (later) docs. Reference
+* these instead of inlining the string at a throw site.
+*/
+const diagnosticCode = {
+	/**
+	* Fallback for an unstructured error with no specific code.
+	*/
+	unknown: "KUBB_UNKNOWN",
+	/**
+	* The `input.path` file or URL could not be read.
+	*/
+	inputNotFound: "KUBB_INPUT_NOT_FOUND",
+	/**
+	* An adapter was configured without an `input`.
+	*/
+	inputRequired: "KUBB_INPUT_REQUIRED",
+	/**
+	* A `$ref` (or equivalent reference) could not be resolved in the source document.
+	*/
+	refNotFound: "KUBB_REF_NOT_FOUND",
+	/**
+	* A server variable value is not allowed by its `enum`.
+	*/
+	invalidServerVariable: "KUBB_INVALID_SERVER_VARIABLE",
+	/**
+	* A required plugin is missing from the config.
+	*/
+	pluginNotFound: "KUBB_PLUGIN_NOT_FOUND",
+	/**
+	* A plugin threw while generating.
+	*/
+	pluginFailed: "KUBB_PLUGIN_FAILED",
+	/**
+	* A plugin reported a non-fatal warning through `ctx.warn`.
+	*/
+	pluginWarning: "KUBB_PLUGIN_WARNING",
+	/**
+	* A plugin reported an informational message through `ctx.info`.
+	*/
+	pluginInfo: "KUBB_PLUGIN_INFO",
+	/**
+	* A schema uses a `format` Kubb does not map to a specific type. Reserved for
+	* adapters to emit as a `warning`.
+	*/
+	unsupportedFormat: "KUBB_UNSUPPORTED_FORMAT",
+	/**
+	* A referenced schema or operation is marked `deprecated`. Reserved for adapters
+	* to emit as an `info`.
+	*/
+	deprecated: "KUBB_DEPRECATED",
+	/**
+	* An adapter is required but the config has none. The build cannot read the input
+	* without one.
+	*/
+	adapterRequired: "KUBB_ADAPTER_REQUIRED",
+	/**
+	* A resolved output path escapes the output directory, which can stem from a path
+	* traversal in the spec or a misconfigured `group.name`.
+	*/
+	pathTraversal: "KUBB_PATH_TRAVERSAL",
+	/**
+	* A post-generate shell hook (`hooks.done`) exited with a failure.
+	*/
+	hookFailed: "KUBB_HOOK_FAILED",
+	/**
+	* The formatter pass over the generated files failed.
+	*/
+	formatFailed: "KUBB_FORMAT_FAILED",
+	/**
+	* The linter pass over the generated files failed.
+	*/
+	lintFailed: "KUBB_LINT_FAILED",
+	/**
+	* Not a failure. Carries a plugin's elapsed time, summed into the run total.
+	*/
+	performance: "KUBB_PERFORMANCE",
+	/**
+	* Not a failure. A newer Kubb version is available on npm.
+	*/
+	updateAvailable: "KUBB_UPDATE_AVAILABLE"
+};
+//#endregion
+//#region src/diagnostics.ts
+/**
+* Docs major, derived from the package version so the link tracks the published major.
+*/
+const docsMajor = version.split(".")[0] ?? "5";
+/**
+* Narrows a {@link Diagnostic} to the variant for `code`, or `null` when it does not match.
+*
+* @example
+* ```ts
+* const update = narrow(diagnostic, diagnosticCode.updateAvailable)
+* if (update) {
+*   console.log(update.latestVersion)
+* }
+* ```
+*/
+function narrow(diagnostic, code) {
+	return diagnostic.code === code ? diagnostic : null;
+}
+/**
+* Builds a type guard that narrows a {@link Diagnostic} to the variant for `kind`. A diagnostic
+* with no `kind` is treated as a `problem`.
+*/
+function isKind(kind) {
+	return (diagnostic) => (diagnostic.kind ?? "problem") === kind;
+}
+/**
+* Returns `true` when the diagnostic is a build {@link ProblemDiagnostic}.
+*
+* @example
+* ```ts
+* if (isProblem(diagnostic)) {
+*   console.log(diagnostic.location)
+* }
+* ```
+*/
+const isProblem = isKind("problem");
+/**
+* Returns `true` when the diagnostic is a per-plugin {@link PerformanceDiagnostic}.
+*
+* @example
+* ```ts
+* const timings = diagnostics.filter(isPerformance)
+* ```
+*/
+const isPerformance = isKind("performance");
+/**
+* Returns `true` when the diagnostic is a version-update {@link UpdateDiagnostic}.
+*
+* @example
+* ```ts
+* if (isUpdate(diagnostic)) {
+*   console.log(diagnostic.latestVersion)
+* }
+* ```
+*/
+const isUpdate = isKind("update");
+/**
+* Glyph and accent color per severity, matching the miette/oxlint convention
+* (`×` error, `⚠` warning, `ℹ` advice).
+*/
+const severityStyle = {
+	error: {
+		glyph: "×",
+		color: "red"
+	},
+	warning: {
+		glyph: "⚠",
+		color: "yellow"
+	},
+	info: {
+		glyph: "ℹ",
+		color: "blue"
+	}
+};
+/**
+* Explanation for every {@link diagnosticCode}. Use {@link Diagnostics.explain} to look one up
+* and `Diagnostics.docsUrl` for the matching kubb.dev page.
+*/
+const diagnosticCatalog = {
+	[diagnosticCode.unknown]: {
+		title: "Unknown error",
+		cause: "An error was thrown without a stable Kubb code, so it is reported as-is.",
+		fix: "Read the underlying message and stack. If it comes from a plugin or adapter, check its configuration; otherwise report it as a possible Kubb bug."
+	},
+	[diagnosticCode.inputNotFound]: {
+		title: "Input not found",
+		cause: "The file or URL set in `input.path` (or passed as `kubb generate PATH`) could not be read.",
+		fix: "Check that the path or URL exists and is readable, then set it in `input.path` or pass it on the CLI."
+	},
+	[diagnosticCode.inputRequired]: {
+		title: "Input required",
+		cause: "An adapter is configured but no `input` was provided.",
+		fix: "Set `input.path` (a file or URL) or `input.data` (an inline spec) in your Kubb config."
+	},
+	[diagnosticCode.refNotFound]: {
+		title: "Reference not found",
+		cause: "A `$ref` could not be resolved in the source document.",
+		fix: "Add the missing definition (for example under `components.schemas`) or fix the `$ref`. Run `kubb validate` to check the spec."
+	},
+	[diagnosticCode.invalidServerVariable]: {
+		title: "Invalid server variable",
+		cause: "A server variable value is not allowed by its `enum`.",
+		fix: "Use one of the values listed in the server variable `enum`, or update the spec."
+	},
+	[diagnosticCode.pluginNotFound]: {
+		title: "Plugin not found",
+		cause: "A plugin that another plugin depends on is missing from the config.",
+		fix: "Add the required plugin to the `plugins` array in kubb.config.ts, or remove the dependency on it."
+	},
+	[diagnosticCode.pluginFailed]: {
+		title: "Plugin failed",
+		cause: "A plugin threw while generating, or reported an error through `ctx.error`.",
+		fix: "Read the underlying error and check the plugin options and the schema or operation it failed on."
+	},
+	[diagnosticCode.pluginWarning]: {
+		title: "Plugin warning",
+		cause: "A plugin reported a non-fatal warning through `ctx.warn`.",
+		fix: "Review the message. It does not fail the build; adjust the plugin options or input if the warning is unwanted."
+	},
+	[diagnosticCode.pluginInfo]: {
+		title: "Plugin info",
+		cause: "A plugin reported an informational message through `ctx.info`.",
+		fix: "Informational only. No action is required."
+	},
+	[diagnosticCode.unsupportedFormat]: {
+		title: "Unsupported format",
+		cause: "A schema uses a `format` Kubb does not map to a specific type, so it falls back to the base type.",
+		fix: "Use a format Kubb supports, or handle the custom format with a parser or plugin."
+	},
+	[diagnosticCode.deprecated]: {
+		title: "Deprecated",
+		cause: "A referenced schema or operation is marked `deprecated`.",
+		fix: "Migrate off the deprecated definition if the warning is unwanted."
+	},
+	[diagnosticCode.adapterRequired]: {
+		title: "Adapter required",
+		cause: "An action needs an adapter but none is configured.",
+		fix: "Set `adapter` in kubb.config.ts, for example `adapterOas()`."
+	},
+	[diagnosticCode.pathTraversal]: {
+		title: "Path traversal",
+		cause: "A resolved output path escaped the output directory, which can stem from a path traversal in the spec or a misconfigured `group.name`.",
+		fix: "Keep generated paths within the output directory. Review the `group.name` function and the names coming from the spec."
+	},
+	[diagnosticCode.hookFailed]: {
+		title: "Hook failed",
+		cause: "A post-generate shell hook (`hooks.done`) exited with a non-zero status.",
+		fix: "Check the command is installed and correct, and run it manually to see the error."
+	},
+	[diagnosticCode.formatFailed]: {
+		title: "Format failed",
+		cause: "The formatter pass over the generated files failed.",
+		fix: "Check the formatter (oxfmt, biome, or prettier) is installed and its config is valid, then run it manually on the output."
+	},
+	[diagnosticCode.lintFailed]: {
+		title: "Lint failed",
+		cause: "The linter pass over the generated files failed.",
+		fix: "Check the linter (oxlint, biome, or eslint) is installed and its config is valid, then run it manually on the output."
+	},
+	[diagnosticCode.performance]: {
+		title: "Performance",
+		cause: "Not a failure. Records a plugin’s elapsed time, summed into the run total.",
+		fix: "No action. This is an informational metric."
+	},
+	[diagnosticCode.updateAvailable]: {
+		title: "Update available",
+		cause: "A newer Kubb version is published on npm than the one running.",
+		fix: "Update the `@kubb/*` packages, for example `npm install -g @kubb/cli`, to get the latest fixes."
+	}
+};
+/**
+* Static helpers for working with {@link Diagnostic}s, plus the run-scoped sink
+* that lets deep code report a diagnostic without threading a callback.
+*
+* The sink lives in a single `AsyncLocalStorage` in the `@kubb/core` bundle.
+* `Diagnostics.scope` activates it for a run, so anything inside that run (the
+* adapter parse, a lazily consumed stream, a generator) reports through
+* `Diagnostics.report` and lands in the same run.
+*/
+var Diagnostics = class Diagnostics {
+	static #reporterStorage = new node_async_hooks.AsyncLocalStorage();
+	/**
+	* The diagnostic code catalog, exposed as `Diagnostics.code` (e.g. `Diagnostics.code.refNotFound`).
+	*/
+	static code = diagnosticCode;
+	/**
+	* Type guard for a build {@link ProblemDiagnostic}.
+	*/
+	static isProblem = isProblem;
+	/**
+	* Type guard for a version-update {@link UpdateDiagnostic}.
+	*/
+	static isUpdate = isUpdate;
+	/**
+	* Type guard for a per-plugin {@link PerformanceDiagnostic}.
+	*/
+	static isPerformance = isPerformance;
+	/**
+	* Narrows a {@link Diagnostic} to the variant for `code`, or `null` when it does not match.
+	*/
+	static narrow = narrow;
+	/**
+	* An `Error` that carries a {@link Diagnostic}, so structured problems can flow
+	* through the existing throw/catch paths while keeping their code and location.
+	*
+	* @example
+	* ```ts
+	* throw new Diagnostics.Error({ code: diagnosticCode.refNotFound, severity: 'error', message: `Could not find ${ref}`, location: { kind: 'schema', pointer: ref, ref } })
+	* ```
+	*/
+	static Error = class DiagnosticError extends Error {
+		diagnostic;
+		constructor(diagnostic) {
+			super(diagnostic.message, { cause: diagnostic.cause });
+			this.name = "DiagnosticError";
+			this.diagnostic = diagnostic;
+		}
+	};
+	/**
+	* Structural check for a {@link Diagnostics.Error}, including one thrown from a duplicated
+	* `@kubb/core` copy where `instanceof` fails. Matches on the `name` and a `diagnostic`
+	* that carries a `code`.
+	*/
+	static isError(error) {
+		if (error instanceof Diagnostics.Error) return true;
+		return error instanceof Error && error.name === "DiagnosticError" && "diagnostic" in error && typeof error.diagnostic === "object" && error.diagnostic !== null && typeof error.diagnostic?.code === "string";
+	}
+	/**
+	* Runs `fn` with `sink` as the active diagnostic sink for the whole async
+	* subtree, so {@link Diagnostics.report} reaches it from anywhere inside.
+	*/
+	static scope(sink, fn) {
+		return Diagnostics.#reporterStorage.run(sink, fn);
+	}
+	/**
+	* Collects a diagnostic into the active build via the run-scoped sink, without throwing.
+	* Returns `true` when a run consumed it, `false` when called outside a {@link Diagnostics.scope}
+	* (so callers can fall back to throwing). Use a `warning`/`info` severity for non-fatal issues.
+	* For rendering a diagnostic live on the hook bus, use {@link Diagnostics.emit} instead.
+	*/
+	static report(diagnostic) {
+		const sink = Diagnostics.#reporterStorage.getStore();
+		if (!sink) return false;
+		sink(diagnostic);
+		return true;
+	}
+	/**
+	* Emits a diagnostic on the run's `kubb:diagnostic` event so the loggers render it live.
+	* Use it instead of calling `hooks.emit('kubb:diagnostic', ...)` directly. To collect a
+	* diagnostic into the build result from deep in a run, use {@link Diagnostics.report} instead.
+	*/
+	static async emit(hooks, diagnostic) {
+		await hooks.emit("kubb:diagnostic", { diagnostic });
+	}
+	/**
+	* Coerces any thrown value into a {@link ProblemDiagnostic}. A {@link Diagnostics.Error}
+	* keeps its structured data, and anything else becomes a `KUBB_UNKNOWN` error.
+	*/
+	static from(error) {
+		const seen = /* @__PURE__ */ new Set();
+		let current = error;
+		let root;
+		while (current instanceof Error && !seen.has(current)) {
+			if (Diagnostics.isError(current)) return current.diagnostic;
+			seen.add(current);
+			root = current;
+			current = current.cause;
+		}
+		return {
+			code: diagnosticCode.unknown,
+			severity: "error",
+			message: root ? root.message : getErrorMessage(error),
+			cause: root
+		};
+	}
+	/**
+	* Builds a per-plugin performance record. Reporters sum these into the run total.
+	*/
+	static performance({ plugin, duration }) {
+		return {
+			kind: "performance",
+			code: diagnosticCode.performance,
+			severity: "info",
+			message: `${plugin} generated in ${Math.round(duration)}ms`,
+			plugin,
+			duration
+		};
+	}
+	/**
+	* Builds the version-update notice shown when a newer Kubb is published on npm.
+	*/
+	static update({ currentVersion, latestVersion }) {
+		return {
+			kind: "update",
+			code: diagnosticCode.updateAvailable,
+			severity: "info",
+			message: `Update available: v${currentVersion} → v${latestVersion}. Run \`npm install -g @kubb/cli\` to update.`,
+			currentVersion,
+			latestVersion
+		};
+	}
+	/**
+	* True when any diagnostic is an error, the severity that fails a build. Non-error
+	* diagnostics are ignored.
+	*/
+	static hasError(diagnostics) {
+		return diagnostics.some((diagnostic) => diagnostic.severity === "error");
+	}
+	/**
+	* Names of the plugins that failed, deduped, derived from the error diagnostics
+	* that carry a `plugin`.
+	*/
+	static failedPlugins(diagnostics) {
+		const names = /* @__PURE__ */ new Set();
+		for (const diagnostic of diagnostics) if (diagnostic.severity === "error" && diagnostic.plugin) names.add(diagnostic.plugin);
+		return [...names];
+	}
+	/**
+	* Counts `problem` diagnostics by severity for the run summary. `timing`
+	* diagnostics are ignored.
+	*/
+	static count(diagnostics) {
+		let errors = 0;
+		let warnings = 0;
+		let infos = 0;
+		for (const diagnostic of diagnostics) {
+			if (!isProblem(diagnostic)) continue;
+			if (diagnostic.severity === "error") errors += 1;
+			else if (diagnostic.severity === "warning") warnings += 1;
+			else infos += 1;
+		}
+		return {
+			errors,
+			warnings,
+			infos
+		};
+	}
+	/**
+	* Drops duplicate `problem` diagnostics that share a code, location pointer, and
+	* plugin, so the same issue reported across several passes is shown once. Non-problem
+	* diagnostics are always kept.
+	*/
+	static dedupe(diagnostics) {
+		const seen = /* @__PURE__ */ new Set();
+		const result = [];
+		for (const diagnostic of diagnostics) {
+			if (!isProblem(diagnostic)) {
+				result.push(diagnostic);
+				continue;
+			}
+			const pointer = diagnostic.location && "pointer" in diagnostic.location ? diagnostic.location.pointer : "";
+			const key = `${diagnostic.code} ${pointer} ${diagnostic.plugin ?? ""}`;
+			if (seen.has(key)) continue;
+			seen.add(key);
+			result.push(diagnostic);
+		}
+		return result;
+	}
+	/**
+	* Builds the kubb.dev docs URL for a diagnostic code, e.g.
+	* `KUBB_REF_NOT_FOUND` → `https://kubb.dev/docs/5.x/reference/diagnostics/kubb-ref-not-found`.
+	*/
+	static docsUrl(code) {
+		return `https://kubb.dev/docs/${docsMajor}.x/reference/diagnostics/${code.toLowerCase().replaceAll("_", "-")}`;
+	}
+	/**
+	* The catalog entry for a code: its title, cause, and fix. Mirrors the kubb.dev
+	* `/diagnostics/<slug>` page.
+	*/
+	static explain(code) {
+		return diagnosticCatalog[code];
+	}
+	/**
+	* Reduces a diagnostic to its JSON-safe fields plus a `docsUrl`, for machine-readable
+	* consumers. The `cause`, `kind`, and `duration` are dropped, and absent optional
+	* fields are omitted rather than set to `undefined`.
+	*/
+	static serialize(diagnostic) {
+		const problem = isProblem(diagnostic) ? diagnostic : void 0;
+		return {
+			code: diagnostic.code,
+			severity: diagnostic.severity,
+			message: diagnostic.message,
+			...problem?.location ? { location: problem.location } : {},
+			...problem?.help ? { help: problem.help } : {},
+			...problem?.plugin ? { plugin: problem.plugin } : {},
+			...diagnostic.code === diagnosticCode.unknown ? {} : { docsUrl: Diagnostics.docsUrl(diagnostic.code) }
+		};
+	}
+	/**
+	* Renders a {@link Diagnostic} for terminal output as its parts: the colored severity `symbol`
+	* (the gutter glyph), the `plugin(CODE): message` `headline`, and the `details` lines (optional
+	* `at <pointer>`, `help:`, and `docs:`).
+	*
+	* Hosts compose these to fit their gutter: a clack logger passes `symbol` as its own gutter and
+	* `[headline, ...details]` as the message, while plain text outputs use {@link Diagnostics.formatLines}.
+	*/
+	static format(diagnostic) {
+		const { code, severity, message } = diagnostic;
+		const { glyph, color } = severityStyle[severity];
+		const problem = isProblem(diagnostic) ? diagnostic : void 0;
+		const rule = (0, node_util.styleText)(color, (0, node_util.styleText)("bold", problem?.plugin ? `${problem.plugin}(${code})` : code));
+		const details = [];
+		if (problem?.location && "pointer" in problem.location) details.push(`  ${(0, node_util.styleText)("dim", "at")} ${(0, node_util.styleText)("cyan", problem.location.pointer)}`);
+		if (problem?.help) details.push(`  ${(0, node_util.styleText)("cyan", "help:")} ${problem.help}`);
+		if (code !== diagnosticCode.unknown) details.push(`  ${(0, node_util.styleText)("dim", "docs:")} ${(0, node_util.styleText)("cyan", Diagnostics.docsUrl(code))}`);
+		return {
+			symbol: (0, node_util.styleText)(color, (0, node_util.styleText)("bold", glyph)),
+			headline: `${rule}: ${message}`,
+			details
+		};
+	}
+	/**
+	* The self-contained block form of {@link Diagnostics.format}: `${symbol} ${headline}` followed by
+	* the detail lines. Used where there is no gutter to own the symbol (plain and file output).
+	*/
+	static formatLines(diagnostic) {
+		const { symbol, headline, details } = Diagnostics.format(diagnostic);
+		return [`${symbol} ${headline}`, ...details];
+	}
+};
+//#endregion
+//#region src/createStorage.ts
+/**
+* Defines a custom storage backend. The builder receives user options and
+* returns a `Storage` implementation. Kubb ships with filesystem and
+* in-memory storages, reach for this when you need to write generated files
+* elsewhere (cloud storage, a database, a remote API).
+*
+* @example In-memory storage (the built-in implementation)
+* ```ts
+* import { createStorage } from '@kubb/core'
+*
+* export const memoryStorage = createStorage(() => {
+*   const store = new Map<string, string>()
+*
+*   return {
+*     name: 'memory',
+*     async hasItem(key) {
+*       return store.has(key)
+*     },
+*     async getItem(key) {
+*       return store.get(key) ?? null
+*     },
+*     async setItem(key, value) {
+*       store.set(key, value)
+*     },
+*     async removeItem(key) {
+*       store.delete(key)
+*     },
+*     async getKeys(base) {
+*       const keys = [...store.keys()]
+*       return base ? keys.filter((k) => k.startsWith(base)) : keys
+*     },
+*     async clear(base) {
+*       if (!base) store.clear()
+*     },
+*   }
+* })
+* ```
+*/
+function createStorage(build) {
+	return (options) => build(options ?? {});
+}
+//#endregion
+//#region src/definePlugin.ts
+/**
+* Wraps a plugin factory and returns a function that accepts user options and
+* yields a fully typed `Plugin`. Lifecycle handlers go inside a single
+* `hooks` object (inspired by Astro integrations).
+*
+* Pass a `PluginFactoryOptions` type parameter to get a typed `ctx` inside
+* `kubb:plugin:setup`. Plugin names should follow the `plugin-<feature>`
+* convention (`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 ?? {});
+}
+/**
+* Detects whether an output path points at a single file (`'single'`) or a
+* directory (`'split'`). Decided purely from the presence of a file extension.
+*
+* @example Directory
+* `getMode('./types') // 'split'`
+*
+* @example Single file
+* `getMode('./api.ts') // 'single'`
+*/
+function getMode(fileOrFolder) {
+	if (!fileOrFolder) return "split";
+	return (0, node_path.extname)(fileOrFolder) ? "single" : "split";
+}
+//#endregion
+//#region src/defineResolver.ts
+/**
+* Merges document `meta` with per-file `file` context into the `BannerMeta` passed to a
+* `banner`/`footer` function. Missing fields default to empty/`false` so the object shape
+* is stable even when a caller (e.g. the barrel middleware) has no document metadata.
+*/
+function buildBannerMeta({ meta, file }) {
+	return {
+		title: meta?.title,
+		description: meta?.description,
+		version: meta?.version,
+		baseURL: meta?.baseURL,
+		circularNames: meta?.circularNames ?? [],
+		enumNames: meta?.enumNames ?? [],
+		filePath: file?.path ?? "",
+		baseName: file?.baseName ?? "",
+		isBarrel: file?.isBarrel ?? false,
+		isAggregation: file?.isAggregation ?? false
+	};
+}
+const stringPatternCache = /* @__PURE__ */ new Map();
+function testPattern(value, pattern) {
+	if (typeof pattern === "string") {
+		let regex = stringPatternCache.get(pattern);
+		if (!regex) {
+			regex = new RegExp(pattern);
+			stringPatternCache.set(pattern, regex);
+		}
+		return regex.test(value);
+	}
+	return value.match(pattern) !== null;
+}
+/**
+* Checks if an operation matches a pattern for a given filter type (`tag`, `operationId`, `path`, `method`).
+*/
+function matchesOperationPattern(node, type, pattern) {
+	if (type === "tag") return node.tags.some((tag) => testPattern(tag, pattern));
+	if (type === "operationId") return testPattern(node.operationId, pattern);
+	if (type === "path") return node.path !== void 0 && testPattern(node.path, pattern);
+	if (type === "method") return node.method !== void 0 && testPattern(node.method.toLowerCase(), pattern);
+	if (type === "contentType") return 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`).
+*
+* Returns `null` when the filter type doesn't apply to schemas.
+*/
+function matchesSchemaPattern(node, type, pattern) {
+	if (type === "schemaName") return node.name ? testPattern(node.name, pattern) : false;
+	return null;
+}
+/**
+* Default name resolver used by `defineResolver`.
+*
+* - `camelCase` for `function` and `file` types.
+* - `PascalCase` for `type`.
+* - `camelCase` for everything else.
+*/
+function defaultResolver(name, type) {
+	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.
+*
+* Returns `null` when the node is filtered out by an `exclude` rule or not matched by any `include` rule.
+*
+* @example Include/exclude filtering
+* ```ts
+* const options = defaultResolveOptions(operationNode, {
+*   options: { output: 'types' },
+*   exclude: [{ type: 'tag', pattern: 'internal' }],
+* })
+* // → null when node has tag 'internal'
+* ```
+*
+* @example Override merging
+* ```ts
+* const options = defaultResolveOptions(operationNode, {
+*   options: { enumType: 'asConst' },
+*   override: [{ type: 'operationId', pattern: 'listPets', options: { enumType: 'enum' } }],
+* })
+* // → { enumType: 'enum' } when operationId matches
+* ```
+*/
+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;
+		const overrideOptions = override.find(({ type, pattern }) => matchesOperationPattern(node, type, pattern))?.options;
+		return {
+			...options,
+			...overrideOptions
+		};
+	}
+	if ((0, _kubb_ast.isSchemaNode)(node)) {
+		if (exclude.some(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)) return null;
+		if (include) {
+			const applicable = include.map(({ type, pattern }) => matchesSchemaPattern(node, type, pattern)).filter((result) => result !== null);
+			if (applicable.length > 0 && !applicable.includes(true)) return null;
+		}
+		const overrideOptions = override.find(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)?.options;
+		return {
+			...options,
+			...overrideOptions
+		};
+	}
+	return options;
+}
+function defaultResolveOptions(node, { options, exclude = [], include, override = [] }) {
+	const optionsKey = options;
+	let byOptions = resolveOptionsCache.get(optionsKey);
+	if (!byOptions) {
+		byOptions = /* @__PURE__ */ new WeakMap();
+		resolveOptionsCache.set(optionsKey, byOptions);
+	}
+	const cached = byOptions.get(node);
+	if (cached !== void 0) return cached.value;
+	const result = computeOptions(node, options, exclude, include, override);
+	byOptions.set(node, { value: result });
+	return result;
+}
+/**
+* Default path resolver used by `defineResolver`.
+*
+* - Returns the output directory in `single` mode.
+* - Resolves into a tag- or path-based subdirectory when `group` and a `tag`/`path` value are provided.
+* - Falls back to a flat `output/baseName` path otherwise.
+*
+* A custom `group.name` function overrides the default subdirectory naming.
+* For `tag` groups the default is `${camelCase(tag)}Controller`.
+* For `path` groups the default is the first path segment after `/`.
+*
+* @example Flat output
+* ```ts
+* defaultResolvePath({ baseName: 'petTypes.ts' }, { root: '/src', output: { path: 'types' } })
+* // → '/src/types/petTypes.ts'
+* ```
+*
+* @example Tag-based grouping
+* ```ts
+* defaultResolvePath(
+*   { baseName: 'petTypes.ts', tag: 'pets' },
+*   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
+* )
+* // → '/src/types/petsController/petTypes.ts'
+* ```
+*
+* @example Path-based grouping
+* ```ts
+* defaultResolvePath(
+*   { baseName: 'petTypes.ts', path: '/pets/list' },
+*   { root: '/src', output: { path: 'types' }, group: { type: 'path' } },
+* )
+* // → '/src/types/pets/petTypes.ts'
+* ```
+*
+* @example Single-file mode
+* ```ts
+* defaultResolvePath(
+*   { baseName: 'petTypes.ts', pathMode: 'single' },
+*   { root: '/src', output: { path: 'types' } },
+* )
+* // → '/src/types'
+* ```
+*/
+function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }, { root, output, group }) {
+	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: groupName }) => `${camelCase(groupName)}Controller` : ({ group: groupName }) => {
+				const segment = groupName.split("/").filter((part) => part !== "" && part !== "." && part !== "..")[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 Diagnostics.Error({
+		code: Diagnostics.code.pathTraversal,
+		severity: "error",
+		message: `Resolved path "${result}" is outside the output directory "${outputDir}".`,
+		help: "This can stem from a path traversal in the OpenAPI specification or a misconfigured `group.name` function. Keep generated paths within the output directory.",
+		location: { kind: "config" }
+	});
+	return result;
+}
+/**
+* Default file resolver used by `defineResolver`.
+*
+* Resolves a `FileNode` by combining name resolution (`resolver.default`) with
+* path resolution (`resolver.resolvePath`). The resolved file always has empty
+* `sources`, `imports`, and `exports` arrays, which consumers populate separately.
+*
+* In `single` mode the name is omitted and the file sits directly in the output directory.
+*
+* @example Resolve a schema file
+* ```ts
+* const file = defaultResolveFile.call(
+*   resolver,
+*   { name: 'pet', extname: '.ts' },
+*   { root: '/src', output: { path: 'types' } },
+* )
+* // → { baseName: 'pet.ts', path: '/src/types/pet.ts', sources: [], ... }
+* ```
+*
+* @example Resolve an operation file with tag grouping
+* ```ts
+* const file = defaultResolveFile.call(
+*   resolver,
+*   { name: 'listPets', extname: '.ts', tag: 'pets' },
+*   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
+* )
+* // → { baseName: 'listPets.ts', path: '/src/types/petsController/listPets.ts', ... }
+* ```
+*/
+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,
+		path: groupPath
+	}, context);
+	return (0, _kubb_ast.createFile)({
+		path: filePath,
+		baseName: node_path.default.basename(filePath),
+		meta: { pluginName: this.pluginName },
+		sources: [],
+		imports: [],
+		exports: []
+	});
+}
+/**
+* Generates the default "Generated by Kubb" banner from config and optional node metadata.
+*/
+function buildDefaultBanner({ title, description, version, config }) {
+	try {
+		const source = (() => {
+			if (Array.isArray(config.input)) {
+				const first = config.input[0];
+				if (first && "path" in first) return 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";
+			return banner;
+		}
+		if (source) banner += `* Source: ${source}\n`;
+		if (title) banner += `* Title: ${title}\n`;
+		if (description) {
+			const formattedDescription = description.replace(/\n/gm, "\n* ");
+			banner += `* Description: ${formattedDescription}\n`;
+		}
+		if (version) banner += `* OpenAPI spec version: ${version}\n`;
+		banner += "*/\n";
+		return banner;
+	} catch (_error) {
+		return "/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n*/";
+	}
+}
+/**
+* Default banner resolver. Returns the banner string for a generated file.
+*
+* 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 document metadata when `meta` is provided).
+*
+* - When `output.banner` is a function, calls it with the file's `BannerMeta` 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.
+*
+* @example String banner overrides default
+* ```ts
+* defaultResolveBanner(undefined, { output: { banner: '// my banner' }, config })
+* // → '// my banner'
+* ```
+*
+* @example Function banner with metadata
+* ```ts
+* defaultResolveBanner(meta, { output: { banner: (m) => `// v${m.version}` }, config })
+* // → '// v3.0.0'
+* ```
+*
+* @example Function banner skips re-export files
+* ```ts
+* defaultResolveBanner(meta, { output: { banner: (m) => (m.isBarrel ? '' : "'use server'") }, config, file: { path, baseName, isBarrel: true } })
+* // → ''
+* ```
+*
+* @example No user banner, Kubb notice with OAS metadata
+* ```ts
+* defaultResolveBanner(meta, { config })
+* // → '/** Generated by Kubb ... Title: Pet Store ... *\/'
+* ```
+*
+* @example Disabled default banner
+* ```ts
+* defaultResolveBanner(undefined, { config: { output: { defaultBanner: false }, ...config } })
+* // → null
+* ```
+*/
+function defaultResolveBanner(meta, { output, config, file }) {
+	if (typeof output?.banner === "function") return output.banner(buildBannerMeta({
+		meta,
+		file
+	}));
+	if (typeof output?.banner === "string") return output.banner;
+	if (config.output.defaultBanner === false) return null;
+	return buildDefaultBanner({
+		title: meta?.title,
+		version: meta?.version,
+		config
+	});
+}
+/**
+* Default footer resolver. Returns the footer string for a generated file.
+*
+* - When `output.footer` is a function, calls it with the file's `BannerMeta` and returns the result.
+* - When `output.footer` is a string, returns it directly.
+* - Otherwise returns `undefined`.
+*
+* @example String footer
+* ```ts
+* defaultResolveFooter(undefined, { output: { footer: '// end of file' }, config })
+* // → '// end of file'
+* ```
+*
+* @example Function footer with metadata
+* ```ts
+* defaultResolveFooter(meta, { output: { footer: (m) => `// ${m.title}` }, config })
+* // → '// Pet Store'
+* ```
+*/
+function defaultResolveFooter(meta, { output, file }) {
+	if (typeof output?.footer === "function") return output.footer(buildBannerMeta({
+		meta,
+		file
+	}));
+	if (typeof output?.footer === "string") return output.footer;
+	return null;
+}
+/**
+* Defines a plugin resolver. The resolver is the object that decides what
+* every generated symbol and file path is called. Built-in defaults handle
+* name casing, include/exclude/override filtering, output path computation,
+* and file construction. Supply your own to override any of them:
+*
+* - `default` sets the name casing strategy (camelCase or PascalCase).
+* - `resolveOptions` does include/exclude/override filtering.
+* - `resolvePath` computes the output path.
+* - `resolveFile` builds the full `FileNode`.
+* - `resolveBanner` and `resolveFooter` produce the top and bottom of file text.
+*
+* Methods in the returned object can call sibling resolver methods via `this`,
+* which keeps custom rules small (`this.default(name, 'type')` to delegate).
+*
+* @example Basic resolver with naming helpers
+* ```ts
+* export const resolverTs = defineResolver<PluginTs>(() => ({
+*   name: 'default',
+*   resolveName(name) {
+*     return this.default(name, 'function')
+*   },
+*   resolveTypeName(name) {
+*     return this.default(name, 'type')
+*   },
+* }))
+* ```
+*
+* @example Custom output path
+* ```ts
+* import path from 'node:path'
+*
+* export const resolverTs = defineResolver<PluginTs>(() => ({
+*   name: 'custom',
+*   resolvePath({ baseName }, { root, output }) {
+*     return path.resolve(root, output.path, 'generated', baseName)
+*   },
+* }))
+* ```
+*/
+function defineResolver(build) {
+	let resolver;
+	resolver = {
+		default: defaultResolver,
+		resolveOptions: defaultResolveOptions,
+		resolvePath: defaultResolvePath,
+		resolveFile: (params, context) => defaultResolveFile.call(resolver, params, context),
+		resolveBanner: defaultResolveBanner,
+		resolveFooter: defaultResolveFooter,
+		...build()
+	};
+	return resolver;
+}
+//#endregion
+//#region src/FileManager.ts
+function mergeFile(a, b) {
+	return {
+		...a,
+		banner: b.banner,
+		footer: b.footer,
+		sources: a.sources.length ? b.sources.length ? [...a.sources, ...b.sources] : a.sources : b.sources,
+		imports: a.imports.length ? b.imports.length ? [...a.imports, ...b.imports] : a.imports : b.imports,
+		exports: a.exports.length ? b.exports.length ? [...a.exports, ...b.exports] : a.exports : b.exports
+	};
+}
+function isIndexPath(path) {
+	return path.endsWith("/index.ts") || path === "index.ts";
+}
+function compareFiles(a, b) {
+	const lenDiff = a.path.length - b.path.length;
+	if (lenDiff !== 0) return lenDiff;
+	const aIsIndex = isIndexPath(a.path);
+	const bIsIndex = isIndexPath(b.path);
+	if (aIsIndex && !bIsIndex) return 1;
+	if (!aIsIndex && bIsIndex) return -1;
+	return 0;
+}
+/**
+* In-memory file store for generated files. Files sharing a `path` are merged
+* (sources/imports/exports concatenated). The `files` getter is sorted by
+* path length (barrel `index.ts` last within a bucket).
+*
+* @example
+* ```ts
+* const manager = new FileManager()
+* manager.upsert(myFile)
+* manager.files // sorted view
+* ```
+*/
+var FileManager = class {
+	/**
+	* Subscribe to file-store changes. Listeners on `upsert` see each resolved file as it lands
+	* through `add` or `upsert`.
+	*/
+	hooks = new AsyncEventEmitter();
+	#cache = /* @__PURE__ */ new Map();
+	#sorted = null;
+	add(...files) {
+		return this.#store(files, false);
+	}
+	upsert(...files) {
+		return this.#store(files, true);
+	}
+	#store(files, mergeExisting) {
+		const batch = files.length > 1 ? this.#dedupe(files) : files;
+		const resolved = [];
+		for (const file of batch) {
+			const existing = this.#cache.get(file.path);
+			const merged = existing && mergeExisting ? (0, _kubb_ast.createFile)(mergeFile(existing, file)) : (0, _kubb_ast.createFile)(file);
+			this.#cache.set(merged.path, merged);
+			resolved.push(merged);
+			this.hooks.emit("upsert", merged);
+		}
+		if (resolved.length > 0) this.#sorted = null;
+		return resolved;
+	}
+	#dedupe(files) {
+		const seen = /* @__PURE__ */ new Map();
+		for (const file of files) {
+			const prev = seen.get(file.path);
+			seen.set(file.path, prev ? mergeFile(prev, file) : file);
+		}
+		return [...seen.values()];
+	}
+	getByPath(path) {
+		return this.#cache.get(path) ?? null;
+	}
+	deleteByPath(path) {
+		if (!this.#cache.delete(path)) return;
+		this.#sorted = null;
+	}
+	clear() {
+		this.#cache.clear();
+		this.#sorted = null;
+	}
+	/**
+	* Releases all stored files and clears every `hooks` listener. Called by the core after
+	* `kubb:build:end`.
+	*/
+	dispose() {
+		this.clear();
+		this.hooks.removeAll();
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+	/**
+	* All stored files in stable sort order (shortest path first, barrel files
+	* last within a length bucket). Returns a cached view, do not mutate.
+	*/
+	get files() {
+		return this.#sorted ??= [...this.#cache.values()].sort(compareFiles);
+	}
+};
+//#endregion
+//#region src/FileProcessor.ts
+function joinSources(file) {
+	const sources = file.sources;
+	if (sources.length === 0) return "";
+	const parts = [];
+	for (const source of sources) {
+		const text = (0, _kubb_ast.extractStringsFromNodes)(source.nodes);
+		if (text) parts.push(text);
+	}
+	return parts.join("\n\n");
+}
+/**
+* Turns `FileNode`s into source strings and writes them to storage.
+*
+* Two modes share the same instance. Stateless mode (`parse`, `stream`, `run`) just runs the
+* conversion. Queue mode (`enqueue`, `flush`, `drain`) buffers files deduped by path and
+* writes each batch through storage with up to `STREAM_FLUSH_EVERY` requests in flight.
+*
+* `flush` does not wait for its batch to finish, so dispatch can overlap with IO. The next
+* `flush` or `drain` picks the in-flight batch up. `drain` blocks until everything has been
+* written and is meant for the end of a build.
+*
+* To surface build-level hook signals (`kubb:files:processing:*` and friends) subscribe to
+* `hooks` and re-emit on the kubb bus.
+*/
+var FileProcessor = class {
+	hooks = new AsyncEventEmitter();
+	#parsers;
+	#storage;
+	#extension;
+	#pending = /* @__PURE__ */ new Map();
+	#runningFlush = null;
+	constructor(options) {
+		this.#parsers = options.parsers ?? null;
+		this.#storage = options.storage;
+		this.#extension = options.extension ?? null;
+	}
+	/**
+	* Files waiting in the queue.
+	*/
+	get size() {
+		return this.#pending.size;
+	}
+	parse(file) {
+		const parsers = this.#parsers;
+		const parseExtName = this.#extension?.[file.extname] || void 0;
+		if (!parsers || !file.extname) return joinSources(file);
+		const parser = parsers.get(file.extname);
+		if (!parser) return joinSources(file);
+		return parser.parse(file, { extname: parseExtName });
+	}
+	*stream(files) {
+		const total = files.length;
+		if (total === 0) return;
+		let processed = 0;
+		for (const file of files) {
+			const source = this.parse(file);
+			processed++;
+			yield {
+				file,
+				source,
+				processed,
+				total,
+				percentage: processed / total * 100
+			};
+		}
+	}
+	async run(files) {
+		await this.hooks.emit("start", files);
+		for (const { file, source, processed, total, percentage } of this.stream(files)) await this.hooks.emit("update", {
+			file,
+			source,
+			processed,
+			percentage,
+			total
+		});
+		await this.hooks.emit("end", files);
+		return files;
+	}
+	/**
+	* Adds a file to the next flush. A later `enqueue` for the same path replaces the previous
+	* entry, matching `FileManager.upsert`. Fires the `enqueue` event.
+	*/
+	enqueue(file) {
+		this.#pending.set(file.path, file);
+		this.hooks.emit("enqueue", file);
+	}
+	/**
+	* Starts processing the queued files. Waits for any previous flush to finish (so two
+	* batches never run together) and then returns without waiting for the new one. The next
+	* `flush` or `drain` picks up the in-flight task.
+	*/
+	async flush() {
+		if (this.#runningFlush) await this.#runningFlush;
+		if (this.#pending.size === 0) return;
+		const batch = [...this.#pending.values()];
+		this.#pending.clear();
+		this.#runningFlush = this.#processAndWrite(batch).finally(() => {
+			this.#runningFlush = null;
+		});
+	}
+	/**
+	* Waits for the in-flight flush and writes any files still queued. Fires the `drain` event
+	* when both are done.
+	*/
+	async drain() {
+		if (this.#runningFlush) await this.#runningFlush;
+		if (this.#pending.size > 0) {
+			const batch = [...this.#pending.values()];
+			this.#pending.clear();
+			await this.#processAndWrite(batch);
+		}
+		await this.hooks.emit("drain");
+	}
+	async #processAndWrite(files) {
+		const storage = this.#storage;
+		await this.hooks.emit("start", files);
+		const items = [...this.stream(files)];
+		for (const item of items) await this.hooks.emit("update", item);
+		const queue = [];
+		for (const { file, source } of items) if (source) {
+			queue.push(storage.setItem(file.path, source));
+			if (queue.length >= 50) await Promise.all(queue.splice(0));
+		}
+		await Promise.all(queue);
+		await this.hooks.emit("end", files);
+	}
+	/**
+	* Clears every listener and the pending queue.
+	*/
+	dispose() {
+		this.hooks.removeAll();
+		this.#pending.clear();
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+};
+//#endregion
+//#region src/HookRegistry.ts
+/**
+* Listener bookkeeping around an `AsyncEventEmitter`. Listeners attached through `register`
+* stay on the emitter but are tracked so `dispose()` removes only them, listeners attached
+* directly via `emitter.on(...)` survive.
+*/
+var HookRegistry = class {
+	#emitter;
+	#entries = /* @__PURE__ */ new Set();
+	constructor(options) {
+		this.#emitter = options.emitter;
+	}
+	get emitter() {
+		return this.#emitter;
+	}
+	get size() {
+		return this.#entries.size;
+	}
+	register(options) {
+		this.#emitter.on(options.event, options.handler);
+		this.#entries.add(options);
+	}
+	dispose() {
+		for (const entry of this.#entries) this.#emitter.off(entry.event, entry.handler);
+		this.#entries.clear();
+	}
+};
+//#endregion
+//#region src/Transform.ts
+/**
+* Holds one `Visitor` per plugin, keyed by plugin name. Each plugin's transformer runs in
+* isolation on the original adapter node. `applyTo` is a lookup, not a chain, so plugin A's
+* visitor never sees plugin B's output. When no transformer is registered, `applyTo` returns
+* the original node reference, and the `@kubb/ast` `transform` primitive does the same when
+* its visitor leaves the tree untouched. Callers can compare by identity to detect a no-op.
+*
+* Registration order matches the order setup hooks fire, which the driver has already sorted
+* by `enforce` and dependency edges. The registry does not re-order anything.
+*/
+var Transform = class {
+	#visitors = /* @__PURE__ */ new Map();
+	/**
+	* Number of plugins with a registered transformer.
+	*/
+	get size() {
+		return this.#visitors.size;
+	}
+	/**
+	* Records `visitor` as the transformer for `pluginName`. A second call for the same plugin
+	* replaces the first.
+	*/
+	register(pluginName, visitor) {
+		this.#visitors.set(pluginName, visitor);
+	}
+	/**
+	* Looks up the transformer for `pluginName`. The generator context uses this so plugins can
+	* read their own visitor through `ctx.transformer`.
+	*/
+	get(pluginName) {
+		return this.#visitors.get(pluginName);
+	}
+	/**
+	* Runs the plugin's transformer on `node`. Returns the original node reference when the
+	* plugin has no transformer, so callers can compare by identity to detect a no-op.
+	*/
+	applyTo(pluginName, node) {
+		const visitor = this.#visitors.get(pluginName);
+		if (!visitor) return node;
+		return (0, _kubb_ast.transform)(node, visitor);
+	}
+	/**
+	* Clears every registration. Called from the driver's `dispose()` so visitors do not leak
+	* across builds.
+	*/
+	dispose() {
+		this.#visitors.clear();
+	}
+};
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/usingCtx.js
+function _usingCtx() {
+	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
+		var n = Error();
+		return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
+	};
+	var e = {};
+	var n = [];
+	function using(r, e) {
+		if (null != e) {
+			if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+			if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+			if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
+			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+			t && (o = function o() {
+				try {
+					t.call(e);
+				} catch (r) {
+					return Promise.reject(r);
+				}
+			}), n.push({
+				v: e,
+				d: o,
+				a: r
+			});
+		} else r && n.push({
+			d: e,
+			a: r
+		});
+		return e;
+	}
+	return {
+		e,
+		u: using.bind(null, !1),
+		a: using.bind(null, !0),
+		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 r = o.d.call(o.v);
+						if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
+					} else s |= 1;
+				} catch (r) {
+					return err(r);
+				}
+				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+				if (t !== e) throw t;
+			}
+			function err(n) {
+				return t = t !== e ? new r(n, t) : n, next();
+			}
+			return next();
+		}
+	};
+}
+//#endregion
+//#region src/KubbDriver.ts
+function enforceOrder(enforce) {
+	return enforce === "pre" ? -1 : enforce === "post" ? 1 : 0;
+}
+var KubbDriver = class KubbDriver {
+	config;
+	options;
+	/**
+	* Returns `'single'` when `fileOrFolder` has a file extension, `'split'` otherwise.
+	*
+	* @example
+	* ```ts
+	* KubbDriver.getMode('src/gen/types.ts')  // 'single'
+	* KubbDriver.getMode('src/gen/types')     // 'split'
+	* ```
+	*/
+	static getMode(fileOrFolder) {
+		return getMode(fileOrFolder);
+	}
+	/**
+	* The streaming `InputStreamNode` produced by the adapter.
+	* Always set after adapter setup, parse-only adapters are wrapped automatically.
+	*/
+	inputNode = null;
+	adapter = null;
+	/**
+	* Raw adapter source so `adapter.parse()` / `adapter.stream()` can run lazily.
+	* Intentionally outlives the build, cleared by `dispose()`.
+	*/
+	#adapterSource = null;
+	/**
+	* Central file store for all generated files.
+	* Plugins should use `this.addFile()` / `this.upsertFile()` (via their context) to
+	* add files. This property gives direct read/write access when needed.
+	*/
+	fileManager = new FileManager();
+	plugins = /* @__PURE__ */ new Map();
+	/**
+	* Tracks which plugins have generators registered via `addGenerator()` (event-based path).
+	* Used by the build loop to decide whether to emit generator events for a given plugin.
+	*/
+	#eventGeneratorPlugins = /* @__PURE__ */ new Set();
+	#resolvers = /* @__PURE__ */ new Map();
+	#defaultResolvers = /* @__PURE__ */ new Map();
+	/**
+	* Tracks every listener the driver added (plugin, middleware, generator) so `dispose()` can
+	* remove them in one pass. Middleware registers after plugins, so it fires last via `Set`
+	* insertion order. External `hooks.on(...)` listeners are not tracked.
+	*/
+	#registry;
+	/**
+	* Transform registry. Plugins populate it during `kubb:plugin:setup` via `setTransformer`,
+	* and `#runGenerators` reads it once per `(plugin, node)` pair through `applyTo`.
+	*/
+	#transforms = new Transform();
+	constructor(config, options) {
+		this.config = config;
+		this.options = options;
+		this.adapter = config.adapter ?? null;
+		this.#registry = new HookRegistry({ emitter: options.hooks });
+	}
+	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);
+		});
+		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) this.#adapterSource = inputToAdapterSource(this.config);
+	}
+	get hooks() {
+		return this.options.hooks;
+	}
+	/**
+	* Creates an `NormalizedPlugin` from a hook-style plugin and registers
+	* its lifecycle handlers on the `AsyncEventEmitter`.
+	*/
+	#normalizePlugin(plugin) {
+		const normalized = {
+			name: plugin.name,
+			dependencies: plugin.dependencies,
+			enforce: plugin.enforce,
+			hooks: plugin.hooks,
+			options: plugin.options ?? {
+				output: { path: "." },
+				exclude: [],
+				override: []
+			}
+		};
+		if ("apply" in plugin && typeof plugin.apply === "function") normalized.apply = plugin.apply;
+		return normalized;
+	}
+	/**
+	* Parses the adapter source into `this.inputNode`. Idempotent, so repeated calls from
+	* `run` do not re-parse. Adapters with `stream()` are used directly.
+	* Adapters with only `parse()` are wrapped via `createStreamInput` so the dispatch loop
+	* stays stream-only.
+	*/
+	async #parseInput() {
+		if (this.inputNode || !this.adapter || !this.#adapterSource) return;
+		const adapter = this.adapter;
+		const source = this.#adapterSource;
+		if (adapter.stream) {
+			this.inputNode = await adapter.stream(source);
+			return;
+		}
+		const parsed = await adapter.parse(source);
+		this.inputNode = (0, _kubb_ast.createStreamInput)(arrayToAsyncIterable(parsed.schemas), arrayToAsyncIterable(parsed.operations), parsed.meta);
+	}
+	#registerMiddleware(event, middlewareHooks) {
+		const handler = middlewareHooks[event];
+		if (!handler) return;
+		this.#registry.register({
+			event,
+			handler,
+			source: "middleware"
+		});
+	}
+	/**
+	* Registers a hook-style plugin's lifecycle handlers on the shared `AsyncEventEmitter`.
+	*
+	* The `kubb:plugin:setup` listener wraps the global context in a plugin-specific one so
+	* `addGenerator`, `setResolver`, and `setTransformer` target the right `normalizedPlugin`.
+	* Every other `KubbHooks` event registers as a pass-through listener that external tooling
+	* can observe via `hooks.on(...)`.
+	*
+	* @internal
+	*/
+	#registerPlugin(plugin) {
+		const { hooks } = plugin;
+		if (!hooks) return;
+		if (hooks["kubb:plugin:setup"]) {
+			const setupHandler = (globalCtx) => {
+				const pluginCtx = {
+					...globalCtx,
+					options: plugin.options ?? {},
+					addGenerator: (gen) => {
+						this.registerGenerator(plugin.name, gen);
+					},
+					setResolver: (resolver) => {
+						this.setPluginResolver(plugin.name, resolver);
+					},
+					setTransformer: (visitor) => {
+						this.#transforms.register(plugin.name, visitor);
+					},
+					setOptions: (opts) => {
+						plugin.options = {
+							...plugin.options,
+							...opts
+						};
+					},
+					injectFile: (userFileNode) => {
+						this.fileManager.add((0, _kubb_ast.createFile)(userFileNode));
+					}
+				};
+				return hooks["kubb:plugin:setup"](pluginCtx);
+			};
+			this.#registry.register({
+				event: "kubb:plugin:setup",
+				handler: setupHandler,
+				source: "plugin"
+			});
+		}
+		for (const event of Object.keys(hooks)) {
+			if (event === "kubb:plugin:setup") continue;
+			const handler = hooks[event];
+			if (!handler) continue;
+			this.#registry.register({
+				event,
+				handler,
+				source: "plugin"
+			});
+		}
+	}
+	/**
+	* Emits the `kubb:plugin:setup` event so that all registered hook-style plugin listeners
+	* can configure generators, resolvers, transformers and renderers before `buildStart` runs.
+	*
+	* Call this once from `safeBuild` before the plugin execution loop begins.
+	*/
+	async emitSetupHooks() {
+		const noop = () => {};
+		await this.hooks.emit("kubb:plugin:setup", {
+			config: this.config,
+			options: {},
+			addGenerator: noop,
+			setResolver: noop,
+			setTransformer: noop,
+			setOptions: noop,
+			injectFile: noop,
+			updateConfig: noop
+		});
+	}
+	/**
+	* Registers a generator for the given plugin on the shared event emitter.
+	*
+	* The generator's `schema`, `operation`, and `operations` methods are registered as
+	* listeners on `kubb:generate:schema`, `kubb:generate:operation`, and `kubb:generate:operations`
+	* respectively. Each listener is scoped to the owning plugin via a `ctx.plugin.name` check
+	* so that generators from different plugins do not cross-fire.
+	*
+	* The renderer comes from `generator.renderer`. Set `generator.renderer = null` (or leave it
+	* unset) to opt out of rendering.
+	*
+	* Call this method inside `addGenerator()` (in `kubb:plugin:setup`) to wire up a generator.
+	*/
+	registerGenerator(pluginName, generator) {
+		if (generator.schema) {
+			const schemaHandler = async (node, ctx) => {
+				if (ctx.plugin.name !== pluginName) return;
+				const result = await generator.schema(node, ctx);
+				await this.dispatch({
+					result,
+					renderer: generator.renderer
+				});
+			};
+			this.#registry.register({
+				event: "kubb:generate:schema",
+				handler: schemaHandler,
+				source: "driver"
+			});
+		}
+		if (generator.operation) {
+			const operationHandler = async (node, ctx) => {
+				if (ctx.plugin.name !== pluginName) return;
+				const result = await generator.operation(node, ctx);
+				await this.dispatch({
+					result,
+					renderer: generator.renderer
+				});
+			};
+			this.#registry.register({
+				event: "kubb:generate:operation",
+				handler: operationHandler,
+				source: "driver"
+			});
+		}
+		if (generator.operations) {
+			const operationsHandler = async (nodes, ctx) => {
+				if (ctx.plugin.name !== pluginName) return;
+				const result = await generator.operations(nodes, ctx);
+				await this.dispatch({
+					result,
+					renderer: generator.renderer
+				});
+			};
+			this.#registry.register({
+				event: "kubb:generate:operations",
+				handler: operationsHandler,
+				source: "driver"
+			});
+		}
+		this.#eventGeneratorPlugins.add(pluginName);
+	}
+	/**
+	* Returns `true` when at least one generator was registered for the given plugin
+	* via `addGenerator()` in `kubb:plugin:setup` (event-based path).
+	*
+	* Used by the build loop to decide whether to walk the AST and emit generator events
+	* for a plugin that has no static `plugin.generators`.
+	*/
+	hasEventGenerators(pluginName) {
+		return this.#eventGeneratorPlugins.has(pluginName);
+	}
+	/**
+	* Runs the full plugin pipeline. Returns the diagnostics collected so far even
+	* when an outer hook throws, since the orchestrator preserves partial state by capturing
+	* the failure as a {@link Diagnostic} instead of propagating. Each plugin also
+	* contributes a `timing` diagnostic for the run summary.
+	*/
+	async run({ storage }) {
+		const { hooks, config } = this;
+		const diagnostics = [];
+		const parsersMap = /* @__PURE__ */ new Map();
+		for (const parser of config.parsers) if (parser.extNames) for (const ext of parser.extNames) parsersMap.set(ext, parser);
+		const processor = new FileProcessor({
+			parsers: parsersMap,
+			storage,
+			extension: config.output.extension
+		});
+		processor.hooks.on("start", async (files) => {
+			await hooks.emit("kubb:files:processing:start", { files });
+		});
+		const updateBuffer = [];
+		processor.hooks.on("update", (item) => {
+			updateBuffer.push(item);
+		});
+		processor.hooks.on("end", async (files) => {
+			await hooks.emit("kubb:files:processing:update", { files: updateBuffer.map((item) => ({
+				...item,
+				config
+			})) });
+			updateBuffer.length = 0;
+			await hooks.emit("kubb:files:processing:end", { files });
+		});
+		const onFileUpsert = (file) => {
+			processor.enqueue(file);
+		};
+		this.fileManager.hooks.on("upsert", onFileUpsert);
+		return Diagnostics.scope((diagnostic) => diagnostics.push(diagnostic), async () => {
+			try {
+				await this.#parseInput();
+				await this.emitSetupHooks();
+				if (this.adapter && this.inputNode) await hooks.emit("kubb:build:start", Object.assign({
+					config,
+					adapter: this.adapter,
+					meta: this.inputNode.meta,
+					getPlugin: this.getPlugin.bind(this)
+				}, this.#filesPayload()));
+				const generatorPlugins = [];
+				for (const plugin of this.plugins.values()) {
+					const context = this.getContext(plugin);
+					const hrStart = process.hrtime();
+					try {
+						await hooks.emit("kubb:plugin:start", { plugin });
+					} catch (caughtError) {
+						const error = caughtError;
+						const duration = getElapsedMs(hrStart);
+						await this.#emitPluginEnd({
+							plugin,
+							duration,
+							success: false,
+							error
+						});
+						diagnostics.push({
+							...Diagnostics.from(error),
+							plugin: plugin.name
+						}, Diagnostics.performance({
+							plugin: plugin.name,
+							duration
+						}));
+						continue;
+					}
+					if (this.hasEventGenerators(plugin.name)) {
+						generatorPlugins.push({
+							plugin,
+							context,
+							hrStart
+						});
+						continue;
+					}
+					const duration = getElapsedMs(hrStart);
+					diagnostics.push(Diagnostics.performance({
+						plugin: plugin.name,
+						duration
+					}));
+					await this.#emitPluginEnd({
+						plugin,
+						duration,
+						success: true
+					});
+				}
+				diagnostics.push(...await this.#runGenerators(generatorPlugins, () => processor.flush()));
+				await processor.drain();
+				await hooks.emit("kubb:plugins:end", Object.assign({ config }, this.#filesPayload()));
+				await processor.drain();
+				await hooks.emit("kubb:build:end", {
+					files: this.fileManager.files,
+					config,
+					outputDir: (0, node_path.resolve)(config.root, config.output.path)
+				});
+				return { diagnostics: Diagnostics.dedupe(diagnostics) };
+			} catch (caughtError) {
+				diagnostics.push(Diagnostics.from(caughtError));
+				return { diagnostics: Diagnostics.dedupe(diagnostics) };
+			} finally {
+				this.fileManager.hooks.off("upsert", onFileUpsert);
+			}
+		});
+	}
+	#filesPayload() {
+		const driver = this;
+		return {
+			get files() {
+				return driver.fileManager.files;
+			},
+			upsertFile: (...files) => driver.fileManager.upsert(...files)
+		};
+	}
+	#emitPluginEnd({ plugin, duration, success, error }) {
+		return this.hooks.emit("kubb:plugin:end", Object.assign({
+			plugin,
+			duration,
+			success,
+			...error ? { error } : {},
+			config: this.config
+		}, this.#filesPayload()));
+	}
+	/**
+	* Streams schemas and operations through every plugin's generators. Each node is run
+	* through the plugin's transformer (from `this.#transforms`) before the generator sees it,
+	* so plugins stay isolated and the hot path stays per-node. Schemas run before operations
+	* because the two passes share `flushPending` and the FileProcessor's event emitter.
+	* A failing plugin contributes an error diagnostic so the rest of the build continues.
+	* Every plugin also contributes a `timing` diagnostic.
+	*
+	* When `entries` is empty or `this.inputNode` is `null`, every entry still gets a
+	* `kubb:plugin:end` so middleware listeners (the barrel writer and friends) complete.
+	*/
+	async #runGenerators(entries, flushPending) {
+		const diagnostics = [];
+		if (entries.length === 0) return diagnostics;
+		if (!this.inputNode) {
+			for (const { plugin, hrStart } of entries) {
+				const duration = getElapsedMs(hrStart);
+				diagnostics.push(Diagnostics.performance({
+					plugin: plugin.name,
+					duration
+				}));
+				await this.#emitPluginEnd({
+					plugin,
+					duration,
+					success: true
+				});
+			}
+			return diagnostics;
+		}
+		const transforms = this.#transforms;
+		const { schemas, operations } = this.inputNode;
+		const states = entries.map(({ plugin, context, hrStart }) => {
+			const { exclude, include, override } = plugin.options;
+			const hasExclude = Array.isArray(exclude) && exclude.length > 0;
+			const hasInclude = Array.isArray(include) && include.length > 0;
+			const hasOverride = Array.isArray(override) && override.length > 0;
+			return {
+				plugin,
+				generatorContext: {
+					...context,
+					resolver: this.getResolver(plugin.name)
+				},
+				generators: plugin.generators ?? [],
+				hrStart,
+				failed: false,
+				error: null,
+				optionsAreStatic: !hasExclude && !hasInclude && !hasOverride,
+				allowedSchemaNames: null
+			};
+		});
+		const emitsSchemaHook = this.hooks.listenerCount("kubb:generate:schema") > 0;
+		const emitsOperationHook = this.hooks.listenerCount("kubb:generate:operation") > 0;
+		const pruningStates = states.filter(({ plugin }) => {
+			const { include } = plugin.options;
+			return (include?.some(({ type }) => OPERATION_FILTER_TYPES.has(type)) ?? false) && !(include?.some(({ type }) => type === "schemaName") ?? false);
+		});
+		if (pruningStates.length > 0) {
+			const allSchemas = [];
+			for await (const schema of schemas) allSchemas.push(schema);
+			const includedOpsByState = new Map(pruningStates.map((state) => [state, []]));
+			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) includedOpsByState.get(state)?.push(operation);
+			}
+			for (const state of pruningStates) {
+				state.allowedSchemaNames = (0, _kubb_ast.collectUsedSchemaNames)(includedOpsByState.get(state) ?? [], allSchemas);
+				includedOpsByState.delete(state);
+			}
+		}
+		const resolveForPlugin = (state, node) => {
+			const { plugin, generatorContext } = state;
+			const transformedNode = transforms.applyTo(plugin.name, node);
+			if (state.optionsAreStatic) return {
+				transformedNode,
+				options: plugin.options
+			};
+			const { exclude, include, override } = plugin.options;
+			const options = generatorContext.resolver.resolveOptions(transformedNode, {
+				options: plugin.options,
+				exclude,
+				include,
+				override
+			});
+			if (options === null) return null;
+			return {
+				transformedNode,
+				options
+			};
+		};
+		const dispatchNode = async (state, node, dispatch) => {
+			if (state.failed) return;
+			try {
+				const resolved = resolveForPlugin(state, node);
+				if (!resolved) return;
+				const { transformedNode, options } = resolved;
+				if (dispatch.checkAllowedNames && state.allowedSchemaNames !== null && "name" in transformedNode && transformedNode.name && !state.allowedSchemaNames.has(transformedNode.name)) return;
+				const ctx = {
+					...state.generatorContext,
+					options
+				};
+				for (const gen of state.generators) {
+					const run = gen[dispatch.method];
+					if (!run) continue;
+					const raw = run(transformedNode, ctx);
+					const result = isPromise(raw) ? await raw : raw;
+					const applied = this.dispatch({
+						result,
+						renderer: gen.renderer
+					});
+					if (isPromise(applied)) await applied;
+				}
+				if (dispatch.emit) await dispatch.emit(transformedNode, ctx);
+			} catch (caughtError) {
+				state.failed = true;
+				state.error = caughtError;
+			}
+		};
+		const schemaDispatch = {
+			method: "schema",
+			checkAllowedNames: true,
+			emit: emitsSchemaHook ? (node, ctx) => this.hooks.emit("kubb:generate:schema", node, ctx) : null
+		};
+		const operationDispatch = {
+			method: "operation",
+			checkAllowedNames: false,
+			emit: emitsOperationHook ? (node, ctx) => this.hooks.emit("kubb:generate:operation", node, ctx) : null
+		};
+		const needsCollectedOperations = this.hooks.listenerCount("kubb:generate:operations") > 0 || states.some((state) => state.generators.some((gen) => !!gen.operations));
+		const collectedOperations = needsCollectedOperations ? [] : void 0;
+		await forBatches(schemas, (nodes) => Promise.all(nodes.flatMap((node) => states.map((state) => dispatchNode(state, node, schemaDispatch)))), {
+			concurrency: 8,
+			flush: flushPending
+		});
+		await forBatches(operations, (nodes) => {
+			if (needsCollectedOperations) collectedOperations?.push(...nodes);
+			return Promise.all(nodes.flatMap((node) => states.map((state) => dispatchNode(state, node, operationDispatch))));
+		}, {
+			concurrency: 8,
+			flush: flushPending
+		});
+		for (const state of states) {
+			if (!state.failed && needsCollectedOperations) try {
+				const { plugin, generatorContext, generators } = state;
+				const ctx = {
+					...generatorContext,
+					options: plugin.options
+				};
+				const pluginOperations = (collectedOperations ?? []).reduce((acc, node) => {
+					const resolved = resolveForPlugin(state, node);
+					if (resolved) acc.push(resolved.transformedNode);
+					return acc;
+				}, []);
+				for (const gen of generators) {
+					if (!gen.operations) continue;
+					const result = await gen.operations(pluginOperations, ctx);
+					await this.dispatch({
+						result,
+						renderer: gen.renderer
+					});
+				}
+				await this.hooks.emit("kubb:generate:operations", pluginOperations, ctx);
+			} catch (caughtError) {
+				state.failed = true;
+				state.error = caughtError;
+			}
+			const duration = getElapsedMs(state.hrStart);
+			await this.#emitPluginEnd({
+				plugin: state.plugin,
+				duration,
+				success: !state.failed,
+				error: state.failed && state.error ? state.error : void 0
+			});
+			if (state.failed && state.error) diagnostics.push({
+				...Diagnostics.from(state.error),
+				plugin: state.plugin.name
+			});
+			diagnostics.push(Diagnostics.performance({
+				plugin: state.plugin.name,
+				duration
+			}));
+		}
+		return diagnostics;
+	}
+	/**
+	* Stores whatever a generator method or `kubb:generate:*` hook returned.
+	*
+	* - An `Array<FileNode>` goes straight into `fileManager` via `upsert`.
+	* - A renderer element runs through `renderer` (the renderer factory, e.g. JSX) and the
+	*   produced files go to `fileManager.upsert`.
+	* - A falsy result is treated as a no-op. The generator wrote files itself via
+	*   `ctx.upsertFile`.
+	*
+	* Pass `renderer` when the result may be a renderer element. Generators that only return
+	* `Array<FileNode>` do not need one.
+	*/
+	async dispatch({ result, renderer }) {
+		try {
+			var _usingCtx$1 = _usingCtx();
+			if (!result) return;
+			if (Array.isArray(result)) {
+				this.fileManager.upsert(...result);
+				return;
+			}
+			if (!renderer) return;
+			const instance = _usingCtx$1.u(renderer());
+			if (instance.stream) {
+				for (const file of instance.stream(result)) this.fileManager.upsert(file);
+				return;
+			}
+			await instance.render(result);
+			this.fileManager.upsert(...instance.files);
+		} catch (_) {
+			_usingCtx$1.e = _;
+		} finally {
+			_usingCtx$1.d();
+		}
+	}
+	/**
+	* Removes every listener the driver added. Listeners attached directly to `hooks` from outside
+	* the driver survive. Called at the end of a build to prevent leaks across repeated builds.
+	*
+	* @internal
+	*/
+	dispose() {
+		this.#registry.dispose();
+		this.#eventGeneratorPlugins.clear();
+		this.#transforms.dispose();
+		this.#resolvers.clear();
+		this.#defaultResolvers.clear();
+		this.fileManager.dispose();
+		this.inputNode = null;
+		this.#adapterSource = null;
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+	#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`
+	* get the up-to-date resolver without going through `getResolver()`.
+	*/
+	setPluginResolver(pluginName, partial) {
+		const merged = {
+			...this.#getDefaultResolver(pluginName),
+			...partial
+		};
+		this.#resolvers.set(pluginName, merged);
+		const plugin = this.plugins.get(pluginName);
+		if (plugin) plugin.resolver = merged;
+	}
+	getResolver(pluginName) {
+		return this.#resolvers.get(pluginName) ?? this.plugins.get(pluginName)?.resolver ?? this.#getDefaultResolver(pluginName);
+	}
+	getContext(plugin) {
+		const driver = this;
+		const report = (diagnostic) => {
+			Diagnostics.report({
+				...diagnostic,
+				plugin: plugin.name
+			});
+		};
+		return {
+			config: driver.config,
+			get root() {
+				return (0, node_path.resolve)(driver.config.root, driver.config.output.path);
+			},
+			getMode(output) {
+				return KubbDriver.getMode((0, node_path.resolve)(driver.config.root, driver.config.output.path, output.path));
+			},
+			hooks: driver.hooks,
+			plugin,
+			getPlugin: driver.getPlugin.bind(driver),
+			requirePlugin: driver.requirePlugin.bind(driver),
+			getResolver: driver.getResolver.bind(driver),
+			driver,
+			addFile: async (...files) => {
+				driver.fileManager.add(...files);
+			},
+			upsertFile: async (...files) => {
+				driver.fileManager.upsert(...files);
+			},
+			get meta() {
+				return driver.inputNode?.meta ?? {
+					circularNames: [],
+					enumNames: []
+				};
+			},
+			get adapter() {
+				return driver.adapter;
+			},
+			get resolver() {
+				return driver.getResolver(plugin.name);
+			},
+			get transformer() {
+				return driver.#transforms.get(plugin.name);
+			},
+			warn(message) {
+				report({
+					code: Diagnostics.code.pluginWarning,
+					severity: "warning",
+					message
+				});
+			},
+			error(error) {
+				const cause = typeof error === "string" ? void 0 : error;
+				report({
+					code: Diagnostics.code.pluginFailed,
+					severity: "error",
+					message: typeof error === "string" ? error : error.message,
+					cause
+				});
+			},
+			info(message) {
+				report({
+					code: Diagnostics.code.pluginInfo,
+					severity: "info",
+					message
+				});
+			}
+		};
+	}
+	getPlugin(pluginName) {
+		return this.plugins.get(pluginName);
+	}
+	requirePlugin(pluginName) {
+		const plugin = this.plugins.get(pluginName);
+		if (!plugin) throw new Diagnostics.Error({
+			code: Diagnostics.code.pluginNotFound,
+			severity: "error",
+			message: `Plugin "${pluginName}" is required but not found. Make sure it is included in your Kubb config.`,
+			help: `Add "${pluginName}" to the \`plugins\` array in kubb.config.ts, or remove the dependency on it.`,
+			location: { kind: "config" }
+		});
+		return plugin;
+	}
+};
+function inputToAdapterSource(config) {
+	const input = config.input;
+	if (!input) throw new Diagnostics.Error({
+		code: Diagnostics.code.inputRequired,
+		severity: "error",
+		message: "An adapter is configured without an input.",
+		help: "Provide `input.path` (a file or URL) or `input.data` (an inline spec) in your Kubb config.",
+		location: { kind: "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
+//#region src/storages/memoryStorage.ts
+/**
+* In-memory storage driver. Useful for testing and dry-run scenarios where
+* generated output should be captured without touching the filesystem.
+*
+* All data lives in a `Map` scoped to the storage instance and is discarded
+* when the instance is garbage-collected.
+*
+* @example
+* ```ts
+* import { memoryStorage } from '@kubb/core'
+* import { defineConfig } from 'kubb'
+*
+* export default defineConfig({
+*   input:  { path: './petStore.yaml' },
+*   output: { path: './src/gen' },
+*   storage: memoryStorage(),
+* })
+* ```
+*/
+const memoryStorage = createStorage(() => {
+	const store = /* @__PURE__ */ new Map();
+	return {
+		name: "memory",
+		async hasItem(key) {
+			return store.has(key);
+		},
+		async getItem(key) {
+			return store.get(key) ?? null;
+		},
+		async setItem(key, value) {
+			store.set(key, value);
+		},
+		async removeItem(key) {
+			store.delete(key);
+		},
+		async getKeys(base) {
+			const keys = [...store.keys()];
+			return base ? keys.filter((k) => k.startsWith(base)) : keys;
+		},
+		async clear(base) {
+			if (!base) {
+				store.clear();
+				return;
+			}
+			for (const key of store.keys()) if (key.startsWith(base)) store.delete(key);
+		}
+	};
+});
+//#endregion
+Object.defineProperty(exports, "AsyncEventEmitter", {
+	enumerable: true,
+	get: function() {
+		return AsyncEventEmitter;
+	}
+});
+Object.defineProperty(exports, "BuildError", {
+	enumerable: true,
+	get: function() {
+		return BuildError;
+	}
+});
+Object.defineProperty(exports, "Diagnostics", {
+	enumerable: true,
+	get: function() {
+		return Diagnostics;
+	}
+});
+Object.defineProperty(exports, "FileManager", {
+	enumerable: true,
+	get: function() {
+		return FileManager;
+	}
+});
+Object.defineProperty(exports, "FileProcessor", {
+	enumerable: true,
+	get: function() {
+		return FileProcessor;
+	}
+});
+Object.defineProperty(exports, "KubbDriver", {
+	enumerable: true,
+	get: function() {
+		return KubbDriver;
+	}
+});
+Object.defineProperty(exports, "OTLP_ENDPOINT", {
+	enumerable: true,
+	get: function() {
+		return OTLP_ENDPOINT;
+	}
+});
+Object.defineProperty(exports, "URLPath", {
+	enumerable: true,
+	get: function() {
+		return URLPath;
+	}
+});
+Object.defineProperty(exports, "__name", {
+	enumerable: true,
+	get: function() {
+		return __name;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "_usingCtx", {
+	enumerable: true,
+	get: function() {
+		return _usingCtx;
+	}
+});
+Object.defineProperty(exports, "camelCase", {
+	enumerable: true,
+	get: function() {
+		return camelCase;
+	}
+});
+Object.defineProperty(exports, "createStorage", {
+	enumerable: true,
+	get: function() {
+		return createStorage;
+	}
+});
+Object.defineProperty(exports, "definePlugin", {
+	enumerable: true,
+	get: function() {
+		return definePlugin;
+	}
+});
+Object.defineProperty(exports, "defineResolver", {
+	enumerable: true,
+	get: function() {
+		return defineResolver;
+	}
+});
+Object.defineProperty(exports, "formatMs", {
+	enumerable: true,
+	get: function() {
+		return formatMs;
+	}
+});
+Object.defineProperty(exports, "getElapsedMs", {
+	enumerable: true,
+	get: function() {
+		return getElapsedMs;
+	}
+});
+Object.defineProperty(exports, "memoryStorage", {
+	enumerable: true,
+	get: function() {
+		return memoryStorage;
+	}
+});
+
+//# sourceMappingURL=memoryStorage-Dkxnid2K.cjs.map