@kubb/cli 5.0.6 → 5.2.0

package/dist/run-CHfPmjaA.cjs

@@ -0,0 +1,283 @@
+const require_rolldown_runtime = require("./rolldown-runtime-qbf5tadS.cjs");
+const require_errors = require("./errors-C-wEou02.cjs");
+const require_Telemetry = require("./Telemetry-DKfJQxnC.cjs");
+const require_utils = require("./utils-B0SrWoNh.cjs");
+const require_package = require("./package-Dzjrfs0O.cjs");
+const require_output = require("./output-B2V2MN_C.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_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
+let node_fs = require("node:fs");
+let _kubb_core = require("@kubb/core");
+//#region src/runners/generate/run.ts
+/**
+* Runs one formatter or linter pass over the output directory. Returns the failure instead of
+* throwing, so the caller can turn it into a coded diagnostic. Failures never render here:
+* the caller emits them through `Diagnostics.emit`, like every other diagnostic.
+*/
+async function runToolPass({ toolValue, tool, outputPath, logLevel, hooks, onStart, onEnd }) {
+	await onStart();
+	let resolvedTool = toolValue;
+	if (resolvedTool === "auto") {
+		const detected = await tool.detect();
+		if (!detected) await hooks.callHook("kubb:warn", { message: tool.noToolMessage });
+		else {
+			resolvedTool = detected;
+			await hooks.callHook("kubb:info", { message: `Auto-detected ${tool.label}: ${(0, node_util.styleText)("dim", resolvedTool)}` });
+		}
+	}
+	let toolError = null;
+	if (resolvedTool && resolvedTool !== "auto" && resolvedTool in tool.map && (0, node_fs.existsSync)(outputPath)) {
+		const toolConfig = tool.map[resolvedTool];
+		const successMessage = [
+			`${tool.successPrefix} with ${(0, node_util.styleText)("dim", resolvedTool)}`,
+			logLevel >= _kubb_core.logLevel.info ? `on ${(0, node_util.styleText)("dim", outputPath)}` : void 0,
+			"successfully"
+		].filter(Boolean).join(" ");
+		try {
+			const hookId = (0, node_crypto.randomUUID)();
+			const hookArgs = toolConfig.args(outputPath);
+			const commandWithArgs = [toolConfig.command, ...hookArgs].join(" ");
+			await hooks.callHook("kubb:hook:start", {
+				id: hookId,
+				command: toolConfig.command,
+				args: hookArgs
+			});
+			const result = await require_utils.runHook({
+				id: hookId,
+				command: toolConfig.command,
+				args: hookArgs,
+				commandWithArgs,
+				hooks
+			});
+			if (result.success) await hooks.callHook("kubb:success", { message: successMessage });
+			else toolError = result.error ?? new Error(toolConfig.errorMessage);
+		} catch (caughtError) {
+			toolError = require_errors.toError(caughtError);
+		}
+	}
+	await onEnd();
+	return toolError;
+}
+async function generate(options) {
+	const { input, hooks, logLevel, dryRun = false } = options;
+	const hrStart = node_process.default.hrtime();
+	const inputPath = input ?? (typeof options.config.input === "string" ? options.config.input : void 0);
+	const config = {
+		...options.config,
+		input: input ?? options.config.input,
+		storage: dryRun ? (0, _kubb_core.memoryStorage)() : options.config.storage,
+		output: dryRun ? {
+			...options.config.output,
+			format: false,
+			lint: false,
+			postGenerate: []
+		} : options.config.output
+	};
+	const processOutput = async ({ config: resolvedConfig, outputPath }) => {
+		if (dryRun) return [];
+		const outputDiagnostics = [];
+		const reportOutputFailure = async (code, label, error) => {
+			const diagnostic = outputDiagnostic(code, label, error);
+			outputDiagnostics.push(diagnostic);
+			await _kubb_core.Diagnostics.emit(hooks, diagnostic);
+		};
+		const toolPasses = [{
+			value: resolvedConfig.output.format,
+			code: _kubb_core.Diagnostics.code.formatFailed,
+			tool: {
+				label: "formatter",
+				map: require_utils.formatters,
+				detect: () => require_utils.detectTool(require_utils.FORMATTER_PREFERENCE),
+				successPrefix: "Formatting",
+				noToolMessage: `No formatter found (${require_utils.FORMATTER_PREFERENCE.join(", ")}). Skipping formatting.`
+			},
+			onStart: () => hooks.callHook("kubb:format:start"),
+			onEnd: () => hooks.callHook("kubb:format:end")
+		}, {
+			value: resolvedConfig.output.lint,
+			code: _kubb_core.Diagnostics.code.lintFailed,
+			tool: {
+				label: "linter",
+				map: require_utils.linters,
+				detect: () => require_utils.detectTool(require_utils.LINTER_PREFERENCE),
+				successPrefix: "Linting",
+				noToolMessage: `No linter found (${require_utils.LINTER_PREFERENCE.join(", ")}). Skipping linting.`
+			},
+			onStart: () => hooks.callHook("kubb:lint:start"),
+			onEnd: () => hooks.callHook("kubb:lint:end")
+		}];
+		for (const pass of toolPasses) {
+			if (!pass.value) continue;
+			const error = await runToolPass({
+				toolValue: pass.value,
+				tool: pass.tool,
+				onStart: pass.onStart,
+				onEnd: pass.onEnd,
+				outputPath,
+				logLevel,
+				hooks
+			});
+			if (error) await reportOutputFailure(pass.code, pass.tool.label, error);
+		}
+		if (resolvedConfig.output.postGenerate?.length) {
+			await hooks.callHook("kubb:hooks:start");
+			const hookResults = await require_utils.runPostGenerate({
+				commands: resolvedConfig.output.postGenerate,
+				hooks
+			});
+			for (const hookResult of hookResults) {
+				if (hookResult.success) continue;
+				await reportOutputFailure(_kubb_core.Diagnostics.code.postGenerateFailed, "Post-generate command", hookResult.error ?? /* @__PURE__ */ new Error("Post-generate command failed"));
+			}
+			await hooks.callHook("kubb:hooks:end");
+		}
+		return outputDiagnostics;
+	};
+	hooks.hook("kubb:generation:end", ({ status }) => {
+		if (status === "success") return hooks.callHook("kubb:success", {
+			message: "Generation succeeded",
+			info: inputPath
+		});
+	});
+	const kubb = (0, _kubb_core.createKubb)(config, { hooks });
+	const result = await kubb.generate({ processOutput });
+	if (dryRun) await hooks.callHook("kubb:info", {
+		message: "Dry run: no files were written",
+		info: `${result.files.length} file(s) would be generated`
+	});
+	const telemetryPlugins = Array.from(kubb.driver.plugins.values(), (p) => ({
+		name: p.name,
+		options: p.options
+	}));
+	await require_Telemetry.sendTelemetry(require_Telemetry.buildTelemetryEvent({
+		command: "generate",
+		kubbVersion: require_package.version,
+		plugins: telemetryPlugins,
+		hrStart,
+		filesCreated: result.files.length,
+		status: result.success ? "success" : "failed"
+	}));
+	return result.success;
+}
+/**
+* Builds a coded diagnostic for an output-phase failure (formatter, linter, or `done` hook).
+*/
+function outputDiagnostic(code, label, caughtError) {
+	const error = require_errors.toError(caughtError);
+	return {
+		code,
+		severity: "error",
+		message: `${label} failed: ${error.message}`,
+		help: "Check that the tool is installed and that the command and its config are correct.",
+		location: { kind: "config" },
+		cause: error
+	};
+}
+async function checkForUpdate(hooks) {
+	try {
+		const data = await (await fetch(require_Telemetry.KUBB_NPM_PACKAGE_URL, { signal: AbortSignal.timeout(require_Telemetry.UPDATE_CHECK_TIMEOUT_MS) })).json();
+		if (data.version && require_utils.isNewerVersion(require_package.version, data.version)) await _kubb_core.Diagnostics.emit(hooks, _kubb_core.Diagnostics.update({
+			currentVersion: require_package.version,
+			latestVersion: data.version
+		}));
+	} catch {}
+}
+/**
+* Runs the full Kubb generation lifecycle for the given CLI options.
+* Loads configs, sets up the reporters (CLI `--reporter` picks which of `config.reporters` to trigger),
+* checks for a newer version, and calls `generate` for each config entry.
+*/
+async function run({ input, configPath, logLevel: logLevelKey, watch, reporters: cliReporters, dryRun }) {
+	const logLevel = _kubb_core.logLevel[logLevelKey] ?? _kubb_core.logLevel.info;
+	const hooks = new _kubb_core.Hookable();
+	let configs;
+	let resolvedConfigPath;
+	try {
+		const loaded = await require_utils.getConfigs({
+			configPath,
+			input,
+			watch,
+			logLevel: logLevelKey
+		});
+		configs = loaded.configs;
+		resolvedConfigPath = loaded.configPath;
+	} catch (error) {
+		await require_utils.setupReporters(hooks, {
+			logLevel,
+			reporters: [_kubb_core.cliReporter]
+		});
+		await hooks.callHook("kubb:error", { error: require_errors.toError(error) });
+		node_process.default.exit(1);
+	}
+	const requestedNames = cliReporters?.length ? cliReporters : ["cli"];
+	const available = configs[0]?.reporters ?? [];
+	const reporters = require_utils.selectReporters(available, requestedNames);
+	await require_utils.setupReporters(hooks, {
+		logLevel,
+		reporters
+	});
+	await hooks.callHook("kubb:lifecycle:start", { version: require_package.version });
+	await checkForUpdate(hooks);
+	try {
+		const relativeConfigPath = node_path.default.relative(node_process.default.cwd(), resolvedConfigPath);
+		await hooks.callHook("kubb:info", {
+			message: "Config loaded",
+			info: relativeConfigPath
+		});
+		await hooks.callHook("kubb:success", {
+			message: "Config loaded successfully",
+			info: relativeConfigPath
+		});
+		let anyFailed = false;
+		for (const config of configs) {
+			const effectiveInput = input ?? config.input;
+			const watchPath = typeof effectiveInput === "string" && (0, _kubb_core.getInputKind)(effectiveInput) === "file" ? effectiveInput : void 0;
+			if (watchPath && watch) {
+				const watchedPaths = [watchPath];
+				const build = async (paths) => {
+					await generate({
+						input,
+						config,
+						logLevel,
+						hooks,
+						dryRun
+					});
+					require_output.logStep((0, node_util.styleText)("yellow", `Watching for changes in ${paths.join(" and ")}`));
+				};
+				try {
+					await build(watchedPaths);
+				} catch (buildError) {
+					await hooks.callHook("kubb:error", { error: require_errors.toError(buildError) });
+				}
+				await require_utils.startWatcher(watchedPaths, build, {
+					info: require_output.logInfo,
+					error: require_output.logError
+				});
+			} else try {
+				if (!await generate({
+					input,
+					config,
+					logLevel,
+					hooks,
+					dryRun
+				})) anyFailed = true;
+			} catch (configError) {
+				await hooks.callHook("kubb:error", { error: require_errors.toError(configError) });
+				anyFailed = true;
+			}
+		}
+		await hooks.callHook("kubb:lifecycle:end");
+		if (anyFailed) node_process.default.exit(1);
+	} catch (error) {
+		await hooks.callHook("kubb:error", { error: require_errors.toError(error) });
+		node_process.default.exit(1);
+	}
+}
+//#endregion
+exports.run = run;
+
+//# sourceMappingURL=run-CHfPmjaA.cjs.map

package/dist/run-CHfPmjaA.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-CHfPmjaA.cjs","names":["styleText","existsSync","logLevelMap","randomUUID","runHook","toError","process","memoryStorage","Diagnostics","formatters","detectTool","FORMATTER_PREFERENCE","linters","LINTER_PREFERENCE","runPostGenerate","createKubb","sendTelemetry","buildTelemetryEvent","version","KUBB_NPM_PACKAGE_URL","UPDATE_CHECK_TIMEOUT_MS","isNewerVersion","Hookable","getConfigs","setupReporters","cliReporter","selectReporters","path","getInputKind","startWatcher","logInfo","logError"],"sources":["../src/runners/generate/run.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto'\nimport { existsSync } from 'node:fs'\nimport path from 'node:path'\nimport process from 'node:process'\nimport { styleText } from 'node:util'\nimport { toError } from '@internals/utils'\nimport {\n  Hookable,\n  type CLIOptions,\n  cliReporter,\n  type Config,\n  createKubb,\n  type Diagnostic,\n  Diagnostics,\n  getInputKind,\n  type KubbHooks,\n  logLevel as logLevelMap,\n  memoryStorage,\n  type ProblemDiagnostic,\n  type ReporterName,\n} from '@kubb/core'\nimport { version } from '../../../package.json'\nimport { KUBB_NPM_PACKAGE_URL, UPDATE_CHECK_TIMEOUT_MS } from '../../constants.ts'\nimport { buildTelemetryEvent, sendTelemetry } from '../../Telemetry.ts'\nimport setupReporters, { selectReporters } from '../../loggers/utils.ts'\nimport { logError, logInfo, logStep } from '../../loggers/output.ts'\nimport { getConfigs, isNewerVersion, runHook, runPostGenerate, startWatcher } from './utils.ts'\nimport { FORMATTER_PREFERENCE, LINTER_PREFERENCE } from '@internals/utils'\nimport { detectTool, formatters, linters } from '../../tools.ts'\n\ntype GenerateProps = {\n  input?: string\n  config: Config\n  hooks: Hookable<KubbHooks>\n  logLevel: number\n  /**\n   * When `true`, generates in memory instead of writing to disk, and skips formatting, linting,\n   * and post-generate commands.\n   */\n  dryRun?: boolean\n}\n\ntype ToolMap = typeof formatters | typeof linters\n\n/**\n * Static description of one output tool: its command table, the label and messages the pass logs,\n * and how to auto-detect it. Format and lint differ only in these values.\n */\ntype Tool = {\n  label: string\n  map: ToolMap\n  detect: () => Promise<string | null>\n  successPrefix: string\n  noToolMessage: string\n}\n\ntype RunToolPassOptions = {\n  toolValue: string\n  tool: Tool\n  outputPath: string\n  logLevel: number\n  hooks: Hookable<KubbHooks>\n  onStart: () => Promise<void> | void\n  onEnd: () => Promise<void> | void\n}\n\n/**\n * Runs one formatter or linter pass over the output directory. Returns the failure instead of\n * throwing, so the caller can turn it into a coded diagnostic. Failures never render here:\n * the caller emits them through `Diagnostics.emit`, like every other diagnostic.\n */\nasync function runToolPass({ toolValue, tool, outputPath, logLevel, hooks, onStart, onEnd }: RunToolPassOptions): Promise<Error | null> {\n  await onStart()\n\n  let resolvedTool = toolValue\n  if (resolvedTool === 'auto') {\n    const detected = await tool.detect()\n    if (!detected) {\n      await hooks.callHook('kubb:warn', { message: tool.noToolMessage })\n    } else {\n      resolvedTool = detected\n      await hooks.callHook('kubb:info', { message: `Auto-detected ${tool.label}: ${styleText('dim', resolvedTool)}` })\n    }\n  }\n\n  let toolError: Error | null = null\n\n  // Nothing to lint or format when the output dir was never written. Skip so the tool\n  // (e.g. oxlint with --no-ignore) doesn't fail with \"No files found to lint\".\n  if (resolvedTool && resolvedTool !== 'auto' && resolvedTool in tool.map && existsSync(outputPath)) {\n    const toolConfig = tool.map[resolvedTool as keyof ToolMap]\n\n    const successMessage = [\n      `${tool.successPrefix} with ${styleText('dim', resolvedTool)}`,\n      logLevel >= logLevelMap.info ? `on ${styleText('dim', outputPath)}` : undefined,\n      'successfully',\n    ]\n      .filter(Boolean)\n      .join(' ')\n\n    try {\n      const hookId = randomUUID()\n      const hookArgs = toolConfig.args(outputPath)\n      const commandWithArgs = [toolConfig.command, ...hookArgs].join(' ')\n\n      await hooks.callHook('kubb:hook:start', { id: hookId, command: toolConfig.command, args: hookArgs })\n\n      const result = await runHook({ id: hookId, command: toolConfig.command, args: hookArgs, commandWithArgs, hooks })\n\n      if (result.success) {\n        await hooks.callHook('kubb:success', { message: successMessage })\n      } else {\n        toolError = result.error ?? new Error(toolConfig.errorMessage)\n      }\n    } catch (caughtError) {\n      toolError = toError(caughtError)\n    }\n  }\n\n  await onEnd()\n\n  return toolError\n}\n\nasync function generate(options: GenerateProps): Promise<boolean> {\n  const { input, hooks, logLevel, dryRun = false } = options\n\n  const hrStart = process.hrtime()\n  const inputPath = input ?? (typeof options.config.input === 'string' ? options.config.input : undefined)\n\n  const config: Config = {\n    ...options.config,\n    input: input ?? options.config.input,\n    // Dry-run never touches disk, regardless of the config's own storage driver.\n    storage: dryRun ? memoryStorage() : options.config.storage,\n    // Also keeps core's `hasOutputPasses` false, so dry-run skips the output manifest write too.\n    output: dryRun ? { ...options.config.output, format: false, lint: false, postGenerate: [] } : options.config.output,\n  }\n\n  // The formatter, linter, and post-generate commands run after a successful build. Collect their\n  // failures as coded diagnostics so they reach the summary, the json report, and the exit code.\n  const processOutput = async ({ config: resolvedConfig, outputPath }: { config: Config; outputPath: string }): Promise<Array<Diagnostic>> => {\n    if (dryRun) return []\n\n    const outputDiagnostics: Array<Diagnostic> = []\n    const reportOutputFailure = async (code: ProblemDiagnostic['code'], label: string, error: Error) => {\n      const diagnostic = outputDiagnostic(code, label, error)\n      outputDiagnostics.push(diagnostic)\n      await Diagnostics.emit(hooks, diagnostic)\n    }\n\n    // Format and lint are the same pass over the output directory, differing only in the tool\n    // table and the hooks they announce themselves with, so run them from one descriptor list.\n    const toolPasses = [\n      {\n        value: resolvedConfig.output.format,\n        code: Diagnostics.code.formatFailed,\n        tool: {\n          label: 'formatter',\n          map: formatters,\n          detect: () => detectTool(FORMATTER_PREFERENCE),\n          successPrefix: 'Formatting',\n          noToolMessage: `No formatter found (${FORMATTER_PREFERENCE.join(', ')}). Skipping formatting.`,\n        },\n        onStart: () => hooks.callHook('kubb:format:start'),\n        onEnd: () => hooks.callHook('kubb:format:end'),\n      },\n      {\n        value: resolvedConfig.output.lint,\n        code: Diagnostics.code.lintFailed,\n        tool: {\n          label: 'linter',\n          map: linters,\n          detect: () => detectTool(LINTER_PREFERENCE),\n          successPrefix: 'Linting',\n          noToolMessage: `No linter found (${LINTER_PREFERENCE.join(', ')}). Skipping linting.`,\n        },\n        onStart: () => hooks.callHook('kubb:lint:start'),\n        onEnd: () => hooks.callHook('kubb:lint:end'),\n      },\n    ]\n\n    for (const pass of toolPasses) {\n      if (!pass.value) continue\n      const error = await runToolPass({\n        toolValue: pass.value,\n        tool: pass.tool,\n        onStart: pass.onStart,\n        onEnd: pass.onEnd,\n        outputPath,\n        logLevel,\n        hooks,\n      })\n      if (error) await reportOutputFailure(pass.code, pass.tool.label, error)\n    }\n\n    if (resolvedConfig.output.postGenerate?.length) {\n      await hooks.callHook('kubb:hooks:start')\n      const hookResults = await runPostGenerate({ commands: resolvedConfig.output.postGenerate, hooks })\n      for (const hookResult of hookResults) {\n        if (hookResult.success) continue\n        await reportOutputFailure(Diagnostics.code.postGenerateFailed, 'Post-generate command', hookResult.error ?? new Error('Post-generate command failed'))\n      }\n      await hooks.callHook('kubb:hooks:end')\n    }\n\n    return outputDiagnostics\n  }\n\n  hooks.hook('kubb:generation:end', ({ status }) => {\n    if (status === 'success') return hooks.callHook('kubb:success', { message: 'Generation succeeded', info: inputPath })\n  })\n\n  const kubb = createKubb(config, { hooks })\n  const result = await kubb.generate({ processOutput })\n\n  if (dryRun) {\n    await hooks.callHook('kubb:info', { message: 'Dry run: no files were written', info: `${result.files.length} file(s) would be generated` })\n  }\n\n  const telemetryPlugins = Array.from(kubb.driver.plugins.values(), (p) => ({ name: p.name, options: p.options as Record<string, unknown> }))\n  await sendTelemetry(\n    buildTelemetryEvent({\n      command: 'generate',\n      kubbVersion: version,\n      plugins: telemetryPlugins,\n      hrStart,\n      filesCreated: result.files.length,\n      status: result.success ? 'success' : 'failed',\n    }),\n  )\n\n  return result.success\n}\n\n/**\n * Builds a coded diagnostic for an output-phase failure (formatter, linter, or `done` hook).\n */\nfunction outputDiagnostic(code: ProblemDiagnostic['code'], label: string, caughtError: unknown): ProblemDiagnostic {\n  const error = toError(caughtError)\n  return {\n    code,\n    severity: 'error',\n    message: `${label} failed: ${error.message}`,\n    help: 'Check that the tool is installed and that the command and its config are correct.',\n    location: { kind: 'config' },\n    cause: error,\n  }\n}\n\ntype GenerateCommandOptions = {\n  input?: string\n  configPath?: string\n  logLevel: string\n  watch: boolean\n  reporters?: Array<ReporterName>\n  dryRun?: boolean\n}\n\nasync function checkForUpdate(hooks: Hookable<KubbHooks>): Promise<void> {\n  try {\n    const res = await fetch(KUBB_NPM_PACKAGE_URL, { signal: AbortSignal.timeout(UPDATE_CHECK_TIMEOUT_MS) })\n    const data = (await res.json()) as { version: string }\n    if (data.version && isNewerVersion(version, data.version)) {\n      await Diagnostics.emit(hooks, Diagnostics.update({ currentVersion: version, latestVersion: data.version }))\n    }\n  } catch {\n    // Ignore network errors\n  }\n}\n\n/**\n * Runs the full Kubb generation lifecycle for the given CLI options.\n * Loads configs, sets up the reporters (CLI `--reporter` picks which of `config.reporters` to trigger),\n * checks for a newer version, and calls `generate` for each config entry.\n */\nexport async function run({ input, configPath, logLevel: logLevelKey, watch, reporters: cliReporters, dryRun }: GenerateCommandOptions): Promise<void> {\n  const logLevel = logLevelMap[logLevelKey as keyof typeof logLevelMap] ?? logLevelMap.info\n  const hooks = new Hookable<KubbHooks>()\n\n  // Load the config first so `config.reporters` can pick the reporters. A failure here has no\n  // reporter installed yet, so fall back to the default `cli` reporter to surface it.\n  let configs: Array<Config>\n  let resolvedConfigPath: string\n  try {\n    const loaded = await getConfigs({\n      configPath,\n      input,\n      watch,\n      logLevel: logLevelKey as CLIOptions['logLevel'],\n    })\n    configs = loaded.configs\n    resolvedConfigPath = loaded.configPath\n  } catch (error) {\n    await setupReporters(hooks, { logLevel, reporters: [cliReporter] })\n    await hooks.callHook('kubb:error', { error: toError(error) })\n    process.exit(1)\n  }\n\n  // CLI `--reporter` selects which reporters to trigger by name, defaulting to `cli`. The config\n  // always carries the available reporters (defineConfig registers the built-ins).\n  const requestedNames: Array<ReporterName> = cliReporters?.length ? cliReporters : ['cli']\n  const available = configs[0]?.reporters ?? []\n  const reporters = selectReporters(available, requestedNames)\n  await setupReporters(hooks, { logLevel, reporters })\n\n  await hooks.callHook('kubb:lifecycle:start', { version })\n\n  await checkForUpdate(hooks)\n\n  try {\n    const relativeConfigPath = path.relative(process.cwd(), resolvedConfigPath)\n\n    await hooks.callHook('kubb:info', { message: 'Config loaded', info: relativeConfigPath })\n    await hooks.callHook('kubb:success', { message: 'Config loaded successfully', info: relativeConfigPath })\n\n    let anyFailed = false\n    for (const config of configs) {\n      const effectiveInput = input ?? config.input\n      const watchPath = typeof effectiveInput === 'string' && getInputKind(effectiveInput) === 'file' ? effectiveInput : undefined\n      if (watchPath && watch) {\n        const watchedPaths = [watchPath]\n        // Don't removeAll() between builds, that would also drop logger and lifecycle\n        // listeners. Plugin listeners are already disposed by safeBuild's dispose()\n        // in its finally block, so re-running generate() on the same hooks emitter is safe.\n        const build = async (paths: Array<string>) => {\n          await generate({ input, config, logLevel, hooks, dryRun })\n          logStep(styleText('yellow', `Watching for changes in ${paths.join(' and ')}`))\n        }\n\n        // The watcher ignores chokidar's startup events, so run the first build here. A failing\n        // first build keeps watching, since the user can fix the input and save.\n        try {\n          await build(watchedPaths)\n        } catch (buildError) {\n          await hooks.callHook('kubb:error', { error: toError(buildError) })\n        }\n\n        await startWatcher(watchedPaths, build, { info: logInfo, error: logError })\n      } else {\n        try {\n          const succeeded = await generate({ input, config, logLevel, hooks, dryRun })\n          if (!succeeded) anyFailed = true\n        } catch (configError) {\n          await hooks.callHook('kubb:error', { error: toError(configError) })\n          anyFailed = true\n        }\n      }\n    }\n\n    await hooks.callHook('kubb:lifecycle:end')\n\n    if (anyFailed) {\n      process.exit(1)\n    }\n  } catch (error) {\n    await hooks.callHook('kubb:error', { error: toError(error) })\n    process.exit(1)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAuEA,eAAe,YAAY,EAAE,WAAW,MAAM,YAAY,UAAU,OAAO,SAAS,SAAoD;CACtI,MAAM,QAAQ;CAEd,IAAI,eAAe;CACnB,IAAI,iBAAiB,QAAQ;EAC3B,MAAM,WAAW,MAAM,KAAK,OAAO;EACnC,IAAI,CAAC,UACH,MAAM,MAAM,SAAS,aAAa,EAAE,SAAS,KAAK,cAAc,CAAC;OAC5D;GACL,eAAe;GACf,MAAM,MAAM,SAAS,aAAa,EAAE,SAAS,iBAAiB,KAAK,MAAM,KAAA,GAAIA,UAAAA,UAAAA,CAAU,OAAO,YAAY,IAAI,CAAC;EACjH;CACF;CAEA,IAAI,YAA0B;CAI9B,IAAI,gBAAgB,iBAAiB,UAAU,gBAAgB,KAAK,QAAA,GAAOC,QAAAA,WAAAA,CAAW,UAAU,GAAG;EACjG,MAAM,aAAa,KAAK,IAAI;EAE5B,MAAM,iBAAiB;GACrB,GAAG,KAAK,cAAc,SAAA,GAAQD,UAAAA,UAAAA,CAAU,OAAO,YAAY;GAC3D,YAAYE,WAAAA,SAAY,OAAO,OAAA,GAAMF,UAAAA,UAAAA,CAAU,OAAO,UAAU,MAAM,KAAA;GACtE;EACF,CAAC,CACE,OAAO,OAAO,CAAC,CACf,KAAK,GAAG;EAEX,IAAI;GACF,MAAM,UAAA,GAASG,YAAAA,WAAAA,CAAW;GAC1B,MAAM,WAAW,WAAW,KAAK,UAAU;GAC3C,MAAM,kBAAkB,CAAC,WAAW,SAAS,GAAG,QAAQ,CAAC,CAAC,KAAK,GAAG;GAElE,MAAM,MAAM,SAAS,mBAAmB;IAAE,IAAI;IAAQ,SAAS,WAAW;IAAS,MAAM;GAAS,CAAC;GAEnG,MAAM,SAAS,MAAMC,cAAAA,QAAQ;IAAE,IAAI;IAAQ,SAAS,WAAW;IAAS,MAAM;IAAU;IAAiB;GAAM,CAAC;GAEhH,IAAI,OAAO,SACT,MAAM,MAAM,SAAS,gBAAgB,EAAE,SAAS,eAAe,CAAC;QAEhE,YAAY,OAAO,SAAS,IAAI,MAAM,WAAW,YAAY;EAEjE,SAAS,aAAa;GACpB,YAAYC,eAAAA,QAAQ,WAAW;EACjC;CACF;CAEA,MAAM,MAAM;CAEZ,OAAO;AACT;AAEA,eAAe,SAAS,SAA0C;CAChE,MAAM,EAAE,OAAO,OAAO,UAAU,SAAS,UAAU;CAEnD,MAAM,UAAUC,aAAAA,QAAQ,OAAO;CAC/B,MAAM,YAAY,UAAU,OAAO,QAAQ,OAAO,UAAU,WAAW,QAAQ,OAAO,QAAQ,KAAA;CAE9F,MAAM,SAAiB;EACrB,GAAG,QAAQ;EACX,OAAO,SAAS,QAAQ,OAAO;EAE/B,SAAS,UAAA,GAASC,WAAAA,cAAAA,CAAc,IAAI,QAAQ,OAAO;EAEnD,QAAQ,SAAS;GAAE,GAAG,QAAQ,OAAO;GAAQ,QAAQ;GAAO,MAAM;GAAO,cAAc,CAAC;EAAE,IAAI,QAAQ,OAAO;CAC/G;CAIA,MAAM,gBAAgB,OAAO,EAAE,QAAQ,gBAAgB,iBAAqF;EAC1I,IAAI,QAAQ,OAAO,CAAC;EAEpB,MAAM,oBAAuC,CAAC;EAC9C,MAAM,sBAAsB,OAAO,MAAiC,OAAe,UAAiB;GAClG,MAAM,aAAa,iBAAiB,MAAM,OAAO,KAAK;GACtD,kBAAkB,KAAK,UAAU;GACjC,MAAMC,WAAAA,YAAY,KAAK,OAAO,UAAU;EAC1C;EAIA,MAAM,aAAa,CACjB;GACE,OAAO,eAAe,OAAO;GAC7B,MAAMA,WAAAA,YAAY,KAAK;GACvB,MAAM;IACJ,OAAO;IACP,KAAKC,cAAAA;IACL,cAAcC,cAAAA,WAAWC,cAAAA,oBAAoB;IAC7C,eAAe;IACf,eAAe,uBAAuBA,cAAAA,qBAAqB,KAAK,IAAI,EAAE;GACxE;GACA,eAAe,MAAM,SAAS,mBAAmB;GACjD,aAAa,MAAM,SAAS,iBAAiB;EAC/C,GACA;GACE,OAAO,eAAe,OAAO;GAC7B,MAAMH,WAAAA,YAAY,KAAK;GACvB,MAAM;IACJ,OAAO;IACP,KAAKI,cAAAA;IACL,cAAcF,cAAAA,WAAWG,cAAAA,iBAAiB;IAC1C,eAAe;IACf,eAAe,oBAAoBA,cAAAA,kBAAkB,KAAK,IAAI,EAAE;GAClE;GACA,eAAe,MAAM,SAAS,iBAAiB;GAC/C,aAAa,MAAM,SAAS,eAAe;EAC7C,CACF;EAEA,KAAK,MAAM,QAAQ,YAAY;GAC7B,IAAI,CAAC,KAAK,OAAO;GACjB,MAAM,QAAQ,MAAM,YAAY;IAC9B,WAAW,KAAK;IAChB,MAAM,KAAK;IACX,SAAS,KAAK;IACd,OAAO,KAAK;IACZ;IACA;IACA;GACF,CAAC;GACD,IAAI,OAAO,MAAM,oBAAoB,KAAK,MAAM,KAAK,KAAK,OAAO,KAAK;EACxE;EAEA,IAAI,eAAe,OAAO,cAAc,QAAQ;GAC9C,MAAM,MAAM,SAAS,kBAAkB;GACvC,MAAM,cAAc,MAAMC,cAAAA,gBAAgB;IAAE,UAAU,eAAe,OAAO;IAAc;GAAM,CAAC;GACjG,KAAK,MAAM,cAAc,aAAa;IACpC,IAAI,WAAW,SAAS;IACxB,MAAM,oBAAoBN,WAAAA,YAAY,KAAK,oBAAoB,yBAAyB,WAAW,yBAAS,IAAI,MAAM,8BAA8B,CAAC;GACvJ;GACA,MAAM,MAAM,SAAS,gBAAgB;EACvC;EAEA,OAAO;CACT;CAEA,MAAM,KAAK,wBAAwB,EAAE,aAAa;EAChD,IAAI,WAAW,WAAW,OAAO,MAAM,SAAS,gBAAgB;GAAE,SAAS;GAAwB,MAAM;EAAU,CAAC;CACtH,CAAC;CAED,MAAM,QAAA,GAAOO,WAAAA,WAAAA,CAAW,QAAQ,EAAE,MAAM,CAAC;CACzC,MAAM,SAAS,MAAM,KAAK,SAAS,EAAE,cAAc,CAAC;CAEpD,IAAI,QACF,MAAM,MAAM,SAAS,aAAa;EAAE,SAAS;EAAkC,MAAM,GAAG,OAAO,MAAM,OAAO;CAA6B,CAAC;CAG5I,MAAM,mBAAmB,MAAM,KAAK,KAAK,OAAO,QAAQ,OAAO,IAAI,OAAO;EAAE,MAAM,EAAE;EAAM,SAAS,EAAE;CAAmC,EAAE;CAC1I,MAAMC,kBAAAA,cACJC,kBAAAA,oBAAoB;EAClB,SAAS;EACT,aAAaC,gBAAAA;EACb,SAAS;EACT;EACA,cAAc,OAAO,MAAM;EAC3B,QAAQ,OAAO,UAAU,YAAY;CACvC,CAAC,CACH;CAEA,OAAO,OAAO;AAChB;;;;AAKA,SAAS,iBAAiB,MAAiC,OAAe,aAAyC;CACjH,MAAM,QAAQb,eAAAA,QAAQ,WAAW;CACjC,OAAO;EACL;EACA,UAAU;EACV,SAAS,GAAG,MAAM,WAAW,MAAM;EACnC,MAAM;EACN,UAAU,EAAE,MAAM,SAAS;EAC3B,OAAO;CACT;AACF;AAWA,eAAe,eAAe,OAA2C;CACvE,IAAI;EAEF,MAAM,OAAQ,OAAM,MADF,MAAMc,kBAAAA,sBAAsB,EAAE,QAAQ,YAAY,QAAQC,kBAAAA,uBAAuB,EAAE,CAAC,EAAA,CAC9E,KAAK;EAC7B,IAAI,KAAK,WAAWC,cAAAA,eAAeH,gBAAAA,SAAS,KAAK,OAAO,GACtD,MAAMV,WAAAA,YAAY,KAAK,OAAOA,WAAAA,YAAY,OAAO;GAAE,gBAAgBU,gBAAAA;GAAS,eAAe,KAAK;EAAQ,CAAC,CAAC;CAE9G,QAAQ,CAER;AACF;;;;;;AAOA,eAAsB,IAAI,EAAE,OAAO,YAAY,UAAU,aAAa,OAAO,WAAW,cAAc,UAAiD;CACrJ,MAAM,WAAWhB,WAAAA,SAAY,gBAA4CA,WAAAA,SAAY;CACrF,MAAM,QAAQ,IAAIoB,WAAAA,SAAoB;CAItC,IAAI;CACJ,IAAI;CACJ,IAAI;EACF,MAAM,SAAS,MAAMC,cAAAA,WAAW;GAC9B;GACA;GACA;GACA,UAAU;EACZ,CAAC;EACD,UAAU,OAAO;EACjB,qBAAqB,OAAO;CAC9B,SAAS,OAAO;EACd,MAAMC,cAAAA,eAAe,OAAO;GAAE;GAAU,WAAW,CAACC,WAAAA,WAAW;EAAE,CAAC;EAClE,MAAM,MAAM,SAAS,cAAc,EAAE,OAAOpB,eAAAA,QAAQ,KAAK,EAAE,CAAC;EAC5D,aAAA,QAAQ,KAAK,CAAC;CAChB;CAIA,MAAM,iBAAsC,cAAc,SAAS,eAAe,CAAC,KAAK;CACxF,MAAM,YAAY,QAAQ,EAAE,EAAE,aAAa,CAAC;CAC5C,MAAM,YAAYqB,cAAAA,gBAAgB,WAAW,cAAc;CAC3D,MAAMF,cAAAA,eAAe,OAAO;EAAE;EAAU;CAAU,CAAC;CAEnD,MAAM,MAAM,SAAS,wBAAwB,EAAE,SAAA,gBAAA,QAAQ,CAAC;CAExD,MAAM,eAAe,KAAK;CAE1B,IAAI;EACF,MAAM,qBAAqBG,UAAAA,QAAK,SAASrB,aAAAA,QAAQ,IAAI,GAAG,kBAAkB;EAE1E,MAAM,MAAM,SAAS,aAAa;GAAE,SAAS;GAAiB,MAAM;EAAmB,CAAC;EACxF,MAAM,MAAM,SAAS,gBAAgB;GAAE,SAAS;GAA8B,MAAM;EAAmB,CAAC;EAExG,IAAI,YAAY;EAChB,KAAK,MAAM,UAAU,SAAS;GAC5B,MAAM,iBAAiB,SAAS,OAAO;GACvC,MAAM,YAAY,OAAO,mBAAmB,aAAA,GAAYsB,WAAAA,aAAAA,CAAa,cAAc,MAAM,SAAS,iBAAiB,KAAA;GACnH,IAAI,aAAa,OAAO;IACtB,MAAM,eAAe,CAAC,SAAS;IAI/B,MAAM,QAAQ,OAAO,UAAyB;KAC5C,MAAM,SAAS;MAAE;MAAO;MAAQ;MAAU;MAAO;KAAO,CAAC;KACzD,eAAA,SAAA,GAAQ5B,UAAAA,UAAAA,CAAU,UAAU,2BAA2B,MAAM,KAAK,OAAO,GAAG,CAAC;IAC/E;IAIA,IAAI;KACF,MAAM,MAAM,YAAY;IAC1B,SAAS,YAAY;KACnB,MAAM,MAAM,SAAS,cAAc,EAAE,OAAOK,eAAAA,QAAQ,UAAU,EAAE,CAAC;IACnE;IAEA,MAAMwB,cAAAA,aAAa,cAAc,OAAO;KAAE,MAAMC,eAAAA;KAAS,OAAOC,eAAAA;IAAS,CAAC;GAC5E,OACE,IAAI;IAEF,IAAI,CAAC,MADmB,SAAS;KAAE;KAAO;KAAQ;KAAU;KAAO;IAAO,CAAC,GAC3D,YAAY;GAC9B,SAAS,aAAa;IACpB,MAAM,MAAM,SAAS,cAAc,EAAE,OAAO1B,eAAAA,QAAQ,WAAW,EAAE,CAAC;IAClE,YAAY;GACd;EAEJ;EAEA,MAAM,MAAM,SAAS,oBAAoB;EAEzC,IAAI,WACF,aAAA,QAAQ,KAAK,CAAC;CAElB,SAAS,OAAO;EACd,MAAM,MAAM,SAAS,cAAc,EAAE,OAAOA,eAAAA,QAAQ,KAAK,EAAE,CAAC;EAC5D,aAAA,QAAQ,KAAK,CAAC;CAChB;AACF"}

package/dist/{run-FPqeAEF4.cjs → run-DRBqVXX0.cjs}

@@ -1,5 +1,6 @@
 const require_rolldown_runtime = require("./rolldown-runtime-qbf5tadS.cjs");
-const require_tools = require("./tools-bwKAf_r-.cjs");
+const require_output = require("./output-B2V2MN_C.cjs");
+const require_constants = require("./constants-CdxpgX3_.cjs");
 let node_util = require("node:util");
 let node_process = require("node:process");
 node_process = require_rolldown_runtime.__toESM(node_process, 1);
@@ -10,95 +11,6 @@ node_fs = require_rolldown_runtime.__toESM(node_fs, 1);
 let _clack_prompts = require("@clack/prompts");
 _clack_prompts = require_rolldown_runtime.__toESM(_clack_prompts, 1);
 let tinyexec = require("tinyexec");
-//#region ../../internals/shared/src/constants.ts
-const KUBB_CONFIG_FILENAME = "kubb.config.ts";
-const KUBB_PACKAGE_NAME = "kubb";
-const initDefaults = {
-	inputPath: "./openapi.yaml",
-	outputPath: "./src/gen",
-	plugins: ["plugin-ts"]
-};
-const availablePlugins = [
-	{
-		value: "plugin-ts",
-		label: "TypeScript",
-		hint: "Recommended",
-		packageName: "@kubb/plugin-ts",
-		importName: "pluginTs",
-		category: "types"
-	},
-	{
-		value: "plugin-axios",
-		label: "Axios Client",
-		packageName: "@kubb/plugin-axios",
-		importName: "pluginAxios",
-		category: "client"
-	},
-	{
-		value: "plugin-fetch",
-		label: "Fetch Client",
-		packageName: "@kubb/plugin-fetch",
-		importName: "pluginFetch",
-		category: "client"
-	},
-	{
-		value: "plugin-react-query",
-		label: "React Query / TanStack Query",
-		packageName: "@kubb/plugin-react-query",
-		importName: "pluginReactQuery",
-		category: "framework"
-	},
-	{
-		value: "plugin-vue-query",
-		label: "Vue Query",
-		packageName: "@kubb/plugin-vue-query",
-		importName: "pluginVueQuery",
-		category: "framework"
-	},
-	{
-		value: "plugin-zod",
-		label: "Zod Schemas",
-		packageName: "@kubb/plugin-zod",
-		importName: "pluginZod",
-		category: "validation"
-	},
-	{
-		value: "plugin-faker",
-		label: "Faker.js Mocks",
-		packageName: "@kubb/plugin-faker",
-		importName: "pluginFaker",
-		category: "mocks"
-	},
-	{
-		value: "plugin-msw",
-		label: "MSW Handlers",
-		packageName: "@kubb/plugin-msw",
-		importName: "pluginMsw",
-		category: "mocks"
-	},
-	{
-		value: "plugin-cypress",
-		label: "Cypress Tests",
-		packageName: "@kubb/plugin-cypress",
-		importName: "pluginCypress",
-		category: "testing"
-	},
-	{
-		value: "plugin-mcp",
-		label: "MCP Server (AI / Model Context Protocol)",
-		packageName: "@kubb/plugin-mcp",
-		importName: "pluginMcp",
-		category: "ai"
-	},
-	{
-		value: "plugin-redoc",
-		label: "ReDoc Documentation",
-		packageName: "@kubb/plugin-redoc",
-		importName: "pluginRedoc",
-		category: "documentation"
-	}
-];
-//#endregion
 //#region ../../internals/shared/src/init.ts
 /**
 * Resolves a comma-separated plugin flag (e.g. `--plugins plugin-ts,plugin-zod`) into the
@@ -108,7 +20,7 @@ const availablePlugins = [
 function resolvePlugins(pluginsFlag) {
 	if (!pluginsFlag) return [];
 	const requested = pluginsFlag.split(",").map((value) => value.trim()).filter(Boolean);
-	return availablePlugins.filter((plugin) => requested.includes(plugin.value));
+	return require_constants.availablePlugins.filter((plugin) => requested.includes(plugin.value));
 }
 function generateConfigFile({ selectedPlugins, inputPath, outputPath }) {
 	return `import { defineConfig } from 'kubb/config'
@@ -139,6 +51,62 @@ function resolveInstallVersions({ packages, version }) {
 	return packages.map((name) => name === "kubb" ? `${name}@${version}` : `${name}@${tag}`);
 }
 //#endregion
+//#region src/tools.ts
+/**
+* Metadata for each supported package manager, keyed by its short name.
+*
+* @example
+* ```ts
+* packageManagers.pnpm.installCommand // ['add', '-D']
+* packageManagers.npm.lockFile        // 'package-lock.json'
+* ```
+*/
+const packageManagers = {
+	pnpm: {
+		name: "pnpm",
+		lockFile: "pnpm-lock.yaml",
+		installCommand: ["add", "-D"]
+	},
+	yarn: {
+		name: "yarn",
+		lockFile: "yarn.lock",
+		installCommand: ["add", "-D"]
+	},
+	bun: {
+		name: "bun",
+		lockFile: "bun.lockb",
+		installCommand: ["add", "-d"]
+	},
+	npm: {
+		name: "npm",
+		lockFile: "package-lock.json",
+		installCommand: ["install", "--save-dev"]
+	}
+};
+/**
+* Detects the active package manager for the given directory.
+* Resolution order: `packageManager` field in `package.json`, then presence of a lock file.
+* Falls back to `npm` when no signal is found.
+*
+* @example
+* ```ts
+* detectPackageManager('/my/project') // { name: 'pnpm', lockFile: 'pnpm-lock.yaml', ... }
+* detectPackageManager()              // falls back to npm when no lock file is found
+* ```
+*/
+function detectPackageManager(cwd = process.cwd()) {
+	const packageJsonPath = (0, node_path.join)(cwd, "package.json");
+	if ((0, node_fs.existsSync)(packageJsonPath)) try {
+		const pmField = JSON.parse((0, node_fs.readFileSync)(packageJsonPath, "utf-8")).packageManager;
+		if (typeof pmField === "string") {
+			const name = pmField.split("@")[0];
+			if (name && name in packageManagers) return packageManagers[name];
+		}
+	} catch {}
+	for (const pm of Object.values(packageManagers)) if ((0, node_fs.existsSync)((0, node_path.join)(cwd, pm.lockFile))) return pm;
+	return packageManagers.npm;
+}
+//#endregion
 //#region src/runners/init/utils.ts
 /**
 * Returns `true` when a `package.json` exists at `cwd`.
@@ -188,18 +156,18 @@ function cancelAndExit(message = "Operation canceled.") {
 */
 async function run({ yes, version, input: inputFlag, output: outputFlag, plugins: pluginsFlag, dryRun }) {
 	const cwd = node_process.default.cwd();
-	_clack_prompts.intro((0, node_util.styleText)("bgCyan", (0, node_util.styleText)("black", " Kubb Init ")));
+	require_output.logIntro({ title: (0, node_util.styleText)("bgCyan", (0, node_util.styleText)("black", " Kubb Init ")) });
 	/**
 	* Returns `flag` when provided, the `defaultValue` when `yes` is set,
 	* or calls `prompt()` for interactive input. Exits on cancellation.
 	*/
 	async function resolveOrPrompt(flag, defaultValue, logLabel, prompt) {
 		if (flag !== void 0) {
-			_clack_prompts.log.info(`${logLabel}: ${(0, node_util.styleText)("cyan", String(flag))}`);
+			require_output.logInfo(`${logLabel}: ${(0, node_util.styleText)("cyan", String(flag))}`);
 			return flag;
 		}
 		if (yes) {
-			_clack_prompts.log.info(`${logLabel}: ${(0, node_util.styleText)("cyan", String(defaultValue))}`);
+			require_output.logInfo(`${logLabel}: ${(0, node_util.styleText)("cyan", String(defaultValue))}`);
 			return defaultValue;
 		}
 		const result = await prompt();
@@ -215,64 +183,64 @@ async function run({ yes, version, input: inputFlag, output: outputFlag, plugins
 				});
 				if (_clack_prompts.isCancel(shouldInit) || !shouldInit) cancelAndExit();
 			}
-			const packageManager = require_tools.detectPackageManager(cwd);
-			const spinner = _clack_prompts.spinner();
+			const packageManager = detectPackageManager(cwd);
+			const spinner = require_output.createSpinner();
 			spinner.start(`Initializing package.json with ${packageManager.name}`);
 			await initPackageJson(cwd, packageManager);
 			spinner.stop(`Created package.json with ${packageManager.name}`);
 		}
-		const packageManager = require_tools.detectPackageManager(cwd);
-		if (hasPackageJson(cwd)) _clack_prompts.log.info(`Detected package manager: ${(0, node_util.styleText)("cyan", packageManager.name)}`);
-		const inputPath = await resolveOrPrompt(inputFlag, initDefaults.inputPath, "Using input path", () => _clack_prompts.text({
+		const packageManager = detectPackageManager(cwd);
+		if (hasPackageJson(cwd)) require_output.logInfo(`Detected package manager: ${(0, node_util.styleText)("cyan", packageManager.name)}`);
+		const inputPath = await resolveOrPrompt(inputFlag, require_constants.initDefaults.inputPath, "Using input path", () => _clack_prompts.text({
 			message: "Where is your OpenAPI specification located?",
-			placeholder: initDefaults.inputPath,
-			defaultValue: initDefaults.inputPath,
+			placeholder: require_constants.initDefaults.inputPath,
+			defaultValue: require_constants.initDefaults.inputPath,
 			validate: (value) => {
 				if (!value) return "Input path is required";
 			}
 		}));
-		const outputPath = await resolveOrPrompt(outputFlag, initDefaults.outputPath, "Using output path", () => _clack_prompts.text({
+		const outputPath = await resolveOrPrompt(outputFlag, require_constants.initDefaults.outputPath, "Using output path", () => _clack_prompts.text({
 			message: "Where should the generated files be output?",
-			placeholder: initDefaults.outputPath,
-			defaultValue: initDefaults.outputPath,
+			placeholder: require_constants.initDefaults.outputPath,
+			defaultValue: require_constants.initDefaults.outputPath,
 			validate: (value) => {
 				if (!value) return "Output path is required";
 			}
 		}));
-		const defaultPlugins = availablePlugins.filter((p) => initDefaults.plugins.includes(p.value));
+		const defaultPlugins = require_constants.availablePlugins.filter((p) => require_constants.initDefaults.plugins.includes(p.value));
 		const pluginLabel = (plugins) => (0, node_util.styleText)("cyan", plugins.map((p) => p.label).join(", "));
 		const selectedPlugins = await (async () => {
 			if (pluginsFlag) {
 				const plugins = resolvePlugins(pluginsFlag);
 				if (plugins.length === 0) {
-					_clack_prompts.log.warn(`No valid plugins found in --plugins value; falling back to default: ${pluginLabel(defaultPlugins)}`);
+					require_output.logWarn(`No valid plugins found in --plugins value; falling back to default: ${pluginLabel(defaultPlugins)}`);
 					return defaultPlugins;
 				}
-				_clack_prompts.log.info(`Using plugins: ${pluginLabel(plugins)}`);
+				require_output.logInfo(`Using plugins: ${pluginLabel(plugins)}`);
 				return plugins;
 			}
 			if (yes) {
-				_clack_prompts.log.info(`Using plugins: ${pluginLabel(defaultPlugins)}`);
+				require_output.logInfo(`Using plugins: ${pluginLabel(defaultPlugins)}`);
 				return defaultPlugins;
 			}
 			const values = await _clack_prompts.multiselect({
 				message: "Select plugins to use:",
-				options: availablePlugins.map(({ value, label, hint }) => ({
+				options: require_constants.availablePlugins.map(({ value, label, hint }) => ({
 					value,
 					label,
 					hint
 				})),
-				initialValues: [...initDefaults.plugins],
+				initialValues: [...require_constants.initDefaults.plugins],
 				required: true
 			});
 			if (_clack_prompts.isCancel(values)) cancelAndExit();
-			return availablePlugins.filter((p) => values.includes(p.value));
+			return require_constants.availablePlugins.filter((p) => values.includes(p.value));
 		})();
 		const packagesToInstall = resolveInstallVersions({
-			packages: [KUBB_PACKAGE_NAME, ...selectedPlugins.map((p) => p.packageName)],
+			packages: [require_constants.KUBB_PACKAGE_NAME, ...selectedPlugins.map((p) => p.packageName)],
 			version
 		});
-		const spinner = _clack_prompts.spinner();
+		const spinner = require_output.createSpinner();
 		spinner.start(`Installing ${packagesToInstall.length} packages with ${packageManager.name}`);
 		try {
 			await dryRun.run(() => installPackages(packagesToInstall, packageManager, cwd), { message: `install ${packagesToInstall.length} packages with ${packageManager.name}` });
@@ -281,35 +249,35 @@ async function run({ yes, version, input: inputFlag, output: outputFlag, plugins
 			spinner.stop("Installation failed");
 			throw error;
 		}
-		const configSpinner = _clack_prompts.spinner();
-		configSpinner.start(`Creating ${KUBB_CONFIG_FILENAME}`);
+		const configSpinner = require_output.createSpinner();
+		configSpinner.start(`Creating ${require_constants.KUBB_CONFIG_FILENAME}`);
 		const configContent = generateConfigFile({
 			selectedPlugins,
 			inputPath,
 			outputPath
 		});
-		const configPath = node_path.default.join(cwd, KUBB_CONFIG_FILENAME);
+		const configPath = node_path.default.join(cwd, require_constants.KUBB_CONFIG_FILENAME);
 		if (node_fs.default.existsSync(configPath)) {
-			configSpinner.stop(`${KUBB_CONFIG_FILENAME} already exists`);
+			configSpinner.stop(`${require_constants.KUBB_CONFIG_FILENAME} already exists`);
 			if (!yes) {
 				const shouldOverwrite = await _clack_prompts.confirm({
-					message: `${KUBB_CONFIG_FILENAME} already exists. Overwrite?`,
+					message: `${require_constants.KUBB_CONFIG_FILENAME} already exists. Overwrite?`,
 					initialValue: false
 				});
 				if (_clack_prompts.isCancel(shouldOverwrite) || !shouldOverwrite) cancelAndExit("Keeping existing configuration. Packages have been installed.");
 			}
-			configSpinner.start(`Overwriting ${KUBB_CONFIG_FILENAME}`);
+			configSpinner.start(`Overwriting ${require_constants.KUBB_CONFIG_FILENAME}`);
 		}
-		await dryRun.run(() => node_fs.default.promises.writeFile(configPath, configContent, "utf-8"), { message: `write ${KUBB_CONFIG_FILENAME}` });
-		configSpinner.stop(`Created ${KUBB_CONFIG_FILENAME}`);
-		_clack_prompts.outro((0, node_util.styleText)("green", "✓ All set!") + "\n\n" + (0, node_util.styleText)("dim", "Next steps:") + "\n" + (0, node_util.styleText)("cyan", `  1. Make sure your OpenAPI spec is at: ${inputPath}`) + "\n" + (0, node_util.styleText)("cyan", "  2. Generate code with: npx kubb generate") + "\n" + (0, node_util.styleText)("cyan", `  3. Find generated files in: ${outputPath}`) + "\n\n" + (0, node_util.styleText)("dim", `Using ${packageManager.name} • Kubb v${version}`));
+		await dryRun.run(() => node_fs.default.promises.writeFile(configPath, configContent, "utf-8"), { message: `write ${require_constants.KUBB_CONFIG_FILENAME}` });
+		configSpinner.stop(`Created ${require_constants.KUBB_CONFIG_FILENAME}`);
+		require_output.logOutro((0, node_util.styleText)("green", "✓ All set!") + "\n\n" + (0, node_util.styleText)("dim", "Next steps:") + "\n" + (0, node_util.styleText)("cyan", `  1. Make sure your OpenAPI spec is at: ${inputPath}`) + "\n" + (0, node_util.styleText)("cyan", "  2. Generate code with: npx kubb generate") + "\n" + (0, node_util.styleText)("cyan", `  3. Find generated files in: ${outputPath}`) + "\n\n" + (0, node_util.styleText)("dim", `Using ${packageManager.name} • Kubb v${version}`));
 	} catch (error) {
-		_clack_prompts.log.error((0, node_util.styleText)("red", "An error occurred during initialization"));
-		if (error instanceof Error) _clack_prompts.log.error(error.message);
+		require_output.logError((0, node_util.styleText)("red", "An error occurred during initialization"));
+		if (error instanceof Error) require_output.logError(error.message);
 		node_process.default.exit(1);
 	}
 }
 //#endregion
 exports.run = run;
 
-//# sourceMappingURL=run-FPqeAEF4.cjs.map
+//# sourceMappingURL=run-DRBqVXX0.cjs.map