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

package/dist/index.cjs

@@ -1,23 +1,17 @@
-Object.defineProperties(exports, {
-	__esModule: { value: true },
-	[Symbol.toStringTag]: { value: "Module" }
-});
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("./chunk-ByKO4r7w.cjs");
 let node_events = require("node:events");
 let node_fs = require("node:fs");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
-node_path = require_chunk.__toESM(node_path);
+node_path = require_chunk.__toESM(node_path, 1);
 let _kubb_ast = require("@kubb/ast");
+_kubb_ast = require_chunk.__toESM(_kubb_ast, 1);
 let node_perf_hooks = require("node:perf_hooks");
 let fflate = require("fflate");
 let tinyexec = require("tinyexec");
-let _kubb_renderer_jsx = require("@kubb/renderer-jsx");
-let _kubb_renderer_jsx_jsx_runtime = require("@kubb/renderer-jsx/jsx-runtime");
 let node_process = require("node:process");
 let remeda = require("remeda");
-let empathic_package = require("empathic/package");
-empathic_package = require_chunk.__toESM(empathic_package);
 let semver = require("semver");
 //#region ../../internals/utils/src/errors.ts
 /**
@@ -135,6 +129,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
@@ -240,6 +246,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 ? (0, node_path.resolve)(cwd) : process.cwd();
+	while (true) {
+		const pkgPath = (0, node_path.join)(dir, "package.json");
+		if ((0, node_fs.existsSync)(pkgPath)) return pkgPath;
+		const parent = (0, node_path.dirname)(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+/**
 * Converts all backslashes to forward slashes.
 * Extended-length Windows paths (`\\?\...`) are left unchanged.
 */
@@ -728,6 +754,26 @@ 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 {
 	value;
@@ -898,214 +944,612 @@ 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 = (0, fflate.deflateSync)(new TextEncoder().encode(JSON.stringify(input)));
-	return Buffer.from(compressed).toString("base64url");
-}
-/**
-* Constructs the Kubb Studio URL for the given `InputNode`.
-* When `options.ast` is `true`, navigates to the AST inspector (`/ast`).
-* The `input` is encoded and attached as the `?root=` query parameter so Studio
-* can decode and render it without a round-trip to any server.
+* 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 (0, tinyexec.x)(cmd, args);
-	} catch {
-		console.log(`\n  ${url}\n`);
-	}
-}
-//#endregion
-//#region src/FileManager.ts
-function mergeFile(a, b) {
-	return {
-		...a,
-		sources: [...a.sources || [], ...b.sources || []],
-		imports: [...a.imports || [], ...b.imports || []],
-		exports: [...a.exports || [], ...b.exports || []]
-	};
-}
-/**
-* In-memory file store for generated files.
+* 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 = (0, _kubb_ast.createFile)(file);
-			this.#cache.set(resolvedFile.path, resolvedFile);
-			this.#filesCache = null;
-			resolvedFiles.push(resolvedFile);
-		}
-		return resolvedFiles;
-	}
-	/**
-	* Adds or merges one or more files.
-	* If a file with the same path already exists, its sources/imports/exports are merged together.
-	*/
-	upsert(...files) {
-		const resolvedFiles = [];
-		const mergedFiles = /* @__PURE__ */ new Map();
-		files.forEach((file) => {
-			const existing = mergedFiles.get(file.path);
-			if (existing) mergedFiles.set(file.path, mergeFile(existing, file));
-			else mergedFiles.set(file.path, file);
-		});
-		for (const file of mergedFiles.values()) {
-			const existing = this.#cache.get(file.path);
-			const resolvedFile = (0, _kubb_ast.createFile)(existing ? mergeFile(existing, file) : file);
-			this.#cache.set(resolvedFile.path, resolvedFile);
-			this.#filesCache = null;
-			resolvedFiles.push(resolvedFile);
-		}
-		return resolvedFiles;
-	}
-	getByPath(path) {
-		return this.#cache.get(path) ?? null;
-	}
-	deleteByPath(path) {
-		this.#cache.delete(path);
-		this.#filesCache = null;
-	}
-	clear() {
-		this.#cache.clear();
-		this.#filesCache = null;
-	}
-	/**
-	* All stored files, sorted by path length (shorter paths first).
-	* Barrel/index files (e.g. index.ts) are sorted last within each length bucket.
-	*/
-	get files() {
-		if (this.#filesCache) return this.#filesCache;
-		const keys = [...this.#cache.keys()].sort((a, b) => {
-			if (a.length !== b.length) return a.length - b.length;
-			const aIsIndex = trimExtName$1(a).endsWith("index");
-			if (aIsIndex !== trimExtName$1(b).endsWith("index")) return aIsIndex ? 1 : -1;
-			return 0;
-		});
-		const files = [];
-		for (const key of keys) {
-			const file = this.#cache.get(key);
-			if (file) files.push(file);
-		}
-		this.#filesCache = files;
-		return files;
-	}
-};
+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 (0, node_path.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 ((0, _kubb_ast.isOperationNode)(node)) {
+		if (exclude.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) return null;
+		if (include && !include.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) return null;
+		const overrideOptions = override.find(({ type, pattern }) => matchesOperationPattern(node, type, pattern))?.options;
+		return {
+			...options,
+			...overrideOptions
+		};
+	}
+	if ((0, _kubb_ast.isSchemaNode)(node)) {
+		if (exclude.some(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)) return null;
+		if (include) {
+			const applicable = include.map(({ type, pattern }) => matchesSchemaPattern(node, type, pattern)).filter((r) => r !== null);
+			if (applicable.length > 0 && !applicable.includes(true)) return null;
+		}
+		const overrideOptions = override.find(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)?.options;
+		return {
+			...options,
+			...overrideOptions
+		};
+	}
+	return options;
+}
+/**
+* Default path resolver used by `defineResolver`.
+*
+* - Returns the output directory in `single` mode.
+* - Resolves into a tag- or path-based subdirectory when `group` and a `tag`/`path` value are provided.
+* - Falls back to a flat `output/baseName` path otherwise.
+*
+* A custom `group.name` function overrides the default subdirectory naming.
+* For `tag` groups the default is `${camelCase(tag)}Controller`.
+* For `path` groups the default is the first path segment after `/`.
+*
+* @example Flat output
+* ```ts
+* defaultResolvePath({ baseName: 'petTypes.ts' }, { root: '/src', output: { path: 'types' } })
+* // → '/src/types/petTypes.ts'
+* ```
+*
+* @example Tag-based grouping
+* ```ts
+* defaultResolvePath(
+*   { baseName: 'petTypes.ts', tag: 'pets' },
+*   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
+* )
+* // → '/src/types/petsController/petTypes.ts'
+* ```
+*
+* @example Path-based grouping
+* ```ts
+* defaultResolvePath(
+*   { baseName: 'petTypes.ts', path: '/pets/list' },
+*   { root: '/src', output: { path: 'types' }, group: { type: 'path' } },
+* )
+* // → '/src/types/pets/petTypes.ts'
+* ```
+*
+* @example Single-file mode
+* ```ts
+* defaultResolvePath(
+*   { baseName: 'petTypes.ts', pathMode: 'single' },
+*   { root: '/src', output: { path: 'types' } },
+* )
+* // → '/src/types'
+* ```
+*/
+function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }, { root, output, group }) {
+	if ((pathMode ?? getMode(node_path.default.resolve(root, output.path))) === "single") return node_path.default.resolve(root, output.path);
+	if (group && (groupPath || tag)) return node_path.default.resolve(root, output.path, group.name({ group: group.type === "path" ? groupPath : tag }), baseName);
+	return node_path.default.resolve(root, output.path, baseName);
+}
+/**
+* Default file resolver used by `defineResolver`.
+*
+* Resolves a `FileNode` by combining name resolution (`resolver.default`) with
+* path resolution (`resolver.resolvePath`). The resolved file always has empty
+* `sources`, `imports`, and `exports` arrays — consumers populate those separately.
+*
+* In `single` mode the name is omitted and the file sits directly in the output directory.
+*
+* @example Resolve a schema file
+* ```ts
+* const file = defaultResolveFile.call(resolver,
+*   { name: 'pet', extname: '.ts' },
+*   { root: '/src', output: { path: 'types' } },
+* )
+* // → { baseName: 'pet.ts', path: '/src/types/pet.ts', sources: [], ... }
+* ```
+*
+* @example Resolve an operation file with tag grouping
+* ```ts
+* const file = defaultResolveFile.call(resolver,
+*   { name: 'listPets', extname: '.ts', tag: 'pets' },
+*   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
+* )
+* // → { baseName: 'listPets.ts', path: '/src/types/petsController/listPets.ts', ... }
+* ```
+*/
+function defaultResolveFile({ name, extname, tag, path: groupPath }, context) {
+	const pathMode = getMode(node_path.default.resolve(context.root, context.output.path));
+	const baseName = `${pathMode === "single" ? "" : this.default(name, "file")}${extname}`;
+	const filePath = this.resolvePath({
+		baseName,
+		pathMode,
+		tag,
+		path: groupPath
+	}, context);
+	return (0, _kubb_ast.createFile)({
+		path: filePath,
+		baseName: node_path.default.basename(filePath),
+		meta: { pluginName: this.pluginName },
+		sources: [],
+		imports: [],
+		exports: []
+	});
+}
+/**
+* Generates the default "Generated by Kubb" banner from config and optional node metadata.
+*/
+function buildDefaultBanner({ title, description, version, config }) {
+	try {
+		let source = "";
+		if (Array.isArray(config.input)) {
+			const first = config.input[0];
+			if (first && "path" in first) source = node_path.default.basename(first.path);
+		} else if ("path" in config.input) source = node_path.default.basename(config.input.path);
+		else if ("data" in config.input) source = "text content";
+		let banner = "/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n";
+		if (config.output.defaultBanner === "simple") {
+			banner += "*/\n";
+			return banner;
+		}
+		if (source) banner += `* Source: ${source}\n`;
+		if (title) banner += `* Title: ${title}\n`;
+		if (description) {
+			const formattedDescription = description.replace(/\n/gm, "\n* ");
+			banner += `* Description: ${formattedDescription}\n`;
+		}
+		if (version) banner += `* OpenAPI spec version: ${version}\n`;
+		banner += "*/\n";
+		return banner;
+	} catch (_error) {
+		return "/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n*/";
+	}
+}
+/**
+* Default banner resolver — returns the banner string for a generated file.
+*
+* A user-supplied `output.banner` overrides the default Kubb "Generated by Kubb" notice.
+* When no `output.banner` is set, the Kubb notice is used (including `title` and `version`
+* from the OAS spec when a `node` is provided).
+*
+* - When `output.banner` is a function and `node` is provided, returns `output.banner(node)`.
+* - When `output.banner` is a function and `node` is absent, falls back to the Kubb notice.
+* - When `output.banner` is a string, returns it directly.
+* - When `config.output.defaultBanner` is `false`, returns `undefined`.
+* - Otherwise returns the Kubb "Generated by Kubb" notice.
+*
+* @example String banner overrides default
+* ```ts
+* defaultResolveBanner(undefined, { output: { banner: '// my banner' }, config })
+* // → '// my banner'
+* ```
+*
+* @example Function banner with node
+* ```ts
+* defaultResolveBanner(inputNode, { output: { banner: (node) => `// v${node.version}` }, config })
+* // → '// v3.0.0'
+* ```
+*
+* @example No user banner — Kubb notice with OAS metadata
+* ```ts
+* defaultResolveBanner(inputNode, { config })
+* // → '/** Generated by Kubb ... Title: Pet Store ... *\/'
+* ```
+*
+* @example Disabled default banner
+* ```ts
+* defaultResolveBanner(undefined, { config: { output: { defaultBanner: false }, ...config } })
+* // → undefined
+* ```
+*/
+function defaultResolveBanner(node, { output, config }) {
+	if (typeof output?.banner === "function") return output.banner(node);
+	if (typeof output?.banner === "string") return output.banner;
+	if (config.output.defaultBanner === false) return;
+	return buildDefaultBanner({
+		title: node?.meta?.title,
+		version: node?.meta?.version,
+		config
+	});
+}
+/**
+* Default footer resolver — returns the footer string for a generated file.
+*
+* - When `output.footer` is a function and `node` is provided, calls it with the node.
+* - When `output.footer` is a function and `node` is absent, returns `undefined`.
+* - When `output.footer` is a string, returns it directly.
+* - Otherwise returns `undefined`.
+*
+* @example String footer
+* ```ts
+* defaultResolveFooter(undefined, { output: { footer: '// end of file' }, config })
+* // → '// end of file'
+* ```
+*
+* @example Function footer with node
+* ```ts
+* defaultResolveFooter(inputNode, { output: { footer: (node) => `// ${node.title}` }, config })
+* // → '// Pet Store'
+* ```
+*/
+function defaultResolveFooter(node, { output }) {
+	if (typeof output?.footer === "function") return node ? output.footer(node) : void 0;
+	if (typeof output?.footer === "string") return output.footer;
+}
+/**
+* Defines a resolver for a plugin, injecting built-in defaults for name casing,
+* include/exclude/override filtering, path resolution, and file construction.
+*
+* All four defaults can be overridden by providing them in the builder function:
+* - `default` — name casing strategy (camelCase / PascalCase)
+* - `resolveOptions` — include/exclude/override filtering
+* - `resolvePath` — output path computation
+* - `resolveFile` — full `FileNode` construction
+*
+* Methods in the builder have access to `this` (the full resolver object), so they
+* can call other resolver methods without circular imports.
+*
+* @example Basic resolver with naming helpers
+* ```ts
+* export const resolver = defineResolver<PluginTs>(() => ({
+*   name: 'default',
+*   resolveName(node) {
+*     return this.default(node.name, 'function')
+*   },
+*   resolveTypedName(node) {
+*     return this.default(node.name, 'type')
+*   },
+* }))
+* ```
+*
+* @example Override resolvePath for a custom output structure
+* ```ts
+* export const resolver = defineResolver<PluginTs>(() => ({
+*   name: 'custom',
+*   resolvePath({ baseName }, { root, output }) {
+*     return path.resolve(root, output.path, 'generated', baseName)
+*   },
+* }))
+* ```
+*
+* @example Use this.default inside a helper
+* ```ts
+* export const resolver = defineResolver<PluginTs>(() => ({
+*   name: 'default',
+*   resolveParamName(node, param) {
+*     return this.default(`${node.operationId} ${param.in} ${param.name}`, 'type')
+*   },
+* }))
+* ```
+*/
+function defineResolver(build) {
+	return {
+		default: defaultResolver,
+		resolveOptions: defaultResolveOptions,
+		resolvePath: defaultResolvePath,
+		resolveFile: defaultResolveFile,
+		resolveBanner: defaultResolveBanner,
+		resolveFooter: defaultResolveFooter,
+		...build()
+	};
+}
+//#endregion
+//#region src/devtools.ts
+/**
+* Encodes an `InputNode` as a compressed, URL-safe string.
+*
+* The JSON representation is deflate-compressed with {@link deflateSync} before
+* base64url encoding, which typically reduces payload size by 70–80 % and
+* keeps URLs well within browser and server path-length limits.
+*
+* Use {@link decodeAst} to reverse.
+*/
+function encodeAst(input) {
+	const compressed = (0, fflate.deflateSync)(new TextEncoder().encode(JSON.stringify(input)));
+	return Buffer.from(compressed).toString("base64url");
+}
+/**
+* Constructs the Kubb Studio URL for the given `InputNode`.
+* When `options.ast` is `true`, navigates to the AST inspector (`/ast`).
+* The `input` is encoded and attached as the `?root=` query parameter so Studio
+* can decode and render it without a round-trip to any server.
+*/
+function getStudioUrl(input, studioUrl, options = {}) {
+	return `${studioUrl.replace(/\/$/, "")}${options.ast ? "/ast" : ""}?root=${encodeAst(input)}`;
+}
+/**
+* Opens the Kubb Studio URL for the given `InputNode` in the default browser —
+*
+* Falls back to printing the URL if the browser cannot be launched.
+*/
+async function openInStudio(input, studioUrl, options = {}) {
+	const url = getStudioUrl(input, studioUrl, options);
+	const cmd = process.platform === "win32" ? "cmd" : process.platform === "darwin" ? "open" : "xdg-open";
+	const args = process.platform === "win32" ? [
+		"/c",
+		"start",
+		"",
+		url
+	] : [url];
+	try {
+		await (0, tinyexec.x)(cmd, args);
+	} catch {
+		console.log(`\n  ${url}\n`);
+	}
+}
+//#endregion
+//#region src/FileManager.ts
+function mergeFile(a, b) {
+	return {
+		...a,
+		sources: [...a.sources || [], ...b.sources || []],
+		imports: [...a.imports || [], ...b.imports || []],
+		exports: [...a.exports || [], ...b.exports || []]
+	};
+}
+/**
+* In-memory file store for generated files.
+*
+* Files with the same `path` are merged — sources, imports, and exports are concatenated.
+* The `files` getter returns all stored files sorted by path length (shortest first).
+*
+* @example
+* ```ts
+* import { FileManager } from '@kubb/core'
+*
+* const manager = new FileManager()
+* manager.upsert(myFile)
+* console.log(manager.files) // all stored files
+* ```
+*/
+var FileManager = class {
+	#cache = /* @__PURE__ */ new Map();
+	#filesCache = null;
+	/**
+	* Adds one or more files. Files with the same path are merged — sources, imports,
+	* and exports from all calls with the same path are concatenated together.
+	*/
+	add(...files) {
+		const resolvedFiles = [];
+		const mergedFiles = /* @__PURE__ */ new Map();
+		files.forEach((file) => {
+			const existing = mergedFiles.get(file.path);
+			if (existing) mergedFiles.set(file.path, mergeFile(existing, file));
+			else mergedFiles.set(file.path, file);
+		});
+		for (const file of mergedFiles.values()) {
+			const resolvedFile = (0, _kubb_ast.createFile)(file);
+			this.#cache.set(resolvedFile.path, resolvedFile);
+			this.#filesCache = null;
+			resolvedFiles.push(resolvedFile);
+		}
+		return resolvedFiles;
+	}
+	/**
+	* Adds or merges one or more files.
+	* If a file with the same path already exists, its sources/imports/exports are merged together.
+	*/
+	upsert(...files) {
+		const resolvedFiles = [];
+		const mergedFiles = /* @__PURE__ */ new Map();
+		files.forEach((file) => {
+			const existing = mergedFiles.get(file.path);
+			if (existing) mergedFiles.set(file.path, mergeFile(existing, file));
+			else mergedFiles.set(file.path, file);
+		});
+		for (const file of mergedFiles.values()) {
+			const existing = this.#cache.get(file.path);
+			const resolvedFile = (0, _kubb_ast.createFile)(existing ? mergeFile(existing, file) : file);
+			this.#cache.set(resolvedFile.path, resolvedFile);
+			this.#filesCache = null;
+			resolvedFiles.push(resolvedFile);
+		}
+		return resolvedFiles;
+	}
+	getByPath(path) {
+		return this.#cache.get(path) ?? null;
+	}
+	deleteByPath(path) {
+		this.#cache.delete(path);
+		this.#filesCache = null;
+	}
+	clear() {
+		this.#cache.clear();
+		this.#filesCache = null;
+	}
+	/**
+	* All stored files, sorted by path length (shorter paths first).
+	* Barrel/index files (e.g. index.ts) are sorted last within each length bucket.
+	*/
+	get files() {
+		if (this.#filesCache) return this.#filesCache;
+		const keys = [...this.#cache.keys()].sort((a, b) => {
+			if (a.length !== b.length) return a.length - b.length;
+			const aIsIndex = trimExtName$1(a).endsWith("index");
+			if (aIsIndex !== trimExtName$1(b).endsWith("index")) return aIsIndex ? 1 : -1;
+			return 0;
+		});
+		const files = [];
+		for (const key of keys) {
+			const file = this.#cache.get(key);
+			if (file) files.push(file);
+		}
+		this.#filesCache = files;
+		return files;
+	}
+};
+//#endregion
+//#region src/renderNode.ts
+/**
+* Handles the return value of a plugin AST hook or generator method.
+*
+* - Renderer output → rendered via the provided `rendererFactory` (e.g. JSX), files stored in `driver.fileManager`
+* - `Array<FileNode>` → added directly into `driver.fileManager`
+* - `void` / `null` / `undefined` → no-op (plugin handled it via `this.upsertFile`)
+*
+* Pass a `rendererFactory` (e.g. `jsxRenderer` from `@kubb/renderer-jsx`) when the result
+* may be a renderer element. Generators that only return `Array<FileNode>` do not need one.
+*/
+async function applyHookResult(result, driver, rendererFactory) {
+	if (!result) return;
+	if (Array.isArray(result)) {
+		driver.fileManager.upsert(...result);
+		return;
+	}
+	if (!rendererFactory) return;
+	const renderer = rendererFactory();
+	await renderer.render(result);
+	driver.fileManager.upsert(...renderer.files);
+	renderer.unmount();
+}
+//#endregion
+//#region src/utils/executeStrategies.ts
+/**
+* Runs promise functions in sequence, threading each result into the next call.
+*
+* - Each function receives the accumulated state from the previous call.
+* - Skips functions that return a falsy value (acts as a no-op for that step).
+* - Returns an array of all individual results.
+*  @deprecated
+*/
+function hookSeq(promises) {
+	return promises.filter(Boolean).reduce((promise, func) => {
+		if (typeof func !== "function") throw new Error("HookSeq needs a function that returns a promise `() => Promise<unknown>`");
+		return promise.then((state) => {
+			const calledFunc = func(state);
+			if (calledFunc) return calledFunc.then(Array.prototype.concat.bind(state));
+			return state;
+		});
+	}, Promise.resolve([]));
+}
+/**
+* Runs promise functions in sequence and returns the first non-null result.
+*
+* - Stops as soon as `nullCheck` passes for a result (default: `!== null`).
+* - Subsequent functions are skipped once a match is found.
+*  @deprecated
+*/
+function hookFirst(promises, nullCheck = (state) => state !== null) {
+	let promise = Promise.resolve(null);
+	for (const func of promises.filter(Boolean)) promise = promise.then((state) => {
+		if (nullCheck(state)) return state;
+		return func(state);
+	});
+	return promise;
+}
+/**
+* Runs promise functions concurrently and returns all settled results.
+*
+* - Limits simultaneous executions to `concurrency` (default: unlimited).
+* - Uses `Promise.allSettled` so individual failures do not cancel other tasks.
+*  @deprecated
+*/
+function hookParallel(promises, concurrency = Number.POSITIVE_INFINITY) {
+	const limit = pLimit(concurrency);
+	const tasks = promises.filter(Boolean).map((promise) => limit(() => promise()));
+	return Promise.allSettled(tasks);
+}
+//#endregion
+//#region src/PluginDriver.ts
+/**
+* Returns `'single'` when `fileOrFolder` has a file extension, `'split'` otherwise.
+*
+* @example
+* ```ts
+* getMode('src/gen/types.ts')  // 'single'
+* getMode('src/gen/types')     // 'split'
+* ```
+*/
+function getMode(fileOrFolder) {
+	if (!fileOrFolder) return "split";
+	return (0, node_path.extname)(fileOrFolder) ? "single" : "split";
+}
+const hookFirstNullCheck = (state) => !!state?.result;
+var PluginDriver = class {
 	config;
 	options;
 	/**
@@ -1122,25 +1566,259 @@ var PluginDriver = class {
 	*/
 	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;
-		config.plugins.map((plugin) => Object.assign({
-			buildStart() {},
-			buildEnd() {}
-		}, plugin)).filter((plugin) => {
+		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.pre?.includes(a.name)) return 1;
-			if (b.post?.includes(a.name)) return -1;
+			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 events() {
-		return this.options.events;
+	get hooks() {
+		if (!this.options.hooks) throw new Error("hooks are not defined");
+		return this.options.hooks;
+	}
+	/**
+	* Creates a `Plugin`-compatible object from a hook-style plugin and registers
+	* its lifecycle handlers on the `AsyncEventEmitter`.
+	*
+	* The normalized plugin has an empty `buildStart` — generators registered via
+	* `addGenerator()` in `kubb:plugin:setup` are stored on `normalizedPlugin.generators`
+	* and used by `runPluginAstHooks` during the build.
+	*/
+	#normalizeHookStylePlugin(hookPlugin) {
+		const generators = [];
+		const driver = this;
+		const normalizedPlugin = {
+			name: hookPlugin.name,
+			dependencies: hookPlugin.dependencies,
+			options: {
+				output: { path: "." },
+				exclude: [],
+				override: []
+			},
+			generators,
+			inject: () => void 0,
+			resolveName(name, type) {
+				return driver.getResolver(hookPlugin.name).default(name, type);
+			},
+			resolvePath(baseName, pathMode, resolveOptions) {
+				const resolver = driver.getResolver(hookPlugin.name);
+				const opts = normalizedPlugin.options;
+				const group = resolveOptions?.group;
+				return resolver.resolvePath({
+					baseName,
+					pathMode,
+					tag: group?.tag,
+					path: group?.path
+				}, {
+					root: (0, node_path.resolve)(driver.config.root, driver.config.output.path),
+					output: opts.output,
+					group: opts.group
+				});
+			},
+			buildStart() {},
+			buildEnd() {}
+		};
+		this.registerPluginHooks(hookPlugin, normalizedPlugin);
+		return normalizedPlugin;
+	}
+	/**
+	* Registers a hook-style plugin's lifecycle handlers on the shared `AsyncEventEmitter`.
+	*
+	* For `kubb:plugin:setup`, the registered listener wraps the globally emitted context with a
+	* plugin-specific one so that `addGenerator`, `setResolver`, `setTransformer`, and
+	* `setRenderer` all target the correct `normalizedPlugin` entry in the plugins map.
+	*
+	* All other hooks are iterated and registered directly as pass-through listeners.
+	* Any event key present in the global `KubbHooks` interface can be subscribed to.
+	*
+	* External tooling can subscribe to any of these events via `hooks.on(...)` to observe
+	* the plugin lifecycle without modifying plugin behavior.
+	*/
+	registerPluginHooks(hookPlugin, normalizedPlugin) {
+		const { hooks } = hookPlugin;
+		if (hooks["kubb:plugin:setup"]) {
+			const setupHandler = (globalCtx) => {
+				const pluginCtx = {
+					...globalCtx,
+					options: hookPlugin.options ?? {},
+					addGenerator: (gen) => {
+						this.registerGenerator(normalizedPlugin.name, gen);
+					},
+					setResolver: (resolver) => {
+						this.setPluginResolver(normalizedPlugin.name, resolver);
+					},
+					setTransformer: (visitor) => {
+						normalizedPlugin.transformer = visitor;
+					},
+					setRenderer: (renderer) => {
+						normalizedPlugin.renderer = renderer;
+					},
+					setOptions: (opts) => {
+						normalizedPlugin.options = {
+							...normalizedPlugin.options,
+							...opts
+						};
+					},
+					injectFile: (file) => {
+						const fileNode = (0, _kubb_ast.createFile)({
+							baseName: file.baseName,
+							path: file.path,
+							sources: file.sources ?? [],
+							imports: [],
+							exports: []
+						});
+						this.fileManager.add(fileNode);
+					}
+				};
+				return hooks["kubb:plugin:setup"](pluginCtx);
+			};
+			this.hooks.on("kubb:plugin:setup", setupHandler);
+			this.#trackHookListener("kubb:plugin:setup", setupHandler);
+		}
+		for (const [event, handler] of Object.entries(hooks)) {
+			if (event === "kubb:plugin:setup" || !handler) continue;
+			this.hooks.on(event, handler);
+			this.#trackHookListener(event, handler);
+		}
+	}
+	/**
+	* Emits the `kubb:plugin:setup` event so that all registered hook-style plugin listeners
+	* can configure generators, resolvers, transformers and renderers before `buildStart` runs.
+	*
+	* Call this once from `safeBuild` before the plugin execution loop begins.
+	*/
+	async emitSetupHooks() {
+		await this.hooks.emit("kubb:plugin:setup", {
+			config: this.config,
+			addGenerator: () => {},
+			setResolver: () => {},
+			setTransformer: () => {},
+			setRenderer: () => {},
+			setOptions: () => {},
+			injectFile: () => {},
+			updateConfig: () => {},
+			options: {}
+		});
+	}
+	/**
+	* Registers a generator for the given plugin on the shared event emitter.
+	*
+	* The generator's `schema`, `operation`, and `operations` methods are registered as
+	* listeners on `kubb:generate:schema`, `kubb:generate:operation`, and `kubb:generate:operations`
+	* respectively. Each listener is scoped to the owning plugin via a `ctx.plugin.name` check
+	* so that generators from different plugins do not cross-fire.
+	*
+	* The renderer resolution chain is: `generator.renderer → plugin.renderer → config.renderer`.
+	* Set `generator.renderer = null` to explicitly opt out of rendering even when the plugin
+	* declares a renderer.
+	*
+	* Call this method inside `addGenerator()` (in `kubb:plugin:setup`) to wire up a generator.
+	*/
+	registerGenerator(pluginName, gen) {
+		const resolveRenderer = () => {
+			const plugin = this.plugins.get(pluginName);
+			return gen.renderer === null ? void 0 : gen.renderer ?? plugin?.renderer ?? this.config.renderer;
+		};
+		if (gen.schema) {
+			const schemaHandler = async (node, ctx) => {
+				if (ctx.plugin.name !== pluginName) return;
+				await applyHookResult(await gen.schema(node, ctx), this, resolveRenderer());
+			};
+			this.hooks.on("kubb:generate:schema", schemaHandler);
+			this.#trackHookListener("kubb:generate:schema", schemaHandler);
+		}
+		if (gen.operation) {
+			const operationHandler = async (node, ctx) => {
+				if (ctx.plugin.name !== pluginName) return;
+				await applyHookResult(await gen.operation(node, ctx), this, resolveRenderer());
+			};
+			this.hooks.on("kubb:generate:operation", operationHandler);
+			this.#trackHookListener("kubb:generate:operation", operationHandler);
+		}
+		if (gen.operations) {
+			const operationsHandler = async (nodes, ctx) => {
+				if (ctx.plugin.name !== pluginName) return;
+				await applyHookResult(await gen.operations(nodes, ctx), this, resolveRenderer());
+			};
+			this.hooks.on("kubb:generate:operations", operationsHandler);
+			this.#trackHookListener("kubb:generate:operations", operationsHandler);
+		}
+		this.#pluginsWithEventGenerators.add(pluginName);
+	}
+	/**
+	* Returns `true` when at least one generator was registered for the given plugin
+	* via `addGenerator()` in `kubb:plugin:setup` (event-based path).
+	*
+	* Used by the build loop to decide whether to walk the AST and emit generator events
+	* for a plugin that has no static `plugin.generators`.
+	*/
+	hasRegisteredGenerators(pluginName) {
+		return this.#pluginsWithEventGenerators.has(pluginName);
+	}
+	dispose() {
+		for (const [event, handlers] of this.#hookListeners) for (const handler of handlers) this.hooks.off(event, handler);
+		this.#hookListeners.clear();
+		this.#pluginsWithEventGenerators.clear();
+	}
+	#trackHookListener(event, handler) {
+		let handlers = this.#hookListeners.get(event);
+		if (!handlers) {
+			handlers = /* @__PURE__ */ new Set();
+			this.#hookListeners.set(event, handlers);
+		}
+		handlers.add(handler);
+	}
+	#createDefaultResolver(pluginName) {
+		const existingResolver = this.#defaultResolvers.get(pluginName);
+		if (existingResolver) return existingResolver;
+		const resolver = defineResolver(() => ({
+			name: "default",
+			pluginName
+		}));
+		this.#defaultResolvers.set(pluginName, resolver);
+		return resolver;
+	}
+	setPluginResolver(pluginName, partial) {
+		const merged = {
+			...this.#createDefaultResolver(pluginName),
+			...partial
+		};
+		this.#resolvers.set(pluginName, merged);
+		const plugin = this.plugins.get(pluginName);
+		if (plugin) plugin.resolver = merged;
+	}
+	getResolver(pluginName) {
+		const dynamicResolver = this.#resolvers.get(pluginName);
+		if (dynamicResolver) return dynamicResolver;
+		const pluginResolver = this.plugins.get(pluginName)?.resolver;
+		if (pluginResolver) return pluginResolver;
+		return this.#createDefaultResolver(pluginName);
 	}
 	getContext(plugin) {
 		const driver = this;
@@ -1152,7 +1830,7 @@ var PluginDriver = class {
 			getMode(output) {
 				return getMode((0, node_path.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),
@@ -1170,19 +1848,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;
@@ -1193,10 +1871,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,
@@ -1272,7 +1953,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]
 		});
@@ -1282,7 +1963,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];
 	}
 	/**
@@ -1305,7 +1986,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
 		});
@@ -1323,7 +2004,7 @@ var PluginDriver = class {
 				});
 			};
 		}), hookFirstNullCheck);
-		this.events.emit("plugins:hook:progress:end", { hookName });
+		this.hooks.emit("kubb:plugins:hook:progress:end", { hookName });
 		return result;
 	}
 	/**
@@ -1348,12 +2029,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
 		});
@@ -1374,7 +2055,7 @@ var PluginDriver = class {
 				const plugin = plugins[index];
 				if (plugin) {
 					const startTime = pluginStartTimes.get(plugin) ?? node_perf_hooks.performance.now();
-					this.events.emit("error", result.reason, {
+					this.hooks.emit("kubb:error", result.reason, {
 						plugin,
 						hookName,
 						strategy: "hookParallel",
@@ -1384,19 +2065,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
 		});
@@ -1408,7 +2089,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);
@@ -1419,13 +2100,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(node_perf_hooks.performance.now() - startTime),
 			parameters,
 			output,
@@ -1437,7 +2115,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,
@@ -1457,7 +2135,7 @@ var PluginDriver = class {
 				});
 				return output;
 			} catch (error) {
-				this.events.emit("error", error, {
+				this.hooks.emit("kubb:error", error, {
 					plugin,
 					hookName,
 					strategy,
@@ -1468,15 +2146,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,
@@ -1495,7 +2170,7 @@ var PluginDriver = class {
 			});
 			return output;
 		} catch (error) {
-			this.events.emit("error", error, {
+			this.hooks.emit("kubb:error", error, {
 				plugin,
 				hookName,
 				strategy,
@@ -1506,26 +2181,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 = (0, _kubb_renderer_jsx.createRenderer)();
-	await renderer.render(/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx_jsx_runtime.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.
@@ -1623,7 +2278,7 @@ const fsStorage = createStorage(() => ({
 }));
 //#endregion
 //#region package.json
-var version = "5.0.0-alpha.33";
+var version = "5.0.0-alpha.35";
 //#endregion
 //#region src/utils/diagnostics.ts
 /**
@@ -1884,24 +2539,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:",
@@ -1920,7 +2565,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}`]
 			});
@@ -1933,8 +2578,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: {
@@ -1952,26 +2597,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((0, node_path.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`,
@@ -1981,53 +2626,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 (0, _kubb_ast.walk)(inputNode, {
 		depth: "shallow",
 		async schema(node) {
-			if (!plugin.schema) return;
 			const transformedNode = plugin.transformer ? (0, _kubb_ast.transform)(node, plugin.transformer) : node;
 			const options = resolver.resolveOptions(transformedNode, {
 				options: plugin.options,
@@ -2036,7 +2660,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 ? (0, _kubb_ast.transform)(node, plugin.transformer) : node;
@@ -2048,28 +2680,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();
@@ -2077,13 +2724,13 @@ async function safeBuild(options, overrides) {
 			const root = (0, node_path.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",
@@ -2095,11 +2742,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)})`]
 				});
@@ -2107,12 +2754,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",
@@ -2131,7 +2778,7 @@ async function safeBuild(options, overrides) {
 		if (config.output.barrelType) {
 			const rootPath = (0, node_path.resolve)((0, node_path.resolve)(config.root), config.output.path, BARREL_FILENAME);
 			const rootDir = (0, node_path.dirname)(rootPath);
-			await events.emit("debug", {
+			await hooks.emit("kubb:debug", {
 				date: /* @__PURE__ */ new Date(),
 				logs: [
 					"Generating barrel file",
@@ -2142,7 +2789,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`]
 			});
@@ -2162,7 +2809,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)`]
 			});
@@ -2171,7 +2818,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...`]
 		});
@@ -2179,591 +2826,272 @@ async function safeBuild(options, overrides) {
 			parsers: parsersMap,
 			extension: config.output.extension,
 			onStart: async (processingFiles) => {
-				await events.emit("files:processing:start", processingFiles);
+				await hooks.emit("kubb:files:processing:start", processingFiles);
 			},
 			onUpdate: async ({ file, source, processed, total, percentage }) => {
-				await events.emit("file:processing:update", {
+				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 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 [(0, _kubb_ast.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 : (0, node_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: (0, node_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);
+					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 ((0, _kubb_ast.isOperationNode)(node)) {
-		if (exclude.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) return null;
-		if (include && !include.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) return null;
-		const overrideOptions = override.find(({ type, pattern }) => matchesOperationPattern(node, type, pattern))?.options;
+		await hooks.emit("kubb:build:end", {
+			files,
+			config,
+			outputDir: (0, node_path.resolve)(config.root, config.output.path)
+		});
 		return {
-			...options,
-			...overrideOptions
+			failedPlugins,
+			files,
+			driver,
+			pluginTimings,
+			sources
 		};
-	}
-	if ((0, _kubb_ast.isSchemaNode)(node)) {
-		if (exclude.some(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)) return null;
-		if (include) {
-			const applicable = include.map(({ type, pattern }) => matchesSchemaPattern(node, type, pattern)).filter((r) => r !== null);
-			if (applicable.length > 0 && !applicable.includes(true)) return null;
-		}
-		const overrideOptions = override.find(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)?.options;
+	} 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(node_path.default.resolve(root, output.path))) === "single") return node_path.default.resolve(root, output.path);
-	if (group && (groupPath || tag)) return node_path.default.resolve(root, output.path, group.name({ group: group.type === "path" ? groupPath : tag }), baseName);
-	return node_path.default.resolve(root, output.path, baseName);
+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 [(0, _kubb_ast.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 : (0, node_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: (0, node_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(node_path.default.resolve(context.root, context.output.path));
-	const baseName = `${pathMode === "single" ? "" : this.default(name, "file")}${extname}`;
-	const filePath = this.resolvePath({
-		baseName,
-		pathMode,
-		tag,
-		path: groupPath
-	}, context);
-	return (0, _kubb_ast.createFile)({
-		path: filePath,
-		baseName: node_path.default.basename(filePath),
-		meta: { pluginName: this.pluginName },
-		sources: [],
-		imports: [],
-		exports: []
-	});
-}
-/**
-* Generates the default "Generated by Kubb" banner from config and optional node metadata.
-*/
-function buildDefaultBanner({ title, description, version, config }) {
-	try {
-		let source = "";
-		if (Array.isArray(config.input)) {
-			const first = config.input[0];
-			if (first && "path" in first) source = node_path.default.basename(first.path);
-		} else if ("path" in config.input) source = node_path.default.basename(config.input.path);
-		else if ("data" in config.input) source = "text content";
-		let banner = "/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n";
-		if (config.output.defaultBanner === "simple") {
-			banner += "*/\n";
-			return banner;
-		}
-		if (source) banner += `* Source: ${source}\n`;
-		if (title) banner += `* Title: ${title}\n`;
-		if (description) {
-			const formattedDescription = description.replace(/\n/gm, "\n* ");
-			banner += `* Description: ${formattedDescription}\n`;
+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 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
 /**
-* 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.
+* 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
@@ -2853,22 +3181,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 (0, remeda.sortBy)(items.filter(Boolean), ([_key, item]) => {
@@ -2987,47 +3299,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 ? (0, _kubb_ast.composeTransformers)(...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.
@@ -3069,7 +3340,7 @@ async function detectLinter() {
 //#endregion
 //#region src/utils/packageJSON.ts
 function getPackageJSONSync(cwd) {
-	const pkgPath = empathic_package.up({ cwd });
+	const pkgPath = findPackageJSON(cwd);
 	if (!pkgPath) return null;
 	return JSON.parse(readSync(pkgPath));
 }
@@ -3114,7 +3385,12 @@ exports.AsyncEventEmitter = AsyncEventEmitter;
 exports.FunctionParams = FunctionParams;
 exports.PluginDriver = PluginDriver;
 exports.URLPath = URLPath;
-exports.build = build;
+Object.defineProperty(exports, "ast", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast;
+	}
+});
 exports.buildDefaultBanner = buildDefaultBanner;
 Object.defineProperty(exports, "composeTransformers", {
 	enumerable: true,
@@ -3124,19 +3400,19 @@ Object.defineProperty(exports, "composeTransformers", {
 });
 exports.createAdapter = createAdapter;
 exports.createFunctionParams = createFunctionParams;
+exports.createKubb = createKubb;
 exports.createPlugin = createPlugin;
+exports.createRenderer = createRenderer;
 exports.createStorage = createStorage;
-exports.default = build;
 exports.defaultResolveBanner = defaultResolveBanner;
 exports.defaultResolveFile = defaultResolveFile;
 exports.defaultResolveFooter = defaultResolveFooter;
 exports.defaultResolveOptions = defaultResolveOptions;
 exports.defaultResolvePath = defaultResolvePath;
-exports.defineConfig = defineConfig;
 exports.defineGenerator = defineGenerator;
 exports.defineLogger = defineLogger;
 exports.defineParser = defineParser;
-exports.definePresets = definePresets;
+exports.definePlugin = definePlugin;
 Object.defineProperty(exports, "definePrinter", {
 	enumerable: true,
 	get: function() {
@@ -3149,17 +3425,12 @@ exports.detectLinter = detectLinter;
 exports.formatters = formatters;
 exports.fsStorage = fsStorage;
 exports.getBarrelFiles = getBarrelFiles;
-exports.getConfigs = getConfigs;
 exports.getFunctionParams = getFunctionParams;
 exports.getMode = getMode;
-exports.getPreset = getPreset;
 exports.isInputPath = isInputPath;
 exports.linters = linters;
 exports.logLevel = logLevel;
 exports.memoryStorage = memoryStorage;
-exports.mergeGenerators = mergeGenerators;
-exports.safeBuild = safeBuild;
 exports.satisfiesDependency = satisfiesDependency;
-exports.setup = setup;
 
 //# sourceMappingURL=index.cjs.map