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

package/dist/index.cjs

@@ -1,200 +1,87 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_PluginDriver = require("./PluginDriver-Ds-Us-e4.cjs");
-let node_events = require("node:events");
+const require_memoryStorage = require("./memoryStorage-Dkxnid2K.cjs");
+let node_util = require("node:util");
+let node_crypto = require("node:crypto");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
+let node_dns = require("node:dns");
 let _kubb_ast = require("@kubb/ast");
-_kubb_ast = require_PluginDriver.__toESM(_kubb_ast, 1);
+_kubb_ast = require_memoryStorage.__toESM(_kubb_ast, 1);
 let node_process = require("node:process");
-//#region ../../internals/utils/src/errors.ts
+node_process = require_memoryStorage.__toESM(node_process, 1);
+let node_os = require("node:os");
+node_os = require_memoryStorage.__toESM(node_os, 1);
+//#region ../../internals/utils/src/colors.ts
 /**
-* Thrown when one or more errors occur during a Kubb build.
-* Carries the full list of underlying errors on `errors`.
-*
-* @example
-* ```ts
-* throw new BuildError('Build failed', { errors: [err1, err2] })
-* ```
+* Parses a CSS hex color string (`#RGB`) into its RGB channels.
+* Falls back to `255` for any channel that cannot be parsed.
 */
-var BuildError = class extends Error {
-	errors;
-	constructor(message, options) {
-		super(message, { cause: options.cause });
-		this.name = "BuildError";
-		this.errors = options.errors;
-	}
-};
-/**
-* Coerces an unknown thrown value to an `Error` instance.
-* Returns the value as-is when it is already an `Error`; otherwise wraps it with `String(value)`.
-*
-* @example
-* ```ts
-* try { ... } catch(err) {
-*   throw new BuildError('Build failed', { cause: toError(err), errors: [] })
-* }
-* ```
-*/
-function toError(value) {
-	return value instanceof Error ? value : new Error(String(value));
+function parseHex(color) {
+	const int = Number.parseInt(color.replace("#", ""), 16);
+	return Number.isNaN(int) ? {
+		r: 255,
+		g: 255,
+		b: 255
+	} : {
+		r: int >> 16 & 255,
+		g: int >> 8 & 255,
+		b: int & 255
+	};
 }
-//#endregion
-//#region ../../internals/utils/src/asyncEventEmitter.ts
 /**
-* Typed `EventEmitter` that awaits all async listeners before resolving.
-* Wraps Node's `EventEmitter` with full TypeScript event-map inference.
-*
-* @example
-* ```ts
-* const emitter = new AsyncEventEmitter<{ build: [name: string] }>()
-* emitter.on('build', async (name) => { console.log(name) })
-* await emitter.emit('build', 'petstore') // all listeners awaited
-* ```
+* Returns a function that wraps a string in a 24-bit ANSI true-color escape sequence
+* for the given hex color.
 */
-var AsyncEventEmitter = class {
-	/**
-	* Maximum number of listeners per event before Node emits a memory-leak warning.
-	* @default 10
-	*/
-	constructor(maxListener = 10) {
-		this.#emitter.setMaxListeners(maxListener);
-	}
-	#emitter = new node_events.EventEmitter();
-	/**
-	* Emits `eventName` and awaits all registered listeners sequentially.
-	* Throws if any listener rejects, wrapping the cause with the event name and serialized arguments.
-	*
-	* @example
-	* ```ts
-	* await emitter.emit('build', 'petstore')
-	* ```
-	*/
-	async emit(eventName, ...eventArgs) {
-		const listeners = this.#emitter.listeners(eventName);
-		if (listeners.length === 0) return;
-		for (const listener of listeners) try {
-			await listener(...eventArgs);
-		} catch (err) {
-			let serializedArgs;
-			try {
-				serializedArgs = JSON.stringify(eventArgs);
-			} catch {
-				serializedArgs = String(eventArgs);
-			}
-			throw new Error(`Error in async listener for "${eventName}" with eventArgs ${serializedArgs}`, { cause: toError(err) });
-		}
-	}
-	/**
-	* Registers a persistent listener for `eventName`.
-	*
-	* @example
-	* ```ts
-	* emitter.on('build', async (name) => { console.log(name) })
-	* ```
-	*/
-	on(eventName, handler) {
-		this.#emitter.on(eventName, handler);
-	}
-	/**
-	* Registers a one-shot listener that removes itself after the first invocation.
-	*
-	* @example
-	* ```ts
-	* emitter.onOnce('build', async (name) => { console.log(name) })
-	* ```
-	*/
-	onOnce(eventName, handler) {
-		const wrapper = (...args) => {
-			this.off(eventName, wrapper);
-			return handler(...args);
-		};
-		this.on(eventName, wrapper);
-	}
-	/**
-	* Removes a previously registered listener.
-	*
-	* @example
-	* ```ts
-	* emitter.off('build', handler)
-	* ```
-	*/
-	off(eventName, handler) {
-		this.#emitter.off(eventName, handler);
-	}
-	/**
-	* Returns the number of listeners registered for `eventName`.
-	*
-	* @example
-	* ```ts
-	* emitter.on('build', handler)
-	* emitter.listenerCount('build') // 1
-	* ```
-	*/
-	listenerCount(eventName) {
-		return this.#emitter.listenerCount(eventName);
-	}
-	/**
-	* Removes all listeners from every event channel.
-	*
-	* @example
-	* ```ts
-	* emitter.removeAll()
-	* ```
-	*/
-	removeAll() {
-		this.#emitter.removeAllListeners();
-	}
-};
-//#endregion
-//#region ../../internals/utils/src/time.ts
+function hex(color) {
+	const { r, g, b } = parseHex(color);
+	return (text) => `\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`;
+}
+hex("#F55A17"), hex("#F5A217"), hex("#F58517"), hex("#B45309"), hex("#FFFFFF"), hex("#adadc6"), hex("#FDA4AF");
 /**
-* Calculates elapsed time in milliseconds from a high-resolution `process.hrtime` start time.
-* Rounds to 2 decimal places for sub-millisecond precision without noise.
-*
-* @example
-* ```ts
-* const start = process.hrtime()
-* doWork()
-* getElapsedMs(start) // 42.35
-* ```
+* ANSI color names used by {@link randomCliColor} for deterministic terminal coloring.
 */
-function getElapsedMs(hrStart) {
-	const [seconds, nanoseconds] = process.hrtime(hrStart);
-	const ms = seconds * 1e3 + nanoseconds / 1e6;
-	return Math.round(ms * 100) / 100;
-}
+const randomColors = [
+	"black",
+	"red",
+	"green",
+	"yellow",
+	"blue",
+	"white",
+	"magenta",
+	"cyan",
+	"gray"
+];
 /**
-* Converts a millisecond duration into a human-readable string (`ms`, `s`, or `m s`).
+* Wraps `text` in a deterministic ANSI color derived from the text's SHA-256 hash.
 *
 * @example
 * ```ts
-* formatMs(250)   // '250ms'
-* formatMs(1500)  // '1.50s'
-* formatMs(90000) // '1m 30.0s'
+* randomCliColor('petstore') // '\x1b[33m' + 'petstore' + '\x1b[39m' (always the same color for 'petstore')
 * ```
 */
-function formatMs(ms) {
-	if (ms >= 6e4) return `${Math.floor(ms / 6e4)}m ${(ms % 6e4 / 1e3).toFixed(1)}s`;
-	if (ms >= 1e3) return `${(ms / 1e3).toFixed(2)}s`;
-	return `${Math.round(ms)}ms`;
+function randomCliColor(text) {
+	if (!text) return "";
+	return (0, node_util.styleText)(randomColors[(0, node_crypto.createHash)("sha256").update(text).digest().readUInt32BE(0) % randomColors.length] ?? "white", text);
 }
 //#endregion
-//#region ../../internals/utils/src/fs.ts
+//#region ../../internals/utils/src/env.ts
 /**
-* Resolves to `true` when the file or directory at `path` exists.
-* Uses `Bun.file().exists()` when running under Bun, `fs.access` otherwise.
+* Returns `true` when the process is running in a CI environment.
+* Covers GitHub Actions, GitLab CI, CircleCI, Travis CI, Jenkins, Bitbucket,
+* TeamCity, Buildkite, and Azure Pipelines.
 *
 * @example
 * ```ts
-* if (await exists('./kubb.config.ts')) {
-*   const content = await read('./kubb.config.ts')
+* if (isCIEnvironment()) {
+*   logger.level = 'error'
 * }
 * ```
 */
-async function exists(path) {
-	if (typeof Bun !== "undefined") return Bun.file(path).exists();
-	return (0, node_fs_promises.access)(path).then(() => true, () => false);
+function isCIEnvironment() {
+	return !!(process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.BITBUCKET_BUILD_NUMBER || process.env.JENKINS_URL || process.env.CIRCLECI || process.env.TRAVIS || process.env.TEAMCITY_VERSION || process.env.BUILDKITE || process.env.TF_BUILD);
 }
+//#endregion
+//#region ../../internals/utils/src/fs.ts
 /**
 * Writes `data` to `path`, trimming leading/trailing whitespace before saving.
 * Skips the write when the trimmed content is empty or identical to what is already on disk.
@@ -245,502 +132,88 @@ async function clean(path) {
 	});
 }
 //#endregion
-//#region ../../internals/utils/src/reserved.ts
+//#region ../../internals/utils/src/network.ts
 /**
-* JavaScript and Java reserved words.
-* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+* Well-known stable domains used as DNS probes to check internet connectivity.
 */
-const reservedWords = new Set([
-	"abstract",
-	"arguments",
-	"boolean",
-	"break",
-	"byte",
-	"case",
-	"catch",
-	"char",
-	"class",
-	"const",
-	"continue",
-	"debugger",
-	"default",
-	"delete",
-	"do",
-	"double",
-	"else",
-	"enum",
-	"eval",
-	"export",
-	"extends",
-	"false",
-	"final",
-	"finally",
-	"float",
-	"for",
-	"function",
-	"goto",
-	"if",
-	"implements",
-	"import",
-	"in",
-	"instanceof",
-	"int",
-	"interface",
-	"let",
-	"long",
-	"native",
-	"new",
-	"null",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"return",
-	"short",
-	"static",
-	"super",
-	"switch",
-	"synchronized",
-	"this",
-	"throw",
-	"throws",
-	"transient",
-	"true",
-	"try",
-	"typeof",
-	"var",
-	"void",
-	"volatile",
-	"while",
-	"with",
-	"yield",
-	"Array",
-	"Date",
-	"hasOwnProperty",
-	"Infinity",
-	"isFinite",
-	"isNaN",
-	"isPrototypeOf",
-	"length",
-	"Math",
-	"name",
-	"NaN",
-	"Number",
-	"Object",
-	"prototype",
-	"String",
-	"toString",
-	"undefined",
-	"valueOf"
-]);
+const TEST_DOMAINS = [
+	"dns.google.com",
+	"cloudflare.com",
+	"one.one.one.one"
+];
 /**
-* Returns `true` when `name` is a syntactically valid JavaScript variable name.
+* Returns `true` when the system has internet connectivity.
+* Probes DNS resolution against well-known stable domains.
 *
 * @example
 * ```ts
-* isValidVarName('status')  // true
-* isValidVarName('class')   // false (reserved word)
-* isValidVarName('42foo')   // false (starts with digit)
+* if (await isOnline()) {
+*   await fetchLatestVersion()
+* }
 * ```
 */
-function isValidVarName(name) {
-	if (!name || reservedWords.has(name)) return false;
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+async function isOnline() {
+	for (const domain of TEST_DOMAINS) try {
+		await node_dns.promises.resolve(domain);
+		return true;
+	} catch {}
+	return false;
 }
-//#endregion
-//#region ../../internals/utils/src/urlPath.ts
-/**
-* Parses and transforms an OpenAPI/Swagger path string into various URL formats.
-*
-* @example
-* const p = new URLPath('/pet/{petId}')
-* p.URL      // '/pet/:petId'
-* p.template // '`/pet/${petId}`'
-*/
-var URLPath = class {
-	/**
-	* The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
-	*/
-	path;
-	#options;
-	constructor(path, options = {}) {
-		this.path = path;
-		this.#options = options;
-	}
-	/** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').URL // '/pet/:petId'
-	* ```
-	*/
-	get URL() {
-		return this.toURLPath();
-	}
-	/** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
-	*
-	* @example
-	* ```ts
-	* new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
-	* new URLPath('/pet/{petId}').isURL                       // false
-	* ```
-	*/
-	get isURL() {
-		try {
-			return !!new URL(this.path).href;
-		} catch {
-			return false;
-		}
-	}
-	/**
-	* Converts the OpenAPI path to a TypeScript template literal string.
-	*
-	* @example
-	* new URLPath('/pet/{petId}').template              // '`/pet/${petId}`'
-	* new URLPath('/account/monetary-accountID').template // '`/account/${monetaryAccountId}`'
-	*/
-	get template() {
-		return this.toTemplateString();
-	}
-	/** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').object
-	* // { url: '/pet/:petId', params: { petId: 'petId' } }
-	* ```
-	*/
-	get object() {
-		return this.toObject();
-	}
-	/** Returns a map of path parameter names, or `undefined` when the path has no parameters.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').params // { petId: 'petId' }
-	* new URLPath('/pet').params         // undefined
-	* ```
-	*/
-	get params() {
-		return this.getParams();
-	}
-	#transformParam(raw) {
-		const param = isValidVarName(raw) ? raw : require_PluginDriver.camelCase(raw);
-		return this.#options.casing === "camelcase" ? require_PluginDriver.camelCase(param) : param;
-	}
-	/**
-	* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
-	*/
-	#eachParam(fn) {
-		for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
-			const raw = match[1];
-			fn(raw, this.#transformParam(raw));
-		}
-	}
-	toObject({ type = "path", replacer, stringify } = {}) {
-		const object = {
-			url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
-			params: this.getParams()
-		};
-		if (stringify) {
-			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
-			if (object.params) return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
-			return `{ url: '${object.url}' }`;
-		}
-		return object;
-	}
-	/**
-	* Converts the OpenAPI path to a TypeScript template literal string.
-	* An optional `replacer` can transform each extracted parameter name before interpolation.
-	*
-	* @example
-	* new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
-	*/
-	toTemplateString({ prefix = "", replacer } = {}) {
-		return `\`${prefix}${this.path.split(/\{([^}]+)\}/).map((part, i) => {
-			if (i % 2 === 0) return part;
-			const param = this.#transformParam(part);
-			return `\${${replacer ? replacer(param) : param}}`;
-		}).join("")}\``;
-	}
-	/**
-	* Extracts all `{param}` segments from the path and returns them as a key-value map.
-	* An optional `replacer` transforms each parameter name in both key and value positions.
-	* Returns `undefined` when no path parameters are found.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}/tag/{tagId}').getParams()
-	* // { petId: 'petId', tagId: 'tagId' }
-	* ```
-	*/
-	getParams(replacer) {
-		const params = {};
-		this.#eachParam((_raw, param) => {
-			const key = replacer ? replacer(param) : param;
-			params[key] = key;
-		});
-		return Object.keys(params).length > 0 ? params : void 0;
-	}
-	/** Converts the OpenAPI path to Express-style colon syntax.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
-	* ```
-	*/
-	toURLPath() {
-		return this.path.replace(/\{([^}]+)\}/g, ":$1");
-	}
-};
-//#endregion
-//#region src/createAdapter.ts
 /**
-* Factory for implementing custom adapters that translate non-OpenAPI specs into Kubb's AST.
-*
-* Use this to support GraphQL schemas, gRPC definitions, AsyncAPI, or custom domain-specific languages.
-* Built-in adapters include `@kubb/adapter-oas` for OpenAPI and Swagger documents.
-*
-* @note Adapters must parse their input format to Kubb's `InputNode` structure.
+* Executes `fn` only when the system is online. Returns `null` when offline or on error.
 *
 * @example
 * ```ts
-* export const myAdapter = createAdapter<MyAdapter>((options) => {
-*   return {
-*     name: 'my-adapter',
-*     options,
-*     async parse(source) {
-*       // Transform source format to InputNode
-*       return { ... }
-*     },
-*   }
-* })
-*
-* // Instantiate:
-* const adapter = myAdapter({ validate: true })
+* const version = await executeIfOnline(() => fetchLatestVersion('kubb'))
+* // null when offline
 * ```
 */
-function createAdapter(build) {
-	return (options) => build(options ?? {});
-}
-//#endregion
-//#region ../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
-var Node = class {
-	value;
-	next;
-	constructor(value) {
-		this.value = value;
-	}
-};
-var Queue = class {
-	#head;
-	#tail;
-	#size;
-	constructor() {
-		this.clear();
-	}
-	enqueue(value) {
-		const node = new Node(value);
-		if (this.#head) {
-			this.#tail.next = node;
-			this.#tail = node;
-		} else {
-			this.#head = node;
-			this.#tail = node;
-		}
-		this.#size++;
-	}
-	dequeue() {
-		const current = this.#head;
-		if (!current) return;
-		this.#head = this.#head.next;
-		this.#size--;
-		if (!this.#head) this.#tail = void 0;
-		return current.value;
-	}
-	peek() {
-		if (!this.#head) return;
-		return this.#head.value;
-	}
-	clear() {
-		this.#head = void 0;
-		this.#tail = void 0;
-		this.#size = 0;
-	}
-	get size() {
-		return this.#size;
-	}
-	*[Symbol.iterator]() {
-		let current = this.#head;
-		while (current) {
-			yield current.value;
-			current = current.next;
-		}
-	}
-	*drain() {
-		while (this.#head) yield this.dequeue();
+async function executeIfOnline(fn) {
+	if (!await isOnline()) return null;
+	try {
+		return await fn();
+	} catch {
+		return null;
 	}
-};
-//#endregion
-//#region ../../node_modules/.pnpm/p-limit@7.3.0/node_modules/p-limit/index.js
-function pLimit(concurrency) {
-	let rejectOnClear = false;
-	if (typeof concurrency === "object") ({concurrency, rejectOnClear = false} = concurrency);
-	validateConcurrency(concurrency);
-	if (typeof rejectOnClear !== "boolean") throw new TypeError("Expected `rejectOnClear` to be a boolean");
-	const queue = new Queue();
-	let activeCount = 0;
-	const resumeNext = () => {
-		if (activeCount < concurrency && queue.size > 0) {
-			activeCount++;
-			queue.dequeue().run();
-		}
-	};
-	const next = () => {
-		activeCount--;
-		resumeNext();
-	};
-	const run = async (function_, resolve, arguments_) => {
-		const result = (async () => function_(...arguments_))();
-		resolve(result);
-		try {
-			await result;
-		} catch {}
-		next();
-	};
-	const enqueue = (function_, resolve, reject, arguments_) => {
-		const queueItem = { reject };
-		new Promise((internalResolve) => {
-			queueItem.run = internalResolve;
-			queue.enqueue(queueItem);
-		}).then(run.bind(void 0, function_, resolve, arguments_));
-		if (activeCount < concurrency) resumeNext();
-	};
-	const generator = (function_, ...arguments_) => new Promise((resolve, reject) => {
-		enqueue(function_, resolve, reject, arguments_);
-	});
-	Object.defineProperties(generator, {
-		activeCount: { get: () => activeCount },
-		pendingCount: { get: () => queue.size },
-		clearQueue: { value() {
-			if (!rejectOnClear) {
-				queue.clear();
-				return;
-			}
-			const abortError = AbortSignal.abort().reason;
-			while (queue.size > 0) queue.dequeue().reject(abortError);
-		} },
-		concurrency: {
-			get: () => concurrency,
-			set(newConcurrency) {
-				validateConcurrency(newConcurrency);
-				concurrency = newConcurrency;
-				queueMicrotask(() => {
-					while (activeCount < concurrency && queue.size > 0) resumeNext();
-				});
-			}
-		},
-		map: { async value(iterable, function_) {
-			const promises = Array.from(iterable, (value, index) => this(function_, value, index));
-			return Promise.all(promises);
-		} }
-	});
-	return generator;
-}
-function validateConcurrency(concurrency) {
-	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) throw new TypeError("Expected `concurrency` to be a number from 1 and up");
-}
-//#endregion
-//#region src/FileProcessor.ts
-function joinSources(file) {
-	return file.sources.map((item) => (0, _kubb_ast.extractStringsFromNodes)(item.nodes)).filter(Boolean).join("\n\n");
 }
-/**
-* Converts a single file to a string using the registered parsers.
-* Falls back to joining source values when no matching parser is found.
-*
-* @internal
-*/
-var FileProcessor = class {
-	#limit = pLimit(100);
-	async parse(file, { parsers, extension } = {}) {
-		const parseExtName = extension?.[file.extname] || void 0;
-		if (!parsers || !file.extname) return joinSources(file);
-		const parser = parsers.get(file.extname);
-		if (!parser) return joinSources(file);
-		return parser.parse(file, { extname: parseExtName });
-	}
-	async run(files, { parsers, mode = "sequential", extension, onStart, onEnd, onUpdate } = {}) {
-		await onStart?.(files);
-		const total = files.length;
-		let processed = 0;
-		const processOne = async (file) => {
-			const source = await this.parse(file, {
-				extension,
-				parsers
-			});
-			const currentProcessed = ++processed;
-			const percentage = currentProcessed / total * 100;
-			await onUpdate?.({
-				file,
-				source,
-				processed: currentProcessed,
-				percentage,
-				total
-			});
-		};
-		if (mode === "sequential") for (const file of files) await processOne(file);
-		else await Promise.all(files.map((file) => this.#limit(() => processOne(file))));
-		await onEnd?.(files);
-		return files;
-	}
-};
 //#endregion
-//#region src/createStorage.ts
+//#region src/createAdapter.ts
 /**
-* Factory for implementing custom storage backends that control where generated files are written.
-*
-* Takes a builder function `(options: TOptions) => Storage` and returns a factory `(options?: TOptions) => Storage`.
-* Kubb provides filesystem and in-memory implementations out of the box.
+* Defines a custom adapter that translates a spec format into Kubb's universal
+* AST. Use this when you need to consume GraphQL, gRPC, AsyncAPI, or another
+* domain-specific schema. Built-in adapters: `@kubb/adapter-oas` for
+* OpenAPI/Swagger documents.
 *
-* @note Call the returned factory with optional options to instantiate the storage adapter.
+* Adapters must return an `InputNode` from `parse`. That node is what every
+* plugin in the build consumes.
 *
 * @example
 * ```ts
-* import { createStorage } from '@kubb/core'
+* import { createAdapter, ast, type AdapterFactoryOptions } from '@kubb/core'
 *
-* export const memoryStorage = createStorage(() => {
-*   const store = new Map<string, string>()
-*   return {
-*     name: 'memory',
-*     async hasItem(key) { return store.has(key) },
-*     async getItem(key) { return store.get(key) ?? null },
-*     async setItem(key, value) { store.set(key, value) },
-*     async removeItem(key) { store.delete(key) },
-*     async getKeys(base) {
-*       const keys = [...store.keys()]
-*       return base ? keys.filter((k) => k.startsWith(base)) : keys
-*     },
-*     async clear(base) { if (!base) store.clear() },
-*   }
-* })
+* type MyAdapter = AdapterFactoryOptions<'my-adapter', { validate?: boolean }>
 *
-* // Instantiate:
-* const storage = memoryStorage()
+* export const myAdapter = createAdapter<MyAdapter>((options) => ({
+*   name: 'my-adapter',
+*   options,
+*   document: null,
+*   async parse(_source) {
+*     // Convert `source` (path or inline data) into an InputNode.
+*     return ast.createInput()
+*   },
+*   getImports: () => [],
+*   async validate() {
+*     // Throw or call ctx.error here when the spec is invalid.
+*   },
+* }))
 * ```
 */
-function createStorage(build) {
+function createAdapter(build) {
 	return (options) => build(options ?? {});
 }
 //#endregion
 //#region src/storages/fsStorage.ts
 /**
-* Detects the filesystem error used to indicate that a path does not exist.
-*/
-function isMissingPathError(error) {
-	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
-/**
 * Built-in filesystem storage driver.
 *
 * This is the default storage when no `storage` option is configured in the root config.
@@ -765,23 +238,21 @@ function isMissingPathError(error) {
 * })
 * ```
 */
-const fsStorage = createStorage(() => ({
+const fsStorage = require_memoryStorage.createStorage(() => ({
 	name: "fs",
 	async hasItem(key) {
 		try {
 			await (0, node_fs_promises.access)((0, node_path.resolve)(key));
 			return true;
-		} catch (error) {
-			if (isMissingPathError(error)) return false;
-			throw new Error(`Failed to access storage item "${key}"`, { cause: error });
+		} catch (_error) {
+			return false;
 		}
 	},
 	async getItem(key) {
 		try {
 			return await (0, node_fs_promises.readFile)((0, node_path.resolve)(key), "utf8");
-		} catch (error) {
-			if (isMissingPathError(error)) return null;
-			throw new Error(`Failed to read storage item "${key}"`, { cause: error });
+		} catch (_error) {
+			return null;
 		}
 	},
 	async setItem(key, value) {
@@ -791,23 +262,22 @@ const fsStorage = createStorage(() => ({
 		await (0, node_fs_promises.rm)((0, node_path.resolve)(key), { force: true });
 	},
 	async getKeys(base) {
-		const keys = [];
 		const resolvedBase = (0, node_path.resolve)(base ?? process.cwd());
-		async function walk(dir, prefix) {
+		async function* walk(dir, prefix) {
 			let entries;
 			try {
 				entries = await (0, node_fs_promises.readdir)(dir, { withFileTypes: true });
-			} catch (error) {
-				if (isMissingPathError(error)) return;
-				throw new Error(`Failed to list storage keys under "${resolvedBase}"`, { cause: error });
+			} catch (_error) {
+				return;
 			}
 			for (const entry of entries) {
 				const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-				if (entry.isDirectory()) await walk((0, node_path.join)(dir, entry.name), rel);
-				else keys.push(rel);
+				if (entry.isDirectory()) yield* walk((0, node_path.join)(dir, entry.name), rel);
+				else yield rel;
 			}
 		}
-		await walk(resolvedBase, "");
+		const keys = [];
+		for await (const key of walk(resolvedBase, "")) keys.push(key);
 		return keys;
 	},
 	async clear(base) {
@@ -816,476 +286,652 @@ const fsStorage = createStorage(() => ({
 	}
 }));
 //#endregion
-//#region package.json
-var version = "5.0.0-beta.4";
-//#endregion
-//#region src/utils/diagnostics.ts
+//#region src/createKubb.ts
 /**
-* Returns a snapshot of the current runtime environment.
-*
-* Useful for attaching context to debug logs and error reports so that
-* issues can be reproduced without manual information gathering.
+* Builds a `Storage` view scoped to the file paths produced by the current build.
+* Reads delegate to the underlying `storage` so source bytes stay where they were
+* written. Writes register the key so subsequent reads and `getKeys` are scoped
+* to this build's output.
 */
-function getDiagnosticInfo() {
-	return {
-		nodeVersion: node_process.version,
-		KubbVersion: version,
-		platform: process.platform,
-		arch: process.arch,
-		cwd: process.cwd()
-	};
-}
-//#endregion
-//#region src/utils/isInputPath.ts
-function isInputPath(config) {
-	return typeof config?.input === "object" && config.input !== null && "path" in config.input;
-}
-//#endregion
-//#region src/createKubb.ts
-async function setup(userConfig, options = {}) {
-	const hooks = options.hooks ?? new AsyncEventEmitter();
-	const sources = /* @__PURE__ */ new Map();
-	const diagnosticInfo = getDiagnosticInfo();
-	if (Array.isArray(userConfig.input)) await hooks.emit("kubb:warn", { message: "This feature is still under development — use with caution" });
-	await hooks.emit("kubb:debug", {
-		date: /* @__PURE__ */ new Date(),
-		logs: [
-			"Configuration:",
-			`  • Name: ${userConfig.name || "unnamed"}`,
-			`  • Root: ${userConfig.root || process.cwd()}`,
-			`  • Output: ${userConfig.output?.path || "not specified"}`,
-			`  • Plugins: ${userConfig.plugins?.length || 0}`,
-			"Output Settings:",
-			`  • Storage: ${userConfig.storage ? `custom(${userConfig.storage.name})` : userConfig.output?.write === false ? "disabled" : "filesystem (default)"}`,
-			`  • Formatter: ${userConfig.output?.format || "none"}`,
-			`  • Linter: ${userConfig.output?.lint || "none"}`,
-			"Environment:",
-			Object.entries(diagnosticInfo).map(([key, value]) => `  • ${key}: ${value}`).join("\n")
-		]
-	});
-	try {
-		if (isInputPath(userConfig) && !new URLPath(userConfig.input.path).isURL) {
-			await exists(userConfig.input.path);
-			await hooks.emit("kubb:debug", {
-				date: /* @__PURE__ */ new Date(),
-				logs: [`✓ Input file validated: ${userConfig.input.path}`]
-			});
-		}
-	} catch (caughtError) {
-		if (isInputPath(userConfig)) {
-			const error = caughtError;
-			throw new Error(`Cannot read file/URL defined in \`input.path\` or set with \`kubb generate PATH\` in the CLI of your Kubb config ${userConfig.input.path}`, { cause: error });
+function createSourcesView(storage) {
+	const paths = /* @__PURE__ */ new Set();
+	return require_memoryStorage.createStorage(() => ({
+		name: `${storage.name}:sources`,
+		async hasItem(key) {
+			return paths.has(key) && await storage.hasItem(key);
+		},
+		async getItem(key) {
+			return paths.has(key) ? storage.getItem(key) : null;
+		},
+		async setItem(key, value) {
+			paths.add(key);
+			await storage.setItem(key, value);
+		},
+		async removeItem(key) {
+			paths.delete(key);
+			await storage.removeItem(key);
+		},
+		async getKeys(base) {
+			if (!base) return [...paths];
+			const result = [];
+			for (const key of paths) if (key.startsWith(base)) result.push(key);
+			return result;
+		},
+		async clear() {
+			paths.clear();
+			await storage.clear();
 		}
-	}
-	const config = {
+	}))();
+}
+function resolveConfig(userConfig) {
+	return {
 		...userConfig,
 		root: userConfig.root || process.cwd(),
 		parsers: userConfig.parsers ?? [],
-		adapter: userConfig.adapter,
 		output: {
 			format: false,
 			lint: false,
-			write: true,
-			extension: require_PluginDriver.DEFAULT_EXTENSION,
-			defaultBanner: require_PluginDriver.DEFAULT_BANNER,
+			extension: { ".ts": ".ts" },
+			defaultBanner: "simple",
 			...userConfig.output
 		},
-		devtools: userConfig.devtools ? {
-			studioUrl: require_PluginDriver.DEFAULT_STUDIO_URL,
-			...typeof userConfig.devtools === "boolean" ? {} : userConfig.devtools
-		} : void 0,
-		plugins: userConfig.plugins
-	};
-	const storage = config.output.write === false ? null : config.storage ?? fsStorage();
-	if (config.output.clean) {
-		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 require_PluginDriver.PluginDriver(config, { hooks });
-	function registerMiddlewareHook(event, middlewareHooks) {
-		const handler = middlewareHooks[event];
-		if (handler) hooks.on(event, handler);
-	}
-	for (const middleware of config.middleware ?? []) for (const event of Object.keys(middleware.hooks)) registerMiddlewareHook(event, middleware.hooks);
-	if (config.adapter) {
-		const source = inputToAdapterSource(config);
-		await hooks.emit("kubb:debug", {
-			date: /* @__PURE__ */ new Date(),
-			logs: [`Running adapter: ${config.adapter.name}`]
-		});
-		driver.adapter = config.adapter;
-		driver.inputNode = await config.adapter.parse(source);
-		await hooks.emit("kubb:debug", {
-			date: /* @__PURE__ */ new Date(),
-			logs: [
-				`✓ Adapter '${config.adapter.name}' resolved InputNode`,
-				`  • Schemas: ${driver.inputNode.schemas.length}`,
-				`  • Operations: ${driver.inputNode.operations.length}`
-			]
-		});
-	}
-	return {
-		config,
-		hooks,
-		driver,
-		sources,
-		storage
+		storage: userConfig.storage ?? fsStorage(),
+		reporters: userConfig.reporters ?? [],
+		plugins: userConfig.plugins ?? []
 	};
 }
 /**
-* Walks the AST and dispatches nodes to a plugin's direct AST hooks
-* (`schema`, `operation`, `operations`).
+* Kubb code-generation instance bound to a single config entry. Resolves the user
+* config during `setup()` and shares `hooks`, `storage`, `driver`, and `config` across
+* the `setup → build` lifecycle.
+*
+* Attach event listeners to `.hooks` before calling `setup()` or `build()`.
 *
-* When `include` contains only operation-scoped filters (`tag`, `operationId`, `path`,
-* `method`, `contentType`) and no `schemaName` filter, the function pre-computes the set
-* of top-level schema names transitively reachable from the included operations and skips
-* schemas that fall outside that set. This ensures that component schemas referenced
-* exclusively by excluded operations are not generated.
+* @example
+* ```ts
+* const kubb = createKubb(userConfig)
+* kubb.hooks.on('kubb:plugin:end', ({ plugin, duration }) => console.log(plugin.name, duration))
+* const { files, diagnostics } = await kubb.safeBuild()
+* ```
 */
-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;
+var Kubb = class {
+	hooks;
+	#userConfig;
+	#config = null;
+	#driver = null;
+	#storage = null;
+	constructor(userConfig, options = {}) {
+		this.#userConfig = userConfig;
+		this.hooks = options.hooks ?? new require_memoryStorage.AsyncEventEmitter();
 	}
-	const generators = plugin.generators ?? [];
-	const collectedOperations = [];
-	const generatorContext = {
-		...context,
-		resolver: driver.getResolver(plugin.name)
-	};
-	const operationFilterTypes = new Set([
-		"tag",
-		"operationId",
-		"path",
-		"method",
-		"contentType"
-	]);
-	const hasOperationBasedIncludes = include?.some(({ type }) => operationFilterTypes.has(type)) ?? false;
-	const hasSchemaNameIncludes = include?.some(({ type }) => type === "schemaName") ?? false;
-	let allowedSchemaNames;
-	if (hasOperationBasedIncludes && !hasSchemaNameIncludes) allowedSchemaNames = (0, _kubb_ast.collectUsedSchemaNames)(inputNode.operations.filter((op) => resolver.resolveOptions(op, {
-		options: plugin.options,
-		exclude,
-		include,
-		override
-	}) !== null), inputNode.schemas);
-	await (0, _kubb_ast.walk)(inputNode, {
-		depth: "shallow",
-		async schema(node) {
-			const transformedNode = plugin.transformer ? (0, _kubb_ast.transform)(node, plugin.transformer) : node;
-			if (allowedSchemaNames !== void 0 && transformedNode.name && !allowedSchemaNames.has(transformedNode.name)) return;
-			const options = resolver.resolveOptions(transformedNode, {
-				options: plugin.options,
-				exclude,
-				include,
-				override
-			});
-			if (options === null) return;
-			const ctx = {
-				...generatorContext,
-				options
-			};
-			for (const gen of generators) {
-				if (!gen.schema) continue;
-				await require_PluginDriver.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;
-			const options = resolver.resolveOptions(transformedNode, {
-				options: plugin.options,
-				exclude,
-				include,
-				override
-			});
-			if (options !== null) {
-				collectedOperations.push(transformedNode);
-				const ctx = {
-					...generatorContext,
-					options
-				};
-				for (const gen of generators) {
-					if (!gen.operation) continue;
-					await require_PluginDriver.applyHookResult(await gen.operation(transformedNode, ctx), driver, resolveRenderer(gen));
-				}
-				await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
-			}
-		}
-	});
-	if (collectedOperations.length > 0) {
-		const ctx = {
-			...generatorContext,
-			options: plugin.options
-		};
-		for (const gen of generators) {
-			if (!gen.operations) continue;
-			await require_PluginDriver.applyHookResult(await gen.operations(collectedOperations, ctx), driver, resolveRenderer(gen));
+	get storage() {
+		if (!this.#storage) throw new Error("[kubb] setup() must be called before accessing storage");
+		return this.#storage;
+	}
+	get driver() {
+		if (!this.#driver) throw new Error("[kubb] setup() must be called before accessing driver");
+		return this.#driver;
+	}
+	get config() {
+		if (!this.#config) throw new Error("[kubb] setup() must be called before accessing config");
+		return this.#config;
+	}
+	/**
+	* Resolves config and initializes the driver. `build()` calls this automatically.
+	*/
+	async setup() {
+		const config = resolveConfig(this.#userConfig);
+		const driver = new require_memoryStorage.KubbDriver(config, { hooks: this.hooks });
+		const storage = createSourcesView(config.storage);
+		this.hooks.setMaxListeners(Math.max(10, config.plugins.length * 4));
+		if (config.output.clean) await config.storage.clear((0, node_path.resolve)(config.root, config.output.path));
+		await driver.setup();
+		this.#config = config;
+		this.#driver = driver;
+		this.#storage = storage;
+	}
+	/**
+	* Runs the full pipeline and throws on any plugin error.
+	* Automatically calls `setup()` if needed.
+	*/
+	async build() {
+		const out = await this.safeBuild();
+		if (require_memoryStorage.Diagnostics.hasError(out.diagnostics)) {
+			const errors = out.diagnostics.filter(require_memoryStorage.Diagnostics.isProblem).filter((diagnostic) => diagnostic.severity === "error").map((diagnostic) => diagnostic.cause ?? new require_memoryStorage.Diagnostics.Error(diagnostic));
+			throw new require_memoryStorage.BuildError(`Build failed with ${errors.length} ${errors.length === 1 ? "error" : "errors"}`, { errors });
 		}
-		await driver.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
+		return out;
 	}
-}
-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: driver.getPlugin.bind(driver),
-			get files() {
-				return driver.fileManager.files;
-			},
-			upsertFile: (...files) => driver.fileManager.upsert(...files)
-		});
-		for (const plugin of driver.plugins.values()) {
-			const context = driver.getContext(plugin);
-			const hrStart = process.hrtime();
-			try {
-				const timestamp = /* @__PURE__ */ new Date();
-				await hooks.emit("kubb:plugin:start", { plugin });
-				await hooks.emit("kubb:debug", {
-					date: timestamp,
-					logs: ["Starting plugin...", `  • Plugin Name: ${plugin.name}`]
-				});
-				if (plugin.generators?.length || driver.hasRegisteredGenerators(plugin.name)) await runPluginAstHooks(plugin, context);
-				const duration = getElapsedMs(hrStart);
-				pluginTimings.set(plugin.name, duration);
-				await hooks.emit("kubb:plugin:end", {
-					plugin,
-					duration,
-					success: true,
-					config,
-					get files() {
-						return driver.fileManager.files;
-					},
-					upsertFile: (...files) => driver.fileManager.upsert(...files)
-				});
-				await hooks.emit("kubb:debug", {
-					date: /* @__PURE__ */ new Date(),
-					logs: [`✓ Plugin started successfully (${formatMs(duration)})`]
-				});
-			} catch (caughtError) {
-				const error = caughtError;
-				const errorTimestamp = /* @__PURE__ */ new Date();
-				const duration = getElapsedMs(hrStart);
-				await hooks.emit("kubb:plugin:end", {
-					plugin,
-					duration,
-					success: false,
-					error,
-					config,
-					get files() {
-						return driver.fileManager.files;
-					},
-					upsertFile: (...files) => driver.fileManager.upsert(...files)
-				});
-				await hooks.emit("kubb:debug", {
-					date: errorTimestamp,
-					logs: [
-						"✗ Plugin start failed",
-						`  • Plugin Name: ${plugin.name}`,
-						`  • Error: ${error.constructor.name} - ${error.message}`,
-						"  • Stack Trace:",
-						error.stack || "No stack trace available"
-					]
-				});
-				failedPlugins.add({
-					plugin,
-					error
-				});
-			}
+	/**
+	* Runs the full pipeline and captures errors in `BuildOutput` instead of throwing.
+	* Automatically calls `setup()` if needed.
+	*/
+	async safeBuild() {
+		try {
+			var _usingCtx$1 = require_memoryStorage._usingCtx();
+			if (!this.#driver) await this.setup();
+			const cleanup = _usingCtx$1.u(this);
+			const driver = cleanup.driver;
+			const storage = cleanup.storage;
+			const { diagnostics } = await driver.run({ storage });
+			return {
+				diagnostics,
+				files: driver.fileManager.files,
+				driver,
+				storage
+			};
+		} catch (_) {
+			_usingCtx$1.e = _;
+		} finally {
+			_usingCtx$1.d();
 		}
-		await hooks.emit("kubb:plugins:end", {
-			config,
-			get files() {
-				return driver.fileManager.files;
-			},
-			upsertFile: (...files) => driver.fileManager.upsert(...files)
-		});
-		const files = driver.fileManager.files;
-		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 hooks.emit("kubb:debug", {
-			date: /* @__PURE__ */ new Date(),
-			logs: [`Writing ${files.length} files...`]
-		});
-		await fileProcessor.run(files, {
-			parsers: parsersMap,
-			extension: config.output.extension,
-			onStart: async (processingFiles) => {
-				await hooks.emit("kubb:files:processing:start", { files: processingFiles });
-			},
-			onUpdate: async ({ file, source, processed, total, percentage }) => {
-				await hooks.emit("kubb:file:processing:update", {
-					file,
-					source,
-					processed,
-					total,
-					percentage,
-					config
-				});
-				if (source) {
-					await storage?.setItem(file.path, source);
-					sources.set(file.path, source);
-				}
-			},
-			onEnd: async (processedFiles) => {
-				await hooks.emit("kubb:files:processing:end", { files: processedFiles });
-				await hooks.emit("kubb:debug", {
-					date: /* @__PURE__ */ new Date(),
-					logs: [`✓ File write process completed for ${processedFiles.length} files`]
-				});
-			}
-		});
-		await hooks.emit("kubb:build:end", {
-			files,
-			config,
-			outputDir: (0, node_path.resolve)(config.root, config.output.path)
-		});
-		return {
-			failedPlugins,
-			files,
-			driver,
-			pluginTimings,
-			sources
-		};
-	} catch (error) {
-		return {
-			failedPlugins,
-			files: [],
-			driver,
-			pluginTimings,
-			error,
-			sources
-		};
-	} finally {
-		driver.dispose();
 	}
-}
-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 });
+	dispose() {
+		this.#driver?.dispose();
 	}
-	return {
-		failedPlugins,
-		files,
-		driver,
-		pluginTimings,
-		error: void 0,
-		sources
-	};
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+};
+/**
+* Constructs a {@link Kubb} build orchestrator from a user config. Equivalent
+* to `new Kubb(userConfig, options)` and the canonical public entry point.
+*
+* @example
+* ```ts
+* import { createKubb } from '@kubb/core'
+* import { adapterOas } from '@kubb/adapter-oas'
+* import { pluginTs } from '@kubb/plugin-ts'
+*
+* const kubb = createKubb({
+*   input: { path: './petStore.yaml' },
+*   output: { path: './src/gen' },
+*   adapter: adapterOas(),
+*   plugins: [pluginTs()],
+* })
+*
+* await kubb.build()
+* ```
+*/
+function createKubb(userConfig, options = {}) {
+	return new Kubb(userConfig, options);
 }
-function inputToAdapterSource(config) {
-	const input = config.input;
-	if (!input) throw new Error("[kubb] input is required when using an adapter. Provide input.path or input.data in your config.");
-	if (Array.isArray(input)) return {
-		type: "paths",
-		paths: input.map((i) => new URLPath(i.path).isURL ? i.path : (0, node_path.resolve)(config.root, i.path))
-	};
-	if ("data" in input) return {
-		type: "data",
-		data: input.data
-	};
-	if (new URLPath(input.path).isURL) return {
-		type: "path",
-		path: input.path
+//#endregion
+//#region src/createReporter.ts
+/**
+* Defines a reporter. When the definition has a `drain`, the returned reporter buffers each value
+* `report` returns and hands the array to `drain` once, then clears it. Without a `drain`, nothing
+* is buffered. Wiring the reporter onto the run's events is the host's job, so the reporter only
+* ever deals with a {@link GenerationResult}.
+*
+* @example
+* ```ts
+* import { createReporter, Diagnostics } from '@kubb/core'
+*
+* export const jsonReporter = createReporter({
+*   name: 'json',
+*   report(result) {
+*     return { status: Diagnostics.hasError(result.diagnostics) ? 'failed' : 'success', diagnostics: result.diagnostics }
+*   },
+*   drain(context, reports) {
+*     process.stdout.write(`${JSON.stringify(reports, null, 2)}\n`)
+*   },
+* })
+* ```
+*/
+function createReporter(reporter) {
+	const drain = reporter.drain;
+	if (!drain) return {
+		name: reporter.name,
+		async report(result, context) {
+			await reporter.report(result, context);
+		}
 	};
+	const reports = [];
 	return {
-		type: "path",
-		path: (0, node_path.resolve)(config.root, input.path)
+		name: reporter.name,
+		async report(result, context) {
+			reports.push(await reporter.report(result, context));
+		},
+		async drain(context) {
+			await drain(context, reports);
+			reports.length = 0;
+		}
 	};
 }
 /**
-* Creates a Kubb instance bound to a single config entry.
+* Picks the reporters whose `name` matches one of `names`, in the order the names are given.
+* The config carries every available reporter, and the host selects which to activate by name
+* (the CLI maps `--reporter` to this). Duplicate names and names without a matching reporter are
+* skipped.
+*/
+function selectReporters(reporters, names) {
+	const seen = /* @__PURE__ */ new Set();
+	const selected = [];
+	for (const name of names) {
+		if (seen.has(name)) continue;
+		seen.add(name);
+		const reporter = reporters.find((candidate) => candidate.name === name);
+		if (reporter) selected.push(reporter);
+	}
+	return selected;
+}
+//#endregion
+//#region src/defineLogger.ts
+/**
+* Numeric log-level thresholds used internally to compare verbosity.
 *
-* Accepts a user-facing config shape and resolves it to a full {@link Config} during
-* `setup()`. The instance then holds shared state (`hooks`, `sources`, `driver`, `config`)
-* across the `setup → build` lifecycle. Attach event listeners to `kubb.hooks` before
-* calling `setup()` or `build()`.
+* Higher numbers are more verbose.
+*/
+const logLevel = {
+	silent: Number.NEGATIVE_INFINITY,
+	error: 0,
+	warn: 1,
+	info: 3,
+	verbose: 4
+};
+/**
+* Defines a typed logger. Use the second type parameter to declare a return
+* value from `install`, which is handy when the logger exposes a sink factory
+* or cleanup callback to the caller.
 *
-* @example
+* @example Basic logger
 * ```ts
-* const kubb = createKubb(userConfig)
+* import { defineLogger } from '@kubb/core'
 *
-* kubb.hooks.on('kubb:plugin:end', ({ plugin, duration }) => {
-*   console.log(`${plugin.name} completed in ${duration}ms`)
+* export const myLogger = defineLogger({
+*   name: 'my-logger',
+*   install(context) {
+*     context.on('kubb:info', ({ message }) => console.log('ℹ', message))
+*     context.on('kubb:error', ({ error }) => console.error('✗', error.message))
+*   },
 * })
+* ```
 *
-* const { files, failedPlugins } = await kubb.safeBuild()
+* @example Logger that returns a hook sink factory
+* ```ts
+* import { defineLogger, type LoggerOptions } from '@kubb/core'
+* import type { HookSinkFactory } from './sinks'
+*
+* export const myLogger = defineLogger<LoggerOptions, HookSinkFactory>({
+*   name: 'my-logger',
+*   install(context) {
+*     // … register event handlers …
+*     return () => ({ onStdout: console.log })
+*   },
+* })
 * ```
 */
-function createKubb(userConfig, 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(userConfig, { hooks });
-		},
-		async build() {
-			if (!setupResult) await instance.setup();
-			return build(setupResult);
+function defineLogger(logger) {
+	return logger;
+}
+//#endregion
+//#region src/reporters/report.ts
+/**
+* Builds the normalized {@link Report} for one config from its {@link GenerationResult}. Splits the
+* diagnostics into problems and per-plugin timings (slowest first) and derives the plugin and issue
+* counts, so every reporter renders the same data.
+*/
+function buildReport(result) {
+	const { config, diagnostics, filesCreated, status, hrStart } = result;
+	const failed = require_memoryStorage.Diagnostics.failedPlugins(diagnostics);
+	const total = config.plugins?.length ?? 0;
+	const counts = require_memoryStorage.Diagnostics.count(diagnostics);
+	const problems = diagnostics.filter(require_memoryStorage.Diagnostics.isProblem);
+	const timings = diagnostics.filter(require_memoryStorage.Diagnostics.isPerformance).sort((a, b) => b.duration - a.duration).map((diagnostic) => ({
+		plugin: diagnostic.plugin,
+		durationMs: diagnostic.duration
+	}));
+	return {
+		name: config.name ?? "",
+		status,
+		plugins: {
+			passed: total - failed.length,
+			failed,
+			total
 		},
-		async safeBuild() {
-			if (!setupResult) await instance.setup();
-			return safeBuild(setupResult);
-		}
+		counts,
+		filesCreated,
+		durationMs: require_memoryStorage.getElapsedMs(hrStart),
+		output: (0, node_path.resolve)(config.root, config.output.path),
+		timings,
+		diagnostics: problems.map((diagnostic) => require_memoryStorage.Diagnostics.serialize(diagnostic))
 	};
-	return instance;
 }
 //#endregion
+//#region src/reporters/cliReporter.ts
+/**
+* Builds the vitest/jest-style summary for one {@link Report}: right-aligned dim labels with
+* `N passed (total)` counts, and a per-plugin `Timings` section when `showTimings`.
+*/
+function buildSummaryLines(report, { showTimings }) {
+	const { status, plugins, counts, filesCreated, durationMs, output, timings } = report;
+	const rows = [];
+	rows.push(["Plugins", status === "success" ? `${(0, node_util.styleText)("green", `${plugins.passed} passed`)} (${plugins.total})` : `${(0, node_util.styleText)("green", `${plugins.passed} passed`)} | ${(0, node_util.styleText)("red", `${plugins.failed.length} failed`)} (${plugins.total})`]);
+	if (status === "failed" && plugins.failed.length > 0) rows.push(["Failed", plugins.failed.map((name) => randomCliColor(name)).join(", ")]);
+	if (counts.errors > 0 || counts.warnings > 0) {
+		const issues = [counts.errors > 0 ? (0, node_util.styleText)("red", `${counts.errors} ${counts.errors === 1 ? "error" : "errors"}`) : void 0, counts.warnings > 0 ? (0, node_util.styleText)("yellow", `${counts.warnings} ${counts.warnings === 1 ? "warning" : "warnings"}`) : void 0].filter(Boolean).join(" | ");
+		rows.push(["Issues", issues]);
+	}
+	rows.push(["Files", `${(0, node_util.styleText)("green", String(filesCreated))} generated`]);
+	rows.push(["Duration", (0, node_util.styleText)("green", require_memoryStorage.formatMs(durationMs))]);
+	rows.push(["Output", output]);
+	const labelWidth = Math.max(...rows.map(([label]) => label.length), timings.length > 0 ? 7 : 0);
+	const lines = rows.map(([label, value]) => `${(0, node_util.styleText)("dim", label.padStart(labelWidth))}  ${value}`);
+	if (showTimings && timings.length > 0) {
+		const nameWidth = Math.max(0, ...timings.map((timing) => timing.plugin.length));
+		const indent = " ".repeat(labelWidth + 2);
+		lines.push((0, node_util.styleText)("dim", "Timings".padStart(labelWidth)));
+		for (const timing of timings) {
+			const timeStr = require_memoryStorage.formatMs(timing.durationMs);
+			const barLength = Math.min(Math.ceil(timing.durationMs / 100), 10);
+			const bar = (0, node_util.styleText)("dim", "█".repeat(barLength));
+			lines.push(`${indent}${(0, node_util.styleText)("dim", "•")} ${timing.plugin.padEnd(nameWidth)} ${bar} ${timeStr}`);
+		}
+	}
+	return lines;
+}
+/**
+* Renders the summary as plain `console.log` lines so it works in every CLI (no clack/TTY
+* dependency): a blank line, the config name colored by status, then the summary rows.
+*/
+function renderSummary(lines, { title, status }) {
+	console.log("");
+	if (title) console.log((0, node_util.styleText)(status === "failed" ? "red" : "green", title));
+	for (const line of lines) console.log(line);
+}
+/**
+* The default `cli` reporter. Renders the {@link Report} for each config as it finishes, independent
+* of the live logger view. Suppressed at `silent`; the `verbose` level adds the per-plugin timings.
+*/
+const cliReporter = createReporter({
+	name: "cli",
+	report(result, { logLevel: logLevel$1 }) {
+		if (logLevel$1 <= logLevel.silent) return;
+		const report = buildReport(result);
+		renderSummary(buildSummaryLines(report, { showTimings: logLevel$1 >= logLevel.verbose }), {
+			title: report.name,
+			status: report.status
+		});
+	}
+});
+//#endregion
+//#region src/reporters/fileReporter.ts
+/**
+* Builds the `## Summary` section: the same counts the cli and json reporters expose, as a list of
+* `label  value` rows with the labels padded to a common width.
+*/
+function buildSummarySection(report) {
+	const { status, plugins, counts, filesCreated, durationMs, output } = report;
+	const rows = [["Status", status], ["Plugins", status === "success" ? `${plugins.passed} passed (${plugins.total})` : `${plugins.passed} passed | ${plugins.failed.length} failed (${plugins.total})`]];
+	if (plugins.failed.length > 0) rows.push(["Failed", plugins.failed.join(", ")]);
+	rows.push(["Issues", `${counts.errors} errors | ${counts.warnings} warnings | ${counts.infos} infos`]);
+	rows.push(["Files", `${filesCreated} generated`]);
+	rows.push(["Duration", require_memoryStorage.formatMs(durationMs)]);
+	rows.push(["Output", output]);
+	const labelWidth = Math.max(...rows.map(([label]) => label.length));
+	return [
+		"## Summary",
+		"",
+		...rows.map(([label, value]) => `  ${label.padEnd(labelWidth)}  ${value}`)
+	];
+}
+/**
+* Builds the `## Problems` section: each problem rendered in the miette block format, blocks
+* separated by a blank line. Returns an empty array when there are no problems, so the caller
+* can drop the heading.
+*/
+function buildProblemSection(diagnostics) {
+	const problems = diagnostics.filter(require_memoryStorage.Diagnostics.isProblem);
+	if (problems.length === 0) return [];
+	return [
+		"## Problems",
+		"",
+		problems.map((diagnostic) => require_memoryStorage.Diagnostics.formatLines(diagnostic).join("\n")).join("\n\n")
+	];
+}
+/**
+* Builds the `## Timings` section from a {@link Report}: one `plugin   duration` row per record,
+* slowest first with the plugin names left-aligned and the durations right-aligned. Returns an
+* empty array when there are no timings.
+*/
+function buildTimingSection(report) {
+	const { timings } = report;
+	if (timings.length === 0) return [];
+	const nameWidth = Math.max(...timings.map((timing) => timing.plugin.length));
+	const durations = timings.map((timing) => require_memoryStorage.formatMs(timing.durationMs));
+	const durationWidth = Math.max(...durations.map((duration) => duration.length));
+	return [
+		"## Timings",
+		"",
+		...timings.map((timing, index) => `  ${timing.plugin.padEnd(nameWidth)}  ${durations[index].padStart(durationWidth)}`)
+	];
+}
+/**
+* The `file` reporter. Writes a config's {@link Report} to `.kubb/kubb-<name>-<timestamp>.log` as a
+* plain-text document: a `# <name> — <timestamp>` header, a `## Summary` with the same counts the
+* cli and json reporters expose, a `## Problems` section in the miette block format, and a
+* `## Timings` section. Selected with `--reporter file` (or `reporters: ['file']`), replacing the
+* old `--debug` flag.
+*
+* @note Unlike the streaming logger it replaced, it captures the collected diagnostics once a
+* config finishes, not the live `kubb:info`/`kubb:plugin` event stream. Color is stripped so the
+* file stays plain text even when the run is attached to a TTY.
+*/
+const fileReporter = createReporter({
+	name: "file",
+	async report(result) {
+		const { diagnostics, config } = result;
+		if (diagnostics.length === 0) return;
+		const report = buildReport(result);
+		const content = (0, node_util.stripVTControlCharacters)([config.name ? `# ${config.name} — ${(/* @__PURE__ */ new Date()).toISOString()}` : `# ${(/* @__PURE__ */ new Date()).toISOString()}`, ...[
+			buildSummarySection(report),
+			buildProblemSection(diagnostics),
+			buildTimingSection(report)
+		].filter((section) => section.length > 0).map((section) => section.join("\n"))].join("\n\n"));
+		const baseName = `${[
+			"kubb",
+			config.name,
+			Date.now()
+		].filter(Boolean).join("-")}.log`;
+		const pathName = (0, node_path.resolve)(node_process.default.cwd(), ".kubb", baseName);
+		await write(pathName, `${content}\n`);
+		console.error(`Debug log written to ${(0, node_path.relative)(node_process.default.cwd(), pathName)}`);
+	}
+});
+//#endregion
+//#region src/reporters/jsonReporter.ts
+/**
+* The `json` reporter. `report` returns one config's {@link Report}, which {@link createReporter}
+* buffers, and `drain` writes them as a single pretty-printed JSON array on `kubb:lifecycle:end`.
+* Buffering keeps a multi-config run one valid JSON document on stdout instead of concatenated
+* objects that would break `jq .`. The terminal reporter is suppressed while `json` is active so
+* stdout stays valid JSON.
+*/
+const jsonReporter = createReporter({
+	name: "json",
+	report(result) {
+		return buildReport(result);
+	},
+	drain(_context, reports) {
+		node_process.default.stdout.write(`${JSON.stringify(reports, null, 2)}\n`);
+	}
+});
+//#endregion
+//#region src/Telemetry.ts
+/**
+* Anonymous OTLP usage telemetry for the Kubb run. All methods are static, so call them as
+* `Telemetry.build(...)`, `Telemetry.send(...)`, and `Telemetry.isDisabled()`. No file paths,
+* OpenAPI specs, or secrets are ever included, and sending fails silently to never break a run.
+*/
+var Telemetry = class Telemetry {
+	/**
+	* Returns `true` when telemetry is disabled via `DO_NOT_TRACK` or `KUBB_DISABLE_TELEMETRY`.
+	*/
+	static isDisabled() {
+		return node_process.default.env["DO_NOT_TRACK"] === "1" || node_process.default.env["DO_NOT_TRACK"] === "true" || node_process.default.env["KUBB_DISABLE_TELEMETRY"] === "1" || node_process.default.env["KUBB_DISABLE_TELEMETRY"] === "true";
+	}
+	/**
+	* Build an anonymous telemetry payload from a completed generation run.
+	*/
+	static build(options) {
+		const [seconds, nanoseconds] = node_process.default.hrtime(options.hrStart);
+		const duration = Math.round(seconds * 1e3 + nanoseconds / 1e6);
+		return {
+			command: options.command,
+			kubbVersion: options.kubbVersion,
+			nodeVersion: node_process.default.versions.node.split(".")[0],
+			platform: node_os.default.platform(),
+			ci: isCIEnvironment(),
+			plugins: options.plugins ?? [],
+			duration,
+			filesCreated: options.filesCreated ?? 0,
+			status: options.status
+		};
+	}
+	/**
+	* Convert a {@link TelemetryEvent} into an OTLP-compatible JSON trace payload.
+	* See https://opentelemetry.io/docs/languages/sdk-configuration/otlp-exporter/
+	*/
+	static buildOtlpPayload(event) {
+		const traceId = (0, node_crypto.randomBytes)(16).toString("hex");
+		const spanId = (0, node_crypto.randomBytes)(8).toString("hex");
+		const endTimeNs = BigInt(Date.now()) * 1000000n;
+		const startTimeNs = endTimeNs - BigInt(event.duration) * 1000000n;
+		const attributes = [
+			{
+				key: "kubb.command",
+				value: { stringValue: event.command }
+			},
+			{
+				key: "kubb.version",
+				value: { stringValue: event.kubbVersion }
+			},
+			{
+				key: "kubb.node_version",
+				value: { stringValue: event.nodeVersion }
+			},
+			{
+				key: "kubb.platform",
+				value: { stringValue: event.platform }
+			},
+			{
+				key: "kubb.ci",
+				value: { boolValue: event.ci }
+			},
+			{
+				key: "kubb.files_created",
+				value: { intValue: event.filesCreated }
+			},
+			{
+				key: "kubb.status",
+				value: { stringValue: event.status }
+			},
+			{
+				key: "kubb.plugins",
+				value: { arrayValue: { values: event.plugins.map((p) => ({ kvlistValue: { values: [{
+					key: "name",
+					value: { stringValue: p.name }
+				}, {
+					key: "options",
+					value: { stringValue: JSON.stringify({
+						...p.options,
+						usedEnumNames: void 0
+					}) }
+				}] } })) } }
+			}
+		];
+		return { resourceSpans: [{
+			resource: { attributes: [
+				{
+					key: "service.name",
+					value: { stringValue: "kubb-core" }
+				},
+				{
+					key: "service.version",
+					value: { stringValue: event.kubbVersion }
+				},
+				{
+					key: "telemetry.sdk.language",
+					value: { stringValue: "nodejs" }
+				}
+			] },
+			scopeSpans: [{
+				scope: {
+					name: "kubb-core",
+					version: event.kubbVersion
+				},
+				spans: [{
+					traceId,
+					spanId,
+					name: event.command,
+					kind: 1,
+					startTimeUnixNano: String(startTimeNs),
+					endTimeUnixNano: String(endTimeNs),
+					attributes,
+					status: { code: event.status === "success" ? 1 : 2 }
+				}]
+			}]
+		}] };
+	}
+	/**
+	* Send an anonymous telemetry event to the Kubb OTLP endpoint. Respects `DO_NOT_TRACK` and
+	* `KUBB_DISABLE_TELEMETRY`, and fails silently so telemetry never interrupts a run.
+	*/
+	static async send(event) {
+		if (Telemetry.isDisabled()) return;
+		await executeIfOnline(async () => {
+			try {
+				await fetch(`${require_memoryStorage.OTLP_ENDPOINT}/v1/traces`, {
+					method: "POST",
+					headers: {
+						"Content-Type": "application/json",
+						"Kubb-Telemetry-Version": "1",
+						"Kubb-Telemetry-Source": "kubb-core"
+					},
+					body: JSON.stringify(Telemetry.buildOtlpPayload(event)),
+					signal: AbortSignal.timeout(5e3)
+				});
+			} catch (_e) {}
+		});
+	}
+};
+//#endregion
 //#region src/createRenderer.ts
 /**
-* Creates a renderer factory for use in generator definitions.
+* Defines a renderer factory. Renderers turn the generator's return value
+* (JSX, a template string, a tree of any shape) into `FileNode`s that get
+* written to disk.
 *
-* 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.
+* Use this to support output formats beyond JSX, for instance, a Handlebars
+* renderer, a string-template renderer, or a renderer that writes binary
+* files. Plugins and generators pick the renderer to use via the `renderer`
+* field on `defineGenerator`.
 *
-* @example
+* @example A minimal renderer that wraps a custom runtime
 * ```ts
-* // packages/renderer-jsx/src/index.ts
-* export const jsxRenderer = createRenderer(() => {
-*   const runtime = new Runtime()
+* import { createRenderer } from '@kubb/core'
+*
+* export const myRenderer = createRenderer(() => {
+*   const runtime = new MyRuntime()
 *   return {
-*     async render(element) { await runtime.render(element) },
-*     get files() { return runtime.nodes },
-*     unmount(error) { runtime.unmount(error) },
+*     async render(element) {
+*       await runtime.render(element)
+*     },
+*     get files() {
+*       return runtime.files
+*     },
+*     dispose() {
+*       runtime.dispose()
+*     },
+*     unmount(error) {
+*       runtime.dispose(error)
+*     },
+*     [Symbol.dispose]() {
+*       this.dispose()
+*     },
 *   }
 * })
-*
-* // 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 createRenderer(factory) {
@@ -1294,47 +940,50 @@ function createRenderer(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
-/**
-* Wraps a logger definition into a typed {@link Logger}.
+* Defines a generator: a unit of work that runs during the plugin's AST walk
+* and produces files. Plugins register generators via `ctx.addGenerator()`
+* inside `kubb:plugin:setup`.
 *
-* @example
-* ```ts
-* 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))
+* The returned object is the input as-is, but with `this` types preserved so
+* `schema`/`operation`/`operations` methods are correctly typed against the
+* plugin's `PluginFactoryOptions`. Renderer elements and `FileNode[]` returns
+* are both handled by the runtime, so pick whichever style fits.
+*
+* @example JSX-based schema generator
+* ```tsx
+* import { defineGenerator } from '@kubb/core'
+* import { jsxRenderer } from '@kubb/renderer-jsx'
+*
+* export const typeGenerator = defineGenerator({
+*   name: 'typescript',
+*   renderer: jsxRenderer,
+*   schema(node, ctx) {
+*     return (
+*       <File path={`${ctx.root}/${node.name}.ts`}>
+*         <Type node={node} resolver={ctx.resolver} />
+*       </File>
+*     )
 *   },
 * })
 * ```
 */
-function defineLogger(logger) {
-	return logger;
+function defineGenerator(generator) {
+	return generator;
 }
 //#endregion
 //#region src/defineMiddleware.ts
 /**
-* Creates a middleware factory using the hook-style `hooks` API.
-*
-* Middleware handlers fire after all plugin handlers for any given event, making them ideal for post-processing, logging, and auditing.
-* Per-build state (such as accumulators) belongs inside the factory closure so each `createKubb` invocation gets its own isolated instance.
+* Creates a middleware factory. Middleware fires after every plugin handler
+* for the same event, which makes it the natural place for post-processing
+* (barrel files, lint runs, audit logs).
 *
-* @note The factory can accept typed options. See examples for using options and per-build state patterns.
+* Per-build state belongs inside the factory closure so each `createKubb`
+* invocation gets its own isolated instance.
 *
-* @example
+* @example Stateless middleware
 * ```ts
 * import { defineMiddleware } from '@kubb/core'
 *
-* // Stateless middleware
 * export const logMiddleware = defineMiddleware(() => ({
 *   name: 'log-middleware',
 *   hooks: {
@@ -1343,8 +992,12 @@ function defineLogger(logger) {
 *     },
 *   },
 * }))
+* ```
+*
+* @example Middleware with options and per-build state
+* ```ts
+* import { defineMiddleware } from '@kubb/core'
 *
-* // Middleware with options and per-build state
 * export const prefixMiddleware = defineMiddleware((options: { prefix: string } = { prefix: '' }) => {
 *   const seen = new Set<string>()
 *   return {
@@ -1364,20 +1017,23 @@ function defineMiddleware(factory) {
 //#endregion
 //#region src/defineParser.ts
 /**
-* Defines a parser with type safety. Creates parsers that transform generated files to strings based on their extension.
-*
-* @note Call the returned factory with optional options to instantiate the parser.
+* Defines a parser with type-safe `this`. Used to register handlers for new
+* file extensions or to plug a non-TypeScript output into the build.
 *
 * @example
 * ```ts
-* import { defineParser } from '@kubb/core'
+* import { defineParser, ast } 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')
+*     return file.sources
+*       .map((source) => ast.extractStringsFromNodes(source.nodes ?? []))
+*       .join('\n')
+*   },
+*   print(...nodes) {
+*     return nodes.map(String).join('\n')
 *   },
 * })
 * ```
@@ -1386,108 +1042,34 @@ function defineParser(parser) {
 	return parser;
 }
 //#endregion
-//#region src/definePlugin.ts
-/**
-* Wraps a factory function and returns a typed `Plugin` with lifecycle handlers grouped under `hooks`.
-*
-* Handlers live in a single `hooks` object (inspired by Astro integrations).
-* All lifecycle events from `KubbHooks` are available for subscription.
-*
-* @note For real plugins, use a `PluginFactoryOptions` type parameter to get type-safe context in `kubb:plugin:setup`.
-* Plugin names should follow the convention `plugin-<feature>` (e.g., `plugin-react-query`, `plugin-zod`).
-*
-* @example
-* ```ts
-* import { definePlugin } from '@kubb/core'
-*
-* export const pluginTs = definePlugin((options: { prefix?: string } = {}) => ({
-*   name: 'plugin-ts',
-*   hooks: {
-*     'kubb:plugin:setup'(ctx) {
-*       ctx.setResolver(resolverTs)
-*     },
-*   },
-* }))
-* ```
-*/
-function definePlugin(factory) {
-	return (options) => factory(options ?? {});
-}
-//#endregion
-//#region src/storages/memoryStorage.ts
-/**
-* In-memory storage driver. Useful for testing and dry-run scenarios where
-* generated output should be captured without touching the filesystem.
-*
-* All data lives in a `Map` scoped to the storage instance and is discarded
-* when the instance is garbage-collected.
-*
-* @example
-* ```ts
-* import { memoryStorage } from '@kubb/core'
-* import { defineConfig } from 'kubb'
-*
-* export default defineConfig({
-*   input:  { path: './petStore.yaml' },
-*   output: { path: './src/gen' },
-*   storage: memoryStorage(),
-* })
-* ```
-*/
-const memoryStorage = createStorage(() => {
-	const store = /* @__PURE__ */ new Map();
-	return {
-		name: "memory",
-		async hasItem(key) {
-			return store.has(key);
-		},
-		async getItem(key) {
-			return store.get(key) ?? null;
-		},
-		async setItem(key, value) {
-			store.set(key, value);
-		},
-		async removeItem(key) {
-			store.delete(key);
-		},
-		async getKeys(base) {
-			const keys = [...store.keys()];
-			return base ? keys.filter((k) => k.startsWith(base)) : keys;
-		},
-		async clear(base) {
-			if (!base) {
-				store.clear();
-				return;
-			}
-			for (const key of store.keys()) if (key.startsWith(base)) store.delete(key);
-		}
-	};
-});
-//#endregion
-exports.AsyncEventEmitter = AsyncEventEmitter;
-exports.FileManager = require_PluginDriver.FileManager;
-exports.FileProcessor = FileProcessor;
-exports.PluginDriver = require_PluginDriver.PluginDriver;
-exports.URLPath = URLPath;
+exports.AsyncEventEmitter = require_memoryStorage.AsyncEventEmitter;
+exports.Diagnostics = require_memoryStorage.Diagnostics;
+exports.KubbDriver = require_memoryStorage.KubbDriver;
+exports.Telemetry = Telemetry;
+exports.URLPath = require_memoryStorage.URLPath;
 Object.defineProperty(exports, "ast", {
 	enumerable: true,
 	get: function() {
 		return _kubb_ast;
 	}
 });
+exports.cliReporter = cliReporter;
 exports.createAdapter = createAdapter;
 exports.createKubb = createKubb;
 exports.createRenderer = createRenderer;
-exports.createStorage = createStorage;
+exports.createReporter = createReporter;
+exports.createStorage = require_memoryStorage.createStorage;
 exports.defineGenerator = defineGenerator;
 exports.defineLogger = defineLogger;
 exports.defineMiddleware = defineMiddleware;
 exports.defineParser = defineParser;
-exports.definePlugin = definePlugin;
-exports.defineResolver = require_PluginDriver.defineResolver;
+exports.definePlugin = require_memoryStorage.definePlugin;
+exports.defineResolver = require_memoryStorage.defineResolver;
+exports.fileReporter = fileReporter;
 exports.fsStorage = fsStorage;
-exports.isInputPath = isInputPath;
-exports.logLevel = require_PluginDriver.logLevel;
-exports.memoryStorage = memoryStorage;
+exports.jsonReporter = jsonReporter;
+exports.logLevel = logLevel;
+exports.memoryStorage = require_memoryStorage.memoryStorage;
+exports.selectReporters = selectReporters;
 
 //# sourceMappingURL=index.cjs.map