@kubb/core 5.0.0-beta.38 → 5.0.0-beta.39

package/dist/index.cjs

@@ -1,9 +1,86 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_KubbDriver = require("./KubbDriver-BYBUfOZ8.cjs");
+const require_memoryStorage = require("./memoryStorage-DHi1d0To.cjs");
+let node_util = require("node:util");
+let node_crypto = require("node:crypto");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
+let node_dns = require("node:dns");
 let _kubb_ast = require("@kubb/ast");
-_kubb_ast = require_KubbDriver.__toESM(_kubb_ast, 1);
+_kubb_ast = require_memoryStorage.__toESM(_kubb_ast, 1);
+let node_process = require("node:process");
+node_process = require_memoryStorage.__toESM(node_process, 1);
+let node_os = require("node:os");
+node_os = require_memoryStorage.__toESM(node_os, 1);
+//#region ../../internals/utils/src/colors.ts
+/**
+* Parses a CSS hex color string (`#RGB`) into its RGB channels.
+* Falls back to `255` for any channel that cannot be parsed.
+*/
+function parseHex(color) {
+	const int = Number.parseInt(color.replace("#", ""), 16);
+	return Number.isNaN(int) ? {
+		r: 255,
+		g: 255,
+		b: 255
+	} : {
+		r: int >> 16 & 255,
+		g: int >> 8 & 255,
+		b: int & 255
+	};
+}
+/**
+* Returns a function that wraps a string in a 24-bit ANSI true-color escape sequence
+* for the given hex color.
+*/
+function hex(color) {
+	const { r, g, b } = parseHex(color);
+	return (text) => `\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`;
+}
+hex("#F55A17"), hex("#F5A217"), hex("#F58517"), hex("#B45309"), hex("#FFFFFF"), hex("#adadc6"), hex("#FDA4AF");
+/**
+* ANSI color names used by {@link randomCliColor} for deterministic terminal coloring.
+*/
+const randomColors = [
+	"black",
+	"red",
+	"green",
+	"yellow",
+	"blue",
+	"white",
+	"magenta",
+	"cyan",
+	"gray"
+];
+/**
+* Wraps `text` in a deterministic ANSI color derived from the text's SHA-256 hash.
+*
+* @example
+* ```ts
+* randomCliColor('petstore') // '\x1b[33m' + 'petstore' + '\x1b[39m' (always the same color for 'petstore')
+* ```
+*/
+function randomCliColor(text) {
+	if (!text) return "";
+	return (0, node_util.styleText)(randomColors[(0, node_crypto.createHash)("sha256").update(text).digest().readUInt32BE(0) % randomColors.length] ?? "white", text);
+}
+//#endregion
+//#region ../../internals/utils/src/env.ts
+/**
+* Returns `true` when the process is running in a CI environment.
+* Covers GitHub Actions, GitLab CI, CircleCI, Travis CI, Jenkins, Bitbucket,
+* TeamCity, Buildkite, and Azure Pipelines.
+*
+* @example
+* ```ts
+* if (isCIEnvironment()) {
+*   logger.level = 'error'
+* }
+* ```
+*/
+function isCIEnvironment() {
+	return !!(process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.BITBUCKET_BUILD_NUMBER || process.env.JENKINS_URL || process.env.CIRCLECI || process.env.TRAVIS || process.env.TEAMCITY_VERSION || process.env.BUILDKITE || process.env.TF_BUILD);
+}
+//#endregion
 //#region ../../internals/utils/src/fs.ts
 /**
 * Writes `data` to `path`, trimming leading/trailing whitespace before saving.
@@ -55,6 +132,51 @@ async function clean(path) {
 	});
 }
 //#endregion
+//#region ../../internals/utils/src/network.ts
+/**
+* Well-known stable domains used as DNS probes to check internet connectivity.
+*/
+const TEST_DOMAINS = [
+	"dns.google.com",
+	"cloudflare.com",
+	"one.one.one.one"
+];
+/**
+* Returns `true` when the system has internet connectivity.
+* Probes DNS resolution against well-known stable domains.
+*
+* @example
+* ```ts
+* if (await isOnline()) {
+*   await fetchLatestVersion()
+* }
+* ```
+*/
+async function isOnline() {
+	for (const domain of TEST_DOMAINS) try {
+		await node_dns.promises.resolve(domain);
+		return true;
+	} catch {}
+	return false;
+}
+/**
+* Executes `fn` only when the system is online. Returns `null` when offline or on error.
+*
+* @example
+* ```ts
+* const version = await executeIfOnline(() => fetchLatestVersion('kubb'))
+* // null when offline
+* ```
+*/
+async function executeIfOnline(fn) {
+	if (!await isOnline()) return null;
+	try {
+		return await fn();
+	} catch {
+		return null;
+	}
+}
+//#endregion
 //#region src/createAdapter.ts
 /**
 * Defines a custom adapter that translates a spec format into Kubb's universal
@@ -90,49 +212,6 @@ function createAdapter(build) {
 	return (options) => build(options ?? {});
 }
 //#endregion
-//#region src/createStorage.ts
-/**
-* Defines a custom storage backend. The builder receives user options and
-* returns a `Storage` implementation. Kubb ships with filesystem and
-* in-memory storages, reach for this when you need to write generated files
-* elsewhere (cloud storage, a database, a remote API).
-*
-* @example In-memory storage (the built-in implementation)
-* ```ts
-* import { createStorage } from '@kubb/core'
-*
-* export const memoryStorage = createStorage(() => {
-*   const store = new Map<string, string>()
-*
-*   return {
-*     name: 'memory',
-*     async hasItem(key) {
-*       return store.has(key)
-*     },
-*     async getItem(key) {
-*       return store.get(key) ?? null
-*     },
-*     async setItem(key, value) {
-*       store.set(key, value)
-*     },
-*     async removeItem(key) {
-*       store.delete(key)
-*     },
-*     async getKeys(base) {
-*       const keys = [...store.keys()]
-*       return base ? keys.filter((k) => k.startsWith(base)) : keys
-*     },
-*     async clear(base) {
-*       if (!base) store.clear()
-*     },
-*   }
-* })
-* ```
-*/
-function createStorage(build) {
-	return (options) => build(options ?? {});
-}
-//#endregion
 //#region src/storages/fsStorage.ts
 /**
 * Built-in filesystem storage driver.
@@ -159,7 +238,7 @@ function createStorage(build) {
 * })
 * ```
 */
-const fsStorage = createStorage(() => ({
+const fsStorage = require_memoryStorage.createStorage(() => ({
 	name: "fs",
 	async hasItem(key) {
 		try {
@@ -216,7 +295,7 @@ const fsStorage = createStorage(() => ({
 */
 function createSourcesView(storage) {
 	const paths = /* @__PURE__ */ new Set();
-	return createStorage(() => ({
+	return require_memoryStorage.createStorage(() => ({
 		name: `${storage.name}:sources`,
 		async hasItem(key) {
 			return paths.has(key) && await storage.hasItem(key);
@@ -257,16 +336,10 @@ function resolveConfig(userConfig) {
 			...userConfig.output
 		},
 		storage: userConfig.storage ?? fsStorage(),
-		devtools: userConfig.devtools ? {
-			studioUrl: require_KubbDriver.DEFAULT_STUDIO_URL,
-			...typeof userConfig.devtools === "boolean" ? {} : userConfig.devtools
-		} : void 0,
+		reporters: userConfig.reporters ?? [],
 		plugins: userConfig.plugins ?? []
 	};
 }
-function isInputPath(config) {
-	return typeof config?.input === "object" && config.input !== null && "path" in config.input;
-}
 /**
 * Kubb code-generation instance bound to a single config entry. Resolves the user
 * config during `setup()` and shares `hooks`, `storage`, `driver`, and `config` across
@@ -289,7 +362,7 @@ var Kubb = class {
 	#storage = null;
 	constructor(userConfig, options = {}) {
 		this.#userConfig = userConfig;
-		this.hooks = options.hooks ?? new require_KubbDriver.AsyncEventEmitter();
+		this.hooks = options.hooks ?? new require_memoryStorage.AsyncEventEmitter();
 	}
 	get storage() {
 		if (!this.#storage) throw new Error("[kubb] setup() must be called before accessing storage");
@@ -308,7 +381,7 @@ var Kubb = class {
 	*/
 	async setup() {
 		const config = resolveConfig(this.#userConfig);
-		const driver = new require_KubbDriver.KubbDriver(config, { hooks: this.hooks });
+		const driver = new require_memoryStorage.KubbDriver(config, { hooks: this.hooks });
 		const storage = createSourcesView(config.storage);
 		this.hooks.setMaxListeners(Math.max(10, config.plugins.length * 4));
 		if (config.output.clean) await config.storage.clear((0, node_path.resolve)(config.root, config.output.path));
@@ -323,9 +396,9 @@ var Kubb = class {
 	*/
 	async build() {
 		const out = await this.safeBuild();
-		if (require_KubbDriver.Diagnostics.hasError(out.diagnostics)) {
-			const errors = out.diagnostics.filter(require_KubbDriver.isProblemDiagnostic).filter((diagnostic) => diagnostic.severity === "error").map((diagnostic) => diagnostic.cause ?? new require_KubbDriver.DiagnosticError(diagnostic));
-			throw new require_KubbDriver.BuildError(`Build failed with ${errors.length} ${errors.length === 1 ? "error" : "errors"}`, { errors });
+		if (require_memoryStorage.Diagnostics.hasError(out.diagnostics)) {
+			const errors = out.diagnostics.filter(require_memoryStorage.Diagnostics.isProblem).filter((diagnostic) => diagnostic.severity === "error").map((diagnostic) => diagnostic.cause ?? new require_memoryStorage.Diagnostics.Error(diagnostic));
+			throw new require_memoryStorage.BuildError(`Build failed with ${errors.length} ${errors.length === 1 ? "error" : "errors"}`, { errors });
 		}
 		return out;
 	}
@@ -335,7 +408,7 @@ var Kubb = class {
 	*/
 	async safeBuild() {
 		try {
-			var _usingCtx$1 = require_KubbDriver._usingCtx();
+			var _usingCtx$1 = require_memoryStorage._usingCtx();
 			if (!this.#driver) await this.setup();
 			const cleanup = _usingCtx$1.u(this);
 			const driver = cleanup.driver;
@@ -386,8 +459,8 @@ function createKubb(userConfig, options = {}) {
 //#endregion
 //#region src/createReporter.ts
 /**
-* Defines a reporter. When the definition has a `flush`, the returned reporter buffers each value
-* `report` returns and hands the array to `flush` once, then clears it. Without a `flush`, nothing
+* Defines a reporter. When the definition has a `drain`, the returned reporter buffers each value
+* `report` returns and hands the array to `drain` once, then clears it. Without a `drain`, nothing
 * is buffered. Wiring the reporter onto the run's events is the host's job, so the reporter only
 * ever deals with a {@link GenerationResult}.
 *
@@ -400,17 +473,19 @@ function createKubb(userConfig, options = {}) {
 *   report(result) {
 *     return { status: Diagnostics.hasError(result.diagnostics) ? 'failed' : 'success', diagnostics: result.diagnostics }
 *   },
-*   flush(context, reports) {
+*   drain(context, reports) {
 *     process.stdout.write(`${JSON.stringify(reports, null, 2)}\n`)
 *   },
 * })
 * ```
 */
 function createReporter(reporter) {
-	const flush = reporter.flush;
-	if (!flush) return {
+	const drain = reporter.drain;
+	if (!drain) return {
 		name: reporter.name,
-		report: reporter.report
+		async report(result, context) {
+			await reporter.report(result, context);
+		}
 	};
 	const reports = [];
 	return {
@@ -418,12 +493,409 @@ function createReporter(reporter) {
 		async report(result, context) {
 			reports.push(await reporter.report(result, context));
 		},
-		async flush(context) {
-			await flush(context, reports);
+		async drain(context) {
+			await drain(context, reports);
 			reports.length = 0;
 		}
 	};
 }
+/**
+* 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 src/defineLogger.ts
+/**
+* Numeric log-level thresholds used internally to compare verbosity.
+*
+* Higher numbers are more verbose.
+*/
+const logLevel = {
+	silent: Number.NEGATIVE_INFINITY,
+	error: 0,
+	warn: 1,
+	info: 3,
+	verbose: 4
+};
+/**
+* Defines a typed logger. Use the second type parameter to declare a return
+* value from `install`, which is handy when the logger exposes a sink factory
+* or cleanup callback to the caller.
+*
+* @example Basic logger
+* ```ts
+* import { defineLogger } from '@kubb/core'
+*
+* export const myLogger = defineLogger({
+*   name: 'my-logger',
+*   install(context) {
+*     context.on('kubb:info', ({ message }) => console.log('ℹ', message))
+*     context.on('kubb:error', ({ error }) => console.error('✗', error.message))
+*   },
+* })
+* ```
+*
+* @example Logger that returns a hook sink factory
+* ```ts
+* import { defineLogger, type LoggerOptions } from '@kubb/core'
+* import type { HookSinkFactory } from './sinks'
+*
+* export const myLogger = defineLogger<LoggerOptions, HookSinkFactory>({
+*   name: 'my-logger',
+*   install(context) {
+*     // … register event handlers …
+*     return () => ({ onStdout: console.log })
+*   },
+* })
+* ```
+*/
+function defineLogger(logger) {
+	return logger;
+}
+//#endregion
+//#region src/reporters/report.ts
+/**
+* Builds the normalized {@link Report} for one config from its {@link GenerationResult}. Splits the
+* diagnostics into problems and per-plugin timings (slowest first) and derives the plugin and issue
+* counts, so every reporter renders the same data.
+*/
+function buildReport(result) {
+	const { config, diagnostics, filesCreated, status, hrStart } = result;
+	const failed = require_memoryStorage.Diagnostics.failedPlugins(diagnostics);
+	const total = config.plugins?.length ?? 0;
+	const counts = require_memoryStorage.Diagnostics.count(diagnostics);
+	const problems = diagnostics.filter(require_memoryStorage.Diagnostics.isProblem);
+	const timings = diagnostics.filter(require_memoryStorage.Diagnostics.isPerformance).sort((a, b) => b.duration - a.duration).map((diagnostic) => ({
+		plugin: diagnostic.plugin,
+		durationMs: diagnostic.duration
+	}));
+	return {
+		name: config.name ?? "",
+		status,
+		plugins: {
+			passed: total - failed.length,
+			failed,
+			total
+		},
+		counts,
+		filesCreated,
+		durationMs: require_memoryStorage.getElapsedMs(hrStart),
+		output: (0, node_path.resolve)(config.root, config.output.path),
+		timings,
+		diagnostics: problems.map((diagnostic) => require_memoryStorage.Diagnostics.serialize(diagnostic))
+	};
+}
+//#endregion
+//#region src/reporters/cliReporter.ts
+/**
+* Builds the vitest/jest-style summary for one {@link Report}: right-aligned dim labels with
+* `N passed (total)` counts, and a per-plugin `Timings` section when `showTimings`.
+*/
+function buildSummaryLines(report, { showTimings }) {
+	const { status, plugins, counts, filesCreated, durationMs, output, timings } = report;
+	const rows = [];
+	rows.push(["Plugins", status === "success" ? `${(0, node_util.styleText)("green", `${plugins.passed} passed`)} (${plugins.total})` : `${(0, node_util.styleText)("green", `${plugins.passed} passed`)} | ${(0, node_util.styleText)("red", `${plugins.failed.length} failed`)} (${plugins.total})`]);
+	if (status === "failed" && plugins.failed.length > 0) rows.push(["Failed", plugins.failed.map((name) => randomCliColor(name)).join(", ")]);
+	if (counts.errors > 0 || counts.warnings > 0) {
+		const issues = [counts.errors > 0 ? (0, node_util.styleText)("red", `${counts.errors} ${counts.errors === 1 ? "error" : "errors"}`) : void 0, counts.warnings > 0 ? (0, node_util.styleText)("yellow", `${counts.warnings} ${counts.warnings === 1 ? "warning" : "warnings"}`) : void 0].filter(Boolean).join(" | ");
+		rows.push(["Issues", issues]);
+	}
+	rows.push(["Files", `${(0, node_util.styleText)("green", String(filesCreated))} generated`]);
+	rows.push(["Duration", (0, node_util.styleText)("green", require_memoryStorage.formatMs(durationMs))]);
+	rows.push(["Output", output]);
+	const labelWidth = Math.max(...rows.map(([label]) => label.length), timings.length > 0 ? 7 : 0);
+	const lines = rows.map(([label, value]) => `${(0, node_util.styleText)("dim", label.padStart(labelWidth))}  ${value}`);
+	if (showTimings && timings.length > 0) {
+		const nameWidth = Math.max(0, ...timings.map((timing) => timing.plugin.length));
+		const indent = " ".repeat(labelWidth + 2);
+		lines.push((0, node_util.styleText)("dim", "Timings".padStart(labelWidth)));
+		for (const timing of timings) {
+			const timeStr = require_memoryStorage.formatMs(timing.durationMs);
+			const barLength = Math.min(Math.ceil(timing.durationMs / 100), 10);
+			const bar = (0, node_util.styleText)("dim", "█".repeat(barLength));
+			lines.push(`${indent}${(0, node_util.styleText)("dim", "•")} ${timing.plugin.padEnd(nameWidth)} ${bar} ${timeStr}`);
+		}
+	}
+	return lines;
+}
+/**
+* Renders the summary as plain `console.log` lines so it works in every CLI (no clack/TTY
+* dependency): a blank line, the config name colored by status, then the summary rows.
+*/
+function renderSummary(lines, { title, status }) {
+	console.log("");
+	if (title) console.log((0, node_util.styleText)(status === "failed" ? "red" : "green", title));
+	for (const line of lines) console.log(line);
+}
+/**
+* The default `cli` reporter. Renders the {@link Report} for each config as it finishes, independent
+* of the live logger view. Suppressed at `silent`; the `verbose` level adds the per-plugin timings.
+*/
+const cliReporter = createReporter({
+	name: "cli",
+	report(result, { logLevel: logLevel$1 }) {
+		if (logLevel$1 <= logLevel.silent) return;
+		const report = buildReport(result);
+		renderSummary(buildSummaryLines(report, { showTimings: logLevel$1 >= logLevel.verbose }), {
+			title: report.name,
+			status: report.status
+		});
+	}
+});
+//#endregion
+//#region src/reporters/fileReporter.ts
+/**
+* Builds the `## Summary` section: the same counts the cli and json reporters expose, as a list of
+* `label  value` rows with the labels padded to a common width.
+*/
+function buildSummarySection(report) {
+	const { status, plugins, counts, filesCreated, durationMs, output } = report;
+	const rows = [["Status", status], ["Plugins", status === "success" ? `${plugins.passed} passed (${plugins.total})` : `${plugins.passed} passed | ${plugins.failed.length} failed (${plugins.total})`]];
+	if (plugins.failed.length > 0) rows.push(["Failed", plugins.failed.join(", ")]);
+	rows.push(["Issues", `${counts.errors} errors | ${counts.warnings} warnings | ${counts.infos} infos`]);
+	rows.push(["Files", `${filesCreated} generated`]);
+	rows.push(["Duration", require_memoryStorage.formatMs(durationMs)]);
+	rows.push(["Output", output]);
+	const labelWidth = Math.max(...rows.map(([label]) => label.length));
+	return [
+		"## Summary",
+		"",
+		...rows.map(([label, value]) => `  ${label.padEnd(labelWidth)}  ${value}`)
+	];
+}
+/**
+* Builds the `## Problems` section: each problem rendered in the miette block format, blocks
+* separated by a blank line. Returns an empty array when there are no problems, so the caller
+* can drop the heading.
+*/
+function buildProblemSection(diagnostics) {
+	const problems = diagnostics.filter(require_memoryStorage.Diagnostics.isProblem);
+	if (problems.length === 0) return [];
+	return [
+		"## Problems",
+		"",
+		problems.map((diagnostic) => require_memoryStorage.Diagnostics.formatLines(diagnostic).join("\n")).join("\n\n")
+	];
+}
+/**
+* Builds the `## Timings` section from a {@link Report}: one `plugin   duration` row per record,
+* slowest first with the plugin names left-aligned and the durations right-aligned. Returns an
+* empty array when there are no timings.
+*/
+function buildTimingSection(report) {
+	const { timings } = report;
+	if (timings.length === 0) return [];
+	const nameWidth = Math.max(...timings.map((timing) => timing.plugin.length));
+	const durations = timings.map((timing) => require_memoryStorage.formatMs(timing.durationMs));
+	const durationWidth = Math.max(...durations.map((duration) => duration.length));
+	return [
+		"## Timings",
+		"",
+		...timings.map((timing, index) => `  ${timing.plugin.padEnd(nameWidth)}  ${durations[index].padStart(durationWidth)}`)
+	];
+}
+/**
+* The `file` reporter. Writes a config's {@link Report} to `.kubb/kubb-<name>-<timestamp>.log` as a
+* plain-text document: a `# <name> — <timestamp>` header, a `## Summary` with the same counts the
+* cli and json reporters expose, a `## Problems` section in the miette block format, and a
+* `## Timings` section. Selected with `--reporter file` (or `reporters: ['file']`), replacing the
+* old `--debug` flag.
+*
+* @note Unlike the streaming logger it replaced, it captures the collected diagnostics once a
+* config finishes, not the live `kubb:info`/`kubb:plugin` event stream. Color is stripped so the
+* file stays plain text even when the run is attached to a TTY.
+*/
+const fileReporter = createReporter({
+	name: "file",
+	async report(result) {
+		const { diagnostics, config } = result;
+		if (diagnostics.length === 0) return;
+		const report = buildReport(result);
+		const content = (0, node_util.stripVTControlCharacters)([config.name ? `# ${config.name} — ${(/* @__PURE__ */ new Date()).toISOString()}` : `# ${(/* @__PURE__ */ new Date()).toISOString()}`, ...[
+			buildSummarySection(report),
+			buildProblemSection(diagnostics),
+			buildTimingSection(report)
+		].filter((section) => section.length > 0).map((section) => section.join("\n"))].join("\n\n"));
+		const baseName = `${[
+			"kubb",
+			config.name,
+			Date.now()
+		].filter(Boolean).join("-")}.log`;
+		const pathName = (0, node_path.resolve)(node_process.default.cwd(), ".kubb", baseName);
+		await write(pathName, `${content}\n`);
+		console.error(`Debug log written to ${(0, node_path.relative)(node_process.default.cwd(), pathName)}`);
+	}
+});
+//#endregion
+//#region src/reporters/jsonReporter.ts
+/**
+* The `json` reporter. `report` returns one config's {@link Report}, which {@link createReporter}
+* buffers, and `drain` writes them as a single pretty-printed JSON array on `kubb:lifecycle:end`.
+* Buffering keeps a multi-config run one valid JSON document on stdout instead of concatenated
+* objects that would break `jq .`. The terminal reporter is suppressed while `json` is active so
+* stdout stays valid JSON.
+*/
+const jsonReporter = createReporter({
+	name: "json",
+	report(result) {
+		return buildReport(result);
+	},
+	drain(_context, reports) {
+		node_process.default.stdout.write(`${JSON.stringify(reports, null, 2)}\n`);
+	}
+});
+//#endregion
+//#region src/Telemetry.ts
+/**
+* Anonymous OTLP usage telemetry for the Kubb run. All methods are static, so call them as
+* `Telemetry.build(...)`, `Telemetry.send(...)`, and `Telemetry.isDisabled()`. No file paths,
+* OpenAPI specs, or secrets are ever included, and sending fails silently to never break a run.
+*/
+var Telemetry = class Telemetry {
+	/**
+	* Returns `true` when telemetry is disabled via `DO_NOT_TRACK` or `KUBB_DISABLE_TELEMETRY`.
+	*/
+	static isDisabled() {
+		return node_process.default.env["DO_NOT_TRACK"] === "1" || node_process.default.env["DO_NOT_TRACK"] === "true" || node_process.default.env["KUBB_DISABLE_TELEMETRY"] === "1" || node_process.default.env["KUBB_DISABLE_TELEMETRY"] === "true";
+	}
+	/**
+	* Build an anonymous telemetry payload from a completed generation run.
+	*/
+	static build(options) {
+		const [seconds, nanoseconds] = node_process.default.hrtime(options.hrStart);
+		const duration = Math.round(seconds * 1e3 + nanoseconds / 1e6);
+		return {
+			command: options.command,
+			kubbVersion: options.kubbVersion,
+			nodeVersion: node_process.default.versions.node.split(".")[0],
+			platform: node_os.default.platform(),
+			ci: isCIEnvironment(),
+			plugins: options.plugins ?? [],
+			duration,
+			filesCreated: options.filesCreated ?? 0,
+			status: options.status
+		};
+	}
+	/**
+	* Convert a {@link TelemetryEvent} into an OTLP-compatible JSON trace payload.
+	* See https://opentelemetry.io/docs/languages/sdk-configuration/otlp-exporter/
+	*/
+	static buildOtlpPayload(event) {
+		const traceId = (0, node_crypto.randomBytes)(16).toString("hex");
+		const spanId = (0, node_crypto.randomBytes)(8).toString("hex");
+		const endTimeNs = BigInt(Date.now()) * 1000000n;
+		const startTimeNs = endTimeNs - BigInt(event.duration) * 1000000n;
+		const attributes = [
+			{
+				key: "kubb.command",
+				value: { stringValue: event.command }
+			},
+			{
+				key: "kubb.version",
+				value: { stringValue: event.kubbVersion }
+			},
+			{
+				key: "kubb.node_version",
+				value: { stringValue: event.nodeVersion }
+			},
+			{
+				key: "kubb.platform",
+				value: { stringValue: event.platform }
+			},
+			{
+				key: "kubb.ci",
+				value: { boolValue: event.ci }
+			},
+			{
+				key: "kubb.files_created",
+				value: { intValue: event.filesCreated }
+			},
+			{
+				key: "kubb.status",
+				value: { stringValue: event.status }
+			},
+			{
+				key: "kubb.plugins",
+				value: { arrayValue: { values: event.plugins.map((p) => ({ kvlistValue: { values: [{
+					key: "name",
+					value: { stringValue: p.name }
+				}, {
+					key: "options",
+					value: { stringValue: JSON.stringify({
+						...p.options,
+						usedEnumNames: void 0
+					}) }
+				}] } })) } }
+			}
+		];
+		return { resourceSpans: [{
+			resource: { attributes: [
+				{
+					key: "service.name",
+					value: { stringValue: "kubb-core" }
+				},
+				{
+					key: "service.version",
+					value: { stringValue: event.kubbVersion }
+				},
+				{
+					key: "telemetry.sdk.language",
+					value: { stringValue: "nodejs" }
+				}
+			] },
+			scopeSpans: [{
+				scope: {
+					name: "kubb-core",
+					version: event.kubbVersion
+				},
+				spans: [{
+					traceId,
+					spanId,
+					name: event.command,
+					kind: 1,
+					startTimeUnixNano: String(startTimeNs),
+					endTimeUnixNano: String(endTimeNs),
+					attributes,
+					status: { code: event.status === "success" ? 1 : 2 }
+				}]
+			}]
+		}] };
+	}
+	/**
+	* Send an anonymous telemetry event to the Kubb OTLP endpoint. Respects `DO_NOT_TRACK` and
+	* `KUBB_DISABLE_TELEMETRY`, and fails silently so telemetry never interrupts a run.
+	*/
+	static async send(event) {
+		if (Telemetry.isDisabled()) return;
+		await executeIfOnline(async () => {
+			try {
+				await fetch(`${require_memoryStorage.OTLP_ENDPOINT}/v1/traces`, {
+					method: "POST",
+					headers: {
+						"Content-Type": "application/json",
+						"Kubb-Telemetry-Version": "1",
+						"Kubb-Telemetry-Source": "kubb-core"
+					},
+					body: JSON.stringify(Telemetry.buildOtlpPayload(event)),
+					signal: AbortSignal.timeout(5e3)
+				});
+			} catch (_e) {}
+		});
+	}
+};
 //#endregion
 //#region src/createRenderer.ts
 /**
@@ -499,43 +971,6 @@ function defineGenerator(generator) {
 	return generator;
 }
 //#endregion
-//#region src/defineLogger.ts
-/**
-* Defines a typed logger. Use the second type parameter to declare a return
-* value from `install`, which is handy when the logger exposes a sink factory
-* or cleanup callback to the caller.
-*
-* @example Basic logger
-* ```ts
-* import { defineLogger } from '@kubb/core'
-*
-* export const myLogger = defineLogger({
-*   name: 'my-logger',
-*   install(context) {
-*     context.on('kubb:info', ({ message }) => console.log('ℹ', message))
-*     context.on('kubb:error', ({ error }) => console.error('✗', error.message))
-*   },
-* })
-* ```
-*
-* @example Logger that returns a hook sink factory
-* ```ts
-* import { defineLogger, type LoggerOptions } from '@kubb/core'
-* import type { HookSinkFactory } from './sinks'
-*
-* export const myLogger = defineLogger<LoggerOptions, HookSinkFactory>({
-*   name: 'my-logger',
-*   install(context) {
-*     // … register event handlers …
-*     return () => ({ onStdout: console.log })
-*   },
-* })
-* ```
-*/
-function defineLogger(logger) {
-	return logger;
-}
-//#endregion
 //#region src/defineMiddleware.ts
 /**
 * Creates a middleware factory. Middleware fires after every plugin handler
@@ -607,89 +1042,33 @@ function defineParser(parser) {
 	return parser;
 }
 //#endregion
-//#region src/storages/memoryStorage.ts
-/**
-* In-memory storage driver. Useful for testing and dry-run scenarios where
-* generated output should be captured without touching the filesystem.
-*
-* All data lives in a `Map` scoped to the storage instance and is discarded
-* when the instance is garbage-collected.
-*
-* @example
-* ```ts
-* import { memoryStorage } from '@kubb/core'
-* import { defineConfig } from 'kubb'
-*
-* export default defineConfig({
-*   input:  { path: './petStore.yaml' },
-*   output: { path: './src/gen' },
-*   storage: memoryStorage(),
-* })
-* ```
-*/
-const memoryStorage = createStorage(() => {
-	const store = /* @__PURE__ */ new Map();
-	return {
-		name: "memory",
-		async hasItem(key) {
-			return store.has(key);
-		},
-		async getItem(key) {
-			return store.get(key) ?? null;
-		},
-		async setItem(key, value) {
-			store.set(key, value);
-		},
-		async removeItem(key) {
-			store.delete(key);
-		},
-		async getKeys(base) {
-			const keys = [...store.keys()];
-			return base ? keys.filter((k) => k.startsWith(base)) : keys;
-		},
-		async clear(base) {
-			if (!base) {
-				store.clear();
-				return;
-			}
-			for (const key of store.keys()) if (key.startsWith(base)) store.delete(key);
-		}
-	};
-});
-//#endregion
-exports.AsyncEventEmitter = require_KubbDriver.AsyncEventEmitter;
-exports.DiagnosticError = require_KubbDriver.DiagnosticError;
-exports.Diagnostics = require_KubbDriver.Diagnostics;
-exports.FileManager = require_KubbDriver.FileManager;
-exports.FileProcessor = require_KubbDriver.FileProcessor;
-exports.KubbDriver = require_KubbDriver.KubbDriver;
-exports.URLPath = require_KubbDriver.URLPath;
+exports.AsyncEventEmitter = require_memoryStorage.AsyncEventEmitter;
+exports.Diagnostics = require_memoryStorage.Diagnostics;
+exports.KubbDriver = require_memoryStorage.KubbDriver;
+exports.Telemetry = Telemetry;
 Object.defineProperty(exports, "ast", {
 	enumerable: true,
 	get: function() {
 		return _kubb_ast;
 	}
 });
+exports.cliReporter = cliReporter;
 exports.createAdapter = createAdapter;
 exports.createKubb = createKubb;
 exports.createRenderer = createRenderer;
 exports.createReporter = createReporter;
-exports.createStorage = createStorage;
+exports.createStorage = require_memoryStorage.createStorage;
 exports.defineGenerator = defineGenerator;
 exports.defineLogger = defineLogger;
 exports.defineMiddleware = defineMiddleware;
 exports.defineParser = defineParser;
-exports.definePlugin = require_KubbDriver.definePlugin;
-exports.defineResolver = require_KubbDriver.defineResolver;
-exports.diagnosticCatalog = require_KubbDriver.diagnosticCatalog;
-exports.diagnosticCode = require_KubbDriver.diagnosticCode;
+exports.definePlugin = require_memoryStorage.definePlugin;
+exports.defineResolver = require_memoryStorage.defineResolver;
+exports.fileReporter = fileReporter;
 exports.fsStorage = fsStorage;
-exports.isInputPath = isInputPath;
-exports.isPerformanceDiagnostic = require_KubbDriver.isPerformanceDiagnostic;
-exports.isProblemDiagnostic = require_KubbDriver.isProblemDiagnostic;
-exports.isUpdateDiagnostic = require_KubbDriver.isUpdateDiagnostic;
-exports.logLevel = require_KubbDriver.logLevel;
-exports.memoryStorage = memoryStorage;
-exports.narrowDiagnostic = require_KubbDriver.narrowDiagnostic;
+exports.jsonReporter = jsonReporter;
+exports.logLevel = logLevel;
+exports.memoryStorage = require_memoryStorage.memoryStorage;
+exports.selectReporters = selectReporters;
 
 //# sourceMappingURL=index.cjs.map