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

package/dist/index.js

@@ -1,17 +1,15 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
 import { EventEmitter } from "node:events";
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { access, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import path, { basename, dirname, extname, join, posix, resolve } from "node:path";
-import { composeTransformers, composeTransformers as composeTransformers$1, createExport, createFile, createSource, definePrinter, extractStringsFromNodes, isOperationNode, isSchemaNode, transform, walk } from "@kubb/ast";
+import * as ast from "@kubb/ast";
+import { composeTransformers, createExport, createFile, createSource, definePrinter, extractStringsFromNodes, isOperationNode, isSchemaNode, transform, walk } from "@kubb/ast";
 import { performance } from "node:perf_hooks";
 import { deflateSync } from "fflate";
 import { x } from "tinyexec";
-import { createRenderer } from "@kubb/renderer-jsx";
-import { Fragment, jsx } from "@kubb/renderer-jsx/jsx-runtime";
 import { version } from "node:process";
 import { sortBy } from "remeda";
-import * as pkg from "empathic/package";
 import { coerce, satisfies } from "semver";
 //#region ../../internals/utils/src/errors.ts
 /**
@@ -129,6 +127,18 @@ var AsyncEventEmitter = class {
 		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
@@ -234,6 +244,26 @@ 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 ? resolve(cwd) : process.cwd();
+	while (true) {
+		const pkgPath = join(dir, "package.json");
+		if (existsSync(pkgPath)) return pkgPath;
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+/**
 * Converts all backslashes to forward slashes.
 * Extended-length Windows paths (`\\?\...`) are left unchanged.
 */
@@ -722,8 +752,31 @@ const formatters = {
 	}
 };
 //#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 {
+var Node$1 = class {
+	static {
+		__name(this, "Node");
+	}
 	value;
 	next;
 	constructor(value) {
@@ -738,7 +791,7 @@ var Queue = class {
 		this.clear();
 	}
 	enqueue(value) {
-		const node = new Node(value);
+		const node = new Node$1(value);
 		if (this.#head) {
 			this.#tail.next = node;
 			this.#tail = node;
@@ -892,249 +945,881 @@ var FileProcessor = class {
 	}
 };
 //#endregion
-//#region src/devtools.ts
+//#region src/definePlugin.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.
+* Returns `true` when `plugin` is a hook-style plugin created with `definePlugin`.
 *
-* Use {@link decodeAst} to reverse.
-*/
-function encodeAst(input) {
-	const compressed = 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.
+* 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 getStudioUrl(input, studioUrl, options = {}) {
-	return `${studioUrl.replace(/\/$/, "")}${options.ast ? "/ast" : ""}?root=${encodeAst(input)}`;
+function isHookStylePlugin(plugin) {
+	return typeof plugin === "object" && plugin !== null && "hooks" in plugin;
 }
 /**
-* Opens the Kubb Studio URL for the given `InputNode` in the default browser —
+* Creates a plugin factory using the new hook-style (`hooks:`) API.
 *
-* 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 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.
+* 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`.
 *
-* 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).
+* 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
-* import { FileManager } from '@kubb/core'
-*
-* const manager = new FileManager()
-* manager.upsert(myFile)
-* console.log(manager.files) // all stored files
+* // 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>
+*     },
+*   },
+* }))
 * ```
 */
-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 = 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 = 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;
-	}
-};
+function definePlugin(factory) {
+	return (options) => factory(options ?? {});
+}
 //#endregion
-//#region src/utils/executeStrategies.ts
+//#region src/defineResolver.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
+* Checks if an operation matches a pattern for a given filter type (`tag`, `operationId`, `path`, `method`).
 */
-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([]));
+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;
+	}
 }
 /**
-* Runs promise functions in sequence and returns the first non-null result.
+* Checks if a schema matches a pattern for a given filter type (`schemaName`).
 *
-* - Stops as soon as `nullCheck` passes for a result (default: `!== null`).
-* - Subsequent functions are skipped once a match is found.
-*  @deprecated
+* Returns `null` when the filter type doesn't apply to schemas.
 */
-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;
+function matchesSchemaPattern(node, type, pattern) {
+	switch (type) {
+		case "schemaName": return node.name ? !!node.name.match(pattern) : false;
+		default: return null;
+	}
 }
 /**
-* Runs promise functions concurrently and returns all settled results.
+* Default name resolver used by `defineResolver`.
 *
-* - Limits simultaneous executions to `concurrency` (default: unlimited).
-* - Uses `Promise.allSettled` so individual failures do not cancel other tasks.
-*  @deprecated
+* - `camelCase` for `function` and `file` types.
+* - `PascalCase` for `type`.
+* - `camelCase` for everything else.
 */
-function hookParallel(promises, concurrency = Number.POSITIVE_INFINITY) {
-	const limit = pLimit(concurrency);
-	const tasks = promises.filter(Boolean).map((promise) => limit(() => promise()));
-	return Promise.allSettled(tasks);
+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;
 }
-//#endregion
-//#region src/PluginDriver.ts
 /**
-* Returns `'single'` when `fileOrFolder` has a file extension, `'split'` otherwise.
+* Default option resolver — applies include/exclude filters and merges matching override options.
 *
-* @example
+* Returns `null` when the node is filtered out by an `exclude` rule or not matched by any `include` rule.
+*
+* @example Include/exclude filtering
 * ```ts
-* getMode('src/gen/types.ts')  // 'single'
-* getMode('src/gen/types')     // 'split'
+* const options = defaultResolveOptions(operationNode, {
+*   options: { output: 'types' },
+*   exclude: [{ type: 'tag', pattern: 'internal' }],
+* })
+* // → null when node has tag 'internal'
 * ```
-*/
-function getMode(fileOrFolder) {
-	if (!fileOrFolder) return "split";
-	return extname(fileOrFolder) ? "single" : "split";
-}
-const hookFirstNullCheck = (state) => !!state?.result;
-var PluginDriver = class {
+*
+* @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 (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 (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(path.resolve(root, output.path))) === "single") return path.resolve(root, output.path);
+	if (group && (groupPath || tag)) return path.resolve(root, output.path, group.name({ group: group.type === "path" ? groupPath : tag }), baseName);
+	return path.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(path.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 createFile({
+		path: filePath,
+		baseName: path.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 = path.basename(first.path);
+		} else if ("path" in config.input) source = path.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 = 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 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 = 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 = 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 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;
+	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: 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 = 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);
+		}
+	}
 	/**
-	* 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.
+	* 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.
 	*/
-	fileManager = new FileManager();
-	plugins = /* @__PURE__ */ new Map();
-	constructor(config, options) {
-		this.config = config;
-		this.options = options;
-		config.plugins.map((plugin) => Object.assign({
-			buildStart() {},
-			buildEnd() {}
-		}, plugin)).filter((plugin) => {
-			if (typeof plugin.apply === "function") return plugin.apply(config);
-			return true;
-		}).sort((a, b) => {
-			if (b.pre?.includes(a.name)) return 1;
-			if (b.post?.includes(a.name)) return -1;
-			return 0;
-		}).forEach((plugin) => {
-			this.plugins.set(plugin.name, plugin);
+	async emitSetupHooks() {
+		await this.hooks.emit("kubb:plugin:setup", {
+			config: this.config,
+			addGenerator: () => {},
+			setResolver: () => {},
+			setTransformer: () => {},
+			setRenderer: () => {},
+			setOptions: () => {},
+			injectFile: () => {},
+			updateConfig: () => {},
+			options: {}
 		});
 	}
-	get events() {
-		return this.options.events;
+	/**
+	* 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;
@@ -1146,7 +1831,7 @@ var PluginDriver = class {
 			getMode(output) {
 				return getMode(resolve(driver.config.root, driver.config.output.path, output.path));
 			},
-			events: driver.options.events,
+			hooks: driver.hooks,
 			plugin,
 			getPlugin: driver.getPlugin.bind(driver),
 			requirePlugin: driver.requirePlugin.bind(driver),
@@ -1164,19 +1849,19 @@ var PluginDriver = class {
 				return driver.adapter;
 			},
 			get resolver() {
-				return plugin.resolver;
+				return driver.getResolver(plugin.name);
 			},
 			get transformer() {
 				return plugin.transformer;
 			},
 			warn(message) {
-				driver.events.emit("warn", message);
+				driver.hooks.emit("kubb:warn", message);
 			},
 			error(error) {
-				driver.events.emit("error", typeof error === "string" ? new Error(error) : error);
+				driver.hooks.emit("kubb:error", typeof error === "string" ? new Error(error) : error);
 			},
 			info(message) {
-				driver.events.emit("info", message);
+				driver.hooks.emit("kubb:info", message);
 			},
 			openInStudio(options) {
 				if (!driver.config.devtools || driver.#studioIsOpen) return;
@@ -1187,10 +1872,13 @@ var PluginDriver = class {
 				return openInStudio(driver.inputNode, studioUrl, options);
 			}
 		};
-		const mergedExtras = {};
+		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") Object.assign(mergedExtras, result);
+			if (result !== null && typeof result === "object") mergedExtras = {
+				...mergedExtras,
+				...result
+			};
 		}
 		return {
 			...baseContext,
@@ -1266,7 +1954,7 @@ var PluginDriver = class {
 	async hookForPlugin({ pluginName, hookName, parameters }) {
 		const plugin = this.plugins.get(pluginName);
 		if (!plugin) return [null];
-		this.events.emit("plugins:hook:progress:start", {
+		this.hooks.emit("kubb:plugins:hook:progress:start", {
 			hookName,
 			plugins: [plugin]
 		});
@@ -1276,7 +1964,7 @@ var PluginDriver = class {
 			parameters,
 			plugin
 		});
-		this.events.emit("plugins:hook:progress:end", { hookName });
+		this.hooks.emit("kubb:plugins:hook:progress:end", { hookName });
 		return [result];
 	}
 	/**
@@ -1299,7 +1987,7 @@ var PluginDriver = class {
 	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.events.emit("plugins:hook:progress:start", {
+		this.hooks.emit("kubb:plugins:hook:progress:start", {
 			hookName,
 			plugins
 		});
@@ -1317,7 +2005,7 @@ var PluginDriver = class {
 				});
 			};
 		}), hookFirstNullCheck);
-		this.events.emit("plugins:hook:progress:end", { hookName });
+		this.hooks.emit("kubb:plugins:hook:progress:end", { hookName });
 		return result;
 	}
 	/**
@@ -1342,12 +2030,12 @@ var PluginDriver = class {
 		return parseResult;
 	}
 	/**
-	* Runs all plugins in parallel based on `this.plugin` order and `pre`/`post` settings.
+	* Runs all plugins in parallel based on `this.plugin` order and `dependencies` settings.
 	*/
 	async hookParallel({ hookName, parameters }) {
 		const plugins = [];
 		for (const plugin of this.plugins.values()) if (hookName in plugin) plugins.push(plugin);
-		this.events.emit("plugins:hook:progress:start", {
+		this.hooks.emit("kubb:plugins:hook:progress:start", {
 			hookName,
 			plugins
 		});
@@ -1368,7 +2056,7 @@ var PluginDriver = class {
 				const plugin = plugins[index];
 				if (plugin) {
 					const startTime = pluginStartTimes.get(plugin) ?? performance.now();
-					this.events.emit("error", result.reason, {
+					this.hooks.emit("kubb:error", result.reason, {
 						plugin,
 						hookName,
 						strategy: "hookParallel",
@@ -1378,19 +2066,19 @@ var PluginDriver = class {
 				}
 			}
 		});
-		this.events.emit("plugins:hook:progress:end", { hookName });
+		this.hooks.emit("kubb:plugins:hook:progress:end", { hookName });
 		return results.reduce((acc, result) => {
 			if (result.status === "fulfilled") acc.push(result.value);
 			return acc;
 		}, []);
 	}
 	/**
-	* Chains plugins
+	* Execute a lifecycle hook sequentially for all plugins that implement it.
 	*/
 	async hookSeq({ hookName, parameters }) {
 		const plugins = [];
 		for (const plugin of this.plugins.values()) if (hookName in plugin) plugins.push(plugin);
-		this.events.emit("plugins:hook:progress:start", {
+		this.hooks.emit("kubb:plugins:hook:progress:start", {
 			hookName,
 			plugins
 		});
@@ -1402,7 +2090,7 @@ var PluginDriver = class {
 				plugin
 			});
 		}));
-		this.events.emit("plugins:hook:progress:end", { hookName });
+		this.hooks.emit("kubb:plugins:hook:progress:end", { hookName });
 	}
 	getPlugin(pluginName) {
 		return this.plugins.get(pluginName);
@@ -1413,13 +2101,10 @@ var PluginDriver = class {
 		return plugin;
 	}
 	/**
-	* Run an async plugin hook and return the result.
-	* @param hookName Name of the plugin hook. Must be either in `PluginHooks` or `OutputPluginValueHooks`.
-	* @param args Arguments passed to the plugin hook.
-	* @param plugin The actual pluginObject to run.
+	* Emit hook-processing completion metadata after a plugin hook resolves.
 	*/
 	#emitProcessingEnd({ startTime, output, strategy, hookName, plugin, parameters }) {
-		this.events.emit("plugins:hook:processing:end", {
+		this.hooks.emit("kubb:plugins:hook:processing:end", {
 			duration: Math.round(performance.now() - startTime),
 			parameters,
 			output,
@@ -1431,7 +2116,7 @@ var PluginDriver = class {
 	#execute({ strategy, hookName, parameters, plugin }) {
 		const hook = plugin[hookName];
 		if (!hook) return null;
-		this.events.emit("plugins:hook:processing:start", {
+		this.hooks.emit("kubb:plugins:hook:processing:start", {
 			strategy,
 			hookName,
 			parameters,
@@ -1451,7 +2136,7 @@ var PluginDriver = class {
 				});
 				return output;
 			} catch (error) {
-				this.events.emit("error", error, {
+				this.hooks.emit("kubb:error", error, {
 					plugin,
 					hookName,
 					strategy,
@@ -1462,15 +2147,12 @@ var PluginDriver = class {
 		})();
 	}
 	/**
-	* Run a sync plugin hook and return the result.
-	* @param hookName Name of the plugin hook. Must be in `PluginHooks`.
-	* @param args Arguments passed to the plugin hook.
-	* @param plugin The actual plugin
+	* Execute a plugin lifecycle hook synchronously and return its output.
 	*/
 	#executeSync({ strategy, hookName, parameters, plugin }) {
 		const hook = plugin[hookName];
 		if (!hook) return null;
-		this.events.emit("plugins:hook:processing:start", {
+		this.hooks.emit("kubb:plugins:hook:processing:start", {
 			strategy,
 			hookName,
 			parameters,
@@ -1489,7 +2171,7 @@ var PluginDriver = class {
 			});
 			return output;
 		} catch (error) {
-			this.events.emit("error", error, {
+			this.hooks.emit("kubb:error", error, {
 				plugin,
 				hookName,
 				strategy,
@@ -1500,26 +2182,6 @@ var PluginDriver = class {
 	}
 };
 //#endregion
-//#region src/renderNode.tsx
-/**
-* Handles the return value of a plugin AST hook or generator method.
-*
-* - React element → rendered via renderer-jsx, files stored in `driver.fileManager`
-* - `Array<FileNode>` → upserted directly into `driver.fileManager`
-* - `void` / `null` / `undefined` → no-op (plugin handled it via `this.upsertFile`)
-*/
-async function applyHookResult(result, driver) {
-	if (!result) return;
-	if (Array.isArray(result)) {
-		driver.fileManager.upsert(...result);
-		return;
-	}
-	const renderer = createRenderer();
-	await renderer.render(/* @__PURE__ */ jsx(Fragment, { children: result }));
-	driver.fileManager.upsert(...renderer.files);
-	renderer.unmount();
-}
-//#endregion
 //#region src/createStorage.ts
 /**
 * Creates a storage factory. Call the returned function with optional options to get the storage instance.
@@ -1617,7 +2279,7 @@ const fsStorage = createStorage(() => ({
 }));
 //#endregion
 //#region package.json
-var version$1 = "5.0.0-alpha.33";
+var version$1 = "5.0.0-alpha.35";
 //#endregion
 //#region src/utils/diagnostics.ts
 /**
@@ -1878,24 +2540,14 @@ function isInputPath(config) {
 	return typeof config?.input === "object" && config.input !== null && "path" in config.input;
 }
 //#endregion
-//#region src/build.ts
-/**
-* Initializes all Kubb infrastructure for a build without executing any plugins.
-*
-* - Validates the input path (when applicable).
-* - Applies config defaults (`root`, `output.*`, `devtools`).
-* - Runs the adapter (if configured) to produce the universal `InputNode`.
-*   When no adapter is supplied and `@kubb/adapter-oas` is installed as an
-*
-* Pass the returned {@link SetupResult} directly to {@link safeBuild} or {@link build}
-* via the `overrides` argument to reuse the same infrastructure across multiple runs.
-*/
+//#region src/createKubb.ts
 async function setup(options) {
-	const { config: userConfig, events = new AsyncEventEmitter() } = options;
+	const { config: userConfig } = options;
+	const hooks = options.hooks ?? new AsyncEventEmitter();
 	const sources = /* @__PURE__ */ new Map();
 	const diagnosticInfo = getDiagnosticInfo();
-	if (Array.isArray(userConfig.input)) await events.emit("warn", "This feature is still under development — use with caution");
-	await events.emit("debug", {
+	if (Array.isArray(userConfig.input)) await hooks.emit("kubb:warn", "This feature is still under development — use with caution");
+	await hooks.emit("kubb:debug", {
 		date: /* @__PURE__ */ new Date(),
 		logs: [
 			"Configuration:",
@@ -1914,7 +2566,7 @@ async function setup(options) {
 	try {
 		if (isInputPath(userConfig) && !new URLPath(userConfig.input.path).isURL) {
 			await exists(userConfig.input.path);
-			await events.emit("debug", {
+			await hooks.emit("kubb:debug", {
 				date: /* @__PURE__ */ new Date(),
 				logs: [`✓ Input file validated: ${userConfig.input.path}`]
 			});
@@ -1927,8 +2579,8 @@ async function setup(options) {
 	}
 	if (!userConfig.adapter) throw new Error("Adapter should be defined");
 	const config = {
-		root: userConfig.root || process.cwd(),
 		...userConfig,
+		root: userConfig.root || process.cwd(),
 		parsers: userConfig.parsers ?? [],
 		adapter: userConfig.adapter,
 		output: {
@@ -1946,26 +2598,26 @@ async function setup(options) {
 	};
 	const storage = config.output.write === false ? null : config.output.storage ?? fsStorage();
 	if (config.output.clean) {
-		await events.emit("debug", {
+		await hooks.emit("kubb:debug", {
 			date: /* @__PURE__ */ new Date(),
 			logs: ["Cleaning output directories", `  • Output: ${config.output.path}`]
 		});
 		await storage?.clear(resolve(config.root, config.output.path));
 	}
 	const driver = new PluginDriver(config, {
-		events,
+		hooks,
 		concurrency: 15
 	});
 	const adapter = config.adapter;
 	if (!adapter) throw new Error("No adapter configured. Please provide an adapter in your kubb.config.ts.");
 	const source = inputToAdapterSource(config);
-	await events.emit("debug", {
+	await hooks.emit("kubb:debug", {
 		date: /* @__PURE__ */ new Date(),
 		logs: [`Running adapter: ${adapter.name}`]
 	});
 	driver.adapter = adapter;
 	driver.inputNode = await adapter.parse(source);
-	await events.emit("debug", {
+	await hooks.emit("kubb:debug", {
 		date: /* @__PURE__ */ new Date(),
 		logs: [
 			`✓ Adapter '${adapter.name}' resolved InputNode`,
@@ -1975,53 +2627,32 @@ async function setup(options) {
 	});
 	return {
 		config,
-		events,
+		hooks,
 		driver,
 		sources,
 		storage
 	};
 }
 /**
-* Runs a full Kubb build and throws on any error or plugin failure.
-*
-* Internally delegates to {@link safeBuild} and rethrows collected errors.
-* Pass an existing {@link SetupResult} via `overrides` to skip the setup phase.
-*/
-async function build(options, overrides) {
-	const { files, driver, failedPlugins, pluginTimings, error, sources } = await safeBuild(options, overrides);
-	if (error) throw error;
-	if (failedPlugins.size > 0) {
-		const errors = [...failedPlugins].map(({ error }) => error);
-		throw new BuildError(`Build Error with ${failedPlugins.size} failed plugins`, { errors });
-	}
-	return {
-		failedPlugins,
-		files,
-		driver,
-		pluginTimings,
-		error: void 0,
-		sources
-	};
-}
-/**
 * Walks the AST and dispatches nodes to a plugin's direct AST hooks
 * (`schema`, `operation`, `operations`).
-*
-* - Each hook accepts a single handler **or an array** — all entries are called in sequence.
-* - Nodes that are excluded by `exclude`/`include` plugin options are skipped automatically.
-* - Return values are handled via `applyHookResult`: React elements are rendered,
-*   `FileNode[]` are written via upsert, and `void` is a no-op (manual handling).
-* - Barrel files are generated automatically when `output.barrelType` is set.
 */
 async function runPluginAstHooks(plugin, context) {
 	const { adapter, inputNode, resolver, driver } = context;
 	const { exclude, include, override } = plugin.options;
 	if (!adapter || !inputNode) throw new Error(`[${plugin.name}] No adapter found. Add an OAS adapter (e.g. pluginOas()) before this plugin in your Kubb config.`);
+	function resolveRenderer(gen) {
+		return gen.renderer === null ? void 0 : gen.renderer ?? plugin.renderer ?? context.config.renderer;
+	}
+	const generators = plugin.generators ?? [];
 	const collectedOperations = [];
+	const generatorContext = {
+		...context,
+		resolver: driver.getResolver(plugin.name)
+	};
 	await walk(inputNode, {
 		depth: "shallow",
 		async schema(node) {
-			if (!plugin.schema) return;
 			const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
 			const options = resolver.resolveOptions(transformedNode, {
 				options: plugin.options,
@@ -2030,7 +2661,15 @@ async function runPluginAstHooks(plugin, context) {
 				override
 			});
 			if (options === null) return;
-			await applyHookResult(await plugin.schema.call(context, transformedNode, options), driver);
+			const ctx = {
+				...generatorContext,
+				options
+			};
+			for (const gen of generators) {
+				if (!gen.schema) continue;
+				await applyHookResult(await gen.schema(transformedNode, ctx), driver, resolveRenderer(gen));
+			}
+			await driver.hooks.emit("kubb:generate:schema", transformedNode, ctx);
 		},
 		async operation(node) {
 			const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
@@ -2042,28 +2681,43 @@ async function runPluginAstHooks(plugin, context) {
 			});
 			if (options !== null) {
 				collectedOperations.push(transformedNode);
-				if (plugin.operation) await applyHookResult(await plugin.operation.call(context, transformedNode, options), driver);
+				const ctx = {
+					...generatorContext,
+					options
+				};
+				for (const gen of generators) {
+					if (!gen.operation) continue;
+					await applyHookResult(await gen.operation(transformedNode, ctx), driver, resolveRenderer(gen));
+				}
+				await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
 			}
 		}
 	});
-	if (plugin.operations && collectedOperations.length > 0) await applyHookResult(await plugin.operations.call(context, collectedOperations, plugin.options), driver);
+	if (collectedOperations.length > 0) {
+		const ctx = {
+			...generatorContext,
+			options: plugin.options
+		};
+		for (const gen of generators) {
+			if (!gen.operations) continue;
+			await applyHookResult(await gen.operations(collectedOperations, ctx), driver, resolveRenderer(gen));
+		}
+		await driver.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
+	}
 }
-/**
-* Runs a full Kubb build and captures errors instead of throwing.
-*
-* - Installs each plugin in order, recording failures in `failedPlugins`.
-* - Generates the root barrel file when `output.barrelType` is set.
-* - Writes all files through the driver's FileManager and FileProcessor.
-*
-* Returns a {@link BuildOutput} even on failure — inspect `error` and
-* `failedPlugins` to determine whether the build succeeded.
-*/
-async function safeBuild(options, overrides) {
-	const { driver, events, sources, storage } = overrides ? overrides : await setup(options);
+async function safeBuild(setupResult) {
+	const { driver, hooks, sources, storage } = setupResult;
 	const failedPlugins = /* @__PURE__ */ new Set();
 	const pluginTimings = /* @__PURE__ */ new Map();
 	const config = driver.config;
 	try {
+		await driver.emitSetupHooks();
+		if (driver.adapter && driver.inputNode) await hooks.emit("kubb:build:start", {
+			config,
+			adapter: driver.adapter,
+			inputNode: driver.inputNode,
+			getPlugin: (name) => driver.getPlugin(name)
+		});
 		for (const plugin of driver.plugins.values()) {
 			const context = driver.getContext(plugin);
 			const hrStart = process.hrtime();
@@ -2071,13 +2725,13 @@ async function safeBuild(options, overrides) {
 			const root = resolve(config.root, config.output.path);
 			try {
 				const timestamp = /* @__PURE__ */ new Date();
-				await events.emit("plugin:start", plugin);
-				await events.emit("debug", {
+				await hooks.emit("kubb:plugin:start", plugin);
+				await hooks.emit("kubb:debug", {
 					date: timestamp,
 					logs: ["Starting plugin...", `  • Plugin Name: ${plugin.name}`]
 				});
 				await plugin.buildStart.call(context);
-				if (plugin.schema || plugin.operation || plugin.operations) await runPluginAstHooks(plugin, context);
+				if (plugin.generators?.length || driver.hasRegisteredGenerators(plugin.name)) await runPluginAstHooks(plugin, context);
 				if (output) {
 					const barrelFiles = await getBarrelFiles(driver.fileManager.files, {
 						type: output.barrelType ?? "named",
@@ -2089,11 +2743,11 @@ async function safeBuild(options, overrides) {
 				}
 				const duration = getElapsedMs(hrStart);
 				pluginTimings.set(plugin.name, duration);
-				await events.emit("plugin:end", plugin, {
+				await hooks.emit("kubb:plugin:end", plugin, {
 					duration,
 					success: true
 				});
-				await events.emit("debug", {
+				await hooks.emit("kubb:debug", {
 					date: /* @__PURE__ */ new Date(),
 					logs: [`✓ Plugin started successfully (${formatMs(duration)})`]
 				});
@@ -2101,12 +2755,12 @@ async function safeBuild(options, overrides) {
 				const error = caughtError;
 				const errorTimestamp = /* @__PURE__ */ new Date();
 				const duration = getElapsedMs(hrStart);
-				await events.emit("plugin:end", plugin, {
+				await hooks.emit("kubb:plugin:end", plugin, {
 					duration,
 					success: false,
 					error
 				});
-				await events.emit("debug", {
+				await hooks.emit("kubb:debug", {
 					date: errorTimestamp,
 					logs: [
 						"✗ Plugin start failed",
@@ -2125,7 +2779,7 @@ async function safeBuild(options, overrides) {
 		if (config.output.barrelType) {
 			const rootPath = resolve(resolve(config.root), config.output.path, BARREL_FILENAME);
 			const rootDir = dirname(rootPath);
-			await events.emit("debug", {
+			await hooks.emit("kubb:debug", {
 				date: /* @__PURE__ */ new Date(),
 				logs: [
 					"Generating barrel file",
@@ -2136,7 +2790,7 @@ async function safeBuild(options, overrides) {
 			const barrelFiles = driver.fileManager.files.filter((file) => {
 				return file.sources.some((source) => source.isIndexable);
 			});
-			await events.emit("debug", {
+			await hooks.emit("kubb:debug", {
 				date: /* @__PURE__ */ new Date(),
 				logs: [`Found ${barrelFiles.length} indexable files for barrel export`]
 			});
@@ -2156,7 +2810,7 @@ async function safeBuild(options, overrides) {
 				meta: {}
 			});
 			driver.fileManager.upsert(rootFile);
-			await events.emit("debug", {
+			await hooks.emit("kubb:debug", {
 				date: /* @__PURE__ */ new Date(),
 				logs: [`✓ Generated barrel file (${rootFile.exports?.length || 0} exports)`]
 			});
@@ -2165,7 +2819,7 @@ async function safeBuild(options, overrides) {
 		const parsersMap = /* @__PURE__ */ new Map();
 		for (const parser of config.parsers) if (parser.extNames) for (const extname of parser.extNames) parsersMap.set(extname, parser);
 		const fileProcessor = new FileProcessor();
-		await events.emit("debug", {
+		await hooks.emit("kubb:debug", {
 			date: /* @__PURE__ */ new Date(),
 			logs: [`Writing ${files.length} files...`]
 		});
@@ -2173,591 +2827,272 @@ async function safeBuild(options, overrides) {
 			parsers: parsersMap,
 			extension: config.output.extension,
 			onStart: async (processingFiles) => {
-				await events.emit("files:processing:start", processingFiles);
-			},
-			onUpdate: async ({ file, source, processed, total, percentage }) => {
-				await events.emit("file:processing:update", {
-					file,
-					source,
-					processed,
-					total,
-					percentage,
-					config
-				});
-				if (source) {
-					await storage?.setItem(file.path, source);
-					sources.set(file.path, source);
-				}
+				await hooks.emit("kubb:files:processing:start", processingFiles);
 			},
-			onEnd: async (processedFiles) => {
-				await events.emit("files:processing:end", processedFiles);
-				await events.emit("debug", {
-					date: /* @__PURE__ */ new Date(),
-					logs: [`✓ File write process completed for ${processedFiles.length} files`]
-				});
-			}
-		});
-		for (const plugin of driver.plugins.values()) if (plugin.buildEnd) {
-			const context = driver.getContext(plugin);
-			await plugin.buildEnd.call(context);
-		}
-		return {
-			failedPlugins,
-			files,
-			driver,
-			pluginTimings,
-			sources
-		};
-	} catch (error) {
-		return {
-			failedPlugins,
-			files: [],
-			driver,
-			pluginTimings,
-			error,
-			sources
-		};
-	}
-}
-function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, driver }) {
-	const pluginNameMap = /* @__PURE__ */ new Map();
-	for (const plugin of driver.plugins.values()) pluginNameMap.set(plugin.name, plugin);
-	return barrelFiles.flatMap((file) => {
-		const containsOnlyTypes = file.sources?.every((source) => source.isTypeOnly);
-		return (file.sources ?? []).flatMap((source) => {
-			if (!file.path || !source.isIndexable) return [];
-			const meta = file.meta;
-			const pluginOptions = (meta?.pluginName ? pluginNameMap.get(meta.pluginName) : void 0)?.options;
-			if (!pluginOptions || pluginOptions.output?.barrelType === false) return [];
-			const exportName = config.output.barrelType === "all" ? void 0 : source.name ? [source.name] : void 0;
-			if (exportName?.some((n) => existingExports.has(n))) return [];
-			return [createExport({
-				name: exportName,
-				path: getRelativePath(rootDir, file.path),
-				isTypeOnly: config.output.barrelType === "all" ? containsOnlyTypes : source.isTypeOnly
-			})];
-		});
-	});
-}
-/**
-* Maps the resolved `Config['input']` shape into an `AdapterSource` that
-* the adapter's `parse()` can consume.
-*/
-function inputToAdapterSource(config) {
-	if (Array.isArray(config.input)) return {
-		type: "paths",
-		paths: config.input.map((i) => new URLPath(i.path).isURL ? i.path : resolve(config.root, i.path))
-	};
-	if ("data" in config.input) return {
-		type: "data",
-		data: config.input.data
-	};
-	if (new URLPath(config.input.path).isURL) return {
-		type: "path",
-		path: config.input.path
-	};
-	return {
-		type: "path",
-		path: resolve(config.root, config.input.path)
-	};
-}
-//#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/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' } })
-* ```
-*/
-function createPlugin(build) {
-	return (options) => build(options ?? {});
-}
-//#endregion
-//#region src/defineConfig.ts
-function defineConfig(config) {
-	return config;
-}
-//#endregion
-//#region src/defineGenerator.ts
-/**
-* Defines a generator. Returns the object as-is with correct `this` typings.
-* No type discrimination (`type: 'react' | 'core'`) needed — `applyHookResult`
-* handles React elements and `File[]` uniformly.
-*/
-function defineGenerator(generator) {
-	return generator;
-}
-/**
-* Merges an array of generators into a single generator.
-*
-* The merged generator's `schema`, `operation`, and `operations` methods run
-* the corresponding method from each input generator in sequence, applying each
-* result via `applyHookResult`. This eliminates the need to write the loop
-* manually in each plugin.
-*
-* @param generators - Array of generators to merge into a single generator.
-*
-* @example
-* ```ts
-* const merged = mergeGenerators(generators)
-*
-* return {
-*   name: pluginName,
-*   schema: merged.schema,
-*   operation: merged.operation,
-*   operations: merged.operations,
-* }
-* ```
-*/
-function mergeGenerators(generators) {
-	return {
-		name: generators.length > 0 ? generators.map((g) => g.name).join("+") : "merged",
-		async schema(node, options) {
-			for (const gen of generators) {
-				if (!gen.schema) continue;
-				await applyHookResult(await gen.schema.call(this, node, options), this.driver);
-			}
-		},
-		async operation(node, options) {
-			for (const gen of generators) {
-				if (!gen.operation) continue;
-				await applyHookResult(await gen.operation.call(this, node, options), this.driver);
-			}
-		},
-		async operations(nodes, options) {
-			for (const gen of generators) {
-				if (!gen.operations) continue;
-				await applyHookResult(await gen.operations.call(this, nodes, options), this.driver);
+			onUpdate: async ({ file, source, processed, total, percentage }) => {
+				await hooks.emit("kubb:file:processing:update", {
+					file,
+					source,
+					processed,
+					total,
+					percentage,
+					config
+				});
+				if (source) {
+					await storage?.setItem(file.path, source);
+					sources.set(file.path, source);
+				}
+			},
+			onEnd: async (processedFiles) => {
+				await hooks.emit("kubb:files:processing:end", processedFiles);
+				await hooks.emit("kubb:debug", {
+					date: /* @__PURE__ */ new Date(),
+					logs: [`✓ File write process completed for ${processedFiles.length} files`]
+				});
 			}
+		});
+		for (const plugin of driver.plugins.values()) if (plugin.buildEnd) {
+			const context = driver.getContext(plugin);
+			await plugin.buildEnd.call(context);
 		}
-	};
-}
-//#endregion
-//#region src/defineLogger.ts
-/**
-* Wraps a logger definition into a typed {@link Logger}.
-*
-* @example
-* export const myLogger = defineLogger({
-*   name: 'my-logger',
-*   install(context, options) {
-*     context.on('info', (message) => console.log('ℹ', message))
-*     context.on('error', (error) => console.error('✗', error.message))
-*   },
-* })
-*/
-function defineLogger(logger) {
-	return logger;
-}
-//#endregion
-//#region src/defineParser.ts
-/**
-* Defines a parser with type safety.
-*
-* Use this function to create parsers that transform generated files to strings
-* based on their extension.
-*
-* @example
-* ```ts
-* import { defineParser } from '@kubb/core'
-*
-* export const jsonParser = defineParser({
-*   name: 'json',
-*   extNames: ['.json'],
-*   parse(file) {
-*     const { extractStringsFromNodes } = await import('@kubb/ast')
-*     return file.sources.map((s) => extractStringsFromNodes(s.nodes ?? [])).join('\n')
-*   },
-* })
-* ```
-*/
-function defineParser(parser) {
-	return parser;
-}
-//#endregion
-//#region src/definePresets.ts
-/**
-* Creates a typed presets registry object — a named collection of {@link Preset} entries.
-*
-* @example
-* import { definePreset, definePresets } from '@kubb/core'
-* import { resolverTsLegacy } from '@kubb/plugin-ts'
-*
-* export const myPresets = definePresets({
-*   kubbV4: definePreset('kubbV4', { resolvers: [resolverTsLegacy] }),
-* })
-*/
-function definePresets(presets) {
-	return presets;
-}
-//#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 (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;
+		await hooks.emit("kubb:build:end", {
+			files,
+			config,
+			outputDir: resolve(config.root, config.output.path)
+		});
 		return {
-			...options,
-			...overrideOptions
+			failedPlugins,
+			files,
+			driver,
+			pluginTimings,
+			sources
 		};
-	}
-	if (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;
+	} catch (error) {
 		return {
-			...options,
-			...overrideOptions
+			failedPlugins,
+			files: [],
+			driver,
+			pluginTimings,
+			error,
+			sources
 		};
+	} finally {
+		driver.dispose();
 	}
-	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(path.resolve(root, output.path))) === "single") return path.resolve(root, output.path);
-	if (group && (groupPath || tag)) return path.resolve(root, output.path, group.name({ group: group.type === "path" ? groupPath : tag }), baseName);
-	return path.resolve(root, output.path, baseName);
+async function build(setupResult) {
+	const { files, driver, failedPlugins, pluginTimings, error, sources } = await safeBuild(setupResult);
+	if (error) throw error;
+	if (failedPlugins.size > 0) {
+		const errors = [...failedPlugins].map(({ error }) => error);
+		throw new BuildError(`Build Error with ${failedPlugins.size} failed plugins`, { errors });
+	}
+	return {
+		failedPlugins,
+		files,
+		driver,
+		pluginTimings,
+		error: void 0,
+		sources
+	};
+}
+function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, driver }) {
+	const pluginNameMap = /* @__PURE__ */ new Map();
+	for (const plugin of driver.plugins.values()) pluginNameMap.set(plugin.name, plugin);
+	return barrelFiles.flatMap((file) => {
+		const containsOnlyTypes = file.sources?.every((source) => source.isTypeOnly);
+		return (file.sources ?? []).flatMap((source) => {
+			if (!file.path || !source.isIndexable) return [];
+			const meta = file.meta;
+			const pluginOptions = (meta?.pluginName ? pluginNameMap.get(meta.pluginName) : void 0)?.options;
+			if (!pluginOptions || pluginOptions.output?.barrelType === false) return [];
+			const exportName = config.output.barrelType === "all" ? void 0 : source.name ? [source.name] : void 0;
+			if (exportName?.some((n) => existingExports.has(n))) return [];
+			return [createExport({
+				name: exportName,
+				path: getRelativePath(rootDir, file.path),
+				isTypeOnly: config.output.barrelType === "all" ? containsOnlyTypes : source.isTypeOnly
+			})];
+		});
+	});
+}
+function inputToAdapterSource(config) {
+	if (Array.isArray(config.input)) return {
+		type: "paths",
+		paths: config.input.map((i) => new URLPath(i.path).isURL ? i.path : resolve(config.root, i.path))
+	};
+	if ("data" in config.input) return {
+		type: "data",
+		data: config.input.data
+	};
+	if (new URLPath(config.input.path).isURL) return {
+		type: "path",
+		path: config.input.path
+	};
+	return {
+		type: "path",
+		path: resolve(config.root, config.input.path)
+	};
 }
 /**
-* 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.
+* Creates a Kubb instance bound to a single config entry.
 *
-* In `single` mode the name is omitted and the file sits directly in the output directory.
+* The instance holds shared state (`hooks`, `sources`, `driver`, `config`) across the
+* `setup → build` lifecycle. Attach event listeners to `kubb.hooks` before
+* calling `setup()` or `build()`.
 *
-* @example Resolve a schema file
+* @example
 * ```ts
-* const file = defaultResolveFile.call(resolver,
-*   { name: 'pet', extname: '.ts' },
-*   { root: '/src', output: { path: 'types' } },
-* )
-* // → { baseName: 'pet.ts', path: '/src/types/pet.ts', sources: [], ... }
-* ```
+* const kubb = createKubb({ config })
 *
-* @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', ... }
+* kubb.hooks.on('kubb:plugin:end', (plugin, { duration }) => {
+*   console.log(`${plugin.name} completed in ${duration}ms`)
+* })
+*
+* const { files, failedPlugins } = await kubb.safeBuild()
 * ```
 */
-function defaultResolveFile({ name, extname, tag, path: groupPath }, context) {
-	const pathMode = getMode(path.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 createFile({
-		path: filePath,
-		baseName: path.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 = path.basename(first.path);
-		} else if ("path" in config.input) source = path.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`;
+function createKubb(options) {
+	const hooks = options.hooks ?? new AsyncEventEmitter();
+	let setupResult;
+	const instance = {
+		get hooks() {
+			return hooks;
+		},
+		get sources() {
+			return setupResult?.sources ?? /* @__PURE__ */ new Map();
+		},
+		get driver() {
+			return setupResult?.driver;
+		},
+		get config() {
+			return setupResult?.config;
+		},
+		async setup() {
+			setupResult = await setup({
+				config: options.config,
+				hooks
+			});
+		},
+		async build() {
+			if (!setupResult) await instance.setup();
+			return build(setupResult);
+		},
+		async safeBuild() {
+			if (!setupResult) await instance.setup();
+			return safeBuild(setupResult);
 		}
-		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*/";
-	}
+	};
+	return instance;
 }
+//#endregion
+//#region src/createPlugin.ts
 /**
-* 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'
-* ```
+* Creates a plugin factory. Call the returned function with optional options to get the plugin instance.
 *
-* @example No user banner — Kubb notice with OAS metadata
+* @example
 * ```ts
-* defaultResolveBanner(inputNode, { config })
-* // → '/** Generated by Kubb ... Title: Pet Store ... *\/'
-* ```
+* export const myPlugin = createPlugin<MyPlugin>((options) => {
+*   return {
+*     name: 'my-plugin',
+*     get options() { return options },
+*     resolvePath(baseName) { ... },
+*     resolveName(name, type) { ... },
+*   }
+* })
 *
-* @example Disabled default banner
-* ```ts
-* defaultResolveBanner(undefined, { config: { output: { defaultBanner: false }, ...config } })
-* // → undefined
+* // instantiate
+* const plugin = myPlugin({ output: { path: 'src/gen' } })
 * ```
+* @deprecated use definePlugin instead
 */
-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
-	});
+function createPlugin(build) {
+	return (options) => build(options ?? {});
 }
+//#endregion
+//#region src/createRenderer.ts
 /**
-* Default footer resolver — returns the footer string for a generated file.
+* Creates a renderer factory for use in generator definitions.
 *
-* - 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`.
+* Wrap your renderer factory function with this helper to register it as the
+* renderer for a generator. Core will call this factory once per render cycle
+* to obtain a fresh renderer instance.
 *
-* @example String footer
+* @example
 * ```ts
-* defaultResolveFooter(undefined, { output: { footer: '// end of file' }, config })
-* // → '// end of file'
-* ```
+* // packages/renderer-jsx/src/index.ts
+* export const jsxRenderer = createRenderer(() => {
+*   const runtime = new Runtime()
+*   return {
+*     async render(element) { await runtime.render(element) },
+*     get files() { return runtime.nodes },
+*     unmount(error) { runtime.unmount(error) },
+*   }
+* })
 *
-* @example Function footer with node
-* ```ts
-* defaultResolveFooter(inputNode, { output: { footer: (node) => `// ${node.title}` }, config })
-* // → '// Pet Store'
+* // packages/plugin-zod/src/generators/zodGenerator.tsx
+* import { jsxRenderer } from '@kubb/renderer-jsx'
+* export const zodGenerator = defineGenerator<PluginZod>({
+*   name: 'zod',
+*   renderer: jsxRenderer,
+*   schema(node, options) { return <File ...>...</File> },
+* })
 * ```
 */
-function defaultResolveFooter(node, { output }) {
-	if (typeof output?.footer === "function") return node ? output.footer(node) : void 0;
-	if (typeof output?.footer === "string") return output.footer;
+function createRenderer(factory) {
+	return factory;
 }
+//#endregion
+//#region src/defineGenerator.ts
 /**
-* 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.
+* Defines a generator. Returns the object as-is with correct `this` typings.
+* `applyHookResult` handles renderer elements and `File[]` uniformly using
+* the generator's declared `renderer` factory.
+*/
+function defineGenerator(generator) {
+	return generator;
+}
+//#endregion
+//#region src/defineLogger.ts
+/**
+* Wraps a logger definition into a typed {@link Logger}.
 *
-* @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
+* export const myLogger = defineLogger({
+*   name: 'my-logger',
+*   install(context, options) {
+*     context.on('kubb:info', (message) => console.log('ℹ', message))
+*     context.on('kubb:error', (error) => console.error('✗', error.message))
 *   },
-* }))
-* ```
+* })
+*/
+function defineLogger(logger) {
+	return logger;
+}
+//#endregion
+//#region src/defineParser.ts
+/**
+* Defines a parser with type safety.
 *
-* @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)
-*   },
-* }))
-* ```
+* Use this function to create parsers that transform generated files to strings
+* based on their extension.
 *
-* @example Use this.default inside a helper
+* @example
 * ```ts
-* export const resolver = defineResolver<PluginTs>(() => ({
-*   name: 'default',
-*   resolveParamName(node, param) {
-*     return this.default(`${node.operationId} ${param.in} ${param.name}`, 'type')
+* import { defineParser } from '@kubb/core'
+*
+* export const jsonParser = defineParser({
+*   name: 'json',
+*   extNames: ['.json'],
+*   parse(file) {
+*     const { extractStringsFromNodes } = await import('@kubb/ast')
+*     return file.sources.map((s) => extractStringsFromNodes(s.nodes ?? [])).join('\n')
 *   },
-* }))
+* })
 * ```
 */
-function defineResolver(build) {
-	return {
-		default: defaultResolver,
-		resolveOptions: defaultResolveOptions,
-		resolvePath: defaultResolvePath,
-		resolveFile: defaultResolveFile,
-		resolveBanner: defaultResolveBanner,
-		resolveFooter: defaultResolveFooter,
-		...build()
-	};
+function defineParser(parser) {
+	return parser;
 }
 //#endregion
 //#region src/storages/memoryStorage.ts
@@ -2847,22 +3182,6 @@ async function detectFormatter() {
 	return null;
 }
 //#endregion
-//#region src/utils/getConfigs.ts
-/**
-* Resolves a {@link ConfigInput} into a normalized array of {@link Config} objects.
-*
-* - Awaits the config when it is a `Promise`.
-* - Calls the factory function with `args` when the config is a function.
-* - Wraps a single config object in an array for uniform downstream handling.
-*/
-async function getConfigs(config, args) {
-	const resolved = await (typeof config === "function" ? config(args) : config);
-	return (Array.isArray(resolved) ? resolved : [resolved]).map((item) => ({
-		plugins: [],
-		...item
-	}));
-}
-//#endregion
 //#region src/utils/getFunctionParams.ts
 function order(items) {
 	return sortBy(items.filter(Boolean), ([_key, item]) => {
@@ -2981,47 +3300,6 @@ var FunctionParams = class FunctionParams {
 	}
 };
 //#endregion
-//#region src/utils/getPreset.ts
-/**
-* Returns a copy of `defaults` where each function in `userOverrides` is wrapped
-* so a `null`/`undefined` return falls back to the original. Non-function values
-* are assigned directly. All calls use the merged object as `this`.
-*/
-function withFallback(defaults, userOverrides) {
-	const merged = { ...defaults };
-	for (const key of Object.keys(userOverrides)) {
-		const userVal = userOverrides[key];
-		const defaultVal = defaults[key];
-		if (typeof userVal === "function" && typeof defaultVal === "function") merged[key] = (...args) => userVal.apply(merged, args) ?? defaultVal.apply(merged, args);
-		else if (userVal !== void 0) merged[key] = userVal;
-	}
-	return merged;
-}
-/**
-* Resolves a named preset into a resolver, transformer, and generators.
-*
-* - Selects the preset resolver; wraps it with user overrides using null/undefined fallback.
-* - Composes the preset's transformers into a single visitor; wraps it with the user transformer using null/undefined fallback.
-* - Combines preset generators with user-supplied generators; falls back to the `default` preset's generators when neither provides any.
-*/
-function getPreset(params) {
-	const { preset: presetName, presets, resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = params;
-	const preset = presets[presetName];
-	const presetResolver = preset?.resolver ?? presets["default"].resolver;
-	const resolver = userResolver ? withFallback(presetResolver, userResolver) : presetResolver;
-	const presetTransformers = preset?.transformers ?? [];
-	const presetTransformer = presetTransformers.length > 0 ? composeTransformers$1(...presetTransformers) : void 0;
-	const transformer = presetTransformer && userTransformer ? withFallback(presetTransformer, userTransformer) : userTransformer ?? presetTransformer;
-	const presetGenerators = preset?.generators ?? [];
-	const defaultGenerators = presets["default"]?.generators ?? [];
-	return {
-		resolver,
-		transformer,
-		generators: presetGenerators.length > 0 || userGenerators.length > 0 ? [...presetGenerators, ...userGenerators] : defaultGenerators,
-		preset
-	};
-}
-//#endregion
 //#region src/utils/linters.ts
 /**
 * Returns `true` when the given linter is installed and callable.
@@ -3063,7 +3341,7 @@ async function detectLinter() {
 //#endregion
 //#region src/utils/packageJSON.ts
 function getPackageJSONSync(cwd) {
-	const pkgPath = pkg.up({ cwd });
+	const pkgPath = findPackageJSON(cwd);
 	if (!pkgPath) return null;
 	return JSON.parse(readSync(pkgPath));
 }
@@ -3104,6 +3382,6 @@ function satisfiesDependency(dependency, version, cwd) {
 	return satisfies(semVer, version);
 }
 //#endregion
-export { AsyncEventEmitter, FunctionParams, PluginDriver, URLPath, build, build as default, buildDefaultBanner, composeTransformers, createAdapter, createFunctionParams, createPlugin, createStorage, defaultResolveBanner, defaultResolveFile, defaultResolveFooter, defaultResolveOptions, defaultResolvePath, defineConfig, defineGenerator, defineLogger, defineParser, definePresets, definePrinter, defineResolver, detectFormatter, detectLinter, formatters, fsStorage, getBarrelFiles, getConfigs, getFunctionParams, getMode, getPreset, isInputPath, linters, logLevel, memoryStorage, mergeGenerators, safeBuild, satisfiesDependency, setup };
+export { AsyncEventEmitter, FunctionParams, PluginDriver, URLPath, ast, buildDefaultBanner, composeTransformers, createAdapter, createFunctionParams, createKubb, createPlugin, createRenderer, createStorage, defaultResolveBanner, defaultResolveFile, defaultResolveFooter, defaultResolveOptions, defaultResolvePath, defineGenerator, defineLogger, defineParser, definePlugin, definePrinter, defineResolver, detectFormatter, detectLinter, formatters, fsStorage, getBarrelFiles, getFunctionParams, getMode, isInputPath, linters, logLevel, memoryStorage, satisfiesDependency };
 
 //# sourceMappingURL=index.js.map