@kubb/cli 5.5.6 → 5.6.0

package/dist/utils-ClRbJfxu.cjs

@@ -1,1210 +0,0 @@
-const require_rolldown_runtime = require("./rolldown-runtime-qbf5tadS.cjs");
-const require_errors = require("./errors-C-wEou02.cjs");
-const require_agent = require("./agent-DiB4CRre.cjs");
-const require_Telemetry = require("./Telemetry-DDHXBdEz.cjs");
-const require_output = require("./output-CVLosNZq.cjs");
-let node_util = require("node:util");
-let node_crypto = require("node:crypto");
-let node_process = require("node:process");
-node_process = require_rolldown_runtime.__toESM(node_process, 1);
-let node_child_process = require("node:child_process");
-let node_path = require("node:path");
-let _kubb_core = require("@kubb/core");
-let _clack_prompts = require("@clack/prompts");
-_clack_prompts = require_rolldown_runtime.__toESM(_clack_prompts, 1);
-let jiti = require("jiti");
-let tinyexec = require("tinyexec");
-let unconfig = require("unconfig");
-let verkit = require("verkit");
-//#region ../../internals/utils/src/tools.ts
-/**
-* CLI command descriptors for each supported code formatter.
-*/
-const formatters = {
-	prettier: {
-		command: "prettier",
-		args: (outputPath) => [
-			"--ignore-unknown",
-			"--write",
-			outputPath
-		],
-		errorMessage: "Prettier not found"
-	},
-	biome: {
-		command: "biome",
-		args: (outputPath) => [
-			"format",
-			"--write",
-			outputPath
-		],
-		errorMessage: "Biome not found"
-	},
-	oxfmt: {
-		command: "oxfmt",
-		args: (outputPath) => [outputPath],
-		errorMessage: "Oxfmt not found"
-	}
-};
-/**
-* CLI command descriptors for each supported linter.
-*/
-const linters = {
-	eslint: {
-		command: "eslint",
-		args: (outputPath) => [outputPath, "--fix"],
-		errorMessage: "Eslint not found"
-	},
-	biome: {
-		command: "biome",
-		args: (outputPath) => [
-			"lint",
-			"--fix",
-			outputPath
-		],
-		errorMessage: "Biome not found"
-	},
-	oxlint: {
-		command: "oxlint",
-		args: (outputPath) => [
-			"--fix",
-			"--no-ignore",
-			outputPath
-		],
-		errorMessage: "Oxlint not found"
-	}
-};
-/**
-* Preference order for `format: 'auto'`, most-preferred first. Spelled out rather than taken from
-* the table's key order, which is arbitrary and would silently change what `auto` picks.
-*/
-const FORMATTER_PREFERENCE = [
-	"oxfmt",
-	"biome",
-	"prettier"
-];
-/**
-* Preference order for `lint: 'auto'`, most-preferred first.
-*/
-const LINTER_PREFERENCE = [
-	"oxlint",
-	"biome",
-	"eslint"
-];
-/**
-* Whether `name` is on PATH and answers `--version` with a zero exit.
-*/
-function isToolAvailable(name) {
-	return new Promise((resolve) => {
-		const child = (0, node_child_process.spawn)(name, ["--version"], { stdio: "ignore" });
-		child.on("close", (code) => resolve(code === 0));
-		child.on("error", () => resolve(false));
-	});
-}
-/**
-* Returns the first installed executable from `candidates`, or `null` when none are found.
-*
-* Not memoized: a long-running host that probes repeatedly should cache the result itself, and a
-* `--watch` build should keep noticing a tool installed mid-session.
-*/
-async function detectTool(candidates) {
-	for (const candidate of candidates) if (await isToolAvailable(candidate)) return candidate;
-	return null;
-}
-/**
-* Tokenizes a shell command string, respecting single and double quotes.
-*
-* @example
-* ```ts
-* tokenize('git commit -m "initial commit"')
-* // → ['git', 'commit', '-m', 'initial commit']
-* ```
-*/
-function tokenize(command) {
-	return (command.match(/[^\s"']+|"([^"]*)"|'([^']*)'/g) ?? []).map((token) => token.replace(/^["']|["']$/g, ""));
-}
-//#endregion
-//#region src/loggers/createLogger.ts
-/**
-* The three output phases, in the order the generate runner runs them.
-*/
-const PHASES = {
-	format: {
-		running: "Formatting",
-		success: "Formatted",
-		failure: "Formatting failed"
-	},
-	lint: {
-		running: "Linting",
-		success: "Linted",
-		failure: "Linting failed"
-	},
-	hooks: {
-		running: "Running post-generate hooks",
-		success: "Post-generate hooks completed",
-		failure: "Post-generate hooks failed",
-		showHookResults: true
-	}
-};
-/**
-* Drops the blank lines a subprocess leaves at either end of its output, so its block does not open
-* or close on an empty row.
-*/
-function trimBlankEdges(lines) {
-	const start = lines.findIndex((line) => line.trim());
-	if (start === -1) return [];
-	return lines.slice(start, lines.findLastIndex((line) => line.trim()) + 1);
-}
-/**
-* Wires a {@link LoggerWriter} onto the run's hooks. This owns what a run says and in what order:
-* one group per config, a step over the plugin work, a progress bar for the writes, one step per
-* output phase, then the summary and the group's closing result. The writer only decides how each
-* line looks, so every logger reports the same run the same way.
-*
-* @example
-* ```ts
-* export const plainLogger = { name: 'plain', install: (context, options) => createLogger(writer)(context, options) }
-* ```
-*/
-function createLogger(writer) {
-	return function install(context, options) {
-		const logLevel = options?.logLevel ?? _kubb_core.logLevel.info;
-		const silent = logLevel <= _kubb_core.logLevel.silent;
-		const state = {
-			...createProgressCounters(),
-			spinner: null,
-			progress: null,
-			hooks: /* @__PURE__ */ new Map(),
-			/**
-			* Plugin results held back while the generation step owns the line.
-			*/
-			pluginLines: [],
-			phase: null,
-			groupOpen: false
-		};
-		function text(message) {
-			return formatMessage(message, logLevel);
-		}
-		function startSpinner(message) {
-			if (silent) return;
-			state.spinner = writer.spinner();
-			state.spinner.start(text(message));
-		}
-		function stopSpinner(message, status = "success") {
-			const spinner = state.spinner;
-			if (!spinner) return;
-			state.spinner = null;
-			if (message === void 0) {
-				spinner.clear();
-				return;
-			}
-			if (status === "failed") {
-				spinner.error(text(message));
-				return;
-			}
-			spinner.stop(text(message));
-		}
-		function stopProgress(message) {
-			const progress = state.progress;
-			if (!progress) return;
-			state.progress = null;
-			progress.stop(message === void 0 ? "" : text(message));
-		}
-		function startPhase({ running, success, failure, showHookResults = false }) {
-			state.phase = {
-				successLabel: success,
-				failureLabel: failure,
-				showHookResults,
-				failed: false,
-				hrStart: node_process.default.hrtime(),
-				lines: [],
-				output: []
-			};
-			startSpinner(running);
-		}
-		function endPhase() {
-			const phase = state.phase;
-			state.phase = null;
-			if (!phase || silent) return;
-			const duration = require_output.formatMsWithColor(require_output.getElapsedMs(phase.hrStart));
-			stopSpinner(phase.failed ? `${phase.failureLabel} after ${duration}` : `${phase.successLabel} in ${duration}`, phase.failed ? "failed" : "success");
-			if (phase.lines.length) writer.block(phase.lines);
-			writeOutput(phase.output);
-		}
-		function writeOutput(lines) {
-			const output = trimBlankEdges(lines);
-			if (output.length) writer.raw(output);
-		}
-		function closeGroup(status) {
-			if (!state.groupOpen) return;
-			state.groupOpen = false;
-			stopSpinner();
-			stopProgress();
-			writer.groupEnd(status === "failed" ? (0, node_util.styleText)("red", "✗ Generation failed") : (0, node_util.styleText)("green", "✓ Generation succeeded"));
-		}
-		function reset() {
-			stopSpinner();
-			stopProgress();
-			resetProgressCounters(state);
-			state.hooks.clear();
-			state.pluginLines = [];
-			state.phase = null;
-			state.groupOpen = false;
-		}
-		context.hook("kubb:info", ({ message, info }) => {
-			if (silent) return;
-			const line = text([
-				(0, node_util.styleText)("blue", "ℹ"),
-				message,
-				info ? (0, node_util.styleText)("dim", info) : void 0
-			].filter(Boolean).join(" "));
-			if (state.phase) {
-				state.phase.lines.push(line);
-				return;
-			}
-			if (state.spinner) {
-				state.spinner.message(line);
-				return;
-			}
-			writer.info(line);
-		});
-		context.hook("kubb:success", ({ message, info }) => {
-			if (silent) return;
-			const line = text([
-				(0, node_util.styleText)("green", "✓"),
-				message,
-				logLevel >= _kubb_core.logLevel.info && info ? (0, node_util.styleText)("dim", info) : void 0
-			].filter(Boolean).join(" "));
-			if (state.spinner) {
-				state.spinner.message(line);
-				return;
-			}
-			writer.success(line);
-		});
-		context.hook("kubb:warn", ({ message, info }) => {
-			if (logLevel < _kubb_core.logLevel.warn) return;
-			writer.warn(text([
-				(0, node_util.styleText)("yellow", "⚠"),
-				message,
-				logLevel >= _kubb_core.logLevel.info && info ? (0, node_util.styleText)("dim", info) : void 0
-			].filter(Boolean).join(" ")));
-		});
-		context.hook("kubb:error", ({ error }) => {
-			if (state.phase) state.phase.failed = true;
-			if (state.spinner) stopSpinner(error.message, "failed");
-			else writer.error(text(error.message));
-			const frames = logLevel >= _kubb_core.logLevel.verbose ? formatErrorFrames(error) : null;
-			if (!frames) return;
-			writer.block(frames.frames.map((frame) => text((0, node_util.styleText)("dim", frame))));
-			if (frames.cause) writer.block([(0, node_util.styleText)("dim", frames.cause.header), ...frames.cause.frames.map((frame) => text(`    ${(0, node_util.styleText)("dim", frame)}`))]);
-		});
-		context.hook("kubb:diagnostic", ({ diagnostic }) => {
-			if (silent && diagnostic.severity !== "error") return;
-			stopSpinner();
-			stopProgress();
-			if (_kubb_core.Diagnostics.isUpdate(diagnostic)) {
-				writer.update([`\`v${diagnostic.currentVersion}\` → \`v${diagnostic.latestVersion}\``, "Run `npm install -g @kubb/cli` to update"], "Update available for `Kubb`");
-				return;
-			}
-			const { headline, details } = _kubb_core.Diagnostics.format(diagnostic);
-			writer.diagnostic([headline, ...details]);
-		});
-		context.hook("studio:connecting", ({ url }) => {
-			startSpinner(`Connecting to ${(0, node_util.styleText)("cyan", url)}`);
-		});
-		context.hook("studio:connected", ({ url, versions }) => {
-			if (silent) return;
-			const line = `Connected to ${(0, node_util.styleText)("cyan", url)} ${(0, node_util.styleText)("dim", `(${formatVersions(versions)})`)}`;
-			if (state.spinner) {
-				stopSpinner(line);
-				return;
-			}
-			writer.success(text(`✓ ${line}`));
-		});
-		context.hook("studio:ready", () => {
-			if (silent) return;
-			startSpinner("✓ Ready to receive jobs");
-		});
-		context.hook("studio:disconnected", ({ reason }) => {
-			if (logLevel < _kubb_core.logLevel.warn) return;
-			stopSpinner();
-			writer.warn(text(`⚠ Kubb Studio ended the session (${reason})`));
-		});
-		context.hook("studio:command:start", ({ command }) => {
-			if (silent) return;
-			stopSpinner();
-			writer.info(text(`Kubb Studio asked to ${(0, node_util.styleText)("bold", command)}`));
-		});
-		context.hook("studio:command:end", ({ command, info }) => {
-			if (silent) return;
-			writer.success(text(`✓ Finished ${command}${info ? ` ${(0, node_util.styleText)("dim", `(${info})`)}` : ""}`));
-			startSpinner("✓ Ready to receive jobs");
-		});
-		context.hook("studio:reconnecting", ({ delayMs }) => {
-			if (silent) return;
-			stopSpinner();
-			writer.info(text((0, node_util.styleText)("dim", `Retrying connection to Kubb Studio in ${require_output.formatMs(delayMs)}`)));
-		});
-		context.hook("studio:warn", ({ message, permission }) => {
-			if (logLevel < _kubb_core.logLevel.warn) return;
-			const remedy = permission ? `; pass --${permission.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`)} to allow it` : "";
-			writer.warn(text(`⚠ ${message}${remedy}`));
-		});
-		context.hook("studio:error", ({ error }) => {
-			if (state.spinner) {
-				stopSpinner(error.message, "failed");
-				return;
-			}
-			writer.error(text(error.message));
-		});
-		context.hook("kubb:lifecycle:start", () => {
-			reset();
-		});
-		context.hook("kubb:generation:start", ({ config }) => {
-			closeGroup("failed");
-			reset();
-			state.totalPlugins = config.plugins?.length ?? 0;
-			if (silent) return;
-			const inputPath = getInputPath(config);
-			writer.group(text([(0, node_util.styleText)("bold", config.name ?? "kubb"), inputPath ? (0, node_util.styleText)("dim", inputPath) : void 0].filter(Boolean).join(" ")));
-			state.groupOpen = true;
-			startSpinner("Generating");
-		});
-		context.hook("kubb:plugin:start", ({ plugin }) => {
-			if (silent) return;
-			state.spinner?.message(text(`Generating ${(0, node_util.styleText)("dim", plugin.name)}`));
-		});
-		context.hook("kubb:plugin:end", ({ plugin, duration, success }) => {
-			if (silent) return;
-			recordPluginResult(state, success);
-			state.pluginLines.push(text(`${plugin.name} ${success ? "completed" : "failed"} in ${require_output.formatMsWithColor(duration)}`));
-		});
-		context.hook("kubb:plugins:end", () => {
-			if (silent) return;
-			const failed = state.failedPlugins > 0;
-			stopSpinner(buildProgressLine(state) ?? "No plugins ran", failed ? "failed" : "success");
-			if (state.pluginLines.length) {
-				writer.block(state.pluginLines);
-				state.pluginLines = [];
-			}
-		});
-		context.hook("kubb:files:processing:start", ({ files }) => {
-			if (silent) return;
-			stopSpinner();
-			state.totalFiles = files.length;
-			state.processedFiles = 0;
-			state.progress = writer.progress(files.length);
-			state.progress.start(text(`Writing ${pluralize(files.length, "file")}`));
-		});
-		context.hook("kubb:files:processing:update", ({ files }) => {
-			if (silent) return;
-			for (const { file, config } of files) {
-				state.processedFiles++;
-				state.progress?.advance(`Writing ${(0, node_path.relative)(config.root, file.path)}`);
-			}
-		});
-		context.hook("kubb:files:processing:end", () => {
-			if (silent) return;
-			stopProgress(`Wrote ${pluralize(state.processedFiles, "file")}`);
-		});
-		context.hook("kubb:format:start", () => startPhase(PHASES.format));
-		context.hook("kubb:format:end", endPhase);
-		context.hook("kubb:lint:start", () => startPhase(PHASES.lint));
-		context.hook("kubb:lint:end", endPhase);
-		context.hook("kubb:hooks:start", () => startPhase(PHASES.hooks));
-		context.hook("kubb:hooks:end", endPhase);
-		context.hook("kubb:hook:start", ({ id }) => {
-			if (silent || !id) return;
-			state.hooks.set(id, {
-				hrStart: node_process.default.hrtime(),
-				lines: []
-			});
-		});
-		if (!silent) context.hook("kubb:hook:line", ({ id, line }) => {
-			const active = state.hooks.get(id);
-			if (!active) return;
-			if (state.phase) {
-				active.lines.push(line);
-				return;
-			}
-			writer.raw([line]);
-		});
-		context.hook("kubb:hook:end", ({ id, command, name, args, success, error, stdout, stderr }) => {
-			if (!id) return;
-			if (!success && state.phase) state.phase.failed = true;
-			if (silent) {
-				if (!success) {
-					if (stdout) console.log(stdout);
-					if (stderr) console.error(stderr);
-				}
-				return;
-			}
-			const active = state.hooks.get(id);
-			if (!active) return;
-			state.hooks.delete(id);
-			const label = (0, node_util.styleText)("dim", name ?? formatCommandWithArgs(command, args));
-			const reason = error?.message ? ` (${error.message})` : "";
-			const result = success ? `${(0, node_util.styleText)("green", "✓")} ${label} in ${require_output.formatMsWithColor(require_output.getElapsedMs(active.hrStart))}` : `${(0, node_util.styleText)("red", "✗")} ${label} failed${reason}`;
-			const phase = state.phase;
-			if (phase) {
-				if (phase.showHookResults || !success) phase.lines.push(result);
-				phase.output.push(...active.lines);
-				return;
-			}
-			stopSpinner();
-			writer.step(text(result));
-			writeOutput(active.lines);
-		});
-		context.hook("kubb:generation:end", () => {
-			stopSpinner();
-			stopProgress();
-		});
-		context.hook("kubb:lifecycle:end", () => {
-			closeGroup("failed");
-			reset();
-		});
-		return { renderSummary(lines, { status }) {
-			if (silent || !state.groupOpen) return;
-			closeGroup(status);
-			writer.diagnostic([...lines]);
-		} };
-	};
-}
-/**
-* TTY logger for local development, with animated steps and progress bars.
-*/
-const clackLogger = {
-	name: "clack",
-	install: createLogger({
-		group: (title) => _clack_prompts.intro(title),
-		groupEnd: (text) => _clack_prompts.outro(text),
-		step: (text) => _clack_prompts.log.step(text, { spacing: 0 }),
-		info: (text) => _clack_prompts.log.info(text),
-		success: (text) => _clack_prompts.log.success(text),
-		warn: (text) => _clack_prompts.log.warn(text),
-		error: (text) => _clack_prompts.log.error(text),
-		block: (lines) => _clack_prompts.log.message(lines, { spacing: 0 }),
-		raw: (lines) => console.log((0, node_util.styleText)("dim", lines.join("\n"))),
-		diagnostic: (lines) => _clack_prompts.log.message(lines, {
-			symbol: "",
-			secondarySymbol: ""
-		}),
-		update: (lines, title) => _clack_prompts.box(lines.join("\n"), title, {
-			width: "auto",
-			formatBorder: (border) => (0, node_util.styleText)("yellow", border),
-			rounded: true,
-			withGuide: false,
-			contentAlign: "center",
-			titleAlign: "center"
-		}),
-		spinner() {
-			const spinner = _clack_prompts.spinner();
-			return {
-				start: (text) => spinner.start(text),
-				message: (text) => spinner.message(text),
-				clear: () => spinner.clear(),
-				stop: (text) => spinner.stop(text),
-				error: (text) => spinner.error(text)
-			};
-		},
-		progress(max) {
-			const bar = _clack_prompts.progress({
-				style: "block",
-				max,
-				size: 30
-			});
-			return {
-				start: (text) => bar.start(text),
-				advance: (text) => bar.advance(1, text),
-				stop: (text) => bar.stop(text)
-			};
-		}
-	})
-};
-//#endregion
-//#region src/loggers/plainLogger.ts
-/**
-* Prefixes that stand in for the symbols clack draws, so plain output reads the same way.
-*/
-const SYMBOLS = {
-	info: "ℹ",
-	warn: "⚠",
-	error: "✗",
-	step: "◇"
-};
-/** Draws with one `write` call per line. Nothing animates, so a step prints at start and end. */
-function createWriter(write) {
-	return {
-		group: write,
-		groupEnd: write,
-		step: (text) => write(`${SYMBOLS.step} ${text}`),
-		info: write,
-		success: write,
-		warn: write,
-		error: (text) => write(`${SYMBOLS.error} ${text}`),
-		block: (lines) => write(lines.join("\n")),
-		raw: (lines) => write(lines.join("\n")),
-		diagnostic: (lines) => write(lines.join("\n")),
-		update: (lines, title) => write([title, ...lines].join("\n")),
-		spinner: () => ({
-			start: write,
-			message: write,
-			clear: () => {},
-			stop: (text) => text && write(text),
-			error: (text) => write(`${SYMBOLS.error} ${text}`)
-		}),
-		progress: () => ({
-			start: write,
-			advance: write,
-			stop: (text) => text && write(text)
-		})
-	};
-}
-/** The plain logger writing through `write`, e.g. `console.error` so stdout carries only JSON. */
-function createPlainLogger(write) {
-	return {
-		name: "plain",
-		install: createLogger(createWriter(write))
-	};
-}
-/**
-* Console adapter for non-TTY environments, and for an AI coding agent reading the output. Reports
-* the same run in the same order as `clackLogger`, without the animation.
-*/
-const plainLogger = createPlainLogger((line) => console.log(line));
-//#endregion
-//#region src/loggers/utils.ts
-/**
-* Display path for a config's input: the string form, or its `path` field when the input is an
-* object. Loggers show it alongside `Generation started`.
-*/
-function getInputPath(config) {
-	const { input } = config;
-	if (typeof input === "string") return input;
-	return typeof input?.path === "string" ? input.path : void 0;
-}
-/**
-* Counts a noun, so a message never reads `1 files`.
-*
-* @example
-* `pluralize(1, 'config')` returns `'1 config'`
-*/
-function pluralize(count, noun) {
-	return `${count} ${count === 1 ? noun : `${noun}s`}`;
-}
-/**
-* Optionally prefix a message with a [HH:MM:SS] timestamp when logLevel >= verbose.
-* Shared across all logger adapters to avoid duplication.
-*/
-function formatMessage(message, logLevel) {
-	if (logLevel >= _kubb_core.logLevel.verbose) {
-		const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", {
-			hour12: false,
-			hour: "2-digit",
-			minute: "2-digit",
-			second: "2-digit"
-		});
-		return `${(0, node_util.styleText)("dim", `[${timestamp}]`)} ${message}`;
-	}
-	return message;
-}
-/**
-* Renders the versions from a `studio:connected` event as one parenthetical. The runtime is listed
-* only when it differs from the host, and Studio's only when it sent one.
-*/
-function formatVersions({ studio, kubb, agent }) {
-	return [
-		`v${agent}`,
-		kubb !== agent ? `runtime v${kubb}` : void 0,
-		studio ? `Studio v${studio}` : void 0
-	].filter(Boolean).join(", ");
-}
-/**
-* Extracts the `.cause` of an `Error` as an `Error`, or `undefined` when absent or not an `Error`.
-*/
-function toCause(error) {
-	return error.cause instanceof Error ? error.cause : void 0;
-}
-/**
-* First stack frames for verbose error output, including an optional `cause` chain.
-*/
-function formatErrorFrames(error) {
-	if (!error.stack) return null;
-	const frames = error.stack.split("\n").slice(1, 4).map((frame) => frame.trim());
-	const caused = toCause(error);
-	if (!caused?.stack) return { frames };
-	return {
-		frames,
-		cause: {
-			header: `└─ caused by ${caused.message}`,
-			frames: caused.stack.split("\n").slice(1, 4).map((frame) => frame.trim())
-		}
-	};
-}
-/**
-* Build the progress summary line shown by the clack logger.
-* Returns null when there is nothing to display.
-*/
-function buildProgressLine(state) {
-	const parts = [];
-	const duration = require_output.formatMs(require_output.getElapsedMs(state.hrStart));
-	if (state.totalPlugins > 0) {
-		const pluginStr = state.failedPlugins > 0 ? `Plugins ${(0, node_util.styleText)("green", state.completedPlugins.toString())}/${state.totalPlugins} ${(0, node_util.styleText)("red", `(${state.failedPlugins} failed)`)}` : `Plugins ${(0, node_util.styleText)("green", state.completedPlugins.toString())}/${state.totalPlugins}`;
-		parts.push(pluginStr);
-	}
-	if (state.totalFiles > 0) parts.push(`Files ${(0, node_util.styleText)("green", state.processedFiles.toString())}/${state.totalFiles}`);
-	if (parts.length === 0) return null;
-	parts.push(`${(0, node_util.styleText)("green", duration)} elapsed`);
-	return parts.join((0, node_util.styleText)("dim", " | "));
-}
-/**
-* Creates the per-run progress counters used by the clack logger.
-*/
-function createProgressCounters() {
-	return {
-		totalPlugins: 0,
-		completedPlugins: 0,
-		failedPlugins: 0,
-		totalFiles: 0,
-		processedFiles: 0,
-		hrStart: node_process.default.hrtime()
-	};
-}
-/**
-* Resets the progress counters in place at the start/end of a generation run.
-*/
-function resetProgressCounters(state) {
-	state.totalPlugins = 0;
-	state.completedPlugins = 0;
-	state.failedPlugins = 0;
-	state.totalFiles = 0;
-	state.processedFiles = 0;
-	state.hrStart = node_process.default.hrtime();
-}
-/**
-* Records a finished plugin against the progress counters.
-*/
-function recordPluginResult(state, success) {
-	if (success) state.completedPlugins++;
-	else state.failedPlugins++;
-}
-/**
-* Join a command and its optional args into a single display string.
-*
-* @example With args
-* `formatCommandWithArgs('prettier', ['--write', '.'])` returns `'prettier --write .'`
-*/
-function formatCommandWithArgs(command, args) {
-	return args?.length ? `${command} ${args.join(" ")}` : command;
-}
-/**
-* Bridges a {@link Reporter} onto the run's hook emitter: calls `report` with each config's
-* {@link GenerationResult} on `kubb:generation:end`. The reporter never touches the emitter.
-*/
-function installReporter(context, reporter, ctx) {
-	const pluginFiles = reporter.needsPluginFiles ? /* @__PURE__ */ new Map() : void 0;
-	if (pluginFiles) context.hook("kubb:plugin:end", ({ config, plugin, files }) => {
-		const filesByPlugin = pluginFiles.get(config) ?? /* @__PURE__ */ new Map();
-		const seen = new Set([...filesByPlugin.values()].flatMap((paths) => [...paths]));
-		const added = files.filter((file) => !seen.has(file.path)).map((file) => file.path);
-		if (added.length) filesByPlugin.set(plugin.name, /* @__PURE__ */ new Set([...filesByPlugin.get(plugin.name) ?? [], ...added]));
-		pluginFiles.set(config, filesByPlugin);
-	});
-	context.hook("kubb:generation:end", async ({ config, diagnostics = [], filesCreated = 0, status = "success", hrStart = node_process.default.hrtime() }) => {
-		const files = pluginFiles?.get(config);
-		const grouped = files && [...files].map(([plugin, paths]) => ({
-			plugin,
-			files: [...paths]
-		}));
-		await reporter.report({
-			config,
-			diagnostics,
-			filesCreated,
-			status,
-			hrStart,
-			pluginFiles: grouped
-		}, ctx);
-		pluginFiles?.delete(config);
-	});
-	if (reporter.drain) context.hook("kubb:lifecycle:end", () => reporter.drain?.(ctx));
-}
-/**
-* Installs the live logger (the TUI view) and the given reporters (the output). The reporters are
-* already selected by the caller (the CLI maps `--reporter` to names via `selectReporters`). This
-* only wires them. Loggers receive hook subprocess output through `kubb:hook:line` and the
-* `stdout`/`stderr` on `kubb:hook:end`, so nothing is returned here.
-*
-* Loggers and reporters are independent, except for `cli`: it both installs the live logger view
-* here and registers a reporter that renders the per-config summary through that logger, so the
-* summary lands inside the group the logger opened. The `json` reporter owns stdout, so the whole
-* `cli` reporter (live logger and summary) is skipped whenever `json` is among the reporters, even
-* if `cli` is also listed.
-*/
-async function setupReporters(context, { logLevel, reporters, logger: forcedLogger }) {
-	let cliHandle;
-	const hasJson = reporters.some((reporter) => reporter.name === "json");
-	const ctx = { logLevel };
-	for (const reporter of reporters) {
-		if (reporter.name !== "cli") {
-			installReporter(context, reporter, ctx);
-			continue;
-		}
-		if (hasJson) continue;
-		const handle = await (forcedLogger ?? (require_output.canUseTTY() && !require_agent.getAgentName() ? clackLogger : plainLogger)).install(context, { logLevel }) ?? void 0;
-		cliHandle = handle;
-		installReporter(context, (0, _kubb_core.createCliReporter)({ render: handle?.renderSummary }), ctx);
-	}
-	return cliHandle;
-}
-/**
-* Picks the reporters whose `name` matches one of `names`, in the order the names are given.
-* The config carries every available reporter, and the host selects which to activate by name
-* (the CLI maps `--reporter` to this). Duplicate names and names without a matching reporter are
-* skipped.
-*/
-function selectReporters(reporters, names) {
-	const seen = /* @__PURE__ */ new Set();
-	const selected = [];
-	for (const name of names) {
-		if (seen.has(name)) continue;
-		seen.add(name);
-		const reporter = reporters.find((candidate) => candidate.name === name);
-		if (reporter) selected.push(reporter);
-	}
-	return selected;
-}
-//#endregion
-//#region ../../internals/shared/src/loader.ts
-/**
-* jiti options for loading Kubb config modules: the automatic JSX runtime pointed at
-* `@kubb/renderer-jsx`, and `moduleCache` off so a re-load re-evaluates the file.
-*/
-const JITI_OPTIONS = {
-	jsx: {
-		runtime: "automatic",
-		importSource: "@kubb/renderer-jsx"
-	},
-	moduleCache: false
-};
-/**
-* Creates a jiti-based loader for Kubb's TypeScript and JavaScript config modules.
-*
-* jiti transpiles TypeScript and the `@kubb/renderer-jsx` JSX runtime on the fly.
-*
-* @example
-* ```ts
-* const config = await createModuleLoader().load('/abs/kubb.config.ts', { default: true })
-* ```
-*/
-function createModuleLoader() {
-	const jiti$1 = (0, jiti.createJiti)(require("url").pathToFileURL(__filename).href, JITI_OPTIONS);
-	return { load(filePath, options) {
-		return options?.default ? jiti$1.import(filePath, { default: true }) : jiti$1.import(filePath);
-	} };
-}
-//#endregion
-//#region src/runners/generate/utils.ts
-const loader = createModuleLoader();
-const tsLoader = (configFile) => loader.load(configFile, { default: true });
-const MODULE_NAME = "kubb";
-const SEARCH_FILES = [
-	"",
-	".config/",
-	"configs/"
-].flatMap((prefix) => [`${prefix}.${MODULE_NAME}rc`, `${prefix}${MODULE_NAME}.config`]);
-const SEARCH_EXTENSIONS = [
-	"ts",
-	"mts",
-	"cts",
-	"js",
-	"mjs",
-	"cjs"
-];
-/**
-* Discovers the Kubb config and resolves it into a normalized array of configs.
-* Every config in the result is guaranteed to have a `plugins` array.
-*/
-async function getConfigs({ configPath, input, watch, logLevel }) {
-	const abs = configPath ? (0, node_path.resolve)(configPath) : void 0;
-	const sources = abs ? [{
-		files: [(0, node_path.basename)(abs)],
-		extensions: [],
-		parser: tsLoader
-	}] : [{
-		files: SEARCH_FILES,
-		extensions: SEARCH_EXTENSIONS,
-		parser: tsLoader
-	}];
-	let result;
-	try {
-		result = await (0, unconfig.loadConfig)({
-			cwd: abs ? (0, node_path.dirname)(abs) : node_process.default.cwd(),
-			sources,
-			merge: false
-		});
-	} catch (error) {
-		throw new Error("Config failed loading", { cause: error });
-	}
-	const [filepath] = result.sources;
-	if (!result.config || !filepath) throw new Error("Config not defined, create a kubb.config.js or pass through your config with the option --config");
-	const config = result.config;
-	const resolved = await (typeof config === "function" ? config({
-		config: configPath,
-		input,
-		watch,
-		logLevel
-	}) : config);
-	return {
-		configPath: filepath,
-		configs: (Array.isArray(resolved) ? resolved : [resolved]).map((item) => {
-			return {
-				...item,
-				plugins: item.plugins ?? []
-			};
-		})
-	};
-}
-/**
-* Returns `true` when `latest` is a newer semver version than `current`. Compares each numeric
-* part, so `5.10.0` beats `5.9.0` where a plain string comparison would not. Prerelease
-* suffixes are ignored, and a malformed version never reports an update.
-*
-* @example Double-digit minor
-* `isNewerVersion('5.9.0', '5.10.0') // true`
-*
-* @example String comparison would get this wrong the other way
-* `isNewerVersion('5.10.0', '5.9.0') // false`
-*/
-function isNewerVersion(current, latest) {
-	if (!(0, verkit.isValid)(current) || !(0, verkit.isValid)(latest)) return false;
-	return (0, verkit.isGreaterThan)((0, verkit.truncate)(latest, "patch"), (0, verkit.truncate)(current, "patch"));
-}
-/**
-* Runs the `output.postGenerate` commands of a Kubb config in sequence and returns each command's
-* outcome, so the caller can turn failures into diagnostics.
-*/
-async function runPostGenerate({ commands, hooks }) {
-	const results = [];
-	for (const entry of commands) {
-		const { command, name } = typeof entry === "string" ? {
-			command: entry,
-			name: void 0
-		} : entry;
-		const [cmd, ...args] = tokenize(command);
-		if (!cmd) continue;
-		const hookId = (0, node_crypto.randomUUID)();
-		const commandWithArgs = [cmd, ...args].join(" ");
-		await hooks.callHook("kubb:hook:start", {
-			id: hookId,
-			command: cmd,
-			name,
-			args
-		});
-		results.push(await runHook({
-			id: hookId,
-			command: cmd,
-			name,
-			args,
-			commandWithArgs,
-			hooks
-		}));
-	}
-	return results;
-}
-/**
-* Spawns a hook command and returns its outcome, mirroring it through `kubb:hook:end` for the
-* loggers. A non-zero exit returns `success: false` rather than throwing, so the caller can turn
-* it into a diagnostic. Other spawn errors do the same. Output is streamed through `kubb:hook:line`
-* only while a listener is attached.
-*/
-async function runHook({ id, command, name, args, commandWithArgs, hooks }) {
-	const emitEnd = async (result) => {
-		await hooks.callHook("kubb:hook:end", {
-			command,
-			name,
-			args,
-			id,
-			...result
-		});
-		return result;
-	};
-	const stream = hooks.listenerCount("kubb:hook:line") > 0;
-	try {
-		const proc = (0, tinyexec.x)(command, [...args ?? []], {
-			nodeOptions: { detached: node_process.default.platform !== "win32" },
-			throwOnError: true
-		});
-		if (stream) for await (const line of proc) await hooks.callHook("kubb:hook:line", {
-			id,
-			line
-		});
-		await proc;
-		await hooks.callHook("kubb:success", { message: `${(0, node_util.styleText)("dim", name ?? commandWithArgs)} successfully executed` });
-		return emitEnd({
-			success: true,
-			error: null
-		});
-	} catch (err) {
-		if (!(err instanceof tinyexec.NonZeroExitError)) return emitEnd({
-			success: false,
-			error: require_errors.toError(err)
-		});
-		const stderr = err.output?.stderr ?? "";
-		const stdout = err.output?.stdout ?? "";
-		return emitEnd({
-			success: false,
-			error: /* @__PURE__ */ new Error(`Hook execute failed: ${commandWithArgs}`),
-			stdout,
-			stderr
-		});
-	}
-}
-/**
-* Wraps `run` so invocations never overlap: a trigger that lands while a run is in flight
-* marks it dirty and runs once more after it finishes, no matter how many triggers arrived.
-* Useful for event-driven reruns (a file watcher, a queue drain) where bursts should
-* coalesce into a single trailing run.
-*
-* @example
-* ```ts
-* const rebuild = createSerialRunner({
-*   run: () => build(),
-*   onError: (error) => log.error(error.message),
-* })
-* watcher.on('change', () => void rebuild())
-* ```
-*/
-function createSerialRunner({ run, onError }) {
-	let running = false;
-	let dirty = false;
-	return async () => {
-		if (running) {
-			dirty = true;
-			return;
-		}
-		running = true;
-		do {
-			dirty = false;
-			try {
-				await run();
-			} catch (error) {
-				onError(require_errors.toError(error));
-			}
-		} while (dirty);
-		running = false;
-	};
-}
-/**
-* Starts a file watcher on the given paths and calls `cb` on any change.
-* Ignores `.git` and `node_modules` directories. Event bursts (an editor save emits several)
-* are debounced into one build, and builds never overlap: changes during a build queue exactly
-* one rebuild.
-*/
-async function startWatcher(path, cb, log = {
-	info: console.log,
-	error: console.log
-}) {
-	const { watch } = await import("chokidar");
-	const watcher = watch(path, {
-		ignorePermissionErrors: true,
-		ignored: require_Telemetry.WATCHER_IGNORED_PATHS,
-		ignoreInitial: true
-	});
-	node_process.default.once("SIGINT", () => {
-		watcher.close();
-	});
-	node_process.default.once("SIGTERM", () => {
-		watcher.close();
-	});
-	const runBuild = createSerialRunner({
-		run: () => cb(path),
-		onError: () => log.error((0, node_util.styleText)("red", "Watcher failed"))
-	});
-	let debounceTimer = null;
-	watcher.on("all", (type, file) => {
-		log.info((0, node_util.styleText)("yellow", (0, node_util.styleText)("bold", `Change detected: ${type} ${file}`)));
-		if (debounceTimer) clearTimeout(debounceTimer);
-		debounceTimer = setTimeout(() => {
-			debounceTimer = null;
-			runBuild();
-		}, 100);
-	});
-}
-/**
-* Fetches the body of a remote spec URL, `undefined` when the server does not answer with a
-* readable 2xx body within the timeout. The caller seeds `startUrlWatcher` with the result, so
-* the watcher compares polls against the content the initial build ran on.
-*/
-async function fetchUrlBody(url, timeoutMs = require_Telemetry.URL_WATCHER_TIMEOUT_MS) {
-	try {
-		const response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
-		if (!response.ok) return void 0;
-		return await response.text();
-	} catch {
-		return;
-	}
-}
-/**
-* Polls a remote spec URL and calls `cb` whenever the response body changes. A remote document
-* emits no filesystem events, so this is the URL counterpart of `startWatcher`.
-*
-* `initialBody` seeds the change detection, so an edit landing between the initial build and the
-* first poll still rebuilds. An unreachable server (the API restarting between saves) is reported
-* once per outage and polling continues; after it recovers, a rebuild happens only when the body
-* actually differs from the last one seen, so a plain restart with an unchanged spec stays quiet.
-* Each request is aborted after `timeoutMs`, so a hung response delays at most one poll.
-*
-* Returns a function that stops polling and aborts the in-flight request, so callers (and tests)
-* can shut the watcher down without signaling the process.
-*/
-function startUrlWatcher(url, cb, options = {}) {
-	const { log = {
-		info: console.log,
-		error: console.log
-	}, intervalMs = require_Telemetry.URL_WATCHER_INTERVAL_MS, timeoutMs = require_Telemetry.URL_WATCHER_TIMEOUT_MS, initialBody } = options;
-	let lastBody = initialBody;
-	let offline = false;
-	let timer = null;
-	let controller = null;
-	let stopped = false;
-	const stop = () => {
-		stopped = true;
-		if (timer) clearTimeout(timer);
-		controller?.abort();
-	};
-	node_process.default.once("SIGINT", stop);
-	node_process.default.once("SIGTERM", stop);
-	const runBuild = createSerialRunner({
-		run: () => cb([url]),
-		onError: () => log.error((0, node_util.styleText)("red", "Watcher failed"))
-	});
-	const poll = async () => {
-		controller = new AbortController();
-		try {
-			const signal = AbortSignal.any([controller.signal, AbortSignal.timeout(timeoutMs)]);
-			const response = await fetch(url, { signal });
-			if (!response.ok) throw new Error(`HTTP ${response.status}`);
-			const body = await response.text();
-			if (offline) {
-				offline = false;
-				log.info((0, node_util.styleText)("yellow", `${url} is reachable again`));
-			}
-			const changed = lastBody !== void 0 && body !== lastBody;
-			if (changed) log.info((0, node_util.styleText)("yellow", (0, node_util.styleText)("bold", `Change detected: ${url}`)));
-			if (changed || lastBody === void 0) runBuild();
-			lastBody = body;
-		} catch {
-			if (!offline && !stopped) {
-				offline = true;
-				log.error((0, node_util.styleText)("red", `Cannot reach ${url}, polling until it responds again`));
-			}
-		}
-		if (!stopped) timer = setTimeout(() => void poll(), intervalMs);
-	};
-	poll();
-	return stop;
-}
-//#endregion
-Object.defineProperty(exports, "FORMATTER_PREFERENCE", {
-	enumerable: true,
-	get: function() {
-		return FORMATTER_PREFERENCE;
-	}
-});
-Object.defineProperty(exports, "LINTER_PREFERENCE", {
-	enumerable: true,
-	get: function() {
-		return LINTER_PREFERENCE;
-	}
-});
-Object.defineProperty(exports, "createPlainLogger", {
-	enumerable: true,
-	get: function() {
-		return createPlainLogger;
-	}
-});
-Object.defineProperty(exports, "detectTool", {
-	enumerable: true,
-	get: function() {
-		return detectTool;
-	}
-});
-Object.defineProperty(exports, "fetchUrlBody", {
-	enumerable: true,
-	get: function() {
-		return fetchUrlBody;
-	}
-});
-Object.defineProperty(exports, "formatters", {
-	enumerable: true,
-	get: function() {
-		return formatters;
-	}
-});
-Object.defineProperty(exports, "getConfigs", {
-	enumerable: true,
-	get: function() {
-		return getConfigs;
-	}
-});
-Object.defineProperty(exports, "isNewerVersion", {
-	enumerable: true,
-	get: function() {
-		return isNewerVersion;
-	}
-});
-Object.defineProperty(exports, "linters", {
-	enumerable: true,
-	get: function() {
-		return linters;
-	}
-});
-Object.defineProperty(exports, "plainLogger", {
-	enumerable: true,
-	get: function() {
-		return plainLogger;
-	}
-});
-Object.defineProperty(exports, "pluralize", {
-	enumerable: true,
-	get: function() {
-		return pluralize;
-	}
-});
-Object.defineProperty(exports, "runHook", {
-	enumerable: true,
-	get: function() {
-		return runHook;
-	}
-});
-Object.defineProperty(exports, "runPostGenerate", {
-	enumerable: true,
-	get: function() {
-		return runPostGenerate;
-	}
-});
-Object.defineProperty(exports, "selectReporters", {
-	enumerable: true,
-	get: function() {
-		return selectReporters;
-	}
-});
-Object.defineProperty(exports, "setupReporters", {
-	enumerable: true,
-	get: function() {
-		return setupReporters;
-	}
-});
-Object.defineProperty(exports, "startUrlWatcher", {
-	enumerable: true,
-	get: function() {
-		return startUrlWatcher;
-	}
-});
-Object.defineProperty(exports, "startWatcher", {
-	enumerable: true,
-	get: function() {
-		return startWatcher;
-	}
-});
-
-//# sourceMappingURL=utils-ClRbJfxu.cjs.map