@kubb/core 5.0.0-alpha.43 → 5.0.0-alpha.45

package/dist/{PluginDriver-CgXFtmNP.js → PluginDriver-Bt_UCn7-.js}

@@ -1,7 +1,6 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import path, { basename, extname, resolve } from "node:path";
+import "./chunk--u3MIqq1.js";
+import path, { extname, resolve } from "node:path";
 import { createFile, isOperationNode, isSchemaNode } from "@kubb/ast";
-import { performance } from "node:perf_hooks";
 import { deflateSync } from "fflate";
 import { x } from "tinyexec";
 //#region ../../internals/utils/src/casing.ts
@@ -62,141 +61,6 @@ function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
 //#endregion
-//#region ../../internals/utils/src/promise.ts
-/** Returns `true` when `result` is a rejected `Promise.allSettled` result with a typed `reason`.
-*
-* @example
-* ```ts
-* const results = await Promise.allSettled([p1, p2])
-* results.filter(isPromiseRejectedResult<Error>).map((r) => r.reason.message)
-* ```
-*/
-function isPromiseRejectedResult(result) {
-	return result.status === "rejected";
-}
-//#endregion
-//#region ../../internals/utils/src/reserved.ts
-/**
-* JavaScript and Java reserved words.
-* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
-*/
-const reservedWords = new Set([
-	"abstract",
-	"arguments",
-	"boolean",
-	"break",
-	"byte",
-	"case",
-	"catch",
-	"char",
-	"class",
-	"const",
-	"continue",
-	"debugger",
-	"default",
-	"delete",
-	"do",
-	"double",
-	"else",
-	"enum",
-	"eval",
-	"export",
-	"extends",
-	"false",
-	"final",
-	"finally",
-	"float",
-	"for",
-	"function",
-	"goto",
-	"if",
-	"implements",
-	"import",
-	"in",
-	"instanceof",
-	"int",
-	"interface",
-	"let",
-	"long",
-	"native",
-	"new",
-	"null",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"return",
-	"short",
-	"static",
-	"super",
-	"switch",
-	"synchronized",
-	"this",
-	"throw",
-	"throws",
-	"transient",
-	"true",
-	"try",
-	"typeof",
-	"var",
-	"void",
-	"volatile",
-	"while",
-	"with",
-	"yield",
-	"Array",
-	"Date",
-	"hasOwnProperty",
-	"Infinity",
-	"isFinite",
-	"isNaN",
-	"isPrototypeOf",
-	"length",
-	"Math",
-	"name",
-	"NaN",
-	"Number",
-	"Object",
-	"prototype",
-	"String",
-	"toString",
-	"undefined",
-	"valueOf"
-]);
-/**
-* Prefixes `word` with `_` when it is a reserved JavaScript/Java identifier or starts with a digit.
-*
-* @example
-* ```ts
-* transformReservedWord('class')  // '_class'
-* transformReservedWord('42foo')  // '_42foo'
-* transformReservedWord('status') // 'status'
-* ```
-*/
-function transformReservedWord(word) {
-	const firstChar = word.charCodeAt(0);
-	if (word && (reservedWords.has(word) || firstChar >= 48 && firstChar <= 57)) return `_${word}`;
-	return word;
-}
-/**
-* Returns `true` when `name` is a syntactically valid JavaScript variable name.
-*
-* @example
-* ```ts
-* isValidVarName('status')  // true
-* isValidVarName('class')   // false (reserved word)
-* isValidVarName('42foo')   // false (starts with digit)
-* ```
-*/
-function isValidVarName(name) {
-	try {
-		new Function(`var ${name}`);
-	} catch {
-		return false;
-	}
-	return true;
-}
-//#endregion
 //#region ../../internals/utils/src/string.ts
 /**
 * Strips the file extension from a path or file name.
@@ -220,9 +84,16 @@ function trimExtName(text) {
 */
 const DEFAULT_STUDIO_URL = "https://studio.kubb.dev";
 /**
+* Basename (without extension) of generated barrel files.
+*
+* Used to detect whether a path already points at a barrel so the generator
+* avoids re-creating one on top of it.
+*/
+const BARREL_BASENAME = "index";
+/**
 * File name used for generated barrel (index) files.
 */
-const BARREL_FILENAME = "index.ts";
+const BARREL_FILENAME = `${BARREL_BASENAME}.ts`;
 /**
 * Default banner style written at the top of every generated file.
 */
@@ -245,184 +116,29 @@ const logLevel = {
 	debug: 5
 };
 //#endregion
-//#region ../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
-var Node$1 = class {
-	static {
-		__name(this, "Node");
-	}
-	value;
-	next;
-	constructor(value) {
-		this.value = value;
-	}
-};
-var Queue = class {
-	#head;
-	#tail;
-	#size;
-	constructor() {
-		this.clear();
-	}
-	enqueue(value) {
-		const node = new Node$1(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;
+//#region src/defineResolver.ts
+const stringPatternCache = /* @__PURE__ */ new Map();
+function testPattern(value, pattern) {
+	if (typeof pattern === "string") {
+		let regex = stringPatternCache.get(pattern);
+		if (!regex) {
+			regex = new RegExp(pattern);
+			stringPatternCache.set(pattern, regex);
 		}
+		return regex.test(value);
 	}
-	*drain() {
-		while (this.#head) yield this.dequeue();
-	}
-};
-//#endregion
-//#region ../../node_modules/.pnpm/p-limit@7.3.0/node_modules/p-limit/index.js
-function pLimit(concurrency) {
-	let rejectOnClear = false;
-	if (typeof concurrency === "object") ({concurrency, rejectOnClear = false} = concurrency);
-	validateConcurrency(concurrency);
-	if (typeof rejectOnClear !== "boolean") throw new TypeError("Expected `rejectOnClear` to be a boolean");
-	const queue = new Queue();
-	let activeCount = 0;
-	const resumeNext = () => {
-		if (activeCount < concurrency && queue.size > 0) {
-			activeCount++;
-			queue.dequeue().run();
-		}
-	};
-	const next = () => {
-		activeCount--;
-		resumeNext();
-	};
-	const run = async (function_, resolve, arguments_) => {
-		const result = (async () => function_(...arguments_))();
-		resolve(result);
-		try {
-			await result;
-		} catch {}
-		next();
-	};
-	const enqueue = (function_, resolve, reject, arguments_) => {
-		const queueItem = { reject };
-		new Promise((internalResolve) => {
-			queueItem.run = internalResolve;
-			queue.enqueue(queueItem);
-		}).then(run.bind(void 0, function_, resolve, arguments_));
-		if (activeCount < concurrency) resumeNext();
-	};
-	const generator = (function_, ...arguments_) => new Promise((resolve, reject) => {
-		enqueue(function_, resolve, reject, arguments_);
-	});
-	Object.defineProperties(generator, {
-		activeCount: { get: () => activeCount },
-		pendingCount: { get: () => queue.size },
-		clearQueue: { value() {
-			if (!rejectOnClear) {
-				queue.clear();
-				return;
-			}
-			const abortError = AbortSignal.abort().reason;
-			while (queue.size > 0) queue.dequeue().reject(abortError);
-		} },
-		concurrency: {
-			get: () => concurrency,
-			set(newConcurrency) {
-				validateConcurrency(newConcurrency);
-				concurrency = newConcurrency;
-				queueMicrotask(() => {
-					while (activeCount < concurrency && queue.size > 0) resumeNext();
-				});
-			}
-		},
-		map: { async value(iterable, function_) {
-			const promises = Array.from(iterable, (value, index) => this(function_, value, index));
-			return Promise.all(promises);
-		} }
-	});
-	return generator;
-}
-function validateConcurrency(concurrency) {
-	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) throw new TypeError("Expected `concurrency` to be a number from 1 and up");
-}
-//#endregion
-//#region src/definePlugin.ts
-/**
-* Returns `true` when `plugin` is a hook-style plugin created with `definePlugin`.
-*
-* Used by `PluginDriver` to distinguish hook-style plugins from legacy `createPlugin` plugins
-* so it can normalize them and register their handlers on the `AsyncEventEmitter`.
-*/
-function isHookStylePlugin(plugin) {
-	return typeof plugin === "object" && plugin !== null && "hooks" in plugin;
+	return value.match(pattern) !== null;
 }
 /**
-* Creates a plugin factory using the new hook-style (`hooks:`) API.
-*
-* The returned factory is called with optional options and produces a `HookStylePlugin`
-* that coexists with plugins created via the legacy `createPlugin` API in the same
-* `kubb.config.ts`.
-*
-* Lifecycle handlers are registered on the `PluginDriver`'s `AsyncEventEmitter`, enabling
-* both the plugin's own handlers and external tooling (CLI, devtools) to observe every event.
-*
-* @example
-* ```ts
-* // With PluginFactoryOptions (recommended for real plugins)
-* export const pluginTs = definePlugin<PluginTs>((options) => ({
-*   name: 'plugin-ts',
-*   hooks: {
-*     'kubb:plugin:setup'(ctx) {
-*       ctx.setResolver(resolverTs)  // typed as Partial<ResolverTs>
-*     },
-*   },
-* }))
-* ```
-*/
-function definePlugin(factory) {
-	return (options) => factory(options ?? {});
-}
-//#endregion
-//#region src/defineResolver.ts
-/**
 * Checks if an operation matches a pattern for a given filter type (`tag`, `operationId`, `path`, `method`).
 */
 function matchesOperationPattern(node, type, pattern) {
 	switch (type) {
-		case "tag": return node.tags.some((tag) => !!tag.match(pattern));
-		case "operationId": return !!node.operationId.match(pattern);
-		case "path": return !!node.path.match(pattern);
-		case "method": return !!node.method.toLowerCase().match(pattern);
-		case "contentType": return !!node.requestBody?.contentType?.match(pattern);
+		case "tag": return node.tags.some((tag) => testPattern(tag, pattern));
+		case "operationId": return testPattern(node.operationId, pattern);
+		case "path": return testPattern(node.path, pattern);
+		case "method": return testPattern(node.method.toLowerCase(), pattern);
+		case "contentType": return node.requestBody?.contentType ? testPattern(node.requestBody.contentType, pattern) : false;
 		default: return false;
 	}
 }
@@ -433,7 +149,7 @@ function matchesOperationPattern(node, type, pattern) {
 */
 function matchesSchemaPattern(node, type, pattern) {
 	switch (type) {
-		case "schemaName": return node.name ? !!node.name.match(pattern) : false;
+		case "schemaName": return node.name ? testPattern(node.name, pattern) : false;
 		default: return null;
 	}
 }
@@ -827,17 +543,16 @@ var FileManager = class {
 	add(...files) {
 		const resolvedFiles = [];
 		const mergedFiles = /* @__PURE__ */ new Map();
-		files.forEach((file) => {
+		for (const file of files) {
 			const existing = mergedFiles.get(file.path);
-			if (existing) mergedFiles.set(file.path, mergeFile(existing, file));
-			else mergedFiles.set(file.path, file);
-		});
+			mergedFiles.set(file.path, existing ? mergeFile(existing, file) : file);
+		}
 		for (const file of mergedFiles.values()) {
 			const resolvedFile = createFile(file);
 			this.#cache.set(resolvedFile.path, resolvedFile);
-			this.#filesCache = null;
 			resolvedFiles.push(resolvedFile);
 		}
+		this.#filesCache = null;
 		return resolvedFiles;
 	}
 	/**
@@ -847,18 +562,17 @@ var FileManager = class {
 	upsert(...files) {
 		const resolvedFiles = [];
 		const mergedFiles = /* @__PURE__ */ new Map();
-		files.forEach((file) => {
+		for (const file of files) {
 			const existing = mergedFiles.get(file.path);
-			if (existing) mergedFiles.set(file.path, mergeFile(existing, file));
-			else mergedFiles.set(file.path, file);
-		});
+			mergedFiles.set(file.path, existing ? mergeFile(existing, file) : file);
+		}
 		for (const file of mergedFiles.values()) {
 			const existing = this.#cache.get(file.path);
 			const resolvedFile = createFile(existing ? mergeFile(existing, file) : file);
 			this.#cache.set(resolvedFile.path, resolvedFile);
-			this.#filesCache = null;
 			resolvedFiles.push(resolvedFile);
 		}
+		this.#filesCache = null;
 		return resolvedFiles;
 	}
 	getByPath(path) {
@@ -878,10 +592,17 @@ var FileManager = class {
 	*/
 	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(a).endsWith("index");
-			if (aIsIndex !== trimExtName(b).endsWith("index")) return aIsIndex ? 1 : -1;
+		const keys = [...this.#cache.keys()];
+		const meta = /* @__PURE__ */ new Map();
+		for (const key of keys) meta.set(key, {
+			length: key.length,
+			isIndex: trimExtName(key).endsWith(BARREL_BASENAME)
+		});
+		keys.sort((a, b) => {
+			const ma = meta.get(a);
+			const mb = meta.get(b);
+			if (ma.length !== mb.length) return ma.length - mb.length;
+			if (ma.isIndex !== mb.isIndex) return ma.isIndex ? 1 : -1;
 			return 0;
 		});
 		const files = [];
@@ -918,55 +639,7 @@ async function applyHookResult(result, driver, rendererFactory) {
 	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
-const hookFirstNullCheck = (state) => !!state?.result;
 var PluginDriver = class PluginDriver {
 	config;
 	options;
@@ -1007,18 +680,8 @@ var PluginDriver = class PluginDriver {
 	#hookListeners = /* @__PURE__ */ new Map();
 	constructor(config, options) {
 		this.config = config;
-		this.options = {
-			...options,
-			hooks: options.hooks
-		};
-		config.plugins.map((rawPlugin) => {
-			if (isHookStylePlugin(rawPlugin)) return this.#normalizeHookStylePlugin(rawPlugin);
-			return {
-				...rawPlugin,
-				buildStart: rawPlugin.buildStart ?? (() => {}),
-				buildEnd: rawPlugin.buildEnd ?? (() => {})
-			};
-		}).filter((plugin) => {
+		this.options = options;
+		config.plugins.map((rawPlugin) => this.#normalizePlugin(rawPlugin)).filter((plugin) => {
 			if (typeof plugin.apply === "function") return plugin.apply(config);
 			return true;
 		}).sort((a, b) => {
@@ -1030,20 +693,13 @@ var PluginDriver = class PluginDriver {
 		});
 	}
 	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
+	* Creates an `NormalizedPlugin` 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;
+	#normalizePlugin(hookPlugin) {
 		const normalizedPlugin = {
 			name: hookPlugin.name,
 			dependencies: hookPlugin.dependencies,
@@ -1051,29 +707,7 @@ var PluginDriver = class PluginDriver {
 				output: { path: "." },
 				exclude: [],
 				override: []
-			},
-			generators,
-			inject: () => void 0,
-			resolveName(name, type) {
-				return driver.getResolver(hookPlugin.name).default(name, type);
-			},
-			resolvePath(baseName, pathMode, resolveOptions) {
-				const resolver = driver.getResolver(hookPlugin.name);
-				const opts = normalizedPlugin.options;
-				const group = resolveOptions?.group;
-				return resolver.resolvePath({
-					baseName,
-					pathMode,
-					tag: group?.tag,
-					path: group?.path
-				}, {
-					root: resolve(driver.config.root, driver.config.output.path),
-					output: opts.output,
-					group: opts.group
-				});
-			},
-			buildStart() {},
-			buildEnd() {}
+			}
 		};
 		this.registerPluginHooks(hookPlugin, normalizedPlugin);
 		return normalizedPlugin;
@@ -1090,6 +724,8 @@ var PluginDriver = class PluginDriver {
 	*
 	* External tooling can subscribe to any of these events via `hooks.on(...)` to observe
 	* the plugin lifecycle without modifying plugin behavior.
+	*
+	* @internal
 	*/
 	registerPluginHooks(hookPlugin, normalizedPlugin) {
 		const { hooks } = hookPlugin;
@@ -1116,15 +752,13 @@ var PluginDriver = class PluginDriver {
 							...opts
 						};
 					},
-					injectFile: (file) => {
-						const fileNode = createFile({
-							baseName: file.baseName,
-							path: file.path,
-							sources: file.sources ?? [],
+					injectFile: ({ sources = [], ...rest }) => {
+						this.fileManager.add(createFile({
 							imports: [],
-							exports: []
-						});
-						this.fileManager.add(fileNode);
+							exports: [],
+							sources,
+							...rest
+						}));
 					}
 				};
 				return hooks["kubb:plugin:setup"](pluginCtx);
@@ -1145,16 +779,17 @@ var PluginDriver = class PluginDriver {
 	* Call this once from `safeBuild` before the plugin execution loop begins.
 	*/
 	async emitSetupHooks() {
+		const noop = () => {};
 		await this.hooks.emit("kubb:plugin:setup", {
 			config: this.config,
-			addGenerator: () => {},
-			setResolver: () => {},
-			setTransformer: () => {},
-			setRenderer: () => {},
-			setOptions: () => {},
-			injectFile: () => {},
-			updateConfig: () => {},
-			options: {}
+			options: {},
+			addGenerator: noop,
+			setResolver: noop,
+			setTransformer: noop,
+			setRenderer: noop,
+			setOptions: noop,
+			injectFile: noop,
+			updateConfig: noop
 		});
 	}
 	/**
@@ -1212,6 +847,12 @@ var PluginDriver = class PluginDriver {
 	hasRegisteredGenerators(pluginName) {
 		return this.#pluginsWithEventGenerators.has(pluginName);
 	}
+	/**
+	* Unregisters all plugin lifecycle listeners from the shared event emitter.
+	* Called at the end of a build to prevent listener leaks across repeated builds.
+	*
+	* @internal
+	*/
 	dispose() {
 		for (const [event, handlers] of this.#hookListeners) for (const handler of handlers) this.hooks.off(event, handler);
 		this.#hookListeners.clear();
@@ -1235,6 +876,11 @@ var PluginDriver = class PluginDriver {
 		this.#defaultResolvers.set(pluginName, resolver);
 		return resolver;
 	}
+	/**
+	* Merges `partial` with the plugin's default resolver and stores the result.
+	* Also mirrors it onto `plugin.resolver` so callers using `getPlugin(name).resolver`
+	* get the up-to-date resolver without going through `getResolver()`.
+	*/
 	setPluginResolver(pluginName, partial) {
 		const merged = {
 			...this.#createDefaultResolver(pluginName),
@@ -1244,16 +890,18 @@ var PluginDriver = class PluginDriver {
 		const plugin = this.plugins.get(pluginName);
 		if (plugin) plugin.resolver = merged;
 	}
+	/**
+	* Returns the resolver for the given plugin.
+	*
+	* Resolution order: dynamic resolver set via `setPluginResolver` → static resolver on the
+	* plugin → lazily created default resolver (identity name, no path transforms).
+	*/
 	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);
+		return this.#resolvers.get(pluginName) ?? this.plugins.get(pluginName)?.resolver ?? this.#createDefaultResolver(pluginName);
 	}
 	getContext(plugin) {
 		const driver = this;
-		const baseContext = {
+		return {
 			config: driver.config,
 			get root() {
 				return resolve(driver.config.root, driver.config.output.path);
@@ -1302,225 +950,6 @@ var PluginDriver = class PluginDriver {
 				return openInStudio(driver.inputNode, studioUrl, options);
 			}
 		};
-		let mergedExtras = {};
-		for (const p of this.plugins.values()) if (typeof p.inject === "function") {
-			const result = p.inject.call(baseContext);
-			if (result !== null && typeof result === "object") mergedExtras = {
-				...mergedExtras,
-				...result
-			};
-		}
-		return {
-			...baseContext,
-			...mergedExtras
-		};
-	}
-	/**
-	* @deprecated use resolvers context instead
-	*/
-	getFile({ name, mode, extname, pluginName, options }) {
-		const resolvedName = mode ? mode === "single" ? "" : this.resolveName({
-			name,
-			pluginName,
-			type: "file"
-		}) : name;
-		const path = this.resolvePath({
-			baseName: `${resolvedName}${extname}`,
-			mode,
-			pluginName,
-			options
-		});
-		if (!path) throw new Error(`Filepath should be defined for resolvedName "${resolvedName}" and pluginName "${pluginName}"`);
-		return createFile({
-			path,
-			baseName: basename(path),
-			meta: { pluginName },
-			sources: [],
-			imports: [],
-			exports: []
-		});
-	}
-	/**
-	* @deprecated use resolvers context instead
-	*/
-	resolvePath = (params) => {
-		const defaultPath = resolve(resolve(this.config.root, this.config.output.path), params.baseName);
-		if (params.pluginName) return this.hookForPluginSync({
-			pluginName: params.pluginName,
-			hookName: "resolvePath",
-			parameters: [
-				params.baseName,
-				params.mode,
-				params.options
-			]
-		})?.at(0) || defaultPath;
-		return this.hookFirstSync({
-			hookName: "resolvePath",
-			parameters: [
-				params.baseName,
-				params.mode,
-				params.options
-			]
-		})?.result || defaultPath;
-	};
-	/**
-	* @deprecated use resolvers context instead
-	*/
-	resolveName = (params) => {
-		if (params.pluginName) return transformReservedWord(this.hookForPluginSync({
-			pluginName: params.pluginName,
-			hookName: "resolveName",
-			parameters: [params.name.trim(), params.type]
-		})?.at(0) ?? params.name);
-		const name = this.hookFirstSync({
-			hookName: "resolveName",
-			parameters: [params.name.trim(), params.type]
-		})?.result;
-		return transformReservedWord(name ?? params.name);
-	};
-	/**
-	* Run a specific hookName for plugin x.
-	*/
-	async hookForPlugin({ pluginName, hookName, parameters }) {
-		const plugin = this.plugins.get(pluginName);
-		if (!plugin) return [null];
-		this.hooks.emit("kubb:plugins:hook:progress:start", {
-			hookName,
-			plugins: [plugin]
-		});
-		const result = await this.#execute({
-			strategy: "hookFirst",
-			hookName,
-			parameters,
-			plugin
-		});
-		this.hooks.emit("kubb:plugins:hook:progress:end", { hookName });
-		return [result];
-	}
-	/**
-	* Run a specific hookName for plugin x.
-	*/
-	hookForPluginSync({ pluginName, hookName, parameters }) {
-		const plugin = this.plugins.get(pluginName);
-		if (!plugin) return null;
-		const result = this.#executeSync({
-			strategy: "hookFirst",
-			hookName,
-			parameters,
-			plugin
-		});
-		return result !== null ? [result] : [];
-	}
-	/**
-	* Returns the first non-null result.
-	*/
-	async hookFirst({ hookName, parameters, skipped }) {
-		const plugins = [];
-		for (const plugin of this.plugins.values()) if (hookName in plugin && (skipped ? !skipped.has(plugin) : true)) plugins.push(plugin);
-		this.hooks.emit("kubb:plugins:hook:progress:start", {
-			hookName,
-			plugins
-		});
-		const result = await hookFirst(plugins.map((plugin) => {
-			return async () => {
-				const value = await this.#execute({
-					strategy: "hookFirst",
-					hookName,
-					parameters,
-					plugin
-				});
-				return Promise.resolve({
-					plugin,
-					result: value
-				});
-			};
-		}), hookFirstNullCheck);
-		this.hooks.emit("kubb:plugins:hook:progress:end", { hookName });
-		return result;
-	}
-	/**
-	* Returns the first non-null result.
-	*/
-	hookFirstSync({ hookName, parameters, skipped }) {
-		let parseResult = null;
-		for (const plugin of this.plugins.values()) {
-			if (!(hookName in plugin)) continue;
-			if (skipped?.has(plugin)) continue;
-			parseResult = {
-				result: this.#executeSync({
-					strategy: "hookFirst",
-					hookName,
-					parameters,
-					plugin
-				}),
-				plugin
-			};
-			if (parseResult.result != null) break;
-		}
-		return parseResult;
-	}
-	/**
-	* 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.hooks.emit("kubb:plugins:hook:progress:start", {
-			hookName,
-			plugins
-		});
-		const pluginStartTimes = /* @__PURE__ */ new Map();
-		const results = await hookParallel(plugins.map((plugin) => {
-			return () => {
-				pluginStartTimes.set(plugin, performance.now());
-				return this.#execute({
-					strategy: "hookParallel",
-					hookName,
-					parameters,
-					plugin
-				});
-			};
-		}), this.options.concurrency);
-		results.forEach((result, index) => {
-			if (isPromiseRejectedResult(result)) {
-				const plugin = plugins[index];
-				if (plugin) {
-					const startTime = pluginStartTimes.get(plugin) ?? performance.now();
-					this.hooks.emit("kubb:error", result.reason, {
-						plugin,
-						hookName,
-						strategy: "hookParallel",
-						duration: Math.round(performance.now() - startTime),
-						parameters
-					});
-				}
-			}
-		});
-		this.hooks.emit("kubb:plugins:hook:progress:end", { hookName });
-		return results.reduce((acc, result) => {
-			if (result.status === "fulfilled") acc.push(result.value);
-			return acc;
-		}, []);
-	}
-	/**
-	* 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.hooks.emit("kubb:plugins:hook:progress:start", {
-			hookName,
-			plugins
-		});
-		await hookSeq(plugins.map((plugin) => {
-			return () => this.#execute({
-				strategy: "hookSeq",
-				hookName,
-				parameters,
-				plugin
-			});
-		}));
-		this.hooks.emit("kubb:plugins:hook:progress:end", { hookName });
 	}
 	getPlugin(pluginName) {
 		return this.plugins.get(pluginName);
@@ -1530,88 +959,8 @@ var PluginDriver = class PluginDriver {
 		if (!plugin) throw new Error(`[kubb] Plugin "${pluginName}" is required but not found. Make sure it is included in your Kubb config.`);
 		return plugin;
 	}
-	/**
-	* Emit hook-processing completion metadata after a plugin hook resolves.
-	*/
-	#emitProcessingEnd({ startTime, output, strategy, hookName, plugin, parameters }) {
-		this.hooks.emit("kubb:plugins:hook:processing:end", {
-			duration: Math.round(performance.now() - startTime),
-			parameters,
-			output,
-			strategy,
-			hookName,
-			plugin
-		});
-	}
-	#execute({ strategy, hookName, parameters, plugin }) {
-		const hook = plugin[hookName];
-		if (!hook) return null;
-		this.hooks.emit("kubb:plugins:hook:processing:start", {
-			strategy,
-			hookName,
-			parameters,
-			plugin
-		});
-		const startTime = performance.now();
-		return (async () => {
-			try {
-				const output = typeof hook === "function" ? await Promise.resolve(hook.apply(this.getContext(plugin), parameters ?? [])) : hook;
-				this.#emitProcessingEnd({
-					startTime,
-					output,
-					strategy,
-					hookName,
-					plugin,
-					parameters
-				});
-				return output;
-			} catch (error) {
-				this.hooks.emit("kubb:error", error, {
-					plugin,
-					hookName,
-					strategy,
-					duration: Math.round(performance.now() - startTime)
-				});
-				return null;
-			}
-		})();
-	}
-	/**
-	* Execute a plugin lifecycle hook synchronously and return its output.
-	*/
-	#executeSync({ strategy, hookName, parameters, plugin }) {
-		const hook = plugin[hookName];
-		if (!hook) return null;
-		this.hooks.emit("kubb:plugins:hook:processing:start", {
-			strategy,
-			hookName,
-			parameters,
-			plugin
-		});
-		const startTime = performance.now();
-		try {
-			const output = typeof hook === "function" ? hook.apply(this.getContext(plugin), parameters) : hook;
-			this.#emitProcessingEnd({
-				startTime,
-				output,
-				strategy,
-				hookName,
-				plugin,
-				parameters
-			});
-			return output;
-		} catch (error) {
-			this.hooks.emit("kubb:error", error, {
-				plugin,
-				hookName,
-				strategy,
-				duration: Math.round(performance.now() - startTime)
-			});
-			return null;
-		}
-	}
 };
 //#endregion
-export { definePlugin as a, DEFAULT_BANNER as c, logLevel as d, isValidVarName as f, defineResolver as i, DEFAULT_EXTENSION as l, applyHookResult as n, pLimit as o, camelCase as p, FileManager as r, BARREL_FILENAME as s, PluginDriver as t, DEFAULT_STUDIO_URL as u };
+export { BARREL_BASENAME as a, DEFAULT_EXTENSION as c, camelCase as d, defineResolver as i, DEFAULT_STUDIO_URL as l, applyHookResult as n, BARREL_FILENAME as o, FileManager as r, DEFAULT_BANNER as s, PluginDriver as t, logLevel as u };
 
-//# sourceMappingURL=PluginDriver-CgXFtmNP.js.map
+//# sourceMappingURL=PluginDriver-Bt_UCn7-.js.map