@kubb/core 5.10.2 → 5.10.4

package/dist/Hookable-RTuEiBd9.cjs

@@ -1,3044 +0,0 @@
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", {
-	value,
-	configurable: true
-});
-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.2";
-//#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;
-	};
-	var e = {};
-	var 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;
-			var t = this.e;
-			var 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, "__name", {
-	enumerable: true,
-	get: function() {
-		return __name;
-	}
-});
-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-RTuEiBd9.cjs.map