@kubb/core 5.10.2 → 5.10.3

package/dist/Hookable-C4S0gBso.cjs

@@ -0,0 +1,3030 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let verkit = require("verkit");
+let node_async_hooks = require("node:async_hooks");
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_util = require("node:util");
+let _kubb_ast = require("@kubb/ast");
+//#region package.json
+var version = "5.10.3";
+//#endregion
+//#region ../../internals/utils/src/casing.ts
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Converts `text` to camelCase.
+*
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
+*
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
+*/
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+//#endregion
+//#region ../../internals/utils/src/errors.ts
+/**
+* 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 Error('Build failed', { cause: toError(err) })
+* }
+* ```
+*/
+function toError(value) {
+	return value instanceof Error ? value : new Error(String(value));
+}
+/**
+* Extracts a human-readable message from any thrown value.
+*
+* @example
+* ```ts
+* getErrorMessage(new Error('oops')) // 'oops'
+* getErrorMessage('plain string')    // 'plain string'
+* ```
+*/
+function getErrorMessage(value) {
+	return value instanceof Error ? value.message : String(value);
+}
+/**
+* Returns `error` followed by every error in its `cause` chain, outermost first. Stops at a
+* non-`Error` cause or a cycle.
+*
+* @example
+* ```ts
+* getErrorChain(new Error('Config failed loading', { cause: new Error('boom') })).map((error) => error.message)
+* // ['Config failed loading', 'boom']
+* ```
+*/
+function getErrorChain(error) {
+	const chain = [];
+	for (let current = error; current instanceof Error && !chain.includes(current); current = current.cause) chain.push(current);
+	return chain;
+}
+//#endregion
+//#region ../../internals/utils/src/jsonPointer.ts
+/**
+* Escapes a single JSON pointer reference token per RFC 6901 (`~` → `~0`, `/` → `~1`), so a
+* name holding those characters maps to a distinct pointer.
+*
+* @example
+* ```ts
+* escapePointerToken('/pets/{id}') // '~1pets~1{id}'
+* ```
+*/
+function escapePointerToken(token) {
+	return token.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+//#endregion
+//#region ../../internals/utils/src/runtime.ts
+const isBun = typeof Bun !== "undefined";
+const isDeno = "Deno" in globalThis;
+/**
+* The JavaScript runtime executing the current process: its name, version and whether it is Bun.
+*
+* @example
+* ```ts
+* runtime.name // 'bun' when run with `bun kubb`, 'node' otherwise
+* ```
+*/
+const runtime = {
+	isBun,
+	...detect()
+};
+function detect() {
+	if (isBun) return {
+		name: "bun",
+		version: process.versions.bun ?? ""
+	};
+	if (isDeno) return {
+		name: "deno",
+		version: globalThis.Deno?.version?.deno ?? ""
+	};
+	return {
+		name: "node",
+		version: process.versions?.node ?? ""
+	};
+}
+//#endregion
+//#region ../../internals/utils/src/fs.ts
+/**
+* Reads the file at `path` as a UTF-8 string.
+* Uses `Bun.file().text()` when running under Bun, `fs.readFile` otherwise.
+*
+* @example
+* ```ts
+* const source = await read('./src/Pet.ts')
+* ```
+*/
+async function read(path) {
+	if (runtime.isBun) return Bun.file(path).text();
+	return (0, node_fs_promises.readFile)(path, { encoding: "utf8" });
+}
+/**
+* Whether `stored` already holds `source`, comparing on the trimmed text rather than the exact
+* bytes. Surrounding whitespace is what a formatter adds and what editors strip, and neither is a
+* reason to rewrite the file.
+*
+* Both sides are trimmed, so a storage that keeps bytes verbatim settles on the same answer as one
+* that normalizes what it stores. Trimming only `stored` would leave a source with leading
+* whitespace rewritten on every build, since the stored copy keeps the whitespace the comparison
+* has already dropped.
+*/
+function matchesStored({ stored, source }) {
+	return stored.trim() === source.trim();
+}
+/**
+* Writes `data` to `path`, trimming surrounding whitespace and ending the file with a single newline
+* the way prettier, biome, and oxfmt all do.
+* Skips the write when the trimmed content is empty, or when the file already holds that content.
+* Creates any missing parent directories automatically.
+* When `sanity` is `true`, re-reads the file after writing and throws if the content does not match.
+*
+* @example
+* ```ts
+* await write('./src/Pet.ts', source)         // writes and returns the trimmed content plus a newline
+* await write('./src/Pet.ts', source)         // null — file unchanged
+* await write('./src/Pet.ts', '  ')           // null — empty content skipped
+* ```
+*/
+async function write(path, data, options = {}) {
+	const trimmed = data.trim();
+	if (trimmed === "") return null;
+	const content = `${trimmed}\n`;
+	const resolved = (0, node_path.resolve)(path);
+	let stored = options.stored;
+	if (stored === void 0) {
+		if (runtime.isBun) {
+			const file = Bun.file(resolved);
+			stored = await file.exists() ? await file.text() : null;
+		} else try {
+			stored = await (0, node_fs_promises.readFile)(resolved, { encoding: "utf-8" });
+		} catch {
+			stored = null;
+		}
+	}
+	if (matchesStored({
+		stored: stored ?? "",
+		source: trimmed
+	})) return null;
+	if (runtime.isBun) {
+		await Bun.write(resolved, content);
+		return content;
+	}
+	try {
+		await (0, node_fs_promises.writeFile)(resolved, content, { encoding: "utf-8" });
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+		await (0, node_fs_promises.mkdir)((0, node_path.dirname)(resolved), { recursive: true });
+		await (0, node_fs_promises.writeFile)(resolved, content, { encoding: "utf-8" });
+	}
+	if (options.sanity) {
+		const savedData = await (0, node_fs_promises.readFile)(resolved, { encoding: "utf-8" });
+		if (savedData !== content) throw new Error(`Sanity check failed for ${path}\n\nData[${data.length}]:\n${data}\n\nSaved[${savedData.length}]:\n${savedData}\n`);
+		return savedData;
+	}
+	return content;
+}
+/**
+* Converts a filesystem path to use POSIX (`/`) separators.
+*
+* Most of the codebase compares and composes paths as strings (prefix matching, joining for
+* import specifiers, splitting on `/`). On POSIX `path.resolve` already returns `/`-separated
+* paths, but on Windows it returns `\`-separated paths, which breaks every such comparison.
+*
+* Routing every path that crosses a module boundary through `toPosixPath` keeps the rest of the
+* code platform-agnostic. The conversion runs unconditionally so Windows-specific behavior is
+* exercisable from POSIX CI.
+*
+* @example
+* toPosixPath('C:\\repo\\src\\pet.ts') // 'C:/repo/src/pet.ts'
+*/
+function toPosixPath(filePath) {
+	return filePath.replaceAll("\\", "/");
+}
+/**
+* Resolves to `true` when `path` is `parent` itself or nested inside it. Both sides are resolved
+* to absolute paths first, so relative and `..`-containing inputs compare correctly.
+*
+* Guards a destructive or an out-of-tree operation: before wiping an output directory, check that
+* it does not contain the project root, and before loading a path a caller supplied, check that it
+* did not escape the directory it is allowed to read from.
+*
+* @example
+* isPathInside('./src/gen', '.')   // true  — nested inside the root
+* isPathInside('.', '.')           // true  — the same directory counts as inside
+* isPathInside('.', './src/gen')   // false — the root is not inside its own output
+* isPathInside('../other', '.')    // false — escapes the root
+*/
+function isPathInside(path, parent) {
+	const resolvedPath = (0, node_path.resolve)(path);
+	const resolvedParent = (0, node_path.resolve)(parent);
+	if (resolvedPath === resolvedParent) return true;
+	const rel = (0, node_path.relative)(resolvedParent, resolvedPath);
+	return rel !== "" && !rel.startsWith("..") && !(0, node_path.isAbsolute)(rel);
+}
+//#endregion
+//#region ../../internals/utils/src/promise.ts
+/**
+* Runs `run` over every item with at most `limit` in flight. Workers share one iterator, so each
+* takes the next item the moment it frees up instead of waiting for a batch to drain.
+*
+* @example
+* ```ts
+* await inParallel({ items: files, limit: 50, run: (file) => storage.writeItem(file.path, file.source) })
+* ```
+*/
+async function inParallel({ items, limit, run }) {
+	const queue = items.entries();
+	const worker = async () => {
+		for (const [index, item] of queue) await run(item, index);
+	};
+	await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
+}
+//#endregion
+//#region ../../internals/utils/src/time.ts
+/**
+* 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
+* ```
+*/
+function getElapsedMs(hrStart) {
+	const [seconds, nanoseconds] = process.hrtime(hrStart);
+	const ms = seconds * 1e3 + nanoseconds / 1e6;
+	return Math.round(ms * 100) / 100;
+}
+/**
+* Converts a millisecond duration into a human-readable string (`ms`, `s`, or `m s`).
+*
+* @example
+* ```ts
+* formatMs(250)   // '250ms'
+* formatMs(1500)  // '1.50s'
+* formatMs(90000) // '1m 30.0s'
+* ```
+*/
+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`;
+}
+//#endregion
+//#region src/diagnosticCatalog.ts
+/**
+* Every diagnostic code with its docs entry: a short title, what triggers it, and how to resolve
+* it. The source of truth for {@link diagnosticCode}, and the kubb.dev `/reference/diagnostics`
+* sections mirror it.
+*/
+const diagnosticCatalog = {
+	unknown: {
+		code: "KUBB_UNKNOWN",
+		title: "Unknown error",
+		cause: "An error was thrown without a stable Kubb code, so it is reported as-is.",
+		fix: "Read the underlying message and stack. If it comes from a plugin or adapter, check its configuration; otherwise report it as a possible Kubb bug."
+	},
+	inputNotFound: {
+		code: "KUBB_INPUT_NOT_FOUND",
+		title: "Input not found",
+		cause: "The file set as `input` (or passed as `kubb generate PATH`) could not be read. A URL reports `KUBB_INPUT_REQUEST_FAILED` or `KUBB_INPUT_UNREACHABLE` instead.",
+		fix: "Check that the path exists and is readable, then set it as `input` or pass it on the CLI."
+	},
+	inputRequestFailed: {
+		code: "KUBB_INPUT_REQUEST_FAILED",
+		title: "Input request failed",
+		cause: "A URL set as `input` (or reached through a `$ref`) answered with a 4xx or 5xx status instead of the document.",
+		fix: "Open the URL to see what the server returns. A 401 or 403 needs credentials Kubb does not send, so download the document and point `input` at the local file. A 404 means the path is wrong, and a 5xx means the server itself failed."
+	},
+	inputUnreachable: {
+		code: "KUBB_INPUT_UNREACHABLE",
+		title: "Input unreachable",
+		cause: "A URL set as `input` (or reached through a `$ref`) never answered, so the request failed before a status came back. A refused connection, an unknown host, an expired certificate, and a timeout all land here.",
+		fix: "Check that the host is running and reachable from this machine. For a local server, start it and confirm the port matches the one in `input`."
+	},
+	inputRequired: {
+		code: "KUBB_INPUT_REQUIRED",
+		title: "Input required",
+		cause: "An adapter is configured but no `input` was provided.",
+		fix: "Set `input` to a file path, a URL, an inline spec (JSON/YAML string), or a parsed object in your Kubb config."
+	},
+	legacyInput: {
+		code: "KUBB_LEGACY_INPUT",
+		title: "Legacy input shape",
+		cause: "`input` is a `{ path }` or `{ data }` wrapper, which v4 used to point at a document and v5 reads as the document itself.",
+		fix: "Unwrap it: `input: { path: \"./petStore.yaml\" }` becomes `input: \"./petStore.yaml\"`, and `input: { data: spec }` becomes `input: spec`."
+	},
+	invalidDocument: {
+		code: "KUBB_INVALID_DOCUMENT",
+		title: "Invalid document",
+		cause: "The `input` cannot be read as an OpenAPI or Swagger document: its JSON or YAML has a syntax error, it declares no `openapi` or `swagger` version field, or its version cannot be upgraded to OpenAPI 3.1.",
+		fix: "Fix the syntax at the reported line, and check that `input` points at the spec and not an HTML page. Point `input` at a Swagger 2.0, OpenAPI 3.0, or OpenAPI 3.1 document, and check that a passed object is the spec itself rather than a wrapper around it."
+	},
+	invalidSpec: {
+		code: "KUBB_INVALID_SPEC",
+		title: "Invalid spec",
+		cause: "The document does not pass OpenAPI schema validation. Kubb still generates from it, but the output can be incomplete or wrong.",
+		fix: "Fix the reported problem in the spec. Run `kubb validate` to list every error, or set `validate: false` on the adapter to skip the check."
+	},
+	refNotFound: {
+		code: "KUBB_REF_NOT_FOUND",
+		title: "Reference not found",
+		cause: "A `$ref` could not be resolved in the source document.",
+		fix: "Add the missing definition (for example under `components.schemas`) or fix the `$ref`. Run `kubb validate` to check the spec."
+	},
+	invalidServerVariable: {
+		code: "KUBB_INVALID_SERVER_VARIABLE",
+		title: "Invalid server variable",
+		cause: "A server variable value is not allowed by its `enum`.",
+		fix: "Use one of the values listed in the server variable `enum`, or update the spec."
+	},
+	pluginNotFound: {
+		code: "KUBB_PLUGIN_NOT_FOUND",
+		title: "Plugin not found",
+		cause: "A plugin that another plugin depends on is missing from the config.",
+		fix: "Add the required plugin to the `plugins` array in kubb.config.ts, or remove the dependency on it."
+	},
+	incompatibleExtension: {
+		code: "KUBB_INCOMPATIBLE_EXTENSION",
+		title: "Incompatible extension",
+		cause: "A plugin sets `meta.compatibility.kubb` or `meta.compatibility.node` to a range the running Kubb or Node.js version does not satisfy.",
+		fix: "Upgrade Kubb or Node.js to a version in the range, or install a version of the plugin that supports your current Kubb and Node.js."
+	},
+	missingDependency: {
+		code: "KUBB_MISSING_DEPENDENCY",
+		title: "Missing dependency",
+		cause: "A plugin lists another plugin in its `dependencies` record without `optional: true`, and the config does not include it.",
+		fix: "Add the missing plugin to the `plugins` array in kubb.config.ts."
+	},
+	incompatibleDependency: {
+		code: "KUBB_INCOMPATIBLE_DEPENDENCY",
+		title: "Incompatible dependency",
+		cause: "A plugin's `dependencies` record sets a `version` range, and the configured plugin's `meta.version` falls outside it.",
+		fix: "Install a version of the dependency inside the range, or a version of the dependent plugin that supports the installed dependency."
+	},
+	pluginFailed: {
+		code: "KUBB_PLUGIN_FAILED",
+		title: "Plugin failed",
+		cause: "A plugin threw while generating, or reported an error through `ctx.error`.",
+		fix: "Check the plugin options and the node at `at:`. If it is a bug, report it with the stack at `report:`."
+	},
+	adapterFailed: {
+		code: "KUBB_ADAPTER_FAILED",
+		title: "Adapter failed",
+		cause: "The adapter threw an unexpected error while parsing the input.",
+		fix: "Check the input and the adapter options. If it is a bug, report it with the stack at `report:`."
+	},
+	parserFailed: {
+		code: "KUBB_PARSER_FAILED",
+		title: "Parser failed",
+		cause: "A parser threw an unexpected error while printing a generated file.",
+		fix: "Check the parser options. If it is a bug, report it with the stack at `report:`."
+	},
+	pluginWarning: {
+		code: "KUBB_PLUGIN_WARNING",
+		title: "Plugin warning",
+		cause: "A plugin reported a non-fatal warning through `ctx.warn`.",
+		fix: "Review the message. It does not fail the build; adjust the plugin options or input if the warning is unwanted."
+	},
+	pluginInfo: {
+		code: "KUBB_PLUGIN_INFO",
+		title: "Plugin info",
+		cause: "A plugin reported an informational message through `ctx.info`.",
+		fix: "Informational only. No action is required."
+	},
+	noContext: {
+		code: "KUBB_NO_CONTEXT",
+		title: "No plugin context",
+		cause: "A `kubb/kit` composable such as `useKubb()` or `addGenerator()` ran outside the `setup` and `kubb:plugin:setup` of a plugin, so there is no plugin to apply it to.",
+		fix: "Call the composable inside `setup` or `kubb:plugin:setup`, including in code that setup awaits."
+	},
+	unsupportedFormat: {
+		code: "KUBB_UNSUPPORTED_FORMAT",
+		title: "Unsupported format",
+		cause: "A schema uses a `format` Kubb does not map to a specific type, so it falls back to the base type.",
+		fix: "Use a format Kubb supports, or handle the custom format with a parser or plugin."
+	},
+	deprecated: {
+		code: "KUBB_DEPRECATED",
+		title: "Deprecated",
+		cause: "A referenced schema or operation is marked `deprecated`.",
+		fix: "Migrate off the deprecated definition if the warning is unwanted."
+	},
+	adapterRequired: {
+		code: "KUBB_ADAPTER_REQUIRED",
+		title: "Adapter required",
+		cause: "An action needs an adapter but none is configured.",
+		fix: "Set `adapter` in kubb.config.ts, for example `adapterOas()`."
+	},
+	pathTraversal: {
+		code: "KUBB_PATH_TRAVERSAL",
+		title: "Path traversal",
+		cause: "A resolved output path escaped the output directory, which can stem from a path traversal in the spec or a misconfigured `group.name`.",
+		fix: "Keep generated paths within the output directory. Review the `group.name` function and the names coming from the spec."
+	},
+	cleanRoot: {
+		code: "KUBB_CLEAN_ROOT",
+		title: "Clean targets the project root",
+		cause: "`output.clean` is enabled and `output.path` resolves to the project root or a parent of it, so cleaning would delete `kubb.config` and every source file.",
+		fix: "Point `output.path` at a subdirectory such as `./src/gen` so clean only removes generated code, or disable `output.clean`."
+	},
+	invalidPluginOptions: {
+		code: "KUBB_INVALID_PLUGIN_OPTIONS",
+		title: "Invalid plugin options",
+		cause: "A plugin was configured with options that cannot be honored, for example `output.mode: 'file'` paired with a `group` option.",
+		fix: "Fix the plugin options. A single-file output has nothing to group, so remove the `group` option or use `output.mode: 'directory'`."
+	},
+	postGenerateFailed: {
+		code: "KUBB_POST_GENERATE_FAILED",
+		title: "Post-generate command failed",
+		cause: "A post-generate command (`output.postGenerate`) exited with a non-zero status.",
+		fix: "Check the command is installed and correct, and run it manually to see the error."
+	},
+	formatFailed: {
+		code: "KUBB_FORMAT_FAILED",
+		title: "Format failed",
+		cause: "The formatter pass over the generated files failed.",
+		fix: "Check the formatter (oxfmt, biome, or prettier) is installed and its config is valid, then run it manually on the output."
+	},
+	lintFailed: {
+		code: "KUBB_LINT_FAILED",
+		title: "Lint failed",
+		cause: "The linter pass over the generated files failed.",
+		fix: "Check the linter (oxlint, biome, or eslint) is installed and its config is valid, then run it manually on the output."
+	},
+	barrelDuplicateExport: {
+		code: "KUBB_BARREL_DUPLICATE_EXPORT",
+		title: "Duplicate barrel export",
+		cause: "Two generated modules export the same name, so the barrel cannot re-export both.",
+		fix: "Rename one of the colliding declarations, or configure the plugin resolver to produce distinct names."
+	},
+	internalError: {
+		code: "KUBB_INTERNAL_ERROR",
+		title: "Internal error",
+		cause: "Kubb hit a state it does not expect. This is a bug in Kubb, not in your config.",
+		fix: "Rerun with `--reporter json` or `--verbose` to get the stack. Then report it at https://github.com/kubb-labs/kubb/issues with the spec and config that trigger it."
+	},
+	performance: {
+		code: "KUBB_PERFORMANCE",
+		title: "Performance",
+		cause: "Not a failure. Records a plugin’s elapsed time, summed into the run total.",
+		fix: "No action. This is an informational metric."
+	},
+	updateAvailable: {
+		code: "KUBB_UPDATE_AVAILABLE",
+		title: "Update available",
+		cause: "A newer Kubb version is published on npm than the one running.",
+		fix: "Update the `@kubb/*` packages, for example `npm install -g @kubb/cli`, to get the latest fixes."
+	}
+};
+/**
+* Stable codes Kubb attaches to a `Diagnostic`, derived from {@link diagnosticCatalog}. Reference
+* these instead of inlining the string at a throw site.
+*/
+const diagnosticCode = Object.fromEntries(Object.entries(diagnosticCatalog).map(([key, { code }]) => [key, code]));
+//#endregion
+//#region src/formatDiagnostic.ts
+/** A problem's `help`, or the catalog fix. `info` gets none: its catalog fix says no action is needed. */
+function getHelp(problem) {
+	if (problem.help || problem.severity === "info") return problem.help;
+	return Diagnostics.explain(problem.code).fix;
+}
+/** The `cause` chain's messages, outermost first, minus those `message` already contains. */
+function getCauses(problem) {
+	return getErrorChain(problem.cause).filter((error) => !problem.message.includes(error.message)).map((error) => error.name === "Error" ? error.message : `${error.name}: ${error.message}`);
+}
+/**
+* Accent color per severity, which paints the icon in the `human` layout (red error, yellow
+* warning, blue info). The code itself stays dim.
+*/
+const severityStyle = {
+	error: "red",
+	warning: "yellow",
+	info: "blue"
+};
+const severityIcon = {
+	error: "✖",
+	warning: "⚠",
+	info: "ℹ"
+};
+/**
+* Codes for a crash, which carry the root cause's stack.
+*/
+const crashCodes = /* @__PURE__ */ new Set([
+	diagnosticCode.unknown,
+	diagnosticCode.internalError,
+	diagnosticCode.pluginFailed,
+	diagnosticCode.adapterFailed,
+	diagnosticCode.parserFailed
+]);
+/**
+* Reduces a diagnostic to its JSON-safe fields plus a `docsUrl`, for machine-readable
+* consumers, with the catalog `title`, `cause`, and fix, and the `cause` error as `causes` and
+* `stack`. Absent optional fields are omitted.
+*/
+function serialize(diagnostic) {
+	const problem = Diagnostics.isProblem(diagnostic) ? diagnostic : void 0;
+	const doc = problem ? Diagnostics.explain(problem.code) : void 0;
+	const help = problem ? getHelp(problem) : void 0;
+	const causes = problem ? getCauses(problem) : [];
+	const stack = problem && crashCodes.has(problem.code) ? getErrorChain(problem.cause).at(-1)?.stack : void 0;
+	return {
+		code: diagnostic.code,
+		severity: diagnostic.severity,
+		message: diagnostic.message,
+		...doc ? {
+			title: doc.title,
+			cause: doc.cause
+		} : {},
+		...problem?.location ? { location: problem.location } : {},
+		...help ? { help } : {},
+		...problem?.plugin ? { plugin: problem.plugin } : {},
+		...problem?.issues ? { issues: problem.issues } : {},
+		...causes.length ? { causes } : {},
+		...stack ? { stack } : {},
+		...diagnostic.code === diagnosticCode.unknown ? {} : { docsUrl: Diagnostics.docsUrl(diagnostic.code) }
+	};
+}
+/**
+* Renders a {@link Diagnostic} as lines: a headline, then indented detail rows. `agent` (the default)
+* prints uncolored labeled rows (`at:`, `why:`, `fix:`, `caused by:`, `stack:` for a crash,
+* `docs:`, `report:`). `human` prints an icon, the bold message, and the code aligned to `width`,
+* with `at`, `fix`, the first cause, and `Learn more` for an error, and one row for a warning.
+* `verbose` adds the full stack.
+*/
+function format(diagnostic, { audience = "agent", verbose = false, width = 0 } = {}) {
+	const { code, severity, message } = diagnostic;
+	const problem = Diagnostics.isProblem(diagnostic) ? diagnostic : void 0;
+	const human = audience === "human";
+	const paint = human ? node_util.styleText : (_format, text) => text;
+	const [firstLine = "", ...rest] = message.split("\n");
+	const pointer = problem?.location && "pointer" in problem.location ? problem.location.pointer : void 0;
+	const help = problem ? getHelp(problem) : void 0;
+	const causes = problem ? getCauses(problem) : [];
+	const crash = problem ? crashCodes.has(problem.code) : false;
+	const frames = (problem && (verbose || !human && crash) ? getErrorChain(problem.cause).at(-1)?.stack : void 0)?.split("\n").slice(1, verbose ? void 0 : 4).map((frame) => `    ${paint("dim", frame.trim())}`);
+	if (!human) {
+		const details = rest.filter((line) => line.trim()).map((line) => `  ${line}`);
+		const row = (label, value) => {
+			if (value) details.push(`  ${label}: ${value}`);
+		};
+		row("at", pointer);
+		if (problem && severity !== "info") row("why", Diagnostics.explain(problem.code).cause);
+		row("fix", help);
+		for (const cause of causes) row("caused by", cause);
+		if (frames?.length) details.push("  stack:", ...frames);
+		if (code !== diagnosticCode.unknown) row("docs", Diagnostics.docsUrl(code));
+		row("report", problem?.issues);
+		return [`${severity} ${code}${problem?.plugin ? ` [${problem.plugin}]` : ""}: ${firstLine}`, ...details];
+	}
+	const left = `${paint(severityStyle[severity], severityIcon[severity])} ${paint("bold", firstLine)}`;
+	const gap = Math.max(2, width - (0, node_util.stripVTControlCharacters)(left).length - code.length);
+	const headline = `${left}${" ".repeat(gap)}${paint("dim", code)}`;
+	const frame = rest.filter((line) => line.trim()).map((line) => `  ${paint("dim", line)}`);
+	const label = (name) => paint("dim", name.length < 4 ? name.padEnd(4) : `${name} `);
+	const rows = [["at", pointer && paint("cyan", pointer)], ["fix", help]];
+	if (severity !== "error") {
+		const first = rows.find(([, value]) => value);
+		return [
+			headline,
+			...frame,
+			...first ? [`  ${label(first[0])} ${first[1]}`] : []
+		];
+	}
+	rows.push(["caused by", causes[0]], ["report", problem?.issues && paint("cyan", problem.issues)]);
+	const details = [...frame, ...rows.flatMap(([name, value]) => value ? [`  ${label(name)} ${value}`] : [])];
+	if (frames?.length) details.push(`  ${paint("dim", "stack")}`, ...frames);
+	if (code !== diagnosticCode.unknown) details.push(`  ${paint("dim", "↳ Learn more")}  ${paint("cyan", Diagnostics.docsUrl(code).replace(/^https:\/\//, ""))}`);
+	return [headline, ...details];
+}
+//#endregion
+//#region src/Diagnostics.ts
+/**
+* Docs major version, derived from the package version so the link tracks the published major.
+*/
+const docsMajor = version.split(".")[0] ?? "5";
+/**
+* Builds a type guard that narrows a {@link Diagnostic} to the variant for `kind`. A diagnostic
+* with no `kind` is treated as a `problem`.
+*/
+function isKind(kind) {
+	return (diagnostic) => (diagnostic.kind ?? "problem") === kind;
+}
+/**
+* Returns `true` when the diagnostic is a build {@link ProblemDiagnostic}.
+*
+* @example
+* ```ts
+* if (isProblem(diagnostic)) {
+*   console.log(diagnostic.location)
+* }
+* ```
+*/
+const isProblem = isKind("problem");
+/**
+* Returns `true` when the diagnostic is a per-plugin {@link PerformanceDiagnostic}.
+*
+* @example
+* ```ts
+* const timings = diagnostics.filter(isPerformance)
+* ```
+*/
+const isPerformance = isKind("performance");
+/**
+* Returns `true` when the diagnostic is a version-update {@link UpdateDiagnostic}.
+*
+* @example
+* ```ts
+* if (isUpdate(diagnostic)) {
+*   console.log(diagnostic.latestVersion)
+* }
+* ```
+*/
+const isUpdate = isKind("update");
+const failedCode = {
+	plugin: diagnosticCode.pluginFailed,
+	adapter: diagnosticCode.adapterFailed,
+	parser: diagnosticCode.parserFailed
+};
+const docsByCode = new Map(Object.values(diagnosticCatalog).map((doc) => [doc.code, doc]));
+const countKey = {
+	error: "errors",
+	warning: "warnings",
+	info: "infos"
+};
+/**
+* Static helpers for working with {@link Diagnostic}s, plus the run-scoped sink
+* that lets deep code report a diagnostic without threading a callback.
+*
+* The sink lives in a single `AsyncLocalStorage` in the `@kubb/core` bundle.
+* `Diagnostics.scope` activates it for a run, so anything inside that run (the
+* adapter parse, a generator) reports through `Diagnostics.report` and lands
+* in the same run.
+*/
+var Diagnostics = class Diagnostics {
+	static #reporterStorage = new node_async_hooks.AsyncLocalStorage();
+	/**
+	* The diagnostic code catalog, exposed as `Diagnostics.code` (e.g. `Diagnostics.code.refNotFound`).
+	*/
+	static code = diagnosticCode;
+	/**
+	* Type guard for a build {@link ProblemDiagnostic}.
+	*/
+	static isProblem = isProblem;
+	/**
+	* Type guard for a version-update {@link UpdateDiagnostic}.
+	*/
+	static isUpdate = isUpdate;
+	/**
+	* Type guard for a per-plugin {@link PerformanceDiagnostic}.
+	*/
+	static isPerformance = isPerformance;
+	/**
+	* An `Error` that carries a {@link Diagnostic}, so structured problems can flow
+	* through the existing throw/catch paths while keeping their code and location.
+	*
+	* @example
+	* ```ts
+	* throw new Diagnostics.Error({ code: diagnosticCode.refNotFound, severity: 'error', message: `Could not find ${ref}`, location: { kind: 'schema', pointer: ref, ref } })
+	* ```
+	*/
+	static Error = class DiagnosticError extends Error {
+		diagnostic;
+		constructor(diagnostic) {
+			super(diagnostic.message, { cause: diagnostic.cause });
+			this.name = "DiagnosticError";
+			this.diagnostic = diagnostic;
+		}
+	};
+	/**
+	* Structural check for a {@link Diagnostics.Error}, including one thrown from a duplicated
+	* `@kubb/core` copy where `instanceof` fails. Matches on the `name` and a `diagnostic`
+	* that carries a `code`.
+	*/
+	static isError(error) {
+		if (error instanceof Diagnostics.Error) return true;
+		if (!(error instanceof Error) || error.name !== "DiagnosticError") return false;
+		const { diagnostic } = error;
+		return typeof diagnostic === "object" && diagnostic !== null && typeof diagnostic.code === "string";
+	}
+	/**
+	* Runs `fn` with `sink` as the active diagnostic sink for the whole async
+	* subtree, so {@link Diagnostics.report} reaches it from anywhere inside.
+	*/
+	static scope(sink, fn) {
+		return Diagnostics.#reporterStorage.run(sink, fn);
+	}
+	/**
+	* Collects a diagnostic into the active build via the run-scoped sink, without throwing.
+	* Returns `true` when a run consumed it, `false` when called outside a {@link Diagnostics.scope}
+	* (so callers can fall back to throwing). Use a `warning`/`info` severity for non-fatal issues.
+	* For rendering a diagnostic live on the hook bus, use {@link Diagnostics.emit} instead.
+	*/
+	static report(diagnostic) {
+		const sink = Diagnostics.#reporterStorage.getStore();
+		if (!sink) return false;
+		sink(diagnostic);
+		return true;
+	}
+	/**
+	* Emits a diagnostic, or any thrown value, on the run's hooks so the loggers render it live.
+	* A coded problem or an update goes to `kubb:diagnostic`. An uncoded one goes to `kubb:error`
+	* whole, so every wrapper's message, its help, and the stack survive. To collect a diagnostic into
+	* the build result from deep in a run, use {@link Diagnostics.report} instead.
+	*/
+	static async emit(hooks, value) {
+		const thrown = value instanceof Error || typeof value?.code !== "string";
+		const diagnostic = thrown ? Diagnostics.from(value) : value;
+		if (!isProblem(diagnostic) || diagnostic.code !== diagnosticCode.unknown) {
+			await hooks.callHook("kubb:diagnostic", { diagnostic });
+			return;
+		}
+		const { cause, help, message } = diagnostic;
+		const bare = cause && !help && cause.message === message;
+		await hooks.callHook("kubb:error", { error: thrown ? toError(value) : bare ? cause : new Diagnostics.Error(diagnostic) });
+	}
+	/**
+	* Coerces any thrown value into a {@link ProblemDiagnostic}. A {@link Diagnostics.Error}
+	* keeps its structured data, and anything else becomes a `KUBB_UNKNOWN` error.
+	*/
+	static from(error) {
+		const chain = getErrorChain(error);
+		const coded = chain.findLast((current) => Diagnostics.isError(current));
+		if (coded) {
+			const { diagnostic } = coded;
+			return diagnostic.cause || !crashCodes.has(diagnostic.code) ? diagnostic : {
+				...diagnostic,
+				cause: coded
+			};
+		}
+		const root = chain.at(-1);
+		return {
+			code: diagnosticCode.unknown,
+			severity: "error",
+			message: root ? root.message : getErrorMessage(error),
+			cause: root
+		};
+	}
+	/**
+	* Coerces an error thrown by a plugin, adapter, or parser into a diagnostic attributed to it.
+	* A structured {@link Diagnostics.Error} keeps its code. Any other error is a crash: it gets the
+	* kind's `*_FAILED` code and the extension's `meta.issues` link, so the user reports it to the
+	* extension's maintainers instead of to Kubb.
+	*/
+	static fromExtension(error, { kind, extension }) {
+		const diagnostic = Diagnostics.from(error);
+		const name = extension.meta?.name ?? extension.name;
+		const owner = kind === "plugin" ? { plugin: diagnostic.plugin ?? name } : {};
+		const crashed = diagnostic.code === diagnosticCode.unknown && diagnostic.cause?.name !== "AbortError";
+		const failed = Object.values(failedCode).includes(diagnostic.code);
+		if (!crashed && !failed) return {
+			...diagnostic,
+			...owner
+		};
+		const issues = extension.meta?.issues;
+		return {
+			...diagnostic,
+			...owner,
+			code: crashed ? failedCode[kind] : diagnostic.code,
+			message: crashed && kind !== "plugin" ? `${kind} "${name}" crashed: ${diagnostic.message}` : diagnostic.message,
+			...issues ? { issues } : {}
+		};
+	}
+	/**
+	* Builds a per-plugin performance record. Reporters sum these into the run total.
+	*/
+	static performance({ plugin, duration }) {
+		return {
+			kind: "performance",
+			code: diagnosticCode.performance,
+			severity: "info",
+			message: `${plugin} generated in ${Math.round(duration)}ms`,
+			plugin,
+			duration
+		};
+	}
+	/**
+	* Builds the version-update notice shown when a newer Kubb is published on npm.
+	*/
+	static update({ currentVersion, latestVersion }) {
+		return {
+			kind: "update",
+			code: diagnosticCode.updateAvailable,
+			severity: "info",
+			message: `Update available: v${currentVersion} → v${latestVersion}. Run \`npm install -g @kubb/cli\` to update.`,
+			currentVersion,
+			latestVersion
+		};
+	}
+	/**
+	* True when any diagnostic is an error, the severity that fails a build. Non-error
+	* diagnostics are ignored.
+	*/
+	static hasError(diagnostics) {
+		return diagnostics.some((diagnostic) => diagnostic.severity === "error");
+	}
+	/**
+	* Names of the plugins that failed, deduped, derived from the error diagnostics
+	* that carry a `plugin`.
+	*/
+	static failedPlugins(diagnostics) {
+		return [...new Set(diagnostics.flatMap((diagnostic) => diagnostic.severity === "error" && diagnostic.plugin ? [diagnostic.plugin] : []))];
+	}
+	/**
+	* Counts `problem` diagnostics by severity for the run summary. `performance` and
+	* `update` diagnostics are ignored.
+	*/
+	static count(diagnostics) {
+		const counts = {
+			errors: 0,
+			warnings: 0,
+			infos: 0
+		};
+		for (const diagnostic of diagnostics.filter(isProblem)) counts[countKey[diagnostic.severity]] += 1;
+		return counts;
+	}
+	/**
+	* Drops duplicate `problem` diagnostics that share a code, location pointer, and
+	* plugin, so the same issue reported across several passes is shown once. Non-problem
+	* diagnostics are always kept.
+	*/
+	static dedupe(diagnostics) {
+		const seen = /* @__PURE__ */ new Set();
+		const result = [];
+		for (const diagnostic of diagnostics) {
+			if (!isProblem(diagnostic)) {
+				result.push(diagnostic);
+				continue;
+			}
+			const pointer = diagnostic.location && "pointer" in diagnostic.location ? diagnostic.location.pointer : "";
+			const key = `${diagnostic.code} ${pointer} ${diagnostic.plugin ?? ""}`;
+			if (seen.has(key)) continue;
+			seen.add(key);
+			result.push(diagnostic);
+		}
+		return result;
+	}
+	/**
+	* Builds the kubb.dev docs URL for a diagnostic code, e.g.
+	* `KUBB_REF_NOT_FOUND` → `https://kubb.dev/docs/5.x/reference/diagnostics#kubb-ref-not-found`.
+	*/
+	static docsUrl(code) {
+		const slug = code.toLowerCase().replaceAll("_", "-");
+		return `https://kubb.dev/docs/${docsMajor}.x/reference/diagnostics#${slug}`;
+	}
+	/**
+	* The catalog entry for a code: its title, cause, and fix. Mirrors the kubb.dev
+	* `/reference/diagnostics#<slug>` section.
+	*/
+	static explain(code) {
+		return docsByCode.get(code);
+	}
+	/**
+	* Reduces a diagnostic to its JSON-safe fields plus a `docsUrl`, for machine-readable
+	* consumers, with the catalog `title`, `cause`, and fix, and the `cause` error as `causes` and
+	* `stack`. Absent optional fields are omitted.
+	*/
+	static serialize = serialize;
+	/**
+	* Renders a diagnostic as lines for an `agent` (the default) or a `human`. See {@link format}.
+	*/
+	static format = format;
+};
+//#endregion
+//#region src/defineExtension.ts
+/**
+* Returns `meta`, or `{ name }` for an extension that only sets the deprecated `name`. Throws `KUBB_INVALID_PLUGIN_OPTIONS` when it has neither.
+*/
+function resolveMeta(extension) {
+	const { name, meta } = extension;
+	if (meta) return meta;
+	if (name) return { name };
+	const keys = Object.keys(extension);
+	throw new Diagnostics.Error({
+		code: Diagnostics.code.invalidPluginOptions,
+		severity: "error",
+		message: `An extension has neither \`meta.name\` nor \`name\`. Received keys: ${keys.length ? keys.join(", ") : "none"}.`,
+		help: "Set `meta: { name }` on the plugin or parser.",
+		location: { kind: "config" }
+	});
+}
+/**
+* Throws `KUBB_INCOMPATIBLE_EXTENSION` when the running Kubb or Node.js version is outside `meta.compatibility`.
+*/
+function checkCompatibility(meta) {
+	const checks = [{
+		target: "Kubb",
+		range: meta.compatibility?.kubb,
+		version
+	}, {
+		target: "Node.js",
+		range: meta.compatibility?.node,
+		version: process.versions.node
+	}];
+	for (const { target, range, version } of checks) {
+		if (!range || (0, verkit.satisfies)(version, range, { includePrerelease: true })) continue;
+		throw new Diagnostics.Error({
+			code: Diagnostics.code.incompatibleExtension,
+			severity: "error",
+			message: `"${meta.name}" requires ${target} ${range}, but ${version} is running.`,
+			help: `Use a ${target} version that satisfies ${range}, or a version of "${meta.name}" that supports ${target} ${version}.`,
+			location: { kind: "config" },
+			plugin: meta.name
+		});
+	}
+}
+/**
+* Throws `KUBB_MISSING_DEPENDENCY` for a missing required entry in a `dependencies` record, and
+* `KUBB_INCOMPATIBLE_DEPENDENCY` when an entry's `meta.version` is out of range. Arrays are not checked.
+*/
+function checkDependencies({ name, dependencies, plugins }) {
+	if (!dependencies || Array.isArray(dependencies)) return;
+	for (const [dependencyName, dependency] of Object.entries(dependencies)) {
+		const target = plugins.get(dependencyName);
+		if (!target) {
+			if (dependency?.optional) continue;
+			throw new Diagnostics.Error({
+				code: Diagnostics.code.missingDependency,
+				severity: "error",
+				message: `Plugin "${dependencyName}" is required by "${name}" but not found.`,
+				help: `Add "${dependencyName}" to the \`plugins\` array in kubb.config.ts.`,
+				location: { kind: "config" },
+				plugin: name
+			});
+		}
+		const range = dependency?.version;
+		const version = target.meta?.version;
+		if (!range || !version || (0, verkit.satisfies)(version, range, { includePrerelease: true })) continue;
+		throw new Diagnostics.Error({
+			code: Diagnostics.code.incompatibleDependency,
+			severity: "error",
+			message: `"${name}" requires "${dependencyName}" ${range}, but ${version} is configured.`,
+			help: `Install a version of "${dependencyName}" that satisfies ${range}.`,
+			location: { kind: "config" },
+			plugin: name
+		});
+	}
+}
+/**
+* Builds the factory behind `defineExtension`. It passes `{}` when called without options, and carries `kind` and
+* `meta` so tools can read them without calling it.
+*
+* @internal
+*/
+function createExtensionFactory({ kind, meta, build }) {
+	return Object.assign((options = {}) => build(options), {
+		kind,
+		meta
+	});
+}
+function defineExtension(definition) {
+	switch (definition.kind) {
+		case "plugin": {
+			const { meta, dependencies, enforce, hooks = {}, setup } = definition;
+			return createExtensionFactory({
+				kind: "plugin",
+				meta,
+				build: (options) => ({
+					name: meta.name,
+					meta,
+					options,
+					dependencies,
+					enforce,
+					hooks,
+					setup
+				})
+			});
+		}
+		case "adapter": {
+			const { meta, setup, build } = definition;
+			return createExtensionFactory({
+				kind: "adapter",
+				meta,
+				build: (raw) => {
+					const options = setup ? setup(raw) : raw;
+					return Object.assign(build(options), {
+						name: meta.name,
+						meta,
+						options
+					});
+				}
+			});
+		}
+		case "parser": {
+			const { meta, build } = definition;
+			return createExtensionFactory({
+				kind: "parser",
+				meta,
+				build: (options) => ({
+					...build(options),
+					name: meta.name,
+					meta,
+					options
+				})
+			});
+		}
+	}
+}
+//#endregion
+//#region src/composables.ts
+const kubbContextKey = Symbol.for("kubb.context");
+const host = globalThis;
+/**
+* Holds the setup context of the plugin whose `setup` or `kubb:plugin:setup` is running. `KubbDriver` sets it for each plugin.
+*
+* The store lives on `globalThis`, so the ESM and CommonJS builds of `@kubb/core` share one. A plugin that a
+* CommonJS config loads would otherwise read an empty store and fail with `KUBB_NO_CONTEXT`.
+*/
+const kubbContext = host[kubbContextKey] ??= new node_async_hooks.AsyncLocalStorage();
+function requireContext(caller) {
+	const ctx = kubbContext.getStore();
+	if (ctx) return ctx;
+	throw new Diagnostics.Error({
+		code: Diagnostics.code.noContext,
+		severity: "error",
+		message: `\`${caller}()\` was called outside a plugin setup.`,
+		help: `Call \`${caller}()\` inside \`setup\` or \`kubb:plugin:setup\`, including in code that setup awaits.`
+	});
+}
+/**
+* Returns the context of the plugin whose `kubb:plugin:setup` is running. It stays available after an `await`.
+* Throws `KUBB_NO_CONTEXT` outside setup.
+*/
+function useKubb() {
+	return requireContext("useKubb");
+}
+/**
+* Returns the same context as {@link useKubb}, or `undefined` outside `setup` and `kubb:plugin:setup`.
+*/
+function tryUseKubb() {
+	return kubbContext.getStore();
+}
+/**
+* Registers generators on the plugin being set up, like `ctx.addGenerator`.
+*
+* @example
+* `addGenerator(typeGenerator, enumGenerator)`
+*/
+function addGenerator(...generators) {
+	requireContext("addGenerator").addGenerator(...generators);
+}
+/**
+* Sets the resolver of the plugin being set up, like `ctx.setResolver`.
+*/
+function setResolver(resolver) {
+	requireContext("setResolver").setResolver(resolver);
+}
+/**
+* Adds a macro to the plugin being set up, like `ctx.addMacro`.
+*/
+function addMacro(macro) {
+	requireContext("addMacro").addMacro(macro);
+}
+/**
+* Replaces the macros of the plugin being set up, like `ctx.setMacros`.
+*/
+function setMacros(macros) {
+	requireContext("setMacros").setMacros(macros);
+}
+/**
+* Adds a raw file to the build output, like `ctx.injectFile`.
+*/
+function injectFile(file) {
+	requireContext("injectFile").injectFile(file);
+}
+/**
+* Returns the options the user passed to the plugin being set up, like `ctx.options`.
+*/
+function useOptions() {
+	return requireContext("useOptions").options;
+}
+/**
+* Sets the resolved options of the plugin being set up, like `ctx.setOptions`.
+*/
+function setOptions(options) {
+	requireContext("setOptions").setOptions(options);
+}
+/**
+* Returns the resolved build configuration, like `ctx.config`.
+*/
+function useConfig() {
+	return requireContext("useConfig").config;
+}
+/**
+* Returns another plugin from the config, typed through `Kubb.PluginRegistry`, like `ctx.requirePlugin`.
+*/
+function requirePlugin(name) {
+	return requireContext("requirePlugin").requirePlugin(name);
+}
+//#endregion
+//#region src/definePlugin.ts
+/**
+* Merges the `output.mode` default into the output config and validates the combination.
+* Throws `KUBB_INVALID_PLUGIN_OPTIONS` when `mode: 'file'` is paired with a `group` option,
+* since a single-file output has nothing to group.
+*
+* An omitted `mode` follows the shape of `path`: an extension means a single file, anything
+* else is a directory. Plugin defaults such as `path: 'types'` name a directory, so they
+* generate without the caller spelling out `mode`.
+*/
+function normalizeOutput({ output, group, pluginName }) {
+	const mode = output.mode ?? (node_path.default.extname(output.path) ? "file" : "directory");
+	if (mode === "file" && group) throw new Diagnostics.Error({
+		code: Diagnostics.code.invalidPluginOptions,
+		severity: "error",
+		message: `Plugin "${pluginName}" resolves \`output.mode\` to 'file' but also configures a \`group\` option.`,
+		help: "A single-file output has nothing to group. Remove the `group` option, give `output.path` an extensionless directory name, or set `output.mode: 'directory'` explicitly.",
+		location: { kind: "config" },
+		plugin: pluginName
+	});
+	return {
+		...output,
+		mode
+	};
+}
+/** Throws `KUBB_INVALID_PLUGIN_OPTIONS`, listing the allowed values, when `value` is not one of `allowed`. */
+function assertPluginOption({ plugin, option, value, allowed }) {
+	if (allowed.includes(value)) return;
+	const format = (item) => typeof item === "string" ? JSON.stringify(item) : String(item);
+	const expected = allowed.map(format).join(", ");
+	throw new Diagnostics.Error({
+		code: Diagnostics.code.invalidPluginOptions,
+		severity: "error",
+		message: `Plugin "${plugin}" option \`${option}\` is ${format(value)}, but it must be one of ${expected}.`,
+		help: `Set \`${option}\` to one of ${expected}.`,
+		location: { kind: "config" },
+		plugin
+	});
+}
+/**
+* Defines a plugin from one object and returns a factory that takes the user's options.
+*
+* @deprecated Use `defineExtension` with `kind: 'plugin'` instead.
+*/
+function definePlugin(definition) {
+	return defineExtension({
+		kind: "plugin",
+		...definition
+	});
+}
+//#endregion
+//#region src/input.ts
+/**
+* Classifies an `input` value so callers branch on it once instead of repeating the checks.
+*
+* A non-string is a parsed spec (`object`). A string is `inline` when it holds OpenAPI content,
+* meaning it starts with `{` or `[`, spans multiple lines, or opens with a YAML `openapi:` or
+* `swagger:` key. Otherwise a string is a `url` when it parses as one, or a `file` path.
+*/
+function getInputKind(input) {
+	if (typeof input !== "string") return "object";
+	const trimmed = input.trimStart();
+	if (trimmed.startsWith("{") || trimmed.startsWith("[") || input.includes("\n") || /^(openapi|swagger)\s*:/i.test(trimmed)) return "inline";
+	if (URL.canParse(input)) return "url";
+	return "file";
+}
+/**
+* The v4 `input` wrapper keys. v4 typed `input` as `{ path }` or `{ data }`; v5 takes the value
+* directly, so the wrapper now matches the "already-parsed document" branch and silently yields
+* an empty build.
+*/
+const legacyInputKeys = ["path", "data"];
+/**
+* Detects the v4 `{ path }` / `{ data }` wrapper so it fails loudly instead of being read as a
+* document. A real spec always carries more than these keys, so an object whose keys are drawn
+* only from them is the old shape rather than a document that happens to have a `path` property.
+*/
+function isLegacyInput(input) {
+	if (Array.isArray(input)) return input.some(isLegacyInput);
+	if (typeof input !== "object" || input === null) return false;
+	const keys = Object.keys(input);
+	return keys.length > 0 && keys.every((key) => legacyInputKeys.includes(key));
+}
+/**
+* Normalizes `config.input` into an `AdapterSource` the adapter can parse.
+*
+* A parsed object and inline content become `{ type: 'data' }`; a URL is kept verbatim and a
+* local path is resolved against `config.root`, both as `{ type: 'path' }`.
+*/
+function inputToAdapterSource(config) {
+	const input = config.input;
+	if (input && isLegacyInput(input)) throw new Diagnostics.Error({
+		code: Diagnostics.code.legacyInput,
+		severity: "error",
+		message: "The `input` option uses the v4 `{ path }` / `{ data }` wrapper.",
+		help: "Unwrap it: `input: { path: \"./petStore.yaml\" }` becomes `input: \"./petStore.yaml\"`, and `input: { data: spec }` becomes `input: spec`.",
+		location: { kind: "config" }
+	});
+	if (!input) throw new Diagnostics.Error({
+		code: Diagnostics.code.inputRequired,
+		severity: "error",
+		message: "An adapter is configured without an input.",
+		help: "Set `input` to a file path, a URL, an inline spec (JSON/YAML string), or a parsed object in your Kubb config.",
+		location: { kind: "config" }
+	});
+	if (typeof input !== "string") return {
+		type: "data",
+		data: input
+	};
+	const kind = getInputKind(input);
+	if (kind === "inline") return {
+		type: "data",
+		data: input
+	};
+	if (kind === "url") return {
+		type: "path",
+		path: input
+	};
+	return {
+		type: "path",
+		path: (0, node_path.resolve)(config.root, input)
+	};
+}
+//#endregion
+//#region src/Resolver.ts
+function isNamespace(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Shared brand for reaching a resolver's build options. `Resolver.merge` reads this instead of
+* relying on `instanceof`, which fails when a CommonJS config and the ESM CLI each load their own
+* copy of `@kubb/core`. `Symbol.for` resolves to one key across those copies, so the options stay
+* reachable and a `file` override is never dropped.
+*/
+const resolverOptions = Symbol.for("@kubb/core/resolver/options");
+/**
+* Builds a nested file path from a dotted name. Splits on dots that precede a letter
+* (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases
+* every segment, and joins with `/`.
+*
+* Empty segments are dropped before joining. They arise when the name starts with a dot
+* followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to
+* an empty string). Without this a leading `/` would form, which `path.resolve` reads as an
+* absolute path, letting generated files escape the configured output directory.
+*
+* @example Nested path from a dotted name
+* `toFilePath('pet.petId') // 'pet/petId'`
+*/
+function toFilePath(name) {
+	return name.split(/\.(?=[a-zA-Z])/).map((part) => camelCase(part)).filter(Boolean).join("/");
+}
+/** Throws `KUBB_PATH_TRAVERSAL` when `target` lies outside `parent`; `target === parent` stays allowed. */
+function assertInside({ target, parent, message, help }) {
+	const parentWithSep = parent.endsWith(node_path.default.sep) ? parent : `${parent}${node_path.default.sep}`;
+	if (target === parent || target.startsWith(parentWithSep)) return;
+	throw new Diagnostics.Error({
+		code: Diagnostics.code.pathTraversal,
+		severity: "error",
+		message,
+		help,
+		location: { kind: "config" }
+	});
+}
+/**
+* Built-in `file.baseName`: casts the identifier with `toFilePath` and appends the extension.
+*/
+function toBaseName({ name, extname }) {
+	return `${toFilePath(name)}${extname}`;
+}
+/**
+* Base constraint for all plugin resolver objects.
+*
+* The built-in machinery lives under `default`. Generators call the top-level `name`, `file`,
+* and `imports`, and a plugin overrides `name` and `file` to set its conventions. Extend with
+* top-level helpers (`typeName`, …) and/or grouped namespaces (`query`, `schema`, …).
+*
+* @example Top-level helper
+* ```ts
+* type MyResolver = Resolver & {
+*   typeName(name: string): string
+* }
+* ```
+*
+* @example Grouped namespace
+* ```ts
+* type MyResolver = Resolver & {
+*   query: {
+*     name(node: OperationNode): string
+*     keyName(node: OperationNode): string
+*   }
+* }
+* ```
+*/
+var Resolver = class Resolver {
+	static #patternCache = /* @__PURE__ */ new Map();
+	static #optionsCache = /* @__PURE__ */ new WeakMap();
+	pluginName;
+	/** The built-in machinery, untouched by `name`/`file` overrides and built once since the driver reads it per node. */
+	default;
+	#options;
+	#baseName;
+	#filePath;
+	constructor(options) {
+		this.pluginName = options.pluginName;
+		this.#options = options;
+		this.#baseName = options.file?.baseName ? options.file.baseName.bind(this) : toBaseName;
+		this.#filePath = options.file?.path ? options.file.path.bind(this) : void 0;
+		this.default = {
+			name: camelCase,
+			options: this.#resolveOptions.bind(this),
+			path: this.#resolvePath.bind(this),
+			file: this.#resolveFile.bind(this),
+			banner: this.#resolveBanner.bind(this),
+			footer: this.#resolveFooter.bind(this)
+		};
+		this.#apply(options);
+	}
+	/** Exposes the raw build options so `Resolver.merge` can read them across `@kubb/core` copies. */
+	get [resolverOptions]() {
+		return this.#options;
+	}
+	name(name) {
+		return this.default.name(name);
+	}
+	file(options) {
+		return this.#resolveFile(options);
+	}
+	/**
+	* Builds one `ImportNode` per unique schema referenced in the tree, in first-occurrence
+	* order. Each ref's target resolves through `resolveRefName`, so collision- or macro-renamed
+	* schemas (`targetName`) import the emitted name. Names and paths go through the top-level
+	* `name` and `file`, so import entries follow the plugin's conventions, and a per-call
+	* `name` override wins over both.
+	*
+	* The subtree scan runs through `collectImportedRefNames`, which memoizes by node identity, so a
+	* schema shared across the ts, zod, and faker plugins is walked once and every plugin's resolver
+	* reads the same ref set instead of re-scanning it per plugin.
+	*/
+	imports(options) {
+		const { node, root, output, group, extname = ".ts", name } = options;
+		const resolveName = name ?? ((schemaName) => this.name(schemaName));
+		return (0, _kubb_ast.collectImportedRefNames)(node).map((schemaName) => _kubb_ast.ast.factory.createImport({
+			name: [resolveName(schemaName)],
+			path: this.file({
+				name: schemaName,
+				extname,
+				root,
+				output,
+				group
+			}).path
+		}));
+	}
+	/**
+	* Folds each `override` over `base`, left to right, and returns a new resolver with helpers
+	* re-bound. Top-level keys replace, and a namespace (or `file`) merges per method, so overriding
+	* `query.name` keeps the base `query.keyName`. The last override wins per key. Used when applying
+	* `setResolver` partial overrides, and to compose shared resolver fragments without spreading each
+	* namespace by hand. Reads a resolver's options through the shared brand rather than `instanceof`,
+	* so a `file` override survives even when `base` and `override` come from different `@kubb/core`
+	* copies.
+	*
+	* @example Fold several partial overrides onto a resolver
+	* ```ts
+	* const resolver = Resolver.merge(defaultResolver, sharedNamingPatch, { name: (name) => name.toUpperCase() })
+	* ```
+	*/
+	static merge(base, ...overrides) {
+		const merged = overrides.reduce((acc, override) => {
+			const patch = resolverOptions in override ? override[resolverOptions] : override;
+			for (const [key, value] of Object.entries(patch)) {
+				if (value === void 0) continue;
+				const current = acc[key];
+				acc[key] = isNamespace(value) && isNamespace(current) ? {
+					...current,
+					...value
+				} : value;
+			}
+			return acc;
+		}, { ...base[resolverOptions] });
+		return new Resolver(merged);
+	}
+	/**
+	* Binds each entry of `options` onto the resolver, so `this.name`, `this.default`, and
+	* `this.file` resolve there for top-level helpers and namespace methods alike. `default`
+	* is skipped so it can't be shadowed.
+	*/
+	#apply(options) {
+		const root = this;
+		const bind = (value) => typeof value === "function" ? value.bind(root) : value;
+		for (const [key, value] of Object.entries(options)) {
+			if (key === "pluginName" || key === "default" || key === "file" || value === void 0) continue;
+			root[key] = isNamespace(value) ? Object.fromEntries(Object.entries(value).map(([method, member]) => [method, bind(member)])) : bind(value);
+		}
+	}
+	static #testPattern(value, pattern) {
+		if (typeof pattern === "string") {
+			let regex = Resolver.#patternCache.get(pattern);
+			regex ??= new RegExp(pattern);
+			Resolver.#patternCache.set(pattern, regex);
+			return regex.test(value);
+		}
+		return value.match(pattern) !== null;
+	}
+	static #matchesOperation(node, { type, pattern }) {
+		if (type === "tag") return node.tags.some((tag) => Resolver.#testPattern(tag, pattern));
+		if (type === "operationId") return Resolver.#testPattern(node.operationId, pattern);
+		if (type === "path") return node.path !== void 0 && Resolver.#testPattern(node.path, pattern);
+		if (type === "method") return node.method !== void 0 && Resolver.#testPattern(node.method.toLowerCase(), pattern);
+		if (type === "contentType") return node.requestBody?.content?.some((c) => Resolver.#testPattern(c.contentType, pattern)) ?? false;
+		return false;
+	}
+	/**
+	* Returns `null` when the filter type doesn't apply to schemas, so include rules built
+	* from operation filters (e.g. `tag`) don't exclude every schema.
+	*/
+	static #matchesSchema(node, { type, pattern }) {
+		if (type === "schemaName") return node.name ? Resolver.#testPattern(node.name, pattern) : false;
+		return null;
+	}
+	static #computeOptions(node, { options, exclude = [], include, override = [] }) {
+		if (node.kind === "Operation") {
+			if (exclude.some((filter) => Resolver.#matchesOperation(node, filter))) return null;
+			if (include && !include.some((filter) => Resolver.#matchesOperation(node, filter))) return null;
+			return {
+				...options,
+				...override.find((filter) => Resolver.#matchesOperation(node, filter))?.options
+			};
+		}
+		if (node.kind === "Schema") {
+			if (exclude.some((filter) => Resolver.#matchesSchema(node, filter) === true)) return null;
+			if (include) {
+				const applicable = include.map((filter) => Resolver.#matchesSchema(node, filter)).filter((result) => result !== null);
+				if (applicable.length > 0 && !applicable.includes(true)) return null;
+			}
+			return {
+				...options,
+				...override.find((filter) => Resolver.#matchesSchema(node, filter) === true)?.options
+			};
+		}
+		return options;
+	}
+	/**
+	* Applies include/exclude filters and merges matching override options, caching the result
+	* per `(options, node)` pair. Returns `null` when the node is filtered out.
+	*/
+	#resolveOptions(node, context) {
+		const { options } = context;
+		if (typeof options !== "object" || options === null) return Resolver.#computeOptions(node, context);
+		let byOptions = Resolver.#optionsCache.get(options);
+		if (!byOptions) {
+			byOptions = /* @__PURE__ */ new WeakMap();
+			Resolver.#optionsCache.set(options, byOptions);
+		}
+		const cached = byOptions.get(node);
+		if (cached) return cached.value;
+		const result = Resolver.#computeOptions(node, context);
+		byOptions.set(node, { value: result });
+		return result;
+	}
+	/**
+	* A custom `group.name` wins; otherwise `tag` groups use the camelCased tag and `path`
+	* groups use the first non-traversal segment (`''` when none remain, placing the file in
+	* the output root, kept safe by the caller's boundary check).
+	*/
+	static #resolveGroupDir(group, groupValue) {
+		if (group.name) return group.name({ group: groupValue });
+		if (group.type === "tag") return camelCase(groupValue);
+		const segment = groupValue.split("/").filter((part) => part !== "" && part !== "." && part !== "..")[0];
+		return segment ? camelCase(segment) : "";
+	}
+	/**
+	* `mode: 'file'` (default) resolves directly to `output.path`. `mode: 'directory'` resolves
+	* to `output.path/{baseName}`, or into a subdirectory when `group` and a `tag`/`path` value
+	* are provided.
+	*/
+	#resolvePath({ baseName, tag, path: groupPath, root, output, group }) {
+		if (output.mode !== "directory") return node_path.default.resolve(root, output.path);
+		const outputDir = node_path.default.resolve(root, output.path);
+		const result = group && (groupPath || tag) ? node_path.default.resolve(outputDir, Resolver.#resolveGroupDir(group, group.type === "path" ? groupPath : tag), baseName) : node_path.default.resolve(outputDir, baseName);
+		assertInside({
+			target: result,
+			parent: outputDir,
+			message: `Resolved path "${result}" is outside the output directory "${outputDir}".`,
+			help: "This can stem from a path traversal in the OpenAPI specification or a misconfigured `group.name` function. Keep generated paths within the output directory."
+		});
+		return result;
+	}
+	/**
+	* Resolves a resolver-supplied full path (`file.path`) against `root`, bypassing `output.path`
+	* and `group`. The path may not escape `root`, which keeps a `file.path` that interpolates
+	* spec-derived values from writing outside the project.
+	*/
+	#resolveOverridePath(filePath, root) {
+		const resolved = node_path.default.resolve(root, filePath);
+		assertInside({
+			target: resolved,
+			parent: root,
+			message: `Resolved path "${resolved}" is outside the project root "${root}".`,
+			help: "A resolver `file.path` must return a path inside the project root."
+		});
+		return resolved;
+	}
+	/**
+	* Builds a `FileNode`. When `#filePath` (the resolver's `file.path`) is set it owns the whole
+	* path; otherwise the base name (from `#baseName`, the resolver's `file.baseName` or the
+	* built-in `toBaseName`) is placed by the `output.path`/`group` layout. The resolved file starts
+	* with empty `sources`, `imports`, and `exports`, which consumers populate separately.
+	*/
+	#resolveFile(options) {
+		const { name, extname, tag, path: groupPath, root, output, group } = options;
+		const baseName = this.#baseName({
+			name,
+			extname
+		});
+		const filePath = this.#filePath ? this.#resolveOverridePath(this.#filePath({
+			baseName,
+			output
+		}), root) : this.#resolvePath({
+			baseName,
+			tag,
+			path: groupPath,
+			root,
+			output,
+			group
+		});
+		return _kubb_ast.ast.factory.createFile({
+			path: filePath,
+			baseName: node_path.default.basename(filePath),
+			meta: { pluginName: this.pluginName },
+			sources: [],
+			imports: [],
+			exports: []
+		});
+	}
+	/**
+	* Missing fields default to empty/`false` so the `BannerMeta` shape stays stable even when
+	* a caller (e.g. the barrel plugin) has no document metadata.
+	*/
+	static #buildBannerMeta(meta, file) {
+		return {
+			title: meta?.title,
+			description: meta?.description,
+			version: meta?.version,
+			baseURL: meta?.baseURL,
+			circularNames: meta?.circularNames ?? [],
+			enumNames: meta?.enumNames ?? [],
+			filePath: file?.path ?? "",
+			baseName: file?.baseName ?? "",
+			isBarrel: file?.isBarrel ?? false,
+			isAggregation: file?.isAggregation ?? false
+		};
+	}
+	/**
+	* Resolves a user-configured banner/footer value. `undefined` means not configured.
+	*/
+	static #resolveUserText(value, meta, file) {
+		if (typeof value === "function") return value(Resolver.#buildBannerMeta(meta, file));
+		if (typeof value === "string") return value;
+	}
+	static #buildDefaultBanner({ title, version, config }) {
+		const lines = [
+			"/**",
+			"* Generated by Kubb (https://kubb.dev/).",
+			"* Do not edit manually."
+		];
+		if (config.output.defaultBanner !== "simple") {
+			const input = config.input;
+			const source = typeof input === "string" ? getInputKind(input) === "inline" ? "text content" : node_path.default.basename(input) : input ? "text content" : "";
+			if (source) lines.push(`* Source: ${source}`);
+			if (title) lines.push(`* Title: ${title}`);
+			if (version) lines.push(`* OpenAPI spec version: ${version}`);
+		}
+		return `${lines.join("\n")}\n*/\n`;
+	}
+	/**
+	* A user-supplied `output.banner` overrides the default Kubb notice. When
+	* `config.output.defaultBanner` is `false` and no user banner is set, returns `null`.
+	*/
+	#resolveBanner(meta, { output, config, file }) {
+		const userBanner = Resolver.#resolveUserText(output?.banner, meta, file);
+		if (userBanner !== void 0) return userBanner;
+		if (config.output.defaultBanner === false) return null;
+		return Resolver.#buildDefaultBanner({
+			title: meta?.title,
+			version: meta?.version,
+			config
+		});
+	}
+	#resolveFooter(meta, { output, file }) {
+		return Resolver.#resolveUserText(output?.footer, meta, file) ?? null;
+	}
+};
+//#endregion
+//#region src/createResolver.ts
+/**
+* Defines a plugin resolver, the object that decides what every generated symbol and file
+* path is called. Override the top-level `name` and `file` to set the plugin's conventions,
+* and add your own naming helpers, top-level (`typeName`, …) or grouped in namespaces
+* (`query`, `schema`, …). Every method reaches sibling helpers and the built-in machinery
+* through `this.name`, `this.file`, and `this.default`.
+*
+* @example Custom identifier casing
+* ```ts
+* export const resolverTs = createResolver<PluginTs>({
+*   pluginName: 'plugin-ts',
+*   name(name) {
+*     return ensureValidVarName(pascalCase(name))
+*   },
+* })
+* ```
+*
+* @example Rename generated files with `file.baseName`
+* ```ts
+* export const resolverFaker = createResolver<PluginFaker>({
+*   pluginName: 'plugin-faker',
+*   name(name) {
+*     return camelCase(name, { prefix: 'create' })
+*   },
+*   file: {
+*     baseName({ name, extname }) {
+*       return `${camelCase(name, { prefix: 'create' })}${extname}`
+*     },
+*   },
+* })
+* ```
+*
+* @example Own the full path with `file.path`
+* ```ts
+* export const resolverFaker = createResolver<PluginFaker>({
+*   pluginName: 'plugin-faker',
+*   file: {
+*     path({ baseName, output }) {
+*       return `${output.path}/mocks/${baseName}`
+*     },
+*   },
+* })
+* ```
+*/
+function createResolver(options) {
+	return new Resolver(options);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.153.0/helpers/esm/usingCtx.js
+function _usingCtx() {
+	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
+		var n = Error();
+		return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
+	}, e = {}, n = [];
+	function using(r, e) {
+		if (null != e) {
+			if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+			if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+			if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
+			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+			t && (o = function o() {
+				try {
+					t.call(e);
+				} catch (r) {
+					return Promise.reject(r);
+				}
+			}), n.push({
+				v: e,
+				d: o,
+				a: r
+			});
+		} else r && n.push({
+			d: e,
+			a: r
+		});
+		return e;
+	}
+	return {
+		e,
+		u: using.bind(null, !1),
+		a: using.bind(null, !0),
+		d: function d() {
+			var o, t = this.e, s = 0;
+			function next() {
+				for (; o = n.pop();) try {
+					if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+					if (o.d) {
+						var r = o.d.call(o.v);
+						if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
+					} else s |= 1;
+				} catch (r) {
+					return err(r);
+				}
+				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+				if (t !== e) throw t;
+			}
+			function err(n) {
+				return t = t !== e ? new r(n, t) : n, next();
+			}
+			return next();
+		}
+	};
+}
+function joinSources(file) {
+	return file.sources.map((source) => (0, _kubb_ast.extractStringsFromNodes)(source.nodes)).filter(Boolean).join("\n\n");
+}
+/** Runs a parser call and turns a crash into a `KUBB_PARSER_FAILED` diagnostic that names the parser. */
+function runParser(parser, print) {
+	try {
+		return print();
+	} catch (error) {
+		throw new Diagnostics.Error(Diagnostics.fromExtension(error, {
+			kind: "parser",
+			extension: parser
+		}));
+	}
+}
+/**
+* Reads a `copy` file and prints it through the parser's `copy` hook, or verbatim with `banner`/`footer` when there is none.
+*/
+async function parseCopy(file, parser) {
+	let content;
+	try {
+		content = await (0, node_fs_promises.readFile)(file.copy, "utf8");
+	} catch (err) {
+		throw new Diagnostics.Error({
+			code: Diagnostics.code.pluginFailed,
+			severity: "error",
+			message: `Could not copy file into output: ${file.copy}`,
+			help: "Check that the file a plugin copies into the output exists and is readable.",
+			cause: toError(err)
+		});
+	}
+	if (parser?.copy) return runParser(parser, () => parser.parse(_kubb_ast.ast.factory.createFile(parser.copy(file, content))));
+	return [
+		file.banner,
+		content,
+		file.footer
+	].filter((segment) => Boolean(segment)).map((segment) => segment.trimEnd()).join("\n");
+}
+function mergeFile(a, b) {
+	return {
+		...a,
+		banner: b.banner,
+		footer: b.footer,
+		copy: b.copy ?? a.copy,
+		sources: a.sources.length ? b.sources.length ? [...a.sources, ...b.sources] : a.sources : b.sources,
+		imports: a.imports.length ? b.imports.length ? [...a.imports, ...b.imports] : a.imports : b.imports,
+		exports: a.exports.length ? b.exports.length ? [...a.exports, ...b.exports] : a.exports : b.exports
+	};
+}
+function isIndexPath(path) {
+	return path.endsWith("/index.ts") || path === "index.ts";
+}
+function compareFiles(a, b) {
+	return a.path.length - b.path.length || Number(isIndexPath(a.path)) - Number(isIndexPath(b.path));
+}
+function isUnchanged({ stored, source, key, manifest }) {
+	if (stored === null) return false;
+	if (matchesStored({
+		stored,
+		source
+	})) return true;
+	return manifest?.isUpToDate({
+		key,
+		source,
+		disk: stored
+	}) ?? false;
+}
+/**
+* In-memory file store for generated files, and the writer that turns them into source
+* strings on `storage`. Files sharing a `path` are merged (sources/imports/exports
+* concatenated). The `files` getter is sorted by path length (barrel `index.ts` last
+* within a bucket).
+*
+* @example
+* ```ts
+* const manager = new FileManager()
+* manager.upsert(myFile)
+* manager.files // sorted view
+* await manager.write(manager.files, { storage: fsStorage() })
+* ```
+*/
+var FileManager = class {
+	#cache = /* @__PURE__ */ new Map();
+	#sorted = null;
+	add(...files) {
+		return this.#store(files, false);
+	}
+	upsert(...files) {
+		return this.#store(files, true);
+	}
+	/** Stores a generator result: a file array is upserted as is, an element renders through `renderer` first, falsy is a no-op. */
+	async dispatch({ result, renderer }) {
+		try {
+			var _usingCtx$1 = _usingCtx();
+			if (!result) return;
+			if (Array.isArray(result)) {
+				this.upsert(...result);
+				return;
+			}
+			if (!renderer) return;
+			const instance = _usingCtx$1.u(renderer());
+			await instance.render(result);
+			this.upsert(...instance.files);
+		} catch (_) {
+			_usingCtx$1.e = _;
+		} finally {
+			_usingCtx$1.d();
+		}
+	}
+	#store(files, mergeExisting) {
+		const batch = files.length > 1 ? this.#dedupe(files) : files;
+		const resolved = [];
+		for (const file of batch) {
+			const existing = this.#cache.get(file.path);
+			const merged = existing && mergeExisting ? _kubb_ast.ast.factory.createFile(mergeFile(existing, file)) : _kubb_ast.ast.factory.createFile(file);
+			this.#cache.set(merged.path, merged);
+			resolved.push(merged);
+		}
+		if (resolved.length > 0) this.#sorted = null;
+		return resolved;
+	}
+	#dedupe(files) {
+		const seen = /* @__PURE__ */ new Map();
+		for (const file of files) {
+			const prev = seen.get(file.path);
+			seen.set(file.path, prev ? mergeFile(prev, file) : file);
+		}
+		return [...seen.values()];
+	}
+	/**
+	* Releases all stored files. Called by the core after `kubb:build:end`.
+	*/
+	dispose() {
+		this.#cache.clear();
+		this.#sorted = null;
+	}
+	/**
+	* All stored files in stable sort order (shortest path first, barrel files
+	* last within a length bucket). Returns a cached view, do not mutate.
+	*/
+	get files() {
+		return this.#sorted ??= [...this.#cache.values()].sort(compareFiles);
+	}
+	/**
+	* Converts a file's AST sources (or its `copy` source) into the final on-disk string.
+	*/
+	async parse(file, { parsers } = {}) {
+		const parser = parsers?.get(file.extname);
+		if (file.copy) return parseCopy(file, parser);
+		if (!parser) return joinSources(file);
+		return runParser(parser, () => parser.parse(file));
+	}
+	/**
+	* Parses and writes every file through a bounded pool of workers. A small spec runs all its files
+	* at once; a spec with thousands of files keeps at most {@link FILE_CONCURRENCY} parsed sources in
+	* memory rather than holding every source, while still overlapping each file's write with the
+	* next file's parse. Files finish in whatever order they parse, so the update rows are sorted back
+	* into input order before `kubb:files:processing:update` fires once with the whole batch.
+	*
+	* A file the storage already holds is skipped, so a rebuild that generates identical output
+	* writes nothing and leaves every mtime where it was.
+	*/
+	async write(files, { storage, parsers, manifest, signal, hooks, config }) {
+		if (files.length === 0) return;
+		await hooks?.callHook("kubb:files:processing:start", { files });
+		const total = files.length;
+		const updates = [];
+		await inParallel({
+			items: files,
+			limit: 50,
+			run: async (file, index) => {
+				signal?.throwIfAborted();
+				const source = await this.parse(file, { parsers });
+				if (config) updates.push({
+					file,
+					processed: index + 1,
+					total,
+					percentage: (index + 1) / total * 100,
+					config
+				});
+				if (!source) return;
+				signal?.throwIfAborted();
+				const stored = await storage.readItem(file.path);
+				if (isUnchanged({
+					stored,
+					source,
+					key: file.path,
+					manifest
+				})) return;
+				signal?.throwIfAborted();
+				await storage.writeItem(file.path, source, { stored });
+				manifest?.track({
+					key: file.path,
+					source
+				});
+			}
+		});
+		updates.sort((a, b) => a.processed - b.processed);
+		await hooks?.callHook("kubb:files:processing:update", { files: updates });
+		await hooks?.callHook("kubb:files:processing:end", { files });
+	}
+};
+//#endregion
+//#region src/nodeCache.ts
+/**
+* Builds an empty {@link NodeCache} backed by a plain `Map`. Called once per node in the generate
+* walk.
+*/
+function createNodeCache() {
+	const store = /* @__PURE__ */ new Map();
+	return {
+		readItem(key) {
+			return store.get(key);
+		},
+		writeItem(key, value) {
+			store.set(key, value);
+			return value;
+		},
+		ensureItem(key, factory) {
+			if (store.has(key)) return store.get(key);
+			const value = factory();
+			store.set(key, value);
+			return value;
+		}
+	};
+}
+//#endregion
+//#region src/KubbDriver.ts
+const ENFORCE_ORDER = {
+	pre: -1,
+	post: 1
+};
+/** `include` filter types that select operations, and so prune the schemas they do not reach. */
+const OPERATION_FILTER_TYPES = /* @__PURE__ */ new Set([
+	"tag",
+	"operationId",
+	"path",
+	"method",
+	"contentType"
+]);
+const enforceWeight = (plugin) => plugin.enforce ? ENFORCE_ORDER[plugin.enforce] : 0;
+/**
+* The options bag a `NormalizedPlugin` starts with before a plugin refines it: a directory output
+* at the plugin root and empty filter lists.
+*/
+const defaultPluginOptions = () => ({
+	output: {
+		path: ".",
+		mode: "directory"
+	},
+	exclude: [],
+	override: []
+});
+/**
+* Fills in the `output`, `exclude`, and `override` a `NormalizedPlugin` needs from a plugin's raw
+* options, running `output` through `normalizeOutput`. Idempotent, so the driver can apply it after
+* `setOptions` has already run without disturbing an already-normalized bag.
+*/
+function normalizePluginOptions(rawOptions, pluginName) {
+	const options = {
+		...defaultPluginOptions(),
+		...rawOptions ?? {}
+	};
+	const group = "group" in options ? options.group : void 0;
+	options.output = normalizeOutput({
+		output: options.output,
+		group,
+		pluginName
+	});
+	return options;
+}
+/**
+* Throws `KUBB_INVALID_PLUGIN_OPTIONS` when a `plugins` entry is not a plugin object, such as a
+* factory passed without calling it.
+*/
+function assertPluginEntry(entry, index) {
+	if (typeof entry === "function") {
+		const name = entry.name || "pluginName";
+		throw new Diagnostics.Error({
+			code: Diagnostics.code.invalidPluginOptions,
+			severity: "error",
+			message: `plugins[${index}] is a function ("${name}"), not a plugin.`,
+			help: `Call it: ${name}()`,
+			location: { kind: "config" }
+		});
+	}
+	if (typeof entry !== "object" || entry === null) throw new Diagnostics.Error({
+		code: Diagnostics.code.invalidPluginOptions,
+		severity: "error",
+		message: `plugins[${index}] is ${entry === null ? "null" : typeof entry}, not a plugin.`,
+		help: "Pass the result of a plugin factory, for example `pluginTs()`, or remove the entry.",
+		location: { kind: "config" }
+	});
+}
+/**
+* Where a generator crashed: a label naming the node and, when the node has one, a JSON pointer
+* to it. Built from the node fields so core stays adapter-agnostic.
+*/
+function getCrashSite(node) {
+	if (node.kind === "Schema") return node.name ? {
+		label: `schema "${node.name}"`,
+		location: {
+			kind: "schema",
+			pointer: `#/components/schemas/${escapePointerToken(node.name)}`
+		}
+	} : { label: "an inline schema" };
+	if (!node.method || !node.path) return { label: `operation "${node.operationId}"` };
+	return {
+		label: `operation "${node.operationId}" (${node.method.toUpperCase()} ${node.path})`,
+		location: {
+			kind: "operation",
+			pointer: `#/paths/${escapePointerToken(node.path)}/${node.method.toLowerCase()}`
+		}
+	};
+}
+var KubbDriver = class {
+	config;
+	options;
+	/**
+	* The `InputNode` produced by the adapter. Set after adapter setup.
+	*/
+	inputNode = null;
+	adapter = null;
+	/**
+	* Raw adapter source so `adapter.parse()` can run lazily.
+	* Intentionally outlives the build, cleared by `dispose()`.
+	*/
+	#adapterSource = null;
+	/**
+	* Central file store for all generated files.
+	* Plugins should use `this.addFile()` / `this.upsertFile()` (via their context) to
+	* add files. This property gives direct read/write access when needed.
+	*/
+	fileManager = new FileManager();
+	plugins = /* @__PURE__ */ new Map();
+	/**
+	* Removers for every listener the driver added (plugin, generator) so `dispose()` can detach
+	* them in one pass. External `hooks.hook(...)` listeners are not tracked.
+	*/
+	#unhooks = [];
+	constructor(config, options) {
+		this.config = config;
+		this.options = options;
+		this.adapter = config.adapter ?? null;
+	}
+	/**
+	* Checks the adapter's and parsers' `meta.compatibility`, then normalizes and checks every configured plugin, orders them, and registers their lifecycle handlers.
+	* A plugin that another lists as a dependency runs first, then `enforce: 'pre'` before
+	* `'post'`. When the config has an adapter, the adapter source is resolved from the input
+	* so `run` can parse it later.
+	*/
+	async setup() {
+		this.options.signal?.throwIfAborted();
+		for (const extension of [this.config.adapter, ...this.config.parsers]) if (extension?.meta) checkCompatibility(extension.meta);
+		const names = /* @__PURE__ */ new Set();
+		const normalized = this.#sortPlugins(this.config.plugins.map((rawPlugin, index) => {
+			assertPluginEntry(rawPlugin, index);
+			if (rawPlugin.meta) checkCompatibility(rawPlugin.meta);
+			const meta = resolveMeta(rawPlugin);
+			if (names.has(meta.name)) throw new Diagnostics.Error({
+				code: Diagnostics.code.invalidPluginOptions,
+				severity: "error",
+				message: `Plugin "${meta.name}" appears twice in \`plugins\`.`,
+				help: "Remove the duplicate, or merge its options.",
+				location: { kind: "config" }
+			});
+			names.add(meta.name);
+			return {
+				name: meta.name,
+				meta,
+				dependencies: typeof rawPlugin.dependencies === "function" ? rawPlugin.dependencies(rawPlugin.options ?? {}, { config: this.config }) : rawPlugin.dependencies,
+				enforce: rawPlugin.enforce,
+				hooks: rawPlugin.hooks,
+				setup: rawPlugin.setup,
+				options: rawPlugin.options ?? defaultPluginOptions(),
+				resolver: createResolver({ pluginName: meta.name })
+			};
+		}));
+		const byName = new Map(normalized.map((plugin) => [plugin.name, plugin]));
+		for (const plugin of normalized) checkDependencies({
+			name: plugin.name,
+			dependencies: plugin.dependencies,
+			plugins: byName
+		});
+		for (const plugin of normalized) {
+			this.#registerPlugin(plugin);
+			this.plugins.set(plugin.name, plugin);
+		}
+		if (this.config.adapter) this.#adapterSource = inputToAdapterSource(this.config);
+	}
+	/**
+	* Orders plugins so every dependency runs before its dependents (Kahn's algorithm), with
+	* `enforce` (`'pre'` before normal before `'post'`) and declaration order as tiebreaks.
+	* A pairwise `Array.sort` comparator cannot do this: dependency relations are not transitive
+	* at the comparator level, so a chain where A depends on B and B depends on C could come out
+	* wrong when A and C are never compared directly. Dependencies on plugins missing from the
+	* config are ignored here and surface later through `requirePlugin`.
+	*/
+	#sortPlugins(plugins) {
+		const queue = [...plugins].sort((a, b) => enforceWeight(a) - enforceWeight(b));
+		const names = new Set(queue.map((plugin) => plugin.name));
+		const blockedBy = new Map(queue.map((plugin) => {
+			const dependencies = Array.isArray(plugin.dependencies) ? plugin.dependencies : Object.keys(plugin.dependencies ?? {});
+			return [plugin.name, new Set(dependencies.filter((name) => names.has(name) && name !== plugin.name))];
+		}));
+		const sorted = [];
+		for (const _ of plugins) {
+			const index = queue.findIndex((plugin) => blockedBy.get(plugin.name)?.size === 0);
+			if (index === -1) throw new Diagnostics.Error({
+				code: Diagnostics.code.invalidPluginOptions,
+				severity: "error",
+				message: `Plugin dependencies form a cycle: ${queue.map((plugin) => plugin.name).join(" → ")}.`,
+				help: "Remove one of the `dependencies` entries so the plugins can be ordered.",
+				location: { kind: "config" }
+			});
+			const [plugin] = queue.splice(index, 1);
+			if (!plugin) break;
+			sorted.push(plugin);
+			for (const blockers of blockedBy.values()) blockers.delete(plugin.name);
+		}
+		return sorted;
+	}
+	get hooks() {
+		return this.options.hooks;
+	}
+	/**
+	* Parses the adapter source into `this.inputNode`. Idempotent, so repeated calls from
+	* `run` do not re-parse.
+	*/
+	async #parseInput() {
+		if (this.inputNode || !this.adapter || !this.#adapterSource) return;
+		this.options.signal?.throwIfAborted();
+		try {
+			this.inputNode = await this.adapter.parse(this.#adapterSource, { signal: this.options.signal });
+		} catch (caughtError) {
+			throw new Diagnostics.Error(Diagnostics.fromExtension(caughtError, {
+				kind: "adapter",
+				extension: this.adapter
+			}));
+		}
+	}
+	/**
+	* Registers a plugin's lifecycle hooks on the shared `Hookable` as pass-through listeners that
+	* external tooling can observe via `hooks.hook(...)`. The returned remover is tracked for
+	* `dispose`. `kubb:plugin:setup` is skipped here; `setupHooks` invokes it directly with a
+	* plugin-scoped context.
+	*
+	* @internal
+	*/
+	#registerPlugin(plugin) {
+		const { hooks } = plugin;
+		if (!hooks) return;
+		const { "kubb:plugin:setup": _setup, ...configHooks } = hooks;
+		this.#unhooks.push(this.hooks.addHooks(configHooks));
+	}
+	/**
+	* Runs each plugin's `setup` and `kubb:plugin:setup` handler, in plugin order, with a context scoped to that
+	* plugin so `addGenerator`, `setResolver`, `addMacro`, `setMacros`, and `setOptions` target its
+	* `NormalizedPlugin` entry. Called once from `run` before the plugin execution loop begins, so
+	* plugins can configure generators, resolvers, macros, and options before `buildStart`.
+	*/
+	async setupHooks() {
+		for (const plugin of this.plugins.values()) {
+			const setupHook = plugin.hooks?.["kubb:plugin:setup"];
+			if (!plugin.setup && !setupHook) continue;
+			const ctx = {
+				config: this.config,
+				options: plugin.options ?? {},
+				addGenerator: (...generators) => {
+					plugin.generators = [...plugin.generators ?? [], ...generators];
+				},
+				setResolver: (resolver) => {
+					plugin.resolver = Resolver.merge(createResolver({ pluginName: plugin.name }), resolver);
+				},
+				addMacro: (macro) => {
+					plugin.macros = [...plugin.macros ?? [], macro];
+				},
+				setMacros: (macros) => {
+					plugin.macros = [...macros];
+				},
+				setOptions: (opts) => {
+					plugin.options = normalizePluginOptions({
+						...plugin.options,
+						...opts
+					}, plugin.name);
+				},
+				injectFile: (userFileNode) => {
+					this.fileManager.add(_kubb_ast.ast.factory.createFile(userFileNode));
+				},
+				requirePlugin: ((name) => this.requirePlugin(name, { requiredBy: plugin.name }))
+			};
+			try {
+				await kubbContext.run(ctx, async () => {
+					if (plugin.setup) plugin.options = normalizePluginOptions(await plugin.setup(ctx.options, ctx), plugin.name);
+					await setupHook?.(ctx);
+				});
+			} catch (caughtError) {
+				throw new Diagnostics.Error(Diagnostics.fromExtension(caughtError, {
+					kind: "plugin",
+					extension: plugin
+				}));
+			}
+		}
+	}
+	/**
+	* Runs the full plugin pipeline. Returns the diagnostics collected so far even
+	* when an outer hook throws, since the orchestrator preserves partial state by capturing
+	* the failure as a {@link Diagnostic} instead of propagating. Each plugin also
+	* contributes a `timing` diagnostic for the run summary.
+	*/
+	async run() {
+		const { hooks, config, fileManager } = this;
+		const diagnostics = [];
+		const parsersMap = /* @__PURE__ */ new Map();
+		for (const parser of config.parsers) if (parser.extNames) for (const ext of parser.extNames) parsersMap.set(ext, parser);
+		return Diagnostics.scope((diagnostic) => diagnostics.push(diagnostic), async () => {
+			try {
+				this.options.signal?.throwIfAborted();
+				const outputRoot = (0, node_path.resolve)(config.root, config.output.path);
+				await this.#parseInput();
+				await this.setupHooks();
+				for (const plugin of this.plugins.values()) {
+					this.options.signal?.throwIfAborted();
+					plugin.options = normalizePluginOptions(plugin.options, plugin.name);
+				}
+				if (this.adapter && this.inputNode) {
+					const buildStartContext = this.#withFiles({
+						config,
+						adapter: this.adapter,
+						meta: this.inputNode.meta,
+						getPlugin: this.getPlugin.bind(this)
+					});
+					await hooks.callHook("kubb:build:start", buildStartContext);
+				}
+				const generatorPlugins = [];
+				for (const plugin of this.plugins.values()) {
+					const context = this.getContext(plugin);
+					const hrStart = process.hrtime();
+					try {
+						await hooks.callHook("kubb:plugin:start", { plugin });
+					} catch (caughtError) {
+						const error = toError(caughtError);
+						const duration = getElapsedMs(hrStart);
+						await this.#emitPluginEnd({
+							plugin,
+							duration,
+							success: false,
+							error
+						});
+						diagnostics.push(Diagnostics.fromExtension(error, {
+							kind: "plugin",
+							extension: plugin
+						}), Diagnostics.performance({
+							plugin: plugin.name,
+							duration
+						}));
+						continue;
+					}
+					if ((plugin.generators?.length ?? 0) > 0) {
+						generatorPlugins.push({
+							plugin,
+							context,
+							hrStart
+						});
+						continue;
+					}
+					const duration = getElapsedMs(hrStart);
+					diagnostics.push(Diagnostics.performance({
+						plugin: plugin.name,
+						duration
+					}));
+					await this.#emitPluginEnd({
+						plugin,
+						duration,
+						success: true
+					});
+				}
+				diagnostics.push(...await this.#runGenerators(generatorPlugins));
+				await hooks.callHook("kubb:plugins:end", this.#withFiles({ config }));
+				if (this.options.cleanPath) await config.storage.empty(this.options.cleanPath);
+				await fileManager.write(fileManager.files, {
+					storage: config.storage,
+					parsers: parsersMap,
+					manifest: this.options.manifest,
+					signal: this.options.signal,
+					hooks,
+					config
+				});
+				await hooks.callHook("kubb:build:end", {
+					files: this.fileManager.files,
+					config,
+					outputDir: outputRoot
+				});
+				return { diagnostics: Diagnostics.dedupe(diagnostics) };
+			} catch (caughtError) {
+				diagnostics.push(Diagnostics.from(caughtError));
+				return { diagnostics: Diagnostics.dedupe(diagnostics) };
+			}
+		});
+	}
+	/**
+	* Widens `extra` with the files present at emit time and a bound `upsertFile`, the shape every
+	* file-carrying hook context shares. Building it here in one place keeps the `files` and
+	* `upsertFile` keys from being dropped by a stray spread at the call site.
+	*/
+	#withFiles(extra) {
+		return {
+			...extra,
+			files: this.fileManager.files,
+			upsertFile: (...files) => this.fileManager.upsert(...files)
+		};
+	}
+	#emitPluginEnd({ plugin, duration, success, error }) {
+		return this.hooks.callHook("kubb:plugin:end", this.#withFiles({
+			plugin,
+			duration,
+			success,
+			...error ? { error } : {},
+			config: this.config
+		}));
+	}
+	/**
+	* Runs schemas and operations through every plugin's generators. The walk is node-outer: each
+	* schema is visited once and each operation once, and the node fans out to the matching
+	* generators of every plugin in dependency order. A per-node cache (`createNodeCache`) is created
+	* once per node and shared by all of that node's plugins, so node-derived work is computed once
+	* and reused instead of recomputed per plugin. Each node still runs through the plugin's macros
+	* and its exclude/include/override filters before that plugin's
+	* generator sees it, so plugins stay isolated. Schemas run before operations so file output
+	* stays deterministic across runs. A generator with a `match` predicate that resolves `false`
+	* for a node is skipped for that node, without calling `schema`/`operation`.
+	*
+	* A failing plugin is dropped from the remaining walk, contributes an error diagnostic, and no
+	* longer aborts the other plugins. `kubb:plugin:end` and each plugin's `timing` diagnostic fire
+	* in dependency order once the walk finishes, driving the CLI's `Plugins N/M` counter. The
+	* `operations` batch fires once per plugin after the single operation walk.
+	*
+	* When `this.inputNode` is `null`, every entry still gets a `kubb:plugin:end` so
+	* post-plugin listeners (the barrel writer and friends) complete.
+	*/
+	async #runGenerators(entries) {
+		const diagnostics = [];
+		if (entries.length === 0) return diagnostics;
+		if (!this.inputNode) {
+			for (const { plugin, hrStart } of entries) {
+				const duration = getElapsedMs(hrStart);
+				diagnostics.push(Diagnostics.performance({
+					plugin: plugin.name,
+					duration
+				}));
+				await this.#emitPluginEnd({
+					plugin,
+					duration,
+					success: true
+				});
+			}
+			return diagnostics;
+		}
+		const { schemas, operations } = this.inputNode;
+		const allowedSchemaNamesByPlugin = /* @__PURE__ */ new Map();
+		for (const { plugin } of entries) {
+			const { exclude, include, override } = plugin.options;
+			if (!((include?.some(({ type }) => OPERATION_FILTER_TYPES.has(type)) ?? false) && !(include?.some(({ type }) => type === "schemaName") ?? false))) continue;
+			const resolver = this.getResolver(plugin.name);
+			const includedOps = operations.filter((operation) => resolver.default.options(operation, {
+				options: plugin.options,
+				exclude,
+				include,
+				override
+			}) !== null);
+			allowedSchemaNamesByPlugin.set(plugin.name, (0, _kubb_ast.collectUsedSchemaNames)(includedOps, schemas));
+		}
+		const states = entries.map(({ plugin, context, hrStart }) => {
+			const generatorContext = {
+				...context,
+				resolver: this.getResolver(plugin.name)
+			};
+			const { exclude, include, override } = plugin.options;
+			const generators = plugin.generators ?? [];
+			return {
+				plugin,
+				hrStart,
+				generatorContext,
+				exclude,
+				include,
+				override,
+				optionsAreStatic: !exclude?.length && !include?.length && !override?.length,
+				allowedSchemaNames: allowedSchemaNamesByPlugin.get(plugin.name) ?? null,
+				schemaGenerators: generators.filter((generator) => generator.schema),
+				operationGenerators: generators.filter((generator) => generator.operation),
+				operationsGenerators: generators.filter((generator) => generator.operations),
+				pluginOperations: [],
+				error: null,
+				crashSite: void 0
+			};
+		});
+		const resolveForPlugin = (state, node) => {
+			const transformedNode = _kubb_ast.ast.applyMacros(node, state.plugin.macros ?? []);
+			if (state.optionsAreStatic) return {
+				transformedNode,
+				options: state.plugin.options
+			};
+			const options = state.generatorContext.resolver.default.options(transformedNode, {
+				options: state.plugin.options,
+				exclude: state.exclude,
+				include: state.include,
+				override: state.override
+			});
+			if (options === null) return null;
+			return {
+				transformedNode,
+				options
+			};
+		};
+		for (const node of schemas) {
+			const cache = createNodeCache();
+			for (const state of states) {
+				if (state.error || !state.schemaGenerators.length) continue;
+				try {
+					const resolved = resolveForPlugin(state, node);
+					if (!resolved) continue;
+					const { transformedNode, options } = resolved;
+					if (state.allowedSchemaNames !== null && transformedNode.name && !state.allowedSchemaNames.has(transformedNode.name)) continue;
+					const ctx = {
+						...state.generatorContext,
+						options,
+						cache
+					};
+					await this.#dispatchNode({
+						generators: state.schemaGenerators,
+						node: transformedNode,
+						ctx,
+						generate: (generator) => generator.schema(transformedNode, ctx)
+					});
+					await this.hooks.callHook("kubb:generate:schema", transformedNode, ctx);
+				} catch (caughtError) {
+					state.error = toError(caughtError);
+					state.crashSite = getCrashSite(node);
+				}
+			}
+		}
+		for (const node of operations) {
+			const cache = createNodeCache();
+			for (const state of states) {
+				if (state.error || !state.operationGenerators.length && !state.operationsGenerators.length) continue;
+				try {
+					const resolved = resolveForPlugin(state, node);
+					if (!resolved) continue;
+					state.pluginOperations.push(resolved.transformedNode);
+					if (state.operationGenerators.length) {
+						const { transformedNode } = resolved;
+						const ctx = {
+							...state.generatorContext,
+							options: resolved.options,
+							cache
+						};
+						await this.#dispatchNode({
+							generators: state.operationGenerators,
+							node: transformedNode,
+							ctx,
+							generate: (generator) => generator.operation(transformedNode, ctx)
+						});
+						await this.hooks.callHook("kubb:generate:operation", transformedNode, ctx);
+					}
+				} catch (caughtError) {
+					state.error = toError(caughtError);
+					state.crashSite = getCrashSite(node);
+				}
+			}
+		}
+		for (const state of states) {
+			if (state.error || !state.operationsGenerators.length) continue;
+			try {
+				const ctx = {
+					...state.generatorContext,
+					options: state.plugin.options,
+					cache: createNodeCache()
+				};
+				for (const generator of state.operationsGenerators) await this.fileManager.dispatch({
+					result: await generator.operations(state.pluginOperations, ctx),
+					renderer: generator.renderer
+				});
+				await this.hooks.callHook("kubb:generate:operations", state.pluginOperations, ctx);
+			} catch (caughtError) {
+				state.error = toError(caughtError);
+			}
+		}
+		for (const state of states) {
+			const duration = getElapsedMs(state.hrStart);
+			await this.#emitPluginEnd({
+				plugin: state.plugin,
+				duration,
+				success: !state.error,
+				error: state.error ?? void 0
+			});
+			if (state.error) {
+				const diagnostic = Diagnostics.fromExtension(state.error, {
+					kind: "plugin",
+					extension: state.plugin
+				});
+				const site = diagnostic.code === Diagnostics.code.pluginFailed && !diagnostic.location ? state.crashSite : void 0;
+				diagnostics.push(site ? {
+					...diagnostic,
+					message: `While generating ${site.label}: ${diagnostic.message}`,
+					...site.location ? { location: site.location } : {}
+				} : diagnostic);
+			}
+			diagnostics.push(Diagnostics.performance({
+				plugin: state.plugin.name,
+				duration
+			}));
+		}
+		return diagnostics;
+	}
+	/** Runs `node` through the generators whose `match` accepts it; `generate` picks the method for the node kind. */
+	async #dispatchNode({ generators, node, ctx, generate }) {
+		for (const generator of generators) {
+			if (!(generator.match ? await generator.match(node, ctx) : true)) continue;
+			await this.fileManager.dispatch({
+				result: await generate(generator),
+				renderer: generator.renderer
+			});
+		}
+	}
+	/**
+	* Removes every listener the driver added. Listeners attached directly to `hooks` from outside
+	* the driver survive. Called at the end of a build to prevent leaks across repeated builds.
+	*
+	* @internal
+	*/
+	dispose() {
+		for (const unhook of this.#unhooks) unhook();
+		this.#unhooks.length = 0;
+		this.fileManager.dispose();
+		this.inputNode = null;
+		this.#adapterSource = null;
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+	getResolver(pluginName) {
+		return this.plugins.get(pluginName)?.resolver ?? createResolver({ pluginName });
+	}
+	getContext(plugin) {
+		const driver = this;
+		const report = (diagnostic) => {
+			Diagnostics.report({
+				...diagnostic,
+				plugin: plugin.name
+			});
+		};
+		return {
+			config: driver.config,
+			signal: driver.options.signal,
+			get root() {
+				return (0, node_path.resolve)(driver.config.root, driver.config.output.path);
+			},
+			hooks: driver.hooks,
+			plugin,
+			getPlugin: driver.getPlugin.bind(driver),
+			requirePlugin: ((name) => driver.requirePlugin(name, { requiredBy: plugin.name })),
+			getResolver: driver.getResolver.bind(driver),
+			driver,
+			addFile: async (...files) => {
+				driver.fileManager.add(...files);
+			},
+			upsertFile: async (...files) => {
+				driver.fileManager.upsert(...files);
+			},
+			get meta() {
+				return driver.inputNode?.meta ?? {
+					circularNames: [],
+					enumNames: []
+				};
+			},
+			get adapter() {
+				return driver.adapter;
+			},
+			get resolver() {
+				return driver.getResolver(plugin.name);
+			},
+			warn(message, options) {
+				report({
+					code: Diagnostics.code.pluginWarning,
+					severity: "warning",
+					message,
+					...options
+				});
+			},
+			error(error, options) {
+				if (Diagnostics.isError(error)) {
+					report({
+						...options,
+						...error.diagnostic
+					});
+					return;
+				}
+				const cause = typeof error === "string" ? void 0 : error;
+				report({
+					code: Diagnostics.code.pluginFailed,
+					severity: "error",
+					message: typeof error === "string" ? error : error.message,
+					cause,
+					...options
+				});
+			},
+			info(message, options) {
+				report({
+					code: Diagnostics.code.pluginInfo,
+					severity: "info",
+					message,
+					...options
+				});
+			}
+		};
+	}
+	getPlugin(pluginName) {
+		return this.plugins.get(pluginName);
+	}
+	requirePlugin(pluginName, context) {
+		const plugin = this.getPlugin(pluginName);
+		if (plugin) return plugin;
+		throw pluginNotFoundError({
+			pluginName,
+			requiredBy: context?.requiredBy
+		});
+	}
+};
+/** The `KUBB_PLUGIN_NOT_FOUND` error `requirePlugin` throws, naming the plugin that needed it. */
+function pluginNotFoundError({ pluginName, requiredBy }) {
+	const by = requiredBy ? ` by "${requiredBy}"` : "";
+	const help = requiredBy ? ` (required by "${requiredBy}")` : "";
+	return new Diagnostics.Error({
+		code: Diagnostics.code.pluginNotFound,
+		severity: "error",
+		message: `Plugin "${pluginName}" is required${by} but not found. Make sure it is included in your Kubb config.`,
+		help: `Add "${pluginName}" to the \`plugins\` array in kubb.config.ts${help}, or remove the dependency on it.`,
+		location: { kind: "config" },
+		...requiredBy ? { plugin: requiredBy } : {}
+	});
+}
+//#endregion
+//#region src/Hookable.ts
+/**
+* Typed hook emitter that awaits all async listeners before resolving.
+*
+* @example
+* ```ts
+* const hooks = new Hookable<{ build: [name: string] }>()
+* hooks.hook('build', async (name) => { console.log(name) })
+* await hooks.callHook('build', 'petstore') // all listeners awaited
+* ```
+*/
+var Hookable = class {
+	#listeners = /* @__PURE__ */ new Map();
+	/**
+	* Calls `hookName` and awaits all registered listeners sequentially.
+	* Throws if any listener rejects, wrapping the cause in an error that names the hook.
+	*
+	* @example
+	* ```ts
+	* await hooks.callHook('build', 'petstore')
+	* ```
+	*/
+	callHook(hookName, ...hookArgs) {
+		const listeners = this.#listeners.get(hookName);
+		if (!listeners?.size) return;
+		return this.#emitAll(hookName, [...listeners], hookArgs);
+	}
+	async #emitAll(hookName, listeners, hookArgs) {
+		for (const listener of listeners) try {
+			await listener(...hookArgs);
+		} catch (err) {
+			throw new Error(`Error in async listener for "${hookName}"`, { cause: toError(err) });
+		}
+	}
+	/**
+	* Registers a persistent listener for `hookName` and returns a function that removes it.
+	*
+	* @example
+	* ```ts
+	* const unhook = hooks.hook('build', async (name) => { console.log(name) })
+	* unhook() // removes it
+	* ```
+	*/
+	hook(hookName, handler) {
+		let listeners = this.#listeners.get(hookName);
+		if (!listeners) this.#listeners.set(hookName, listeners = /* @__PURE__ */ new Set());
+		listeners.add(handler);
+		return () => this.removeHook(hookName, handler);
+	}
+	/**
+	* Registers every handler in `configHooks` at once and returns a function that removes them
+	* all. Undefined entries are skipped, so a partial hook object registers only its present keys.
+	*
+	* @example
+	* ```ts
+	* const unhook = hooks.addHooks({ build: onBuild, done: onDone })
+	* unhook() // removes both
+	* ```
+	*/
+	addHooks(configHooks) {
+		const unhooks = Object.keys(configHooks).filter((name) => configHooks[name]).map((name) => this.hook(name, configHooks[name]));
+		return () => {
+			for (const unhook of unhooks) unhook();
+		};
+	}
+	/**
+	* Removes a previously registered listener.
+	*
+	* @example
+	* ```ts
+	* hooks.removeHook('build', handler)
+	* ```
+	*/
+	removeHook(hookName, handler) {
+		this.#listeners.get(hookName)?.delete(handler);
+	}
+	/**
+	* Returns the number of listeners registered for `hookName`.
+	*
+	* @example
+	* ```ts
+	* hooks.hook('build', handler)
+	* hooks.listenerCount('build') // 1
+	* ```
+	*/
+	listenerCount(hookName) {
+		return this.#listeners.get(hookName)?.size ?? 0;
+	}
+	/**
+	* No-op kept for callers written against the `EventEmitter`-backed version. Listeners are unbounded.
+	*
+	* @deprecated There is no listener ceiling anymore.
+	*/
+	setMaxListeners(_max) {}
+	/**
+	* Removes all listeners from every hook channel.
+	*
+	* @example
+	* ```ts
+	* hooks.removeAllHooks()
+	* ```
+	*/
+	removeAllHooks() {
+		this.#listeners.clear();
+	}
+};
+//#endregion
+Object.defineProperty(exports, "Diagnostics", {
+	enumerable: true,
+	get: function() {
+		return Diagnostics;
+	}
+});
+Object.defineProperty(exports, "FileManager", {
+	enumerable: true,
+	get: function() {
+		return FileManager;
+	}
+});
+Object.defineProperty(exports, "Hookable", {
+	enumerable: true,
+	get: function() {
+		return Hookable;
+	}
+});
+Object.defineProperty(exports, "KubbDriver", {
+	enumerable: true,
+	get: function() {
+		return KubbDriver;
+	}
+});
+Object.defineProperty(exports, "Resolver", {
+	enumerable: true,
+	get: function() {
+		return Resolver;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "_usingCtx", {
+	enumerable: true,
+	get: function() {
+		return _usingCtx;
+	}
+});
+Object.defineProperty(exports, "addGenerator", {
+	enumerable: true,
+	get: function() {
+		return addGenerator;
+	}
+});
+Object.defineProperty(exports, "addMacro", {
+	enumerable: true,
+	get: function() {
+		return addMacro;
+	}
+});
+Object.defineProperty(exports, "assertPluginOption", {
+	enumerable: true,
+	get: function() {
+		return assertPluginOption;
+	}
+});
+Object.defineProperty(exports, "camelCase", {
+	enumerable: true,
+	get: function() {
+		return camelCase;
+	}
+});
+Object.defineProperty(exports, "checkCompatibility", {
+	enumerable: true,
+	get: function() {
+		return checkCompatibility;
+	}
+});
+Object.defineProperty(exports, "createNodeCache", {
+	enumerable: true,
+	get: function() {
+		return createNodeCache;
+	}
+});
+Object.defineProperty(exports, "createResolver", {
+	enumerable: true,
+	get: function() {
+		return createResolver;
+	}
+});
+Object.defineProperty(exports, "defineExtension", {
+	enumerable: true,
+	get: function() {
+		return defineExtension;
+	}
+});
+Object.defineProperty(exports, "definePlugin", {
+	enumerable: true,
+	get: function() {
+		return definePlugin;
+	}
+});
+Object.defineProperty(exports, "formatMs", {
+	enumerable: true,
+	get: function() {
+		return formatMs;
+	}
+});
+Object.defineProperty(exports, "getElapsedMs", {
+	enumerable: true,
+	get: function() {
+		return getElapsedMs;
+	}
+});
+Object.defineProperty(exports, "getInputKind", {
+	enumerable: true,
+	get: function() {
+		return getInputKind;
+	}
+});
+Object.defineProperty(exports, "inParallel", {
+	enumerable: true,
+	get: function() {
+		return inParallel;
+	}
+});
+Object.defineProperty(exports, "injectFile", {
+	enumerable: true,
+	get: function() {
+		return injectFile;
+	}
+});
+Object.defineProperty(exports, "isPathInside", {
+	enumerable: true,
+	get: function() {
+		return isPathInside;
+	}
+});
+Object.defineProperty(exports, "kubbContext", {
+	enumerable: true,
+	get: function() {
+		return kubbContext;
+	}
+});
+Object.defineProperty(exports, "pluginNotFoundError", {
+	enumerable: true,
+	get: function() {
+		return pluginNotFoundError;
+	}
+});
+Object.defineProperty(exports, "read", {
+	enumerable: true,
+	get: function() {
+		return read;
+	}
+});
+Object.defineProperty(exports, "requirePlugin", {
+	enumerable: true,
+	get: function() {
+		return requirePlugin;
+	}
+});
+Object.defineProperty(exports, "resolveMeta", {
+	enumerable: true,
+	get: function() {
+		return resolveMeta;
+	}
+});
+Object.defineProperty(exports, "setMacros", {
+	enumerable: true,
+	get: function() {
+		return setMacros;
+	}
+});
+Object.defineProperty(exports, "setOptions", {
+	enumerable: true,
+	get: function() {
+		return setOptions;
+	}
+});
+Object.defineProperty(exports, "setResolver", {
+	enumerable: true,
+	get: function() {
+		return setResolver;
+	}
+});
+Object.defineProperty(exports, "toError", {
+	enumerable: true,
+	get: function() {
+		return toError;
+	}
+});
+Object.defineProperty(exports, "toPosixPath", {
+	enumerable: true,
+	get: function() {
+		return toPosixPath;
+	}
+});
+Object.defineProperty(exports, "tryUseKubb", {
+	enumerable: true,
+	get: function() {
+		return tryUseKubb;
+	}
+});
+Object.defineProperty(exports, "useConfig", {
+	enumerable: true,
+	get: function() {
+		return useConfig;
+	}
+});
+Object.defineProperty(exports, "useKubb", {
+	enumerable: true,
+	get: function() {
+		return useKubb;
+	}
+});
+Object.defineProperty(exports, "useOptions", {
+	enumerable: true,
+	get: function() {
+		return useOptions;
+	}
+});
+Object.defineProperty(exports, "write", {
+	enumerable: true,
+	get: function() {
+		return write;
+	}
+});
+
+//# sourceMappingURL=Hookable-C4S0gBso.cjs.map