@kubb/core 5.0.0-alpha.35 → 5.0.0-alpha.38

package/dist/index.cjs

@@ -1,18 +1,12 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_chunk = require("./chunk-ByKO4r7w.cjs");
+const require_PluginDriver = require("./PluginDriver-BQwm8hDd.cjs");
 let node_events = require("node:events");
-let node_fs = require("node:fs");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
-node_path = require_chunk.__toESM(node_path, 1);
+node_path = require_PluginDriver.__toESM(node_path, 1);
 let _kubb_ast = require("@kubb/ast");
-_kubb_ast = require_chunk.__toESM(_kubb_ast, 1);
-let node_perf_hooks = require("node:perf_hooks");
-let fflate = require("fflate");
-let tinyexec = require("tinyexec");
+_kubb_ast = require_PluginDriver.__toESM(_kubb_ast, 1);
 let node_process = require("node:process");
-let remeda = require("remeda");
-let semver = require("semver");
 //#region ../../internals/utils/src/errors.ts
 /**
 * Thrown when one or more errors occur during a Kubb build.
@@ -153,64 +147,6 @@ var AsyncEventEmitter = class {
 	}
 };
 //#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.
-*/
-function applyToFileParts(text, transformPart) {
-	const parts = text.split(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).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.
@@ -246,26 +182,6 @@ function formatMs(ms) {
 //#endregion
 //#region ../../internals/utils/src/fs.ts
 /**
-* Walks up the directory tree from `cwd` (defaults to `process.cwd()`) and
-* returns the absolute path of the nearest `package.json`, or `null` when none
-* is found before reaching the filesystem root.
-*
-* @example
-* ```ts
-* const pkgPath = findPackageJSON('/home/user/project/src') // '/home/user/project/package.json'
-* ```
-*/
-function findPackageJSON(cwd) {
-	let dir = cwd ? (0, node_path.resolve)(cwd) : process.cwd();
-	while (true) {
-		const pkgPath = (0, node_path.join)(dir, "package.json");
-		if ((0, node_fs.existsSync)(pkgPath)) return pkgPath;
-		const parent = (0, node_path.dirname)(dir);
-		if (parent === dir) return null;
-		dir = parent;
-	}
-}
-/**
 * Converts all backslashes to forward slashes.
 * Extended-length Windows paths (`\\?\...`) are left unchanged.
 */
@@ -304,17 +220,6 @@ async function exists(path) {
 	return (0, node_fs_promises.access)(path).then(() => true, () => false);
 }
 /**
-* Synchronous counterpart of `read`.
-*
-* @example
-* ```ts
-* const source = readSync('./src/Pet.ts')
-* ```
-*/
-function readSync(path) {
-	return (0, node_fs.readFileSync)(path, { encoding: "utf8" });
-}
-/**
 * Writes `data` to `path`, trimming leading/trailing whitespace before saving.
 * Skips the write when the trimmed content is empty or identical to what is already on disk.
 * Creates any missing parent directories automatically.
@@ -364,159 +269,6 @@ async function clean(path) {
 	});
 }
 //#endregion
-//#region ../../internals/utils/src/string.ts
-/**
-* Strips the file extension from a path or file name.
-* Only removes the last `.ext` segment when the dot is not part of a directory name.
-*
-* @example
-* trimExtName('petStore.ts')             // 'petStore'
-* trimExtName('/src/models/pet.ts')      // '/src/models/pet'
-* trimExtName('/project.v2/gen/pet.ts')  // '/project.v2/gen/pet'
-* trimExtName('noExtension')             // 'noExtension'
-*/
-function trimExtName$1(text) {
-	const dotIndex = text.lastIndexOf(".");
-	if (dotIndex > 0 && !text.includes("/", dotIndex)) return text.slice(0, dotIndex);
-	return text;
-}
-require_chunk.__name(trimExtName$1, "trimExtName");
-//#endregion
-//#region ../../internals/utils/src/promise.ts
-/** Returns `true` when `result` is a rejected `Promise.allSettled` result with a typed `reason`.
-*
-* @example
-* ```ts
-* const results = await Promise.allSettled([p1, p2])
-* results.filter(isPromiseRejectedResult<Error>).map((r) => r.reason.message)
-* ```
-*/
-function isPromiseRejectedResult(result) {
-	return result.status === "rejected";
-}
-//#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"
-]);
-/**
-* Prefixes `word` with `_` when it is a reserved JavaScript/Java identifier or starts with a digit.
-*
-* @example
-* ```ts
-* transformReservedWord('class')  // '_class'
-* transformReservedWord('42foo')  // '_42foo'
-* transformReservedWord('status') // 'status'
-* ```
-*/
-function transformReservedWord(word) {
-	const firstChar = word.charCodeAt(0);
-	if (word && (reservedWords.has(word) || firstChar >= 48 && firstChar <= 57)) return `_${word}`;
-	return word;
-}
-/**
-* 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) {
-	try {
-		new Function(`var ${name}`);
-	} catch {
-		return false;
-	}
-	return true;
-}
-//#endregion
 //#region ../../internals/utils/src/urlPath.ts
 /**
 * Parses and transforms an OpenAPI/Swagger path string into various URL formats.
@@ -574,1610 +326,155 @@ var URLPath = class {
 	/** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
 	*
 	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').object
-	* // { url: '/pet/:petId', params: { petId: 'petId' } }
-	* ```
-	*/
-	get object() {
-		return this.toObject();
-	}
-	/** Returns a map of path parameter names, or `undefined` when the path has no parameters.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').params // { petId: 'petId' }
-	* new URLPath('/pet').params         // undefined
-	* ```
-	*/
-	get params() {
-		return this.getParams();
-	}
-	#transformParam(raw) {
-		const param = isValidVarName(raw) ? raw : camelCase(raw);
-		return this.#options.casing === "camelcase" ? camelCase(param) : param;
-	}
-	/**
-	* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
-	*/
-	#eachParam(fn) {
-		for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
-			const raw = match[1];
-			fn(raw, this.#transformParam(raw));
-		}
-	}
-	toObject({ type = "path", replacer, stringify } = {}) {
-		const object = {
-			url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
-			params: this.getParams()
-		};
-		if (stringify) {
-			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
-			if (object.params) return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
-			return `{ url: '${object.url}' }`;
-		}
-		return object;
-	}
-	/**
-	* Converts the OpenAPI path to a TypeScript template literal string.
-	* An optional `replacer` can transform each extracted parameter name before interpolation.
-	*
-	* @example
-	* new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
-	*/
-	toTemplateString({ prefix = "", replacer } = {}) {
-		return `\`${prefix}${this.path.split(/\{([^}]+)\}/).map((part, i) => {
-			if (i % 2 === 0) return part;
-			const param = this.#transformParam(part);
-			return `\${${replacer ? replacer(param) : param}}`;
-		}).join("")}\``;
-	}
-	/**
-	* Extracts all `{param}` segments from the path and returns them as a key-value map.
-	* An optional `replacer` transforms each parameter name in both key and value positions.
-	* Returns `undefined` when no path parameters are found.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}/tag/{tagId}').getParams()
-	* // { petId: 'petId', tagId: 'tagId' }
-	* ```
-	*/
-	getParams(replacer) {
-		const params = {};
-		this.#eachParam((_raw, param) => {
-			const key = replacer ? replacer(param) : param;
-			params[key] = key;
-		});
-		return Object.keys(params).length > 0 ? params : void 0;
-	}
-	/** Converts the OpenAPI path to Express-style colon syntax.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
-	* ```
-	*/
-	toURLPath() {
-		return this.path.replace(/\{([^}]+)\}/g, ":$1");
-	}
-};
-//#endregion
-//#region src/constants.ts
-/**
-* Base URL for the Kubb Studio web app.
-*/
-const DEFAULT_STUDIO_URL = "https://studio.kubb.dev";
-/**
-* File name used for generated barrel (index) files.
-*/
-const BARREL_FILENAME = "index.ts";
-/**
-* 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
-};
-/**
-* CLI command descriptors for each supported linter.
-*
-* Each entry contains the executable `command`, an `args` factory that maps an
-* output path to the correct argument list, and an `errorMessage` shown when
-* the linter is not found.
-*/
-const linters = {
-	eslint: {
-		command: "eslint",
-		args: (outputPath) => [outputPath, "--fix"],
-		errorMessage: "Eslint not found"
-	},
-	biome: {
-		command: "biome",
-		args: (outputPath) => [
-			"lint",
-			"--fix",
-			outputPath
-		],
-		errorMessage: "Biome not found"
-	},
-	oxlint: {
-		command: "oxlint",
-		args: (outputPath) => ["--fix", outputPath],
-		errorMessage: "Oxlint not found"
-	}
-};
-/**
-* CLI command descriptors for each supported code formatter.
-*
-* Each entry contains the executable `command`, an `args` factory that maps an
-* output path to the correct argument list, and an `errorMessage` shown when
-* the formatter is not found.
-*/
-const formatters = {
-	prettier: {
-		command: "prettier",
-		args: (outputPath) => [
-			"--ignore-unknown",
-			"--write",
-			outputPath
-		],
-		errorMessage: "Prettier not found"
-	},
-	biome: {
-		command: "biome",
-		args: (outputPath) => [
-			"format",
-			"--write",
-			outputPath
-		],
-		errorMessage: "Biome not found"
-	},
-	oxfmt: {
-		command: "oxfmt",
-		args: (outputPath) => [outputPath],
-		errorMessage: "Oxfmt not found"
-	}
-};
-//#endregion
-//#region src/createAdapter.ts
-/**
-* Creates an adapter factory. Call the returned function with optional options to get the adapter instance.
-*
-* @example
-* export const myAdapter = createAdapter<MyAdapter>((options) => {
-*   return {
-*     name: 'my-adapter',
-*     options,
-*     async parse(source) { ... },
-*   }
-* })
-*
-* // instantiate
-* const adapter = myAdapter({ validate: true })
-*/
-function createAdapter(build) {
-	return (options) => build(options ?? {});
-}
-//#endregion
-//#region ../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
-var Node = class {
-	value;
-	next;
-	constructor(value) {
-		this.value = value;
-	}
-};
-var Queue = class {
-	#head;
-	#tail;
-	#size;
-	constructor() {
-		this.clear();
-	}
-	enqueue(value) {
-		const node = new Node(value);
-		if (this.#head) {
-			this.#tail.next = node;
-			this.#tail = node;
-		} else {
-			this.#head = node;
-			this.#tail = node;
-		}
-		this.#size++;
-	}
-	dequeue() {
-		const current = this.#head;
-		if (!current) return;
-		this.#head = this.#head.next;
-		this.#size--;
-		if (!this.#head) this.#tail = void 0;
-		return current.value;
-	}
-	peek() {
-		if (!this.#head) return;
-		return this.#head.value;
-	}
-	clear() {
-		this.#head = void 0;
-		this.#tail = void 0;
-		this.#size = 0;
-	}
-	get size() {
-		return this.#size;
-	}
-	*[Symbol.iterator]() {
-		let current = this.#head;
-		while (current) {
-			yield current.value;
-			current = current.next;
-		}
-	}
-	*drain() {
-		while (this.#head) yield this.dequeue();
-	}
-};
-//#endregion
-//#region ../../node_modules/.pnpm/p-limit@7.3.0/node_modules/p-limit/index.js
-function pLimit(concurrency) {
-	let rejectOnClear = false;
-	if (typeof concurrency === "object") ({concurrency, rejectOnClear = false} = concurrency);
-	validateConcurrency(concurrency);
-	if (typeof rejectOnClear !== "boolean") throw new TypeError("Expected `rejectOnClear` to be a boolean");
-	const queue = new Queue();
-	let activeCount = 0;
-	const resumeNext = () => {
-		if (activeCount < concurrency && queue.size > 0) {
-			activeCount++;
-			queue.dequeue().run();
-		}
-	};
-	const next = () => {
-		activeCount--;
-		resumeNext();
-	};
-	const run = async (function_, resolve, arguments_) => {
-		const result = (async () => function_(...arguments_))();
-		resolve(result);
-		try {
-			await result;
-		} catch {}
-		next();
-	};
-	const enqueue = (function_, resolve, reject, arguments_) => {
-		const queueItem = { reject };
-		new Promise((internalResolve) => {
-			queueItem.run = internalResolve;
-			queue.enqueue(queueItem);
-		}).then(run.bind(void 0, function_, resolve, arguments_));
-		if (activeCount < concurrency) resumeNext();
-	};
-	const generator = (function_, ...arguments_) => new Promise((resolve, reject) => {
-		enqueue(function_, resolve, reject, arguments_);
-	});
-	Object.defineProperties(generator, {
-		activeCount: { get: () => activeCount },
-		pendingCount: { get: () => queue.size },
-		clearQueue: { value() {
-			if (!rejectOnClear) {
-				queue.clear();
-				return;
-			}
-			const abortError = AbortSignal.abort().reason;
-			while (queue.size > 0) queue.dequeue().reject(abortError);
-		} },
-		concurrency: {
-			get: () => concurrency,
-			set(newConcurrency) {
-				validateConcurrency(newConcurrency);
-				concurrency = newConcurrency;
-				queueMicrotask(() => {
-					while (activeCount < concurrency && queue.size > 0) resumeNext();
-				});
-			}
-		},
-		map: { async value(iterable, function_) {
-			const promises = Array.from(iterable, (value, index) => this(function_, value, index));
-			return Promise.all(promises);
-		} }
-	});
-	return generator;
-}
-function validateConcurrency(concurrency) {
-	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) throw new TypeError("Expected `concurrency` to be a number from 1 and up");
-}
-//#endregion
-//#region src/FileProcessor.ts
-function joinSources(file) {
-	return file.sources.map((item) => (0, _kubb_ast.extractStringsFromNodes)(item.nodes)).filter(Boolean).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.
-*/
-var FileProcessor = class {
-	#limit = pLimit(100);
-	async 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 });
-	}
-	async run(files, { parsers, mode = "sequential", extension, onStart, onEnd, onUpdate } = {}) {
-		await onStart?.(files);
-		const total = files.length;
-		let processed = 0;
-		const processOne = async (file) => {
-			const source = await this.parse(file, {
-				extension,
-				parsers
-			});
-			const currentProcessed = ++processed;
-			const percentage = currentProcessed / total * 100;
-			await onUpdate?.({
-				file,
-				source,
-				processed: currentProcessed,
-				percentage,
-				total
-			});
-		};
-		if (mode === "sequential") for (const file of files) await processOne(file);
-		else await Promise.all(files.map((file) => this.#limit(() => processOne(file))));
-		await onEnd?.(files);
-		return files;
-	}
-};
-//#endregion
-//#region src/definePlugin.ts
-/**
-* Returns `true` when `plugin` is a hook-style plugin created with `definePlugin`.
-*
-* Used by `PluginDriver` to distinguish hook-style plugins from legacy `createPlugin` plugins
-* so it can normalize them and register their handlers on the `AsyncEventEmitter`.
-*/
-function isHookStylePlugin(plugin) {
-	return typeof plugin === "object" && plugin !== null && "hooks" in plugin;
-}
-/**
-* Creates a plugin factory using the new hook-style (`hooks:`) API.
-*
-* The returned factory is called with optional options and produces a `HookStylePlugin`
-* that coexists with plugins created via the legacy `createPlugin` API in the same
-* `kubb.config.ts`.
-*
-* Lifecycle handlers are registered on the `PluginDriver`'s `AsyncEventEmitter`, enabling
-* both the plugin's own handlers and external tooling (CLI, devtools) to observe every event.
-*
-* @example
-* ```ts
-* // With PluginFactoryOptions (recommended for real plugins)
-* export const pluginTs = definePlugin<PluginTs>((options) => ({
-*   name: 'plugin-ts',
-*   hooks: {
-*     'kubb:plugin:setup'(ctx) {
-*       ctx.setResolver(resolverTs)  // typed as Partial<ResolverTs>
-*     },
-*   },
-* }))
-* ```
-*/
-function definePlugin(factory) {
-	return (options) => factory(options ?? {});
-}
-//#endregion
-//#region src/defineResolver.ts
-/**
-* Checks if an operation matches a pattern for a given filter type (`tag`, `operationId`, `path`, `method`).
-*/
-function matchesOperationPattern(node, type, pattern) {
-	switch (type) {
-		case "tag": return node.tags.some((tag) => !!tag.match(pattern));
-		case "operationId": return !!node.operationId.match(pattern);
-		case "path": return !!node.path.match(pattern);
-		case "method": return !!node.method.toLowerCase().match(pattern);
-		case "contentType": return !!node.requestBody?.contentType?.match(pattern);
-		default: 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) {
-	switch (type) {
-		case "schemaName": return node.name ? !!node.name.match(pattern) : false;
-		default: 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) {
-	let resolvedName = camelCase(name);
-	if (type === "file" || type === "function") resolvedName = camelCase(name, { isFile: type === "file" });
-	if (type === "type") resolvedName = pascalCase(name);
-	return resolvedName;
-}
-/**
-* 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
-* ```
-*/
-function defaultResolveOptions(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;
-}
-/**
-* 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);
-	if (group && (groupPath || tag)) return node_path.default.resolve(root, output.path, group.name({ group: group.type === "path" ? groupPath : tag }), baseName);
-	return node_path.default.resolve(root, output.path, baseName);
-}
-/**
-* 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 {
-		let source = "";
-		if (Array.isArray(config.input)) {
-			const first = config.input[0];
-			if (first && "path" in first) source = node_path.default.basename(first.path);
-		} else if ("path" in config.input) source = node_path.default.basename(config.input.path);
-		else if ("data" in config.input) source = "text content";
-		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 OAS spec when a `node` is provided).
-*
-* - When `output.banner` is a function and `node` is provided, returns `output.banner(node)`.
-* - When `output.banner` is a function and `node` is absent, falls back to the Kubb notice.
-* - When `output.banner` is a 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 node
-* ```ts
-* defaultResolveBanner(inputNode, { output: { banner: (node) => `// v${node.version}` }, config })
-* // → '// v3.0.0'
-* ```
-*
-* @example No user banner — Kubb notice with OAS metadata
-* ```ts
-* defaultResolveBanner(inputNode, { config })
-* // → '/** Generated by Kubb ... Title: Pet Store ... *\/'
-* ```
-*
-* @example Disabled default banner
-* ```ts
-* defaultResolveBanner(undefined, { config: { output: { defaultBanner: false }, ...config } })
-* // → undefined
-* ```
-*/
-function defaultResolveBanner(node, { output, config }) {
-	if (typeof output?.banner === "function") return output.banner(node);
-	if (typeof output?.banner === "string") return output.banner;
-	if (config.output.defaultBanner === false) return;
-	return buildDefaultBanner({
-		title: node?.meta?.title,
-		version: node?.meta?.version,
-		config
-	});
-}
-/**
-* Default footer resolver — returns the footer string for a generated file.
-*
-* - When `output.footer` is a function and `node` is provided, calls it with the node.
-* - When `output.footer` is a function and `node` is absent, returns `undefined`.
-* - When `output.footer` is a 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 node
-* ```ts
-* defaultResolveFooter(inputNode, { output: { footer: (node) => `// ${node.title}` }, config })
-* // → '// Pet Store'
-* ```
-*/
-function defaultResolveFooter(node, { output }) {
-	if (typeof output?.footer === "function") return node ? output.footer(node) : void 0;
-	if (typeof output?.footer === "string") return output.footer;
-}
-/**
-* 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 builder have access to `this` (the full resolver object), so they
-* can call other resolver methods without circular imports.
-*
-* @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) {
-	return {
-		default: defaultResolver,
-		resolveOptions: defaultResolveOptions,
-		resolvePath: defaultResolvePath,
-		resolveFile: defaultResolveFile,
-		resolveBanner: defaultResolveBanner,
-		resolveFooter: defaultResolveFooter,
-		...build()
-	};
-}
-//#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,
-		sources: [...a.sources || [], ...b.sources || []],
-		imports: [...a.imports || [], ...b.imports || []],
-		exports: [...a.exports || [], ...b.exports || []]
-	};
-}
-/**
-* In-memory file store for generated files.
-*
-* Files with the same `path` are merged — sources, imports, and exports are concatenated.
-* The `files` getter returns all stored files sorted by path length (shortest first).
-*
-* @example
-* ```ts
-* import { FileManager } from '@kubb/core'
-*
-* const manager = new FileManager()
-* manager.upsert(myFile)
-* console.log(manager.files) // all stored files
-* ```
-*/
-var FileManager = class {
-	#cache = /* @__PURE__ */ new Map();
-	#filesCache = null;
-	/**
-	* Adds one or more files. Files with the same path are merged — sources, imports,
-	* and exports from all calls with the same path are concatenated together.
-	*/
-	add(...files) {
-		const resolvedFiles = [];
-		const mergedFiles = /* @__PURE__ */ new Map();
-		files.forEach((file) => {
-			const existing = mergedFiles.get(file.path);
-			if (existing) mergedFiles.set(file.path, mergeFile(existing, file));
-			else mergedFiles.set(file.path, file);
-		});
-		for (const file of mergedFiles.values()) {
-			const resolvedFile = (0, _kubb_ast.createFile)(file);
-			this.#cache.set(resolvedFile.path, resolvedFile);
-			this.#filesCache = null;
-			resolvedFiles.push(resolvedFile);
-		}
-		return resolvedFiles;
-	}
-	/**
-	* Adds or merges one or more files.
-	* If a file with the same path already exists, its sources/imports/exports are merged together.
-	*/
-	upsert(...files) {
-		const resolvedFiles = [];
-		const mergedFiles = /* @__PURE__ */ new Map();
-		files.forEach((file) => {
-			const existing = mergedFiles.get(file.path);
-			if (existing) mergedFiles.set(file.path, mergeFile(existing, file));
-			else mergedFiles.set(file.path, file);
-		});
-		for (const file of mergedFiles.values()) {
-			const existing = this.#cache.get(file.path);
-			const resolvedFile = (0, _kubb_ast.createFile)(existing ? mergeFile(existing, file) : file);
-			this.#cache.set(resolvedFile.path, resolvedFile);
-			this.#filesCache = null;
-			resolvedFiles.push(resolvedFile);
-		}
-		return resolvedFiles;
-	}
-	getByPath(path) {
-		return this.#cache.get(path) ?? null;
-	}
-	deleteByPath(path) {
-		this.#cache.delete(path);
-		this.#filesCache = null;
-	}
-	clear() {
-		this.#cache.clear();
-		this.#filesCache = null;
-	}
-	/**
-	* All stored files, sorted by path length (shorter paths first).
-	* Barrel/index files (e.g. index.ts) are sorted last within each length bucket.
-	*/
-	get files() {
-		if (this.#filesCache) return this.#filesCache;
-		const keys = [...this.#cache.keys()].sort((a, b) => {
-			if (a.length !== b.length) return a.length - b.length;
-			const aIsIndex = trimExtName$1(a).endsWith("index");
-			if (aIsIndex !== trimExtName$1(b).endsWith("index")) return aIsIndex ? 1 : -1;
-			return 0;
-		});
-		const files = [];
-		for (const key of keys) {
-			const file = this.#cache.get(key);
-			if (file) files.push(file);
-		}
-		this.#filesCache = files;
-		return files;
-	}
-};
-//#endregion
-//#region src/renderNode.ts
-/**
-* Handles the return value of a plugin AST hook or generator method.
-*
-* - Renderer output → rendered via the provided `rendererFactory` (e.g. JSX), files stored in `driver.fileManager`
-* - `Array<FileNode>` → added directly into `driver.fileManager`
-* - `void` / `null` / `undefined` → no-op (plugin handled it via `this.upsertFile`)
-*
-* Pass a `rendererFactory` (e.g. `jsxRenderer` from `@kubb/renderer-jsx`) when the result
-* may be a renderer element. Generators that only return `Array<FileNode>` do not need one.
-*/
-async function applyHookResult(result, driver, rendererFactory) {
-	if (!result) return;
-	if (Array.isArray(result)) {
-		driver.fileManager.upsert(...result);
-		return;
-	}
-	if (!rendererFactory) return;
-	const renderer = rendererFactory();
-	await renderer.render(result);
-	driver.fileManager.upsert(...renderer.files);
-	renderer.unmount();
-}
-//#endregion
-//#region src/utils/executeStrategies.ts
-/**
-* Runs promise functions in sequence, threading each result into the next call.
-*
-* - Each function receives the accumulated state from the previous call.
-* - Skips functions that return a falsy value (acts as a no-op for that step).
-* - Returns an array of all individual results.
-*  @deprecated
-*/
-function hookSeq(promises) {
-	return promises.filter(Boolean).reduce((promise, func) => {
-		if (typeof func !== "function") throw new Error("HookSeq needs a function that returns a promise `() => Promise<unknown>`");
-		return promise.then((state) => {
-			const calledFunc = func(state);
-			if (calledFunc) return calledFunc.then(Array.prototype.concat.bind(state));
-			return state;
-		});
-	}, Promise.resolve([]));
-}
-/**
-* Runs promise functions in sequence and returns the first non-null result.
-*
-* - Stops as soon as `nullCheck` passes for a result (default: `!== null`).
-* - Subsequent functions are skipped once a match is found.
-*  @deprecated
-*/
-function hookFirst(promises, nullCheck = (state) => state !== null) {
-	let promise = Promise.resolve(null);
-	for (const func of promises.filter(Boolean)) promise = promise.then((state) => {
-		if (nullCheck(state)) return state;
-		return func(state);
-	});
-	return promise;
-}
-/**
-* Runs promise functions concurrently and returns all settled results.
-*
-* - Limits simultaneous executions to `concurrency` (default: unlimited).
-* - Uses `Promise.allSettled` so individual failures do not cancel other tasks.
-*  @deprecated
-*/
-function hookParallel(promises, concurrency = Number.POSITIVE_INFINITY) {
-	const limit = pLimit(concurrency);
-	const tasks = promises.filter(Boolean).map((promise) => limit(() => promise()));
-	return Promise.allSettled(tasks);
-}
-//#endregion
-//#region src/PluginDriver.ts
-/**
-* Returns `'single'` when `fileOrFolder` has a file extension, `'split'` otherwise.
-*
-* @example
-* ```ts
-* getMode('src/gen/types.ts')  // 'single'
-* getMode('src/gen/types')     // 'split'
-* ```
-*/
-function getMode(fileOrFolder) {
-	if (!fileOrFolder) return "split";
-	return (0, node_path.extname)(fileOrFolder) ? "single" : "split";
-}
-const hookFirstNullCheck = (state) => !!state?.result;
-var PluginDriver = class {
-	config;
-	options;
-	/**
-	* The universal `@kubb/ast` `InputNode` produced by the adapter, set by
-	* the build pipeline after the adapter's `parse()` resolves.
-	*/
-	inputNode = void 0;
-	adapter = void 0;
-	#studioIsOpen = false;
-	/**
-	* 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.
-	*/
-	#pluginsWithEventGenerators = /* @__PURE__ */ new Set();
-	#resolvers = /* @__PURE__ */ new Map();
-	#defaultResolvers = /* @__PURE__ */ new Map();
-	#hookListeners = /* @__PURE__ */ new Map();
-	constructor(config, options) {
-		this.config = config;
-		this.options = {
-			...options,
-			hooks: options.hooks
-		};
-		config.plugins.map((rawPlugin) => {
-			if (isHookStylePlugin(rawPlugin)) return this.#normalizeHookStylePlugin(rawPlugin);
-			return {
-				...rawPlugin,
-				buildStart: rawPlugin.buildStart ?? (() => {}),
-				buildEnd: rawPlugin.buildEnd ?? (() => {})
-			};
-		}).filter((plugin) => {
-			if (typeof plugin.apply === "function") return plugin.apply(config);
-			return true;
-		}).sort((a, b) => {
-			if (b.dependencies?.includes(a.name)) return -1;
-			if (a.dependencies?.includes(b.name)) return 1;
-			return 0;
-		}).forEach((plugin) => {
-			this.plugins.set(plugin.name, plugin);
-		});
-	}
-	get hooks() {
-		if (!this.options.hooks) throw new Error("hooks are not defined");
-		return this.options.hooks;
-	}
-	/**
-	* Creates a `Plugin`-compatible object from a hook-style plugin and registers
-	* its lifecycle handlers on the `AsyncEventEmitter`.
-	*
-	* The normalized plugin has an empty `buildStart` — generators registered via
-	* `addGenerator()` in `kubb:plugin:setup` are stored on `normalizedPlugin.generators`
-	* and used by `runPluginAstHooks` during the build.
-	*/
-	#normalizeHookStylePlugin(hookPlugin) {
-		const generators = [];
-		const driver = this;
-		const normalizedPlugin = {
-			name: hookPlugin.name,
-			dependencies: hookPlugin.dependencies,
-			options: {
-				output: { path: "." },
-				exclude: [],
-				override: []
-			},
-			generators,
-			inject: () => void 0,
-			resolveName(name, type) {
-				return driver.getResolver(hookPlugin.name).default(name, type);
-			},
-			resolvePath(baseName, pathMode, resolveOptions) {
-				const resolver = driver.getResolver(hookPlugin.name);
-				const opts = normalizedPlugin.options;
-				const group = resolveOptions?.group;
-				return resolver.resolvePath({
-					baseName,
-					pathMode,
-					tag: group?.tag,
-					path: group?.path
-				}, {
-					root: (0, node_path.resolve)(driver.config.root, driver.config.output.path),
-					output: opts.output,
-					group: opts.group
-				});
-			},
-			buildStart() {},
-			buildEnd() {}
-		};
-		this.registerPluginHooks(hookPlugin, normalizedPlugin);
-		return normalizedPlugin;
-	}
-	/**
-	* 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.
-	*/
-	registerPluginHooks(hookPlugin, normalizedPlugin) {
-		const { hooks } = hookPlugin;
-		if (hooks["kubb:plugin:setup"]) {
-			const setupHandler = (globalCtx) => {
-				const pluginCtx = {
-					...globalCtx,
-					options: hookPlugin.options ?? {},
-					addGenerator: (gen) => {
-						this.registerGenerator(normalizedPlugin.name, gen);
-					},
-					setResolver: (resolver) => {
-						this.setPluginResolver(normalizedPlugin.name, resolver);
-					},
-					setTransformer: (visitor) => {
-						normalizedPlugin.transformer = visitor;
-					},
-					setRenderer: (renderer) => {
-						normalizedPlugin.renderer = renderer;
-					},
-					setOptions: (opts) => {
-						normalizedPlugin.options = {
-							...normalizedPlugin.options,
-							...opts
-						};
-					},
-					injectFile: (file) => {
-						const fileNode = (0, _kubb_ast.createFile)({
-							baseName: file.baseName,
-							path: file.path,
-							sources: file.sources ?? [],
-							imports: [],
-							exports: []
-						});
-						this.fileManager.add(fileNode);
-					}
-				};
-				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() {
-		await this.hooks.emit("kubb:plugin:setup", {
-			config: this.config,
-			addGenerator: () => {},
-			setResolver: () => {},
-			setTransformer: () => {},
-			setRenderer: () => {},
-			setOptions: () => {},
-			injectFile: () => {},
-			updateConfig: () => {},
-			options: {}
-		});
-	}
-	/**
-	* 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(await gen.schema(node, ctx), this, 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(await gen.operation(node, ctx), this, 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(await gen.operations(nodes, ctx), this, resolveRenderer());
-			};
-			this.hooks.on("kubb:generate:operations", operationsHandler);
-			this.#trackHookListener("kubb:generate:operations", operationsHandler);
-		}
-		this.#pluginsWithEventGenerators.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`.
-	*/
-	hasRegisteredGenerators(pluginName) {
-		return this.#pluginsWithEventGenerators.has(pluginName);
-	}
-	dispose() {
-		for (const [event, handlers] of this.#hookListeners) for (const handler of handlers) this.hooks.off(event, handler);
-		this.#hookListeners.clear();
-		this.#pluginsWithEventGenerators.clear();
-	}
-	#trackHookListener(event, handler) {
-		let handlers = this.#hookListeners.get(event);
-		if (!handlers) {
-			handlers = /* @__PURE__ */ new Set();
-			this.#hookListeners.set(event, handlers);
-		}
-		handlers.add(handler);
-	}
-	#createDefaultResolver(pluginName) {
-		const existingResolver = this.#defaultResolvers.get(pluginName);
-		if (existingResolver) return existingResolver;
-		const resolver = defineResolver(() => ({
-			name: "default",
-			pluginName
-		}));
-		this.#defaultResolvers.set(pluginName, resolver);
-		return resolver;
-	}
-	setPluginResolver(pluginName, partial) {
-		const merged = {
-			...this.#createDefaultResolver(pluginName),
-			...partial
-		};
-		this.#resolvers.set(pluginName, merged);
-		const plugin = this.plugins.get(pluginName);
-		if (plugin) plugin.resolver = merged;
-	}
-	getResolver(pluginName) {
-		const dynamicResolver = this.#resolvers.get(pluginName);
-		if (dynamicResolver) return dynamicResolver;
-		const pluginResolver = this.plugins.get(pluginName)?.resolver;
-		if (pluginResolver) return pluginResolver;
-		return this.#createDefaultResolver(pluginName);
-	}
-	getContext(plugin) {
-		const driver = this;
-		const baseContext = {
-			config: driver.config,
-			get root() {
-				return (0, node_path.resolve)(driver.config.root, driver.config.output.path);
-			},
-			getMode(output) {
-				return 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),
-			driver,
-			addFile: async (...files) => {
-				driver.fileManager.add(...files);
-			},
-			upsertFile: async (...files) => {
-				driver.fileManager.upsert(...files);
-			},
-			get inputNode() {
-				return driver.inputNode;
-			},
-			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", typeof error === "string" ? new Error(error) : error);
-			},
-			info(message) {
-				driver.hooks.emit("kubb:info", message);
-			},
-			openInStudio(options) {
-				if (!driver.config.devtools || driver.#studioIsOpen) return;
-				if (typeof driver.config.devtools !== "object") throw new Error("Devtools must be an object");
-				if (!driver.inputNode || !driver.adapter) throw new Error("adapter is not defined, make sure you have set the parser in kubb.config.ts");
-				driver.#studioIsOpen = true;
-				const studioUrl = driver.config.devtools?.studioUrl ?? "https://studio.kubb.dev";
-				return openInStudio(driver.inputNode, studioUrl, options);
-			}
-		};
-		let mergedExtras = {};
-		for (const p of this.plugins.values()) if (typeof p.inject === "function") {
-			const result = p.inject.call(baseContext);
-			if (result !== null && typeof result === "object") mergedExtras = {
-				...mergedExtras,
-				...result
-			};
-		}
-		return {
-			...baseContext,
-			...mergedExtras
-		};
-	}
-	/**
-	* @deprecated use resolvers context instead
-	*/
-	getFile({ name, mode, extname, pluginName, options }) {
-		const resolvedName = mode ? mode === "single" ? "" : this.resolveName({
-			name,
-			pluginName,
-			type: "file"
-		}) : name;
-		const path = this.resolvePath({
-			baseName: `${resolvedName}${extname}`,
-			mode,
-			pluginName,
-			options
-		});
-		if (!path) throw new Error(`Filepath should be defined for resolvedName "${resolvedName}" and pluginName "${pluginName}"`);
-		return (0, _kubb_ast.createFile)({
-			path,
-			baseName: (0, node_path.basename)(path),
-			meta: { pluginName },
-			sources: [],
-			imports: [],
-			exports: []
-		});
-	}
-	/**
-	* @deprecated use resolvers context instead
-	*/
-	resolvePath = (params) => {
-		const defaultPath = (0, node_path.resolve)((0, node_path.resolve)(this.config.root, this.config.output.path), params.baseName);
-		if (params.pluginName) return this.hookForPluginSync({
-			pluginName: params.pluginName,
-			hookName: "resolvePath",
-			parameters: [
-				params.baseName,
-				params.mode,
-				params.options
-			]
-		})?.at(0) || defaultPath;
-		return this.hookFirstSync({
-			hookName: "resolvePath",
-			parameters: [
-				params.baseName,
-				params.mode,
-				params.options
-			]
-		})?.result || defaultPath;
-	};
-	/**
-	* @deprecated use resolvers context instead
-	*/
-	resolveName = (params) => {
-		if (params.pluginName) return transformReservedWord(this.hookForPluginSync({
-			pluginName: params.pluginName,
-			hookName: "resolveName",
-			parameters: [params.name.trim(), params.type]
-		})?.at(0) ?? params.name);
-		const name = this.hookFirstSync({
-			hookName: "resolveName",
-			parameters: [params.name.trim(), params.type]
-		})?.result;
-		return transformReservedWord(name ?? params.name);
-	};
-	/**
-	* Run a specific hookName for plugin x.
+	* ```ts
+	* new URLPath('/pet/{petId}').object
+	* // { url: '/pet/:petId', params: { petId: 'petId' } }
+	* ```
 	*/
-	async hookForPlugin({ pluginName, hookName, parameters }) {
-		const plugin = this.plugins.get(pluginName);
-		if (!plugin) return [null];
-		this.hooks.emit("kubb:plugins:hook:progress:start", {
-			hookName,
-			plugins: [plugin]
-		});
-		const result = await this.#execute({
-			strategy: "hookFirst",
-			hookName,
-			parameters,
-			plugin
-		});
-		this.hooks.emit("kubb:plugins:hook:progress:end", { hookName });
-		return [result];
+	get object() {
+		return this.toObject();
 	}
-	/**
-	* Run a specific hookName for plugin x.
+	/** 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
+	* ```
 	*/
-	hookForPluginSync({ pluginName, hookName, parameters }) {
-		const plugin = this.plugins.get(pluginName);
-		if (!plugin) return null;
-		const result = this.#executeSync({
-			strategy: "hookFirst",
-			hookName,
-			parameters,
-			plugin
-		});
-		return result !== null ? [result] : [];
+	get params() {
+		return this.getParams();
 	}
-	/**
-	* Returns the first non-null result.
-	*/
-	async hookFirst({ hookName, parameters, skipped }) {
-		const plugins = [];
-		for (const plugin of this.plugins.values()) if (hookName in plugin && (skipped ? !skipped.has(plugin) : true)) plugins.push(plugin);
-		this.hooks.emit("kubb:plugins:hook:progress:start", {
-			hookName,
-			plugins
-		});
-		const result = await hookFirst(plugins.map((plugin) => {
-			return async () => {
-				const value = await this.#execute({
-					strategy: "hookFirst",
-					hookName,
-					parameters,
-					plugin
-				});
-				return Promise.resolve({
-					plugin,
-					result: value
-				});
-			};
-		}), hookFirstNullCheck);
-		this.hooks.emit("kubb:plugins:hook:progress:end", { hookName });
-		return result;
+	#transformParam(raw) {
+		const param = require_PluginDriver.isValidVarName(raw) ? raw : require_PluginDriver.camelCase(raw);
+		return this.#options.casing === "camelcase" ? require_PluginDriver.camelCase(param) : param;
 	}
 	/**
-	* Returns the first non-null result.
+	* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
 	*/
-	hookFirstSync({ hookName, parameters, skipped }) {
-		let parseResult = null;
-		for (const plugin of this.plugins.values()) {
-			if (!(hookName in plugin)) continue;
-			if (skipped?.has(plugin)) continue;
-			parseResult = {
-				result: this.#executeSync({
-					strategy: "hookFirst",
-					hookName,
-					parameters,
-					plugin
-				}),
-				plugin
-			};
-			if (parseResult.result != null) break;
+	#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 parseResult;
+		return object;
 	}
 	/**
-	* Runs all plugins in parallel based on `this.plugin` order and `dependencies` settings.
+	* 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}`'
 	*/
-	async hookParallel({ hookName, parameters }) {
-		const plugins = [];
-		for (const plugin of this.plugins.values()) if (hookName in plugin) plugins.push(plugin);
-		this.hooks.emit("kubb:plugins:hook:progress:start", {
-			hookName,
-			plugins
-		});
-		const pluginStartTimes = /* @__PURE__ */ new Map();
-		const results = await hookParallel(plugins.map((plugin) => {
-			return () => {
-				pluginStartTimes.set(plugin, node_perf_hooks.performance.now());
-				return this.#execute({
-					strategy: "hookParallel",
-					hookName,
-					parameters,
-					plugin
-				});
-			};
-		}), this.options.concurrency);
-		results.forEach((result, index) => {
-			if (isPromiseRejectedResult(result)) {
-				const plugin = plugins[index];
-				if (plugin) {
-					const startTime = pluginStartTimes.get(plugin) ?? node_perf_hooks.performance.now();
-					this.hooks.emit("kubb:error", result.reason, {
-						plugin,
-						hookName,
-						strategy: "hookParallel",
-						duration: Math.round(node_perf_hooks.performance.now() - startTime),
-						parameters
-					});
-				}
-			}
-		});
-		this.hooks.emit("kubb:plugins:hook:progress:end", { hookName });
-		return results.reduce((acc, result) => {
-			if (result.status === "fulfilled") acc.push(result.value);
-			return acc;
-		}, []);
+	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("")}\``;
 	}
 	/**
-	* Execute a lifecycle hook sequentially for all plugins that implement it.
+	* 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' }
+	* ```
 	*/
-	async hookSeq({ hookName, parameters }) {
-		const plugins = [];
-		for (const plugin of this.plugins.values()) if (hookName in plugin) plugins.push(plugin);
-		this.hooks.emit("kubb:plugins:hook:progress:start", {
-			hookName,
-			plugins
+	getParams(replacer) {
+		const params = {};
+		this.#eachParam((_raw, param) => {
+			const key = replacer ? replacer(param) : param;
+			params[key] = key;
 		});
-		await hookSeq(plugins.map((plugin) => {
-			return () => this.#execute({
-				strategy: "hookSeq",
-				hookName,
-				parameters,
-				plugin
-			});
-		}));
-		this.hooks.emit("kubb:plugins:hook:progress:end", { hookName });
-	}
-	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;
+		return Object.keys(params).length > 0 ? params : void 0;
 	}
-	/**
-	* Emit hook-processing completion metadata after a plugin hook resolves.
+	/** Converts the OpenAPI path to Express-style colon syntax.
+	*
+	* @example
+	* ```ts
+	* new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
+	* ```
 	*/
-	#emitProcessingEnd({ startTime, output, strategy, hookName, plugin, parameters }) {
-		this.hooks.emit("kubb:plugins:hook:processing:end", {
-			duration: Math.round(node_perf_hooks.performance.now() - startTime),
-			parameters,
-			output,
-			strategy,
-			hookName,
-			plugin
-		});
+	toURLPath() {
+		return this.path.replace(/\{([^}]+)\}/g, ":$1");
 	}
-	#execute({ strategy, hookName, parameters, plugin }) {
-		const hook = plugin[hookName];
-		if (!hook) return null;
-		this.hooks.emit("kubb:plugins:hook:processing:start", {
-			strategy,
-			hookName,
-			parameters,
-			plugin
-		});
-		const startTime = node_perf_hooks.performance.now();
-		return (async () => {
-			try {
-				const output = typeof hook === "function" ? await Promise.resolve(hook.apply(this.getContext(plugin), parameters ?? [])) : hook;
-				this.#emitProcessingEnd({
-					startTime,
-					output,
-					strategy,
-					hookName,
-					plugin,
-					parameters
-				});
-				return output;
-			} catch (error) {
-				this.hooks.emit("kubb:error", error, {
-					plugin,
-					hookName,
-					strategy,
-					duration: Math.round(node_perf_hooks.performance.now() - startTime)
-				});
-				return null;
-			}
-		})();
+};
+//#endregion
+//#region src/createAdapter.ts
+/**
+* Creates an adapter factory. Call the returned function with optional options to get the adapter instance.
+*
+* @example
+* export const myAdapter = createAdapter<MyAdapter>((options) => {
+*   return {
+*     name: 'my-adapter',
+*     options,
+*     async parse(source) { ... },
+*   }
+* })
+*
+* // instantiate
+* const adapter = myAdapter({ validate: true })
+*/
+function createAdapter(build) {
+	return (options) => build(options ?? {});
+}
+//#endregion
+//#region src/FileProcessor.ts
+function joinSources(file) {
+	return file.sources.map((item) => (0, _kubb_ast.extractStringsFromNodes)(item.nodes)).filter(Boolean).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.
+*/
+var FileProcessor = class {
+	#limit = require_PluginDriver.pLimit(100);
+	async 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 });
 	}
-	/**
-	* Execute a plugin lifecycle hook synchronously and return its output.
-	*/
-	#executeSync({ strategy, hookName, parameters, plugin }) {
-		const hook = plugin[hookName];
-		if (!hook) return null;
-		this.hooks.emit("kubb:plugins:hook:processing:start", {
-			strategy,
-			hookName,
-			parameters,
-			plugin
-		});
-		const startTime = node_perf_hooks.performance.now();
-		try {
-			const output = typeof hook === "function" ? hook.apply(this.getContext(plugin), parameters) : hook;
-			this.#emitProcessingEnd({
-				startTime,
-				output,
-				strategy,
-				hookName,
-				plugin,
-				parameters
+	async run(files, { parsers, mode = "sequential", extension, onStart, onEnd, onUpdate } = {}) {
+		await onStart?.(files);
+		const total = files.length;
+		let processed = 0;
+		const processOne = async (file) => {
+			const source = await this.parse(file, {
+				extension,
+				parsers
 			});
-			return output;
-		} catch (error) {
-			this.hooks.emit("kubb:error", error, {
-				plugin,
-				hookName,
-				strategy,
-				duration: Math.round(node_perf_hooks.performance.now() - startTime)
+			const currentProcessed = ++processed;
+			const percentage = currentProcessed / total * 100;
+			await onUpdate?.({
+				file,
+				source,
+				processed: currentProcessed,
+				percentage,
+				total
 			});
-			return null;
-		}
+		};
+		if (mode === "sequential") for (const file of files) await processOne(file);
+		else await Promise.all(files.map((file) => this.#limit(() => processOne(file))));
+		await onEnd?.(files);
+		return files;
 	}
 };
 //#endregion
@@ -2278,7 +575,7 @@ const fsStorage = createStorage(() => ({
 }));
 //#endregion
 //#region package.json
-var version = "5.0.0-alpha.35";
+var version = "5.0.0-alpha.38";
 //#endregion
 //#region src/utils/diagnostics.ts
 /**
@@ -2393,14 +690,14 @@ var TreeNode = class TreeNode {
 				name: filteredTree.name,
 				path: filteredTree.path,
 				file: filteredTree.file,
-				type: getMode(filteredTree.path)
+				type: require_PluginDriver.PluginDriver.getMode(filteredTree.path)
 			});
 			const recurse = (node, item) => {
 				const subNode = node.addChild({
 					name: item.name,
 					path: item.path,
 					file: item.file,
-					type: getMode(item.path)
+					type: require_PluginDriver.PluginDriver.getMode(item.path)
 				});
 				if (item.children?.length) item.children?.forEach((child) => {
 					recurse(subNode, child);
@@ -2585,12 +882,12 @@ async function setup(options) {
 		output: {
 			write: true,
 			barrelType: "named",
-			extension: DEFAULT_EXTENSION,
-			defaultBanner: DEFAULT_BANNER,
+			extension: require_PluginDriver.DEFAULT_EXTENSION,
+			defaultBanner: require_PluginDriver.DEFAULT_BANNER,
 			...userConfig.output
 		},
 		devtools: userConfig.devtools ? {
-			studioUrl: DEFAULT_STUDIO_URL,
+			studioUrl: require_PluginDriver.DEFAULT_STUDIO_URL,
 			...typeof userConfig.devtools === "boolean" ? {} : userConfig.devtools
 		} : void 0,
 		plugins: userConfig.plugins
@@ -2603,7 +900,7 @@ async function setup(options) {
 		});
 		await storage?.clear((0, node_path.resolve)(config.root, config.output.path));
 	}
-	const driver = new PluginDriver(config, {
+	const driver = new require_PluginDriver.PluginDriver(config, {
 		hooks,
 		concurrency: 15
 	});
@@ -2666,7 +963,7 @@ async function runPluginAstHooks(plugin, context) {
 			};
 			for (const gen of generators) {
 				if (!gen.schema) continue;
-				await applyHookResult(await gen.schema(transformedNode, ctx), driver, resolveRenderer(gen));
+				await require_PluginDriver.applyHookResult(await gen.schema(transformedNode, ctx), driver, resolveRenderer(gen));
 			}
 			await driver.hooks.emit("kubb:generate:schema", transformedNode, ctx);
 		},
@@ -2686,7 +983,7 @@ async function runPluginAstHooks(plugin, context) {
 				};
 				for (const gen of generators) {
 					if (!gen.operation) continue;
-					await applyHookResult(await gen.operation(transformedNode, ctx), driver, resolveRenderer(gen));
+					await require_PluginDriver.applyHookResult(await gen.operation(transformedNode, ctx), driver, resolveRenderer(gen));
 				}
 				await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
 			}
@@ -2699,7 +996,7 @@ async function runPluginAstHooks(plugin, context) {
 		};
 		for (const gen of generators) {
 			if (!gen.operations) continue;
-			await applyHookResult(await gen.operations(collectedOperations, ctx), driver, resolveRenderer(gen));
+			await require_PluginDriver.applyHookResult(await gen.operations(collectedOperations, ctx), driver, resolveRenderer(gen));
 		}
 		await driver.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
 	}
@@ -2776,7 +1073,7 @@ async function safeBuild(setupResult) {
 			}
 		}
 		if (config.output.barrelType) {
-			const rootPath = (0, node_path.resolve)((0, node_path.resolve)(config.root), config.output.path, BARREL_FILENAME);
+			const rootPath = (0, node_path.resolve)((0, node_path.resolve)(config.root), config.output.path, require_PluginDriver.BARREL_FILENAME);
 			const rootDir = (0, node_path.dirname)(rootPath);
 			await hooks.emit("kubb:debug", {
 				date: /* @__PURE__ */ new Date(),
@@ -2796,7 +1093,7 @@ async function safeBuild(setupResult) {
 			const existingBarrel = driver.fileManager.files.find((f) => f.path === rootPath);
 			const rootFile = (0, _kubb_ast.createFile)({
 				path: rootPath,
-				baseName: BARREL_FILENAME,
+				baseName: require_PluginDriver.BARREL_FILENAME,
 				exports: buildBarrelExports({
 					barrelFiles,
 					rootDir,
@@ -2985,30 +1282,6 @@ function createKubb(options) {
 	return instance;
 }
 //#endregion
-//#region src/createPlugin.ts
-/**
-* Creates a plugin factory. Call the returned function with optional options to get the plugin instance.
-*
-* @example
-* ```ts
-* export const myPlugin = createPlugin<MyPlugin>((options) => {
-*   return {
-*     name: 'my-plugin',
-*     get options() { return options },
-*     resolvePath(baseName) { ... },
-*     resolveName(name, type) { ... },
-*   }
-* })
-*
-* // instantiate
-* const plugin = myPlugin({ output: { path: 'src/gen' } })
-* ```
-* @deprecated use definePlugin instead
-*/
-function createPlugin(build) {
-	return (options) => build(options ?? {});
-}
-//#endregion
 //#region src/createRenderer.ts
 /**
 * Creates a renderer factory for use in generator definitions.
@@ -3142,248 +1415,10 @@ const memoryStorage = createStorage(() => {
 	};
 });
 //#endregion
-//#region src/utils/formatters.ts
-/**
-* Returns `true` when the given formatter is installed and callable.
-*
-* Availability is detected by running `<formatter> --version` and checking
-* that the process exits without error.
-*/
-async function isFormatterAvailable(formatter) {
-	try {
-		await (0, tinyexec.x)(formatter, ["--version"], { nodeOptions: { stdio: "ignore" } });
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* Detects the first available code formatter on the current system.
-*
-* - Checks in preference order: `biome`, `oxfmt`, `prettier`.
-* - Returns `null` when none are found.
-*
-* @example
-* ```ts
-* const formatter = await detectFormatter()
-* if (formatter) {
-*   console.log(`Using ${formatter} for formatting`)
-* }
-* ```
-*/
-async function detectFormatter() {
-	const formatterNames = new Set([
-		"biome",
-		"oxfmt",
-		"prettier"
-	]);
-	for (const formatter of formatterNames) if (await isFormatterAvailable(formatter)) return formatter;
-	return null;
-}
-//#endregion
-//#region src/utils/getFunctionParams.ts
-function order(items) {
-	return (0, remeda.sortBy)(items.filter(Boolean), ([_key, item]) => {
-		if (item?.children) return 0;
-		if (item?.optional) return 1;
-		if (item?.default) return 2;
-		return 0;
-	});
-}
-function parseChild(key, item, options) {
-	const entries = order(Object.entries(item.children));
-	const types = [];
-	const names = [];
-	const optional = entries.every(([_key, item]) => item?.optional || !!item?.default);
-	entries.forEach(([key, entryItem]) => {
-		if (entryItem) {
-			const name = parseItem(key, {
-				...entryItem,
-				type: void 0
-			}, options);
-			if (entryItem.children) {
-				const subTypes = Object.entries(entryItem.children).map(([key]) => {
-					return key;
-				}).join(", ");
-				if (subTypes) names.push(`${name}: { ${subTypes} }`);
-				else names.push(name);
-			} else if (options.type === "call" && options.transformName) names.push(`${key}: ${name}`);
-			else names.push(name);
-			if (entries.some(([_key, item]) => item?.type)) types.push(parseItem(key, {
-				...entryItem,
-				default: void 0
-			}, options));
-		}
-	});
-	const name = item.mode === "inline" ? key : names.length ? `{ ${names.join(", ")} }` : void 0;
-	const type = item.type ? item.type : types.length ? `{ ${types.join("; ")} }` : void 0;
-	if (!name) return null;
-	return parseItem(name, {
-		type,
-		default: item.default,
-		optional: !item.default ? optional : void 0
-	}, options);
-}
-function parseItem(name, item, options) {
-	const acc = [];
-	const transformedName = options.transformName ? options.transformName(name) : name;
-	const transformedType = options.transformType && item.type ? options.transformType(item.type) : item.type;
-	if (options.type === "object") return transformedName;
-	if (options.type === "objectValue") return item.value ? `${transformedName}: ${item.value}` : transformedName;
-	if (item.type && options.type === "constructor") if (item.optional) if (transformedName.startsWith("{")) acc.push(`${transformedName}: ${transformedType} = {}`);
-	else acc.push(`${transformedName}?: ${transformedType}`);
-	else acc.push(`${transformedName}: ${transformedType}${item.default ? ` = ${item.default}` : ""}`);
-	else if (item.default && options.type === "constructor") acc.push(`${transformedName} = ${item.default}`);
-	else if (item.value) acc.push(`${transformedName} : ${item.value}`);
-	else if (item.mode === "inlineSpread") acc.push(`... ${transformedName}`);
-	else acc.push(transformedName);
-	return acc[0];
-}
-function getFunctionParams(params, options) {
-	return order(Object.entries(params)).reduce((acc, [key, item]) => {
-		if (!item) return acc;
-		if (item.children) {
-			if (Object.keys(item.children).length === 0) return acc;
-			if (item.mode === "inlineSpread") return [...acc, getFunctionParams(item.children, options)];
-			const parsedItem = parseChild(key, item, options);
-			if (!parsedItem) return acc;
-			return [...acc, parsedItem];
-		}
-		const parsedItem = parseItem(key, item, options);
-		return [...acc, parsedItem];
-	}, []).join(", ");
-}
-/**
-* @deprecated use @kubb/ast
-*/
-function createFunctionParams(params) {
-	return params;
-}
-/**
-* @deprecated use @kubb/ast
-*/
-var FunctionParams = class FunctionParams {
-	#params;
-	static factory(params) {
-		return new FunctionParams(params);
-	}
-	constructor(params) {
-		this.#params = params;
-	}
-	get params() {
-		return this.#params;
-	}
-	get flatParams() {
-		const flatter = (acc, [key, item]) => {
-			if (item?.children) return Object.entries(item.children).reduce(flatter, acc);
-			if (item) acc[key] = item;
-			return acc;
-		};
-		return Object.entries(this.#params).reduce(flatter, {});
-	}
-	toCall({ transformName, transformType } = {}) {
-		return getFunctionParams(this.#params, {
-			type: "call",
-			transformName,
-			transformType
-		});
-	}
-	toObject() {
-		return getFunctionParams(this.#params, { type: "object" });
-	}
-	toObjectValue() {
-		return getFunctionParams(this.#params, { type: "objectValue" });
-	}
-	toConstructor() {
-		return getFunctionParams(this.#params, { type: "constructor" });
-	}
-};
-//#endregion
-//#region src/utils/linters.ts
-/**
-* Returns `true` when the given linter is installed and callable.
-*
-* Availability is detected by running `<linter> --version` and checking
-* that the process exits without error.
-*/
-async function isLinterAvailable(linter) {
-	try {
-		await (0, tinyexec.x)(linter, ["--version"], { nodeOptions: { stdio: "ignore" } });
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* Detects the first available linter on the current system.
-*
-* - Checks in preference order: `biome`, `oxlint`, `eslint`.
-* - Returns `null` when none are found.
-*
-* @example
-* ```ts
-* const linter = await detectLinter()
-* if (linter) {
-*   console.log(`Using ${linter} for linting`)
-* }
-* ```
-*/
-async function detectLinter() {
-	const linterNames = new Set([
-		"biome",
-		"oxlint",
-		"eslint"
-	]);
-	for (const linter of linterNames) if (await isLinterAvailable(linter)) return linter;
-	return null;
-}
-//#endregion
-//#region src/utils/packageJSON.ts
-function getPackageJSONSync(cwd) {
-	const pkgPath = findPackageJSON(cwd);
-	if (!pkgPath) return null;
-	return JSON.parse(readSync(pkgPath));
-}
-function match(packageJSON, dependency) {
-	const dependencies = {
-		...packageJSON.dependencies || {},
-		...packageJSON.devDependencies || {}
-	};
-	if (typeof dependency === "string" && dependencies[dependency]) return dependencies[dependency];
-	const matched = Object.keys(dependencies).find((dep) => dep.match(dependency));
-	return matched ? dependencies[matched] ?? null : null;
-}
-function getVersionSync(dependency, cwd) {
-	const packageJSON = getPackageJSONSync(cwd);
-	return packageJSON ? match(packageJSON, dependency) : null;
-}
-/**
-* Returns `true` when the nearest `package.json` declares a dependency that
-* satisfies the given semver range.
-*
-* - Searches both `dependencies` and `devDependencies`.
-* - Accepts a string package name or a `RegExp` to match scoped/pattern packages.
-* - Uses `semver.satisfies` for range comparison; returns `false` when the
-*   version string cannot be coerced into a valid semver.
-*
-* @example
-* ```ts
-* satisfiesDependency('react', '>=18')          // true when react@18.x is installed
-* satisfiesDependency(/^@tanstack\//, '>=5')    // true when any @tanstack/* >=5 is found
-* ```
-*/
-function satisfiesDependency(dependency, version, cwd) {
-	const packageVersion = getVersionSync(dependency, cwd);
-	if (!packageVersion) return false;
-	if (packageVersion === version) return true;
-	const semVer = (0, semver.coerce)(packageVersion);
-	if (!semVer) return false;
-	return (0, semver.satisfies)(semVer, version);
-}
-//#endregion
 exports.AsyncEventEmitter = AsyncEventEmitter;
-exports.FunctionParams = FunctionParams;
-exports.PluginDriver = PluginDriver;
+exports.FileManager = require_PluginDriver.FileManager;
+exports.FileProcessor = FileProcessor;
+exports.PluginDriver = require_PluginDriver.PluginDriver;
 exports.URLPath = URLPath;
 Object.defineProperty(exports, "ast", {
 	enumerable: true,
@@ -3391,46 +1426,18 @@ Object.defineProperty(exports, "ast", {
 		return _kubb_ast;
 	}
 });
-exports.buildDefaultBanner = buildDefaultBanner;
-Object.defineProperty(exports, "composeTransformers", {
-	enumerable: true,
-	get: function() {
-		return _kubb_ast.composeTransformers;
-	}
-});
 exports.createAdapter = createAdapter;
-exports.createFunctionParams = createFunctionParams;
 exports.createKubb = createKubb;
-exports.createPlugin = createPlugin;
 exports.createRenderer = createRenderer;
 exports.createStorage = createStorage;
-exports.defaultResolveBanner = defaultResolveBanner;
-exports.defaultResolveFile = defaultResolveFile;
-exports.defaultResolveFooter = defaultResolveFooter;
-exports.defaultResolveOptions = defaultResolveOptions;
-exports.defaultResolvePath = defaultResolvePath;
 exports.defineGenerator = defineGenerator;
 exports.defineLogger = defineLogger;
 exports.defineParser = defineParser;
-exports.definePlugin = definePlugin;
-Object.defineProperty(exports, "definePrinter", {
-	enumerable: true,
-	get: function() {
-		return _kubb_ast.definePrinter;
-	}
-});
-exports.defineResolver = defineResolver;
-exports.detectFormatter = detectFormatter;
-exports.detectLinter = detectLinter;
-exports.formatters = formatters;
+exports.definePlugin = require_PluginDriver.definePlugin;
+exports.defineResolver = require_PluginDriver.defineResolver;
 exports.fsStorage = fsStorage;
-exports.getBarrelFiles = getBarrelFiles;
-exports.getFunctionParams = getFunctionParams;
-exports.getMode = getMode;
 exports.isInputPath = isInputPath;
-exports.linters = linters;
-exports.logLevel = logLevel;
+exports.logLevel = require_PluginDriver.logLevel;
 exports.memoryStorage = memoryStorage;
-exports.satisfiesDependency = satisfiesDependency;
 
 //# sourceMappingURL=index.cjs.map