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

package/dist/{KubbDriver-CyNF-NIb.js → memoryStorage-CNQTs-YG.js}

@@ -1,10 +1,9 @@
 import "./chunk-C0LytTxp.js";
 import { EventEmitter } from "node:events";
+import { styleText } from "node:util";
 import path, { extname, resolve } from "node:path";
 import { collectUsedSchemaNames, createFile, createStreamInput, extractStringsFromNodes, isOperationNode, isSchemaNode, transform } from "@kubb/ast";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { deflateSync } from "fflate";
-import { x } from "tinyexec";
 //#region ../../internals/utils/src/errors.ts
 /**
 * Thrown when one or more errors occur during a Kubb build.
@@ -259,6 +258,21 @@ function getElapsedMs(hrStart) {
 	const ms = seconds * 1e3 + nanoseconds / 1e6;
 	return Math.round(ms * 100) / 100;
 }
+/**
+* Converts a millisecond duration into a human-readable string (`ms`, `s`, or `m s`).
+*
+* @example
+* ```ts
+* formatMs(250)   // '250ms'
+* formatMs(1500)  // '1.50s'
+* formatMs(90000) // '1m 30.0s'
+* ```
+*/
+function formatMs(ms) {
+	if (ms >= 6e4) return `${Math.floor(ms / 6e4)}m ${(ms % 6e4 / 1e3).toFixed(1)}s`;
+	if (ms >= 1e3) return `${(ms / 1e3).toFixed(2)}s`;
+	return `${Math.round(ms)}ms`;
+}
 //#endregion
 //#region ../../internals/utils/src/promise.ts
 function* chunks(arr, size) {
@@ -620,11 +634,14 @@ var URLPath = class {
 	}
 };
 //#endregion
+//#region package.json
+var version = "5.0.0-beta.39";
+//#endregion
 //#region src/constants.ts
 /**
-* Base URL for the Kubb Studio web app.
+* OpenTelemetry ingestion endpoint for anonymous usage telemetry.
 */
-const DEFAULT_STUDIO_URL = "https://kubb.studio";
+const OTLP_ENDPOINT = "https://otlp.kubb.dev";
 /**
 * Plugin `include` filter types that select operations directly. When one of these is set
 * without a `schemaName` include, the generate phase pre-scans operations to compute the set
@@ -638,18 +655,6 @@ const OPERATION_FILTER_TYPES = new Set([
 	"contentType"
 ]);
 /**
-* 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
-};
-/**
 * Stable codes Kubb attaches to a `Diagnostic`. Each maps to a known failure mode
 * and stays stable so it can be referenced in tooling and (later) docs. Reference
 * these instead of inlining the string at a throw site.
@@ -707,10 +712,6 @@ const diagnosticCode = {
 	*/
 	adapterRequired: "KUBB_ADAPTER_REQUIRED",
 	/**
-	* The `devtools` config is set to something other than an object.
-	*/
-	devtoolsInvalid: "KUBB_DEVTOOLS_INVALID",
-	/**
 	* A resolved output path escapes the output directory, which can stem from a path
 	* traversal in the spec or a misconfigured `group.name`.
 	*/
@@ -741,19 +742,19 @@ const diagnosticCode = {
 /**
 * Docs major, derived from the package version so the link tracks the published major.
 */
-const docsMajor = "5.0.0-beta.38".split(".")[0] ?? "5";
+const docsMajor = version.split(".")[0] ?? "5";
 /**
 * Narrows a {@link Diagnostic} to the variant for `code`, or `null` when it does not match.
 *
 * @example
 * ```ts
-* const update = narrowDiagnostic(diagnostic, diagnosticCode.updateAvailable)
+* const update = narrow(diagnostic, diagnosticCode.updateAvailable)
 * if (update) {
 *   console.log(update.latestVersion)
 * }
 * ```
 */
-function narrowDiagnostic(diagnostic, code) {
+function narrow(diagnostic, code) {
 	return diagnostic.code === code ? diagnostic : null;
 }
 /**
@@ -768,59 +769,51 @@ function isKind(kind) {
 *
 * @example
 * ```ts
-* if (isProblemDiagnostic(diagnostic)) {
+* if (isProblem(diagnostic)) {
 *   console.log(diagnostic.location)
 * }
 * ```
 */
-const isProblemDiagnostic = isKind("problem");
+const isProblem = isKind("problem");
 /**
 * Returns `true` when the diagnostic is a per-plugin {@link PerformanceDiagnostic}.
 *
 * @example
 * ```ts
-* const timings = diagnostics.filter(isPerformanceDiagnostic)
+* const timings = diagnostics.filter(isPerformance)
 * ```
 */
-const isPerformanceDiagnostic = isKind("performance");
+const isPerformance = isKind("performance");
 /**
 * Returns `true` when the diagnostic is a version-update {@link UpdateDiagnostic}.
 *
 * @example
 * ```ts
-* if (isUpdateDiagnostic(diagnostic)) {
+* if (isUpdate(diagnostic)) {
 *   console.log(diagnostic.latestVersion)
 * }
 * ```
 */
-const isUpdateDiagnostic = isKind("update");
+const isUpdate = isKind("update");
 /**
-* An `Error` that carries a {@link Diagnostic}, so structured problems can flow
-* through the existing throw/catch paths while keeping their code and location.
-*
-* @example
-* ```ts
-* throw new DiagnosticError({ code: diagnosticCode.refNotFound, severity: 'error', message: `Could not find ${ref}`, location: { kind: 'schema', pointer: ref, ref } })
-* ```
+* Glyph and accent color per severity, matching the miette/oxlint convention
+* (`×` error, `⚠` warning, `ℹ` advice).
 */
-var DiagnosticError = class extends Error {
-	diagnostic;
-	constructor(diagnostic) {
-		super(diagnostic.message, { cause: diagnostic.cause });
-		this.name = "DiagnosticError";
-		this.diagnostic = diagnostic;
+const severityStyle = {
+	error: {
+		glyph: "×",
+		color: "red"
+	},
+	warning: {
+		glyph: "⚠",
+		color: "yellow"
+	},
+	info: {
+		glyph: "ℹ",
+		color: "blue"
 	}
 };
 /**
-* Structural check for a {@link DiagnosticError}, including one thrown from a duplicated
-* `@kubb/core` copy where `instanceof` fails. Matches on the `name` and a `diagnostic`
-* that carries a `code`.
-*/
-function isDiagnosticError(error) {
-	if (error instanceof DiagnosticError) return true;
-	return error instanceof Error && error.name === "DiagnosticError" && "diagnostic" in error && typeof error.diagnostic === "object" && error.diagnostic !== null && typeof error.diagnostic?.code === "string";
-}
-/**
 * Explanation for every {@link diagnosticCode}. Use {@link Diagnostics.explain} to look one up
 * and `Diagnostics.docsUrl` for the matching kubb.dev page.
 */
@@ -882,14 +875,9 @@ const diagnosticCatalog = {
 	},
 	[diagnosticCode.adapterRequired]: {
 		title: "Adapter required",
-		cause: "An action needs an adapter (for example opening Kubb Studio) but none is configured.",
+		cause: "An action needs an adapter but none is configured.",
 		fix: "Set `adapter` in kubb.config.ts, for example `adapterOas()`."
 	},
-	[diagnosticCode.devtoolsInvalid]: {
-		title: "Invalid devtools config",
-		cause: "The `devtools` config is set to something other than an object.",
-		fix: "Set `devtools` to an options object, or remove it to disable Kubb Studio."
-	},
 	[diagnosticCode.pathTraversal]: {
 		title: "Path traversal",
 		cause: "A resolved output path escaped the output directory, which can stem from a path traversal in the spec or a misconfigured `group.name`.",
@@ -933,6 +921,52 @@ const diagnosticCatalog = {
 var Diagnostics = class Diagnostics {
 	static #reporterStorage = new AsyncLocalStorage();
 	/**
+	* The diagnostic code catalog, exposed as `Diagnostics.code` (e.g. `Diagnostics.code.refNotFound`).
+	*/
+	static code = diagnosticCode;
+	/**
+	* Type guard for a build {@link ProblemDiagnostic}.
+	*/
+	static isProblem = isProblem;
+	/**
+	* Type guard for a version-update {@link UpdateDiagnostic}.
+	*/
+	static isUpdate = isUpdate;
+	/**
+	* Type guard for a per-plugin {@link PerformanceDiagnostic}.
+	*/
+	static isPerformance = isPerformance;
+	/**
+	* Narrows a {@link Diagnostic} to the variant for `code`, or `null` when it does not match.
+	*/
+	static narrow = narrow;
+	/**
+	* An `Error` that carries a {@link Diagnostic}, so structured problems can flow
+	* through the existing throw/catch paths while keeping their code and location.
+	*
+	* @example
+	* ```ts
+	* throw new Diagnostics.Error({ code: diagnosticCode.refNotFound, severity: 'error', message: `Could not find ${ref}`, location: { kind: 'schema', pointer: ref, ref } })
+	* ```
+	*/
+	static Error = class DiagnosticError extends Error {
+		diagnostic;
+		constructor(diagnostic) {
+			super(diagnostic.message, { cause: diagnostic.cause });
+			this.name = "DiagnosticError";
+			this.diagnostic = diagnostic;
+		}
+	};
+	/**
+	* Structural check for a {@link Diagnostics.Error}, including one thrown from a duplicated
+	* `@kubb/core` copy where `instanceof` fails. Matches on the `name` and a `diagnostic`
+	* that carries a `code`.
+	*/
+	static isError(error) {
+		if (error instanceof Diagnostics.Error) return true;
+		return error instanceof Error && error.name === "DiagnosticError" && "diagnostic" in error && typeof error.diagnostic === "object" && error.diagnostic !== null && typeof error.diagnostic?.code === "string";
+	}
+	/**
 	* Runs `fn` with `sink` as the active diagnostic sink for the whole async
 	* subtree, so {@link Diagnostics.report} reaches it from anywhere inside.
 	*/
@@ -960,7 +994,7 @@ var Diagnostics = class Diagnostics {
 		await hooks.emit("kubb:diagnostic", { diagnostic });
 	}
 	/**
-	* Coerces any thrown value into a {@link ProblemDiagnostic}. A {@link DiagnosticError}
+	* Coerces any thrown value into a {@link ProblemDiagnostic}. A {@link Diagnostics.Error}
 	* keeps its structured data, and anything else becomes a `KUBB_UNKNOWN` error.
 	*/
 	static from(error) {
@@ -968,7 +1002,7 @@ var Diagnostics = class Diagnostics {
 		let current = error;
 		let root;
 		while (current instanceof Error && !seen.has(current)) {
-			if (isDiagnosticError(current)) return current.diagnostic;
+			if (Diagnostics.isError(current)) return current.diagnostic;
 			seen.add(current);
 			root = current;
 			current = current.cause;
@@ -1031,7 +1065,7 @@ var Diagnostics = class Diagnostics {
 		let warnings = 0;
 		let infos = 0;
 		for (const diagnostic of diagnostics) {
-			if (!isProblemDiagnostic(diagnostic)) continue;
+			if (!isProblem(diagnostic)) continue;
 			if (diagnostic.severity === "error") errors += 1;
 			else if (diagnostic.severity === "warning") warnings += 1;
 			else infos += 1;
@@ -1051,7 +1085,7 @@ var Diagnostics = class Diagnostics {
 		const seen = /* @__PURE__ */ new Set();
 		const result = [];
 		for (const diagnostic of diagnostics) {
-			if (!isProblemDiagnostic(diagnostic)) {
+			if (!isProblem(diagnostic)) {
 				result.push(diagnostic);
 				continue;
 			}
@@ -1083,7 +1117,7 @@ var Diagnostics = class Diagnostics {
 	* fields are omitted rather than set to `undefined`.
 	*/
 	static serialize(diagnostic) {
-		const problem = isProblemDiagnostic(diagnostic) ? diagnostic : void 0;
+		const problem = isProblem(diagnostic) ? diagnostic : void 0;
 		return {
 			code: diagnostic.code,
 			severity: diagnostic.severity,
@@ -1094,8 +1128,82 @@ var Diagnostics = class Diagnostics {
 			...diagnostic.code === diagnosticCode.unknown ? {} : { docsUrl: Diagnostics.docsUrl(diagnostic.code) }
 		};
 	}
+	/**
+	* Renders a {@link Diagnostic} for terminal output as its parts: the colored severity `symbol`
+	* (the gutter glyph), the `plugin(CODE): message` `headline`, and the `details` lines (optional
+	* `at <pointer>`, `help:`, and `docs:`).
+	*
+	* Hosts compose these to fit their gutter: a clack logger passes `symbol` as its own gutter and
+	* `[headline, ...details]` as the message, while plain text outputs use {@link Diagnostics.formatLines}.
+	*/
+	static format(diagnostic) {
+		const { code, severity, message } = diagnostic;
+		const { glyph, color } = severityStyle[severity];
+		const problem = isProblem(diagnostic) ? diagnostic : void 0;
+		const rule = styleText(color, styleText("bold", problem?.plugin ? `${problem.plugin}(${code})` : code));
+		const details = [];
+		if (problem?.location && "pointer" in problem.location) details.push(`  ${styleText("dim", "at")} ${styleText("cyan", problem.location.pointer)}`);
+		if (problem?.help) details.push(`  ${styleText("cyan", "help:")} ${problem.help}`);
+		if (code !== diagnosticCode.unknown) details.push(`  ${styleText("dim", "docs:")} ${styleText("cyan", Diagnostics.docsUrl(code))}`);
+		return {
+			symbol: styleText(color, styleText("bold", glyph)),
+			headline: `${rule}: ${message}`,
+			details
+		};
+	}
+	/**
+	* The self-contained block form of {@link Diagnostics.format}: `${symbol} ${headline}` followed by
+	* the detail lines. Used where there is no gutter to own the symbol (plain and file output).
+	*/
+	static formatLines(diagnostic) {
+		const { symbol, headline, details } = Diagnostics.format(diagnostic);
+		return [`${symbol} ${headline}`, ...details];
+	}
 };
 //#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/definePlugin.ts
 /**
 * Wraps a plugin factory and returns a function that accepts user options and
@@ -1323,8 +1431,8 @@ function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }, { root
 	})();
 	const outputDir = path.resolve(root, output.path);
 	const outputDirWithSep = outputDir.endsWith(path.sep) ? outputDir : `${outputDir}${path.sep}`;
-	if (result !== outputDir && !result.startsWith(outputDirWithSep)) throw new DiagnosticError({
-		code: diagnosticCode.pathTraversal,
+	if (result !== outputDir && !result.startsWith(outputDirWithSep)) throw new Diagnostics.Error({
+		code: Diagnostics.code.pathTraversal,
 		severity: "error",
 		message: `Resolved path "${result}" is outside the output directory "${outputDir}".`,
 		help: "This can stem from a path traversal in the OpenAPI specification or a misconfigured `group.name` function. Keep generated paths within the output directory.",
@@ -1548,47 +1656,6 @@ function defineResolver(build) {
 	return resolver;
 }
 //#endregion
-//#region src/devtools.ts
-/**
-* Encodes an `InputNode` as a compressed, URL-safe string.
-*
-* The JSON representation is deflate-compressed with {@link deflateSync} before
-* base64url encoding, which typically reduces payload size by 70, 80 % and
-* keeps URLs well within browser and server path-length limits.
-*/
-function encodeAst(input) {
-	const compressed = deflateSync(new TextEncoder().encode(JSON.stringify(input)));
-	return Buffer.from(compressed).toString("base64url");
-}
-/**
-* Constructs the Kubb Studio URL for the given `InputNode`.
-* When `options.ast` is `true`, navigates to the AST inspector (`/ast`).
-* The `input` is encoded and attached as the `?root=` query parameter so Studio
-* can decode and render it without a round-trip to any server.
-*/
-function getStudioUrl(input, studioUrl, options = {}) {
-	return `${studioUrl.replace(/\/$/, "")}${options.ast ? "/ast" : ""}?root=${encodeAst(input)}`;
-}
-/**
-* Opens the Kubb Studio URL for the given `InputNode` in the default browser,  *
-* Falls back to printing the URL if the browser cannot be launched.
-*/
-async function openInStudio(input, studioUrl, options = {}) {
-	const url = getStudioUrl(input, studioUrl, options);
-	const cmd = process.platform === "win32" ? "cmd" : process.platform === "darwin" ? "open" : "xdg-open";
-	const args = process.platform === "win32" ? [
-		"/c",
-		"start",
-		"",
-		url
-	] : [url];
-	try {
-		await x(cmd, args);
-	} catch {
-		console.log(`\n  ${url}\n`);
-	}
-}
-//#endregion
 //#region src/FileManager.ts
 function mergeFile(a, b) {
 	return {
@@ -1994,19 +2061,10 @@ var KubbDriver = class KubbDriver {
 	inputNode = null;
 	adapter = null;
 	/**
-	* Studio session state, kept together so `dispose()` can reset it atomically.
-	*
-	* - `source` holds the raw adapter source so `adapter.parse()` can be called lazily.
-	*   Intentionally outlives the build, cleared by `dispose()`.
-	* - `isOpen` prevents opening the studio more than once per build.
-	* - `inputNode` caches the parse promise so `adapter.parse()` is called at most once
-	*   per studio session, even when `openInStudio()` is called multiple times.
-	*/
-	#studio = {
-		source: null,
-		isOpen: false,
-		inputNode: null
-	};
+	* Raw adapter source so `adapter.parse()` / `adapter.stream()` can run lazily.
+	* Intentionally outlives the build, cleared by `dispose()`.
+	*/
+	#adapterSource = null;
 	/**
 	* Central file store for all generated files.
 	* Plugins should use `this.addFile()` / `this.upsertFile()` (via their context) to
@@ -2051,7 +2109,7 @@ var KubbDriver = class KubbDriver {
 			this.plugins.set(plugin.name, plugin);
 		}
 		if (this.config.middleware) for (const middleware of this.config.middleware) for (const event of Object.keys(middleware.hooks)) this.#registerMiddleware(event, middleware.hooks);
-		if (this.config.adapter) this.#studio.source = inputToAdapterSource(this.config);
+		if (this.config.adapter) this.#adapterSource = inputToAdapterSource(this.config);
 	}
 	get hooks() {
 		return this.options.hooks;
@@ -2077,14 +2135,14 @@ var KubbDriver = class KubbDriver {
 	}
 	/**
 	* Parses the adapter source into `this.inputNode`. Idempotent, so repeated calls from
-	* `run` or the studio path do not re-parse. Adapters with `stream()` are used directly.
+	* `run` do not re-parse. Adapters with `stream()` are used directly.
 	* Adapters with only `parse()` are wrapped via `createStreamInput` so the dispatch loop
 	* stays stream-only.
 	*/
 	async #parseInput() {
-		if (this.inputNode || !this.adapter || !this.#studio.source) return;
+		if (this.inputNode || !this.adapter || !this.#adapterSource) return;
 		const adapter = this.adapter;
-		const source = this.#studio.source;
+		const source = this.#adapterSource;
 		if (adapter.stream) {
 			this.inputNode = await adapter.stream(source);
 			return;
@@ -2607,11 +2665,7 @@ var KubbDriver = class KubbDriver {
 		this.#defaultResolvers.clear();
 		this.fileManager.dispose();
 		this.inputNode = null;
-		this.#studio = {
-			source: null,
-			isOpen: false,
-			inputNode: null
-		};
+		this.#adapterSource = null;
 	}
 	[Symbol.dispose]() {
 		this.dispose();
@@ -2682,7 +2736,7 @@ var KubbDriver = class KubbDriver {
 			},
 			warn(message) {
 				report({
-					code: diagnosticCode.pluginWarning,
+					code: Diagnostics.code.pluginWarning,
 					severity: "warning",
 					message
 				});
@@ -2690,7 +2744,7 @@ var KubbDriver = class KubbDriver {
 			error(error) {
 				const cause = typeof error === "string" ? void 0 : error;
 				report({
-					code: diagnosticCode.pluginFailed,
+					code: Diagnostics.code.pluginFailed,
 					severity: "error",
 					message: typeof error === "string" ? error : error.message,
 					cause
@@ -2698,31 +2752,10 @@ var KubbDriver = class KubbDriver {
 			},
 			info(message) {
 				report({
-					code: diagnosticCode.pluginInfo,
+					code: Diagnostics.code.pluginInfo,
 					severity: "info",
 					message
 				});
-			},
-			async openInStudio(options) {
-				if (!driver.config.devtools || driver.#studio.isOpen) return;
-				if (typeof driver.config.devtools !== "object") throw new DiagnosticError({
-					code: diagnosticCode.devtoolsInvalid,
-					severity: "error",
-					message: "The `devtools` config must be an object.",
-					help: "Set `devtools` to an options object, or remove it to disable Kubb Studio.",
-					location: { kind: "config" }
-				});
-				if (!driver.adapter || !driver.#studio.source) throw new DiagnosticError({
-					code: diagnosticCode.adapterRequired,
-					severity: "error",
-					message: "An adapter is required to open Kubb Studio, but none is configured.",
-					help: "Set `adapter` in kubb.config.ts (for example `adapterOas()`).",
-					location: { kind: "config" }
-				});
-				driver.#studio.isOpen = true;
-				const studioUrl = driver.config.devtools?.studioUrl ?? "https://kubb.studio";
-				driver.#studio.inputNode ??= Promise.resolve(driver.adapter.parse(driver.#studio.source));
-				return openInStudio(await driver.#studio.inputNode, studioUrl, options);
 			}
 		};
 	}
@@ -2731,8 +2764,8 @@ var KubbDriver = class KubbDriver {
 	}
 	requirePlugin(pluginName) {
 		const plugin = this.plugins.get(pluginName);
-		if (!plugin) throw new DiagnosticError({
-			code: diagnosticCode.pluginNotFound,
+		if (!plugin) throw new Diagnostics.Error({
+			code: Diagnostics.code.pluginNotFound,
 			severity: "error",
 			message: `Plugin "${pluginName}" is required but not found. Make sure it is included in your Kubb config.`,
 			help: `Add "${pluginName}" to the \`plugins\` array in kubb.config.ts, or remove the dependency on it.`,
@@ -2743,8 +2776,8 @@ var KubbDriver = class KubbDriver {
 };
 function inputToAdapterSource(config) {
 	const input = config.input;
-	if (!input) throw new DiagnosticError({
-		code: diagnosticCode.inputRequired,
+	if (!input) throw new Diagnostics.Error({
+		code: Diagnostics.code.inputRequired,
 		severity: "error",
 		message: "An adapter is configured without an input.",
 		help: "Provide `input.path` (a file or URL) or `input.data` (an inline spec) in your Kubb config.",
@@ -2764,6 +2797,56 @@ function inputToAdapterSource(config) {
 	};
 }
 //#endregion
-export { URLPath as _, defineResolver as a, Diagnostics as c, isProblemDiagnostic as d, isUpdateDiagnostic as f, logLevel as g, diagnosticCode as h, FileManager as i, diagnosticCatalog as l, DEFAULT_STUDIO_URL as m, _usingCtx as n, definePlugin as o, narrowDiagnostic as p, FileProcessor as r, DiagnosticError as s, KubbDriver as t, isPerformanceDiagnostic as u, AsyncEventEmitter as v, BuildError as y };
+//#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
+export { FileManager as a, createStorage as c, formatMs as d, getElapsedMs as f, BuildError as h, FileProcessor as i, Diagnostics as l, AsyncEventEmitter as m, KubbDriver as n, defineResolver as o, camelCase as p, _usingCtx as r, definePlugin as s, memoryStorage as t, OTLP_ENDPOINT as u };
 
-//# sourceMappingURL=KubbDriver-CyNF-NIb.js.map
+//# sourceMappingURL=memoryStorage-CNQTs-YG.js.map