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

package/dist/KubbDriver-BBRa5CH2.cjs

@@ -0,0 +1,2231 @@
+//#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_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let _kubb_ast = require("@kubb/ast");
+let fflate = require("fflate");
+let tinyexec = require("tinyexec");
+//#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));
+}
+//#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);
+	}
+	/**
+	* 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 } = {}) {
+		return `\`${prefix}${this.path.split(/\{([^}]+)\}/).map((part, i) => {
+			if (i % 2 === 0) return part;
+			const param = this.#transformParam(part);
+			return `\${${replacer ? replacer(param) : param}}`;
+		}).join("")}\``;
+	}
+	/**
+	* Extracts all `{param}` segments from the path and returns them as a key-value map.
+	* An optional `replacer` transforms each parameter name in both key and value positions.
+	* Returns `undefined` when no path parameters are found.
+	*
+	* @example
+	* ```ts
+	* new URLPath('/pet/{petId}/tag/{tagId}').getParams()
+	* // { petId: 'petId', tagId: 'tagId' }
+	* ```
+	*/
+	getParams(replacer) {
+		const params = {};
+		this.#eachParam((_raw, param) => {
+			const key = replacer ? replacer(param) : param;
+			params[key] = key;
+		});
+		return Object.keys(params).length > 0 ? params : void 0;
+	}
+	/** Converts the OpenAPI path to Express-style colon syntax.
+	*
+	* @example
+	* ```ts
+	* new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
+	* ```
+	*/
+	toURLPath() {
+		return this.path.replace(/\{([^}]+)\}/g, ":$1");
+	}
+};
+//#endregion
+//#region src/constants.ts
+/**
+* Base URL for the Kubb Studio web app.
+*/
+const DEFAULT_STUDIO_URL = "https://kubb.studio";
+/**
+* Default banner style written at the top of every generated file.
+*/
+const DEFAULT_BANNER = "simple";
+/**
+* Default file-extension mapping used when no explicit mapping is configured.
+*/
+const DEFAULT_EXTENSION = { ".ts": ".ts" };
+/**
+* Numeric log-level thresholds used internally to compare verbosity.
+*
+* Higher numbers are more verbose.
+*/
+const logLevel = {
+	silent: Number.NEGATIVE_INFINITY,
+	error: 0,
+	warn: 1,
+	info: 3,
+	verbose: 4,
+	debug: 5
+};
+//#endregion
+//#region src/definePlugin.ts
+/**
+* Wraps a factory function and returns a typed `Plugin` with lifecycle handlers grouped under `hooks`.
+*
+* Handlers live in a single `hooks` object (inspired by Astro integrations).
+* All lifecycle events from `KubbHooks` are available for subscription.
+*
+* @note For real plugins, use a `PluginFactoryOptions` type parameter to get type-safe context in `kubb:plugin:setup`.
+* Plugin names should follow the convention `plugin-<feature>` (e.g., `plugin-react-query`, `plugin-zod`).
+*
+* @example
+* ```ts
+* import { definePlugin } from '@kubb/core'
+*
+* export const pluginTs = definePlugin((options: { prefix?: string } = {}) => ({
+*   name: 'plugin-ts',
+*   hooks: {
+*     'kubb:plugin:setup'(ctx) {
+*       ctx.setResolver(resolverTs)
+*     },
+*   },
+* }))
+* ```
+*/
+function definePlugin(factory) {
+	return (options) => factory(options ?? {});
+}
+/**
+* Returns `'single'` when `fileOrFolder` has a file extension, `'split'` otherwise.
+* Used to determine whether an output path targets a single file or a directory.
+*/
+function getMode(fileOrFolder) {
+	if (!fileOrFolder) return "split";
+	return (0, node_path.extname)(fileOrFolder) ? "single" : "split";
+}
+//#endregion
+//#region src/defineResolver.ts
+const stringPatternCache = /* @__PURE__ */ new Map();
+function testPattern(value, pattern) {
+	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 testPattern(node.path, pattern);
+	if (type === "method") return testPattern(node.method.toLowerCase(), pattern);
+	if (type === "contentType") return node.requestBody?.content?.some((c) => testPattern(c.contentType, pattern)) ?? false;
+	return false;
+}
+/**
+* Checks if a schema matches a pattern for a given filter type (`schemaName`).
+*
+* 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((r) => r !== 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: g }) => `${camelCase(g)}Controller` : ({ group: g }) => {
+				const segment = g.split("/").filter((s) => s !== "" && s !== "." && s !== "..")[0];
+				return segment ? camelCase(segment) : "";
+			};
+			const resolveName = group.name ?? defaultName;
+			return node_path.default.resolve(root, output.path, resolveName({ group: groupValue }), baseName);
+		}
+		return node_path.default.resolve(root, output.path, baseName);
+	})();
+	const outputDir = node_path.default.resolve(root, output.path);
+	const outputDirWithSep = outputDir.endsWith(node_path.default.sep) ? outputDir : `${outputDir}${node_path.default.sep}`;
+	if (result !== outputDir && !result.startsWith(outputDirWithSep)) throw new Error(`[Kubb] Resolved path "${result}" is outside the output directory "${outputDir}". This may indicate a path traversal attempt in the OpenAPI specification or a misconfigured group.name function.`);
+	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 — consumers populate those 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 `meta` and returns the result.
+* - When `output.banner` is a string, returns it directly.
+* - When `config.output.defaultBanner` is `false`, returns `undefined`.
+* - Otherwise returns the Kubb "Generated by Kubb" notice.
+*
+* @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 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 }) {
+	if (typeof output?.banner === "function") return output.banner(meta);
+	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 `meta` 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 }) {
+	if (typeof output?.footer === "function") return output.footer(meta);
+	if (typeof output?.footer === "string") return output.footer;
+	return null;
+}
+/**
+* Defines a resolver for a plugin, injecting built-in defaults for name casing,
+* include/exclude/override filtering, path resolution, and file construction.
+*
+* All four defaults can be overridden by providing them in the builder function:
+* - `default` — name casing strategy (camelCase / PascalCase)
+* - `resolveOptions` — include/exclude/override filtering
+* - `resolvePath` — output path computation
+* - `resolveFile` — full `FileNode` construction
+*
+* Methods in the returned object can call sibling resolver methods via `this`.
+*
+* @example Basic resolver with naming helpers
+* ```ts
+* export const resolver = defineResolver<PluginTs>(() => ({
+*   name: 'default',
+*   resolveName(node) {
+*     return this.default(node.name, 'function')
+*   },
+*   resolveTypedName(node) {
+*     return this.default(node.name, 'type')
+*   },
+* }))
+* ```
+*
+* @example Override resolvePath for a custom output structure
+* ```ts
+* export const resolver = defineResolver<PluginTs>(() => ({
+*   name: 'custom',
+*   resolvePath({ baseName }, { root, output }) {
+*     return path.resolve(root, output.path, 'generated', baseName)
+*   },
+* }))
+* ```
+*
+* @example Use this.default inside a helper
+* ```ts
+* export const resolver = defineResolver<PluginTs>(() => ({
+*   name: 'default',
+*   resolveParamName(node, param) {
+*     return this.default(`${node.operationId} ${param.in} ${param.name}`, 'type')
+*   },
+* }))
+* ```
+*/
+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/devtools.ts
+/**
+* Encodes an `InputNode` as a compressed, URL-safe string.
+*
+* The JSON representation is deflate-compressed with {@link deflateSync} before
+* base64url encoding, which typically reduces payload size by 70–80 % and
+* keeps URLs well within browser and server path-length limits.
+*
+* Use {@link decodeAst} to reverse.
+*/
+function encodeAst(input) {
+	const compressed = (0, fflate.deflateSync)(new TextEncoder().encode(JSON.stringify(input)));
+	return Buffer.from(compressed).toString("base64url");
+}
+/**
+* Constructs the Kubb Studio URL for the given `InputNode`.
+* When `options.ast` is `true`, navigates to the AST inspector (`/ast`).
+* The `input` is encoded and attached as the `?root=` query parameter so Studio
+* can decode and render it without a round-trip to any server.
+*/
+function getStudioUrl(input, studioUrl, options = {}) {
+	return `${studioUrl.replace(/\/$/, "")}${options.ast ? "/ast" : ""}?root=${encodeAst(input)}`;
+}
+/**
+* Opens the Kubb Studio URL for the given `InputNode` in the default browser —
+*
+* Falls back to printing the URL if the browser cannot be launched.
+*/
+async function openInStudio(input, studioUrl, options = {}) {
+	const url = getStudioUrl(input, studioUrl, options);
+	const cmd = process.platform === "win32" ? "cmd" : process.platform === "darwin" ? "open" : "xdg-open";
+	const args = process.platform === "win32" ? [
+		"/c",
+		"start",
+		"",
+		url
+	] : [url];
+	try {
+		await (0, tinyexec.x)(cmd, args);
+	} catch {
+		console.log(`\n  ${url}\n`);
+	}
+}
+//#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 {
+	#cache = /* @__PURE__ */ new Map();
+	#sorted = null;
+	#onUpsert = null;
+	/**
+	* Registers a callback invoked with the resolved {@link FileNode} on every
+	* `add` / `upsert`. Used by the build loop to track newly written files
+	* without keeping its own scan-based diff. Single subscriber by design —
+	* setting again replaces the previous callback. Pass `null` to detach.
+	*/
+	setOnUpsert(callback) {
+		this.#onUpsert = callback;
+	}
+	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)) : file;
+			this.#cache.set(merged.path, merged);
+			resolved.push(merged);
+			this.#onUpsert?.(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. Called by the core after `kubb:build:end`.
+	*/
+	dispose() {
+		this.clear();
+		this.#onUpsert = null;
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+	/**
+	* All stored files in stable sort order (shortest path first, barrel files
+	* last within a length bucket). Returns a cached view — do not mutate.
+	*/
+	get files() {
+		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 s = (0, _kubb_ast.extractStringsFromNodes)(source.nodes);
+		if (s) parts.push(s);
+	}
+	return parts.join("\n\n");
+}
+/**
+* Converts a single file to a string using the registered parsers.
+* Falls back to joining source values when no matching parser is found.
+*
+* @internal
+*/
+var FileProcessor = class {
+	events = new AsyncEventEmitter();
+	parse(file, { parsers, extension } = {}) {
+		const parseExtName = extension?.[file.extname] || void 0;
+		if (!parsers || !file.extname) return joinSources(file);
+		const parser = parsers.get(file.extname);
+		if (!parser) return joinSources(file);
+		return parser.parse(file, { extname: parseExtName });
+	}
+	*stream(files, options = {}) {
+		const total = files.length;
+		if (total === 0) return;
+		let processed = 0;
+		for (const file of files) {
+			const source = this.parse(file, options);
+			processed++;
+			yield {
+				file,
+				source,
+				processed,
+				total,
+				percentage: processed / total * 100
+			};
+		}
+	}
+	async run(files, options = {}) {
+		await this.events.emit("start", files);
+		for (const { file, source, processed, total, percentage } of this.stream(files, options)) await this.events.emit("update", {
+			file,
+			source,
+			processed,
+			percentage,
+			total
+		});
+		await this.events.emit("end", files);
+		return files;
+	}
+	/**
+	* Clears all registered event listeners.
+	*/
+	dispose() {
+		this.events.removeAll();
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+};
+//#endregion
+//#region \0@oxc-project+runtime@0.129.0/helpers/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;
+}
+const OPERATION_FILTER_TYPES = new Set([
+	"tag",
+	"operationId",
+	"path",
+	"method",
+	"contentType"
+]);
+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;
+	/**
+	* Studio session state, kept together so `dispose()` can reset it atomically.
+	*
+	* - `source` holds the raw adapter source so `adapter.parse()` can be called lazily.
+	*   Intentionally outlives the build; cleared by `dispose()`.
+	* - `isOpen` prevents opening the studio more than once per build.
+	* - `inputNode` caches the parse promise so `adapter.parse()` is called at most once
+	*   per studio session, even when `openInStudio()` is called multiple times.
+	*/
+	#studio = {
+		source: null,
+		isOpen: false,
+		inputNode: null
+	};
+	#middlewareListeners = [];
+	/**
+	* Central file store for all generated files.
+	* Plugins should use `this.addFile()` / `this.upsertFile()` (via their context) to
+	* add files; this property gives direct read/write access when needed.
+	*/
+	fileManager = new FileManager();
+	#fileProcessor = new FileProcessor();
+	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();
+	#hookListeners = /* @__PURE__ */ new Map();
+	constructor(config, options) {
+		this.config = config;
+		this.options = options;
+		this.adapter = config.adapter ?? null;
+	}
+	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) await this.#registerAdapter(this.config.adapter);
+	}
+	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;
+	}
+	async #registerAdapter(adapter) {
+		const source = inputToAdapterSource(this.config);
+		this.#studio.source = source;
+		if (adapter.stream) {
+			this.inputNode = await adapter.stream(source);
+			await this.hooks.emit("kubb:debug", {
+				date: /* @__PURE__ */ new Date(),
+				logs: [`✓ Adapter '${adapter.name}' producing input stream`]
+			});
+		} else {
+			const inputNode = await adapter.parse(source);
+			this.inputNode = (0, _kubb_ast.createStreamInput)(arrayToAsyncIterable(inputNode.schemas), arrayToAsyncIterable(inputNode.operations), inputNode.meta);
+			await this.hooks.emit("kubb:debug", {
+				date: /* @__PURE__ */ new Date(),
+				logs: [
+					`✓ Adapter '${adapter.name}' resolved InputNode (wrapped as stream)`,
+					`  • Schemas: ${inputNode.schemas.length}`,
+					`  • Operations: ${inputNode.operations.length}`
+				]
+			});
+		}
+	}
+	#registerMiddleware(event, middlewareHooks) {
+		const handler = middlewareHooks[event];
+		if (!handler) return;
+		this.hooks.on(event, handler);
+		this.#middlewareListeners.push([event, handler]);
+	}
+	/**
+	* Registers a hook-style plugin's lifecycle handlers on the shared `AsyncEventEmitter`.
+	*
+	* For `kubb:plugin:setup`, the registered listener wraps the globally emitted context with a
+	* plugin-specific one so that `addGenerator`, `setResolver`, `setTransformer`, and
+	* `setRenderer` all target the correct `normalizedPlugin` entry in the plugins map.
+	*
+	* All other hooks are iterated and registered directly as pass-through listeners.
+	* Any event key present in the global `KubbHooks` interface can be subscribed to.
+	*
+	* External tooling can subscribe to any of these events via `hooks.on(...)` to observe
+	* the plugin lifecycle without modifying plugin behavior.
+	*
+	* @internal
+	*/
+	#registerPlugin(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) => {
+						plugin.transformer = visitor;
+					},
+					setRenderer: (renderer) => {
+						plugin.renderer = renderer;
+					},
+					setOptions: (opts) => {
+						plugin.options = {
+							...plugin.options,
+							...opts
+						};
+					},
+					injectFile: (userFileNode) => {
+						this.fileManager.add((0, _kubb_ast.createFile)(userFileNode));
+					}
+				};
+				return hooks["kubb:plugin:setup"](pluginCtx);
+			};
+			this.hooks.on("kubb:plugin:setup", setupHandler);
+			this.#trackHookListener("kubb:plugin:setup", setupHandler);
+		}
+		for (const [event, handler] of Object.entries(hooks)) {
+			if (event === "kubb:plugin:setup" || !handler) continue;
+			this.hooks.on(event, handler);
+			this.#trackHookListener(event, handler);
+		}
+	}
+	/**
+	* Emits the `kubb:plugin:setup` event so that all registered hook-style plugin listeners
+	* can configure generators, resolvers, transformers and renderers before `buildStart` runs.
+	*
+	* Call this once from `safeBuild` before the plugin execution loop begins.
+	*/
+	async emitSetupHooks() {
+		const noop = () => {};
+		await this.hooks.emit("kubb:plugin:setup", {
+			config: this.config,
+			options: {},
+			addGenerator: noop,
+			setResolver: noop,
+			setTransformer: noop,
+			setRenderer: noop,
+			setOptions: noop,
+			injectFile: noop,
+			updateConfig: noop
+		});
+	}
+	/**
+	* Registers a generator for the given plugin on the shared event emitter.
+	*
+	* The generator's `schema`, `operation`, and `operations` methods are registered as
+	* listeners on `kubb:generate:schema`, `kubb:generate:operation`, and `kubb:generate:operations`
+	* respectively. Each listener is scoped to the owning plugin via a `ctx.plugin.name` check
+	* so that generators from different plugins do not cross-fire.
+	*
+	* The renderer resolution chain is: `generator.renderer → plugin.renderer → config.renderer`.
+	* Set `generator.renderer = null` to explicitly opt out of rendering even when the plugin
+	* declares a renderer.
+	*
+	* Call this method inside `addGenerator()` (in `kubb:plugin:setup`) to wire up a generator.
+	*/
+	registerGenerator(pluginName, gen) {
+		const resolveRenderer = () => {
+			const plugin = this.plugins.get(pluginName);
+			return gen.renderer === null ? void 0 : gen.renderer ?? plugin?.renderer ?? this.config.renderer;
+		};
+		if (gen.schema) {
+			const schemaHandler = async (node, ctx) => {
+				if (ctx.plugin.name !== pluginName) return;
+				await applyHookResult({
+					result: await gen.schema(node, ctx),
+					driver: this,
+					rendererFactory: resolveRenderer()
+				});
+			};
+			this.hooks.on("kubb:generate:schema", schemaHandler);
+			this.#trackHookListener("kubb:generate:schema", schemaHandler);
+		}
+		if (gen.operation) {
+			const operationHandler = async (node, ctx) => {
+				if (ctx.plugin.name !== pluginName) return;
+				await applyHookResult({
+					result: await gen.operation(node, ctx),
+					driver: this,
+					rendererFactory: resolveRenderer()
+				});
+			};
+			this.hooks.on("kubb:generate:operation", operationHandler);
+			this.#trackHookListener("kubb:generate:operation", operationHandler);
+		}
+		if (gen.operations) {
+			const operationsHandler = async (nodes, ctx) => {
+				if (ctx.plugin.name !== pluginName) return;
+				await applyHookResult({
+					result: await gen.operations(nodes, ctx),
+					driver: this,
+					rendererFactory: resolveRenderer()
+				});
+			};
+			this.hooks.on("kubb:generate:operations", operationsHandler);
+			this.#trackHookListener("kubb:generate:operations", operationsHandler);
+		}
+		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 timings/failures collected so far even
+	* when an outer hook throws — the orchestrator preserves partial state by capturing
+	* the error into `error` instead of propagating.
+	*/
+	async run({ storage }) {
+		const hooks = this.hooks;
+		const config = this.config;
+		const failedPlugins = /* @__PURE__ */ new Set();
+		const pluginTimings = /* @__PURE__ */ new Map();
+		const parsersMap = /* @__PURE__ */ new Map();
+		for (const parser of config.parsers) if (parser.extNames) for (const ext of parser.extNames) parsersMap.set(ext, parser);
+		const pendingFiles = /* @__PURE__ */ new Map();
+		this.fileManager.setOnUpsert((file) => {
+			pendingFiles.set(file.path, file);
+		});
+		try {
+			const flushPending = async () => {
+				if (pendingFiles.size === 0) return;
+				const files = [...pendingFiles.values()];
+				pendingFiles.clear();
+				await hooks.emit("kubb:debug", {
+					date: /* @__PURE__ */ new Date(),
+					logs: [`Writing ${files.length} files...`]
+				});
+				await hooks.emit("kubb:files:processing:start", { files });
+				const items = [...this.#fileProcessor.stream(files, {
+					parsers: parsersMap,
+					extension: config.output.extension
+				})];
+				await hooks.emit("kubb:files:processing:update", { files: items.map(({ file, source, processed, total, percentage }) => ({
+					file,
+					source,
+					processed,
+					total,
+					percentage,
+					config
+				})) });
+				const queue = [];
+				for (const { file, source } of items) if (source) {
+					queue.push(storage.setItem(file.path, source));
+					if (queue.length >= 50) await Promise.all(queue.splice(0));
+				}
+				await Promise.all(queue);
+				await hooks.emit("kubb:files:processing:end", { files });
+				await hooks.emit("kubb:debug", {
+					date: /* @__PURE__ */ new Date(),
+					logs: [`✓ File write process completed for ${files.length} files`]
+				});
+			};
+			await this.emitSetupHooks();
+			if (this.adapter && this.inputNode) await hooks.emit("kubb:build:start", Object.assign({
+				config,
+				adapter: this.adapter,
+				meta: this.inputNode.meta,
+				getPlugin: this.getPlugin.bind(this)
+			}, 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 });
+					await hooks.emit("kubb:debug", {
+						date: /* @__PURE__ */ new Date(),
+						logs: ["Starting plugin...", `  • Plugin Name: ${plugin.name}`]
+					});
+				} catch (caughtError) {
+					const error = caughtError;
+					const duration = getElapsedMs(hrStart);
+					pluginTimings.set(plugin.name, duration);
+					await this.#emitPluginEnd({
+						plugin,
+						duration,
+						success: false,
+						error
+					});
+					failedPlugins.add({
+						plugin,
+						error
+					});
+					continue;
+				}
+				if (plugin.generators?.length || this.hasEventGenerators(plugin.name)) {
+					generatorPlugins.push({
+						plugin,
+						context,
+						hrStart
+					});
+					continue;
+				}
+				const duration = getElapsedMs(hrStart);
+				pluginTimings.set(plugin.name, duration);
+				await this.#emitPluginEnd({
+					plugin,
+					duration,
+					success: true
+				});
+				await hooks.emit("kubb:debug", {
+					date: /* @__PURE__ */ new Date(),
+					logs: [`✓ Plugin started successfully (${formatMs(duration)})`]
+				});
+			}
+			if (generatorPlugins.length > 0) if (this.inputNode) {
+				const { timings, failed } = await this.#runGenerators(generatorPlugins, flushPending);
+				await flushPending();
+				for (const [name, duration] of timings) pluginTimings.set(name, duration);
+				for (const entry of failed) failedPlugins.add(entry);
+			} else for (const { plugin, hrStart } of generatorPlugins) {
+				const duration = getElapsedMs(hrStart);
+				pluginTimings.set(plugin.name, duration);
+				await this.#emitPluginEnd({
+					plugin,
+					duration,
+					success: true
+				});
+			}
+			await hooks.emit("kubb:plugins:end", Object.assign({ config }, this.#filesPayload()));
+			await flushPending();
+			const files = this.fileManager.files;
+			await hooks.emit("kubb:build:end", {
+				files,
+				config,
+				outputDir: (0, node_path.resolve)(config.root, config.output.path)
+			});
+			return {
+				failedPlugins,
+				pluginTimings
+			};
+		} catch (caughtError) {
+			return {
+				failedPlugins,
+				pluginTimings,
+				error: caughtError
+			};
+		} finally {
+			this.fileManager.setOnUpsert(null);
+		}
+	}
+	#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()));
+	}
+	async #runGenerators(entries, flushPending) {
+		const timings = /* @__PURE__ */ new Map();
+		const failed = /* @__PURE__ */ new Set();
+		const driver = this;
+		const { schemas, operations } = this.inputNode;
+		const states = entries.map(({ plugin, context, hrStart }) => {
+			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((s) => [s, []]));
+			for await (const operation of operations) for (const state of pruningStates) {
+				const { exclude, include, override } = state.plugin.options;
+				if (state.generatorContext.resolver.resolveOptions(operation, {
+					options: state.plugin.options,
+					exclude,
+					include,
+					override
+				}) !== null) includedOpsByState.get(state)?.push(operation);
+			}
+			for (const state of pruningStates) {
+				state.allowedSchemaNames = (0, _kubb_ast.collectUsedSchemaNames)(includedOpsByState.get(state) ?? [], allSchemas);
+				includedOpsByState.delete(state);
+			}
+		}
+		const resolveRendererFor = (gen, state) => gen.renderer === null ? void 0 : gen.renderer ?? state.plugin.renderer ?? state.generatorContext.config.renderer;
+		const dispatchSchema = async (state, node) => {
+			if (state.failed) return;
+			try {
+				const { plugin, generatorContext, generators } = state;
+				const transformedNode = plugin.transformer ? (0, _kubb_ast.transform)(node, plugin.transformer) : node;
+				if (state.allowedSchemaNames !== null && transformedNode.name && !state.allowedSchemaNames.has(transformedNode.name)) return;
+				const { exclude, include, override } = plugin.options;
+				const options = state.optionsAreStatic ? plugin.options : generatorContext.resolver.resolveOptions(transformedNode, {
+					options: plugin.options,
+					exclude,
+					include,
+					override
+				});
+				if (options === null) return;
+				const ctx = {
+					...generatorContext,
+					options
+				};
+				for (const gen of generators) {
+					if (!gen.schema) continue;
+					const raw = gen.schema(transformedNode, ctx);
+					const applied = applyHookResult({
+						result: isPromise(raw) ? await raw : raw,
+						driver,
+						rendererFactory: resolveRendererFor(gen, state)
+					});
+					if (isPromise(applied)) await applied;
+				}
+				if (emitsSchemaHook) await this.hooks.emit("kubb:generate:schema", transformedNode, ctx);
+			} catch (caughtError) {
+				state.failed = true;
+				state.error = caughtError;
+			}
+		};
+		const dispatchOperation = async (state, node) => {
+			if (state.failed) return;
+			try {
+				const { plugin, generatorContext, generators } = state;
+				const transformedNode = plugin.transformer ? (0, _kubb_ast.transform)(node, plugin.transformer) : node;
+				const { exclude, include, override } = plugin.options;
+				const options = state.optionsAreStatic ? plugin.options : generatorContext.resolver.resolveOptions(transformedNode, {
+					options: plugin.options,
+					exclude,
+					include,
+					override
+				});
+				if (options === null) return;
+				const ctx = {
+					...generatorContext,
+					options
+				};
+				for (const gen of generators) {
+					if (!gen.operation) continue;
+					const raw = gen.operation(transformedNode, ctx);
+					const applied = applyHookResult({
+						result: isPromise(raw) ? await raw : raw,
+						driver,
+						rendererFactory: resolveRendererFor(gen, state)
+					});
+					if (isPromise(applied)) await applied;
+				}
+				if (emitsOperationHook) await this.hooks.emit("kubb:generate:operation", transformedNode, ctx);
+			} catch (caughtError) {
+				state.failed = true;
+				state.error = caughtError;
+			}
+		};
+		const needsCollectedOperations = this.hooks.listenerCount("kubb:generate:operations") > 0 || states.some((s) => s.generators.some((g) => !!g.operations));
+		const collectedOperations = needsCollectedOperations ? [] : void 0;
+		await forBatches(schemas, (nodes) => Promise.all(nodes.flatMap((n) => states.map((state) => dispatchSchema(state, n)))), {
+			concurrency: 8,
+			flush: flushPending
+		});
+		await forBatches(operations, (nodes) => {
+			if (needsCollectedOperations) collectedOperations.push(...nodes);
+			return Promise.all(nodes.flatMap((n) => states.map((state) => dispatchOperation(state, n))));
+		}, {
+			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
+				};
+				for (const gen of generators) {
+					if (!gen.operations) continue;
+					await applyHookResult({
+						result: await gen.operations(collectedOperations, ctx),
+						driver,
+						rendererFactory: resolveRendererFor(gen, state)
+					});
+				}
+				await this.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
+			} catch (caughtError) {
+				state.failed = true;
+				state.error = caughtError;
+			}
+			const duration = getElapsedMs(state.hrStart);
+			timings.set(state.plugin.name, duration);
+			await this.#emitPluginEnd({
+				plugin: state.plugin,
+				duration,
+				success: !state.failed,
+				error: state.failed && state.error ? state.error : void 0
+			});
+			if (state.failed && state.error) failed.add({
+				plugin: state.plugin,
+				error: state.error
+			});
+			await this.hooks.emit("kubb:debug", {
+				date: /* @__PURE__ */ new Date(),
+				logs: [state.failed ? "✗ Plugin start failed" : `✓ Plugin started successfully (${formatMs(duration)})`]
+			});
+		}
+		return {
+			timings,
+			failed
+		};
+	}
+	/**
+	* Unregisters all plugin lifecycle listeners from the shared event emitter.
+	* Called at the end of a build to prevent listener leaks across repeated builds.
+	*
+	* @internal
+	*/
+	dispose() {
+		for (const [event, handlers] of this.#hookListeners) for (const handler of handlers) this.hooks.off(event, handler);
+		this.#hookListeners.clear();
+		this.#eventGeneratorPlugins.clear();
+		this.#resolvers.clear();
+		this.#defaultResolvers.clear();
+		this.fileManager.dispose();
+		this.#fileProcessor.dispose();
+		this.inputNode = null;
+		this.#studio = {
+			source: null,
+			isOpen: false,
+			inputNode: null
+		};
+		for (const [event, handler] of this.#middlewareListeners) this.hooks.off(event, handler);
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+	#trackHookListener(event, handler) {
+		let handlers = this.#hookListeners.get(event);
+		if (!handlers) {
+			handlers = /* @__PURE__ */ new Set();
+			this.#hookListeners.set(event, handlers);
+		}
+		handlers.add(handler);
+	}
+	#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;
+		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 plugin.transformer;
+			},
+			warn(message) {
+				driver.hooks.emit("kubb:warn", { message });
+			},
+			error(error) {
+				driver.hooks.emit("kubb:error", { error: typeof error === "string" ? new Error(error) : error });
+			},
+			info(message) {
+				driver.hooks.emit("kubb:info", { message });
+			},
+			async openInStudio(options) {
+				if (!driver.config.devtools || driver.#studio.isOpen) return;
+				if (typeof driver.config.devtools !== "object") throw new Error("Devtools must be an object");
+				if (!driver.adapter || !driver.#studio.source) throw new Error("adapter is not defined, make sure you have set the parser in kubb.config.ts");
+				driver.#studio.isOpen = true;
+				const studioUrl = driver.config.devtools?.studioUrl ?? "https://kubb.studio";
+				driver.#studio.inputNode ??= Promise.resolve(driver.adapter.parse(driver.#studio.source));
+				return openInStudio(await driver.#studio.inputNode, studioUrl, options);
+			}
+		};
+	}
+	getPlugin(pluginName) {
+		return this.plugins.get(pluginName);
+	}
+	requirePlugin(pluginName) {
+		const plugin = this.plugins.get(pluginName);
+		if (!plugin) throw new Error(`[kubb] Plugin "${pluginName}" is required but not found. Make sure it is included in your Kubb config.`);
+		return plugin;
+	}
+};
+/**
+* Handles the return value of a plugin AST hook or generator method.
+*
+* - Renderer output → rendered via the provided `rendererFactory` (e.g. JSX), files stored in `driver.fileManager`
+* - `Array<FileNode>` → added directly into `driver.fileManager`
+* - `void` / `null` / `undefined` → no-op (plugin handled it via `this.upsertFile`)
+*
+* Pass a `rendererFactory` (e.g. `jsxRenderer` from `@kubb/renderer-jsx`) when the result
+* may be a renderer element. Generators that only return `Array<FileNode>` do not need one.
+*/
+function applyHookResult({ result, driver, rendererFactory }) {
+	if (!result) return;
+	if (Array.isArray(result)) {
+		driver.fileManager.upsert(...result);
+		return;
+	}
+	if (!rendererFactory) return;
+	const renderer = rendererFactory();
+	if (renderer.stream) try {
+		var _usingCtx$1 = _usingCtx();
+		const r = _usingCtx$1.u(renderer);
+		for (const file of r.stream(result)) driver.fileManager.upsert(file);
+		return;
+	} catch (_) {
+		_usingCtx$1.e = _;
+	} finally {
+		_usingCtx$1.d();
+	}
+	return applyAsyncRender({
+		renderer,
+		result,
+		driver
+	});
+}
+async function applyAsyncRender({ renderer, result, driver }) {
+	try {
+		var _usingCtx3 = _usingCtx();
+		const r = _usingCtx3.u(renderer);
+		await r.render(result);
+		driver.fileManager.upsert(...r.files);
+	} catch (_) {
+		_usingCtx3.e = _;
+	} finally {
+		_usingCtx3.d();
+	}
+}
+function inputToAdapterSource(config) {
+	const input = config.input;
+	if (!input) throw new Error("[kubb] input is required when using an adapter. Provide input.path or input.data in your config.");
+	if ("data" in input) return {
+		type: "data",
+		data: input.data
+	};
+	if (new URLPath(input.path).isURL) return {
+		type: "path",
+		path: input.path
+	};
+	return {
+		type: "path",
+		path: (0, node_path.resolve)(config.root, input.path)
+	};
+}
+//#endregion
+Object.defineProperty(exports, "AsyncEventEmitter", {
+	enumerable: true,
+	get: function() {
+		return AsyncEventEmitter;
+	}
+});
+Object.defineProperty(exports, "BuildError", {
+	enumerable: true,
+	get: function() {
+		return BuildError;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_BANNER", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_BANNER;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_EXTENSION", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_EXTENSION;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_STUDIO_URL", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_STUDIO_URL;
+	}
+});
+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, "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, "applyHookResult", {
+	enumerable: true,
+	get: function() {
+		return applyHookResult;
+	}
+});
+Object.defineProperty(exports, "definePlugin", {
+	enumerable: true,
+	get: function() {
+		return definePlugin;
+	}
+});
+Object.defineProperty(exports, "defineResolver", {
+	enumerable: true,
+	get: function() {
+		return defineResolver;
+	}
+});
+Object.defineProperty(exports, "logLevel", {
+	enumerable: true,
+	get: function() {
+		return logLevel;
+	}
+});
+
+//# sourceMappingURL=KubbDriver-BBRa5CH2.cjs.map