@kubb/core 5.0.0-beta.54 → 5.0.0-beta.55

package/dist/index.js

@@ -1,9 +1,9 @@
 import "./chunk-C0LytTxp.js";
-import { a as createStorage, c as camelCase, d as BuildError, f as getErrorMessage, i as FileManager, l as pascalCase, n as _usingCtx, o as OPERATION_FILTER_TYPES, r as FileProcessor, s as diagnosticCode, t as memoryStorage, u as AsyncEventEmitter } from "./memoryStorage-Bdv42rxp.js";
-import { createHash, hash } from "node:crypto";
+import { a as createStorage, c as camelCase, d as BuildError, f as getErrorMessage, i as FileManager, l as pascalCase, n as _usingCtx, o as OPERATION_FILTER_TYPES, r as FileProcessor, s as diagnosticCode, t as memoryStorage, u as AsyncEventEmitter } from "./memoryStorage-B0W-w994.js";
+import { hash } from "node:crypto";
 import { stripVTControlCharacters, styleText } from "node:util";
 import { access, glob, mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import path, { basename, dirname, join, relative, resolve } from "node:path";
+import path, { dirname, join, relative, resolve } from "node:path";
 import * as ast from "@kubb/ast";
 import { collectUsedSchemaNames, createFile, createStreamInput, isOperationNode, isSchemaNode, transform } from "@kubb/ast";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -96,37 +96,75 @@ function randomCliColor(text) {
 //#endregion
 //#region ../../internals/utils/src/runtime.ts
 /**
-* Returns `true` when the current process is running under Bun.
+* Detects the JavaScript runtime executing the current process and exposes its name and version.
 *
-* Detection keys off the global `Bun` object rather than `process.versions`,
-* because Bun polyfills `process.versions.node` for Node compatibility and would
-* otherwise look like Node.
-*
-* @example
-* ```ts
-* if (isBun()) {
-*   await Bun.write(path, data)
-* }
-* ```
+* Prefer the shared {@link runtime} instance over constructing your own.
 */
-function isBun() {
-	return typeof Bun !== "undefined";
-}
-//#endregion
-//#region ../../internals/utils/src/fs.ts
+var Runtime = class {
+	/**
+	* `true` when the current process is running under Bun.
+	*
+	* Detection keys off the global `Bun` object rather than `process.versions`,
+	* because Bun polyfills `process.versions.node` for Node compatibility and would
+	* otherwise look like Node.
+	*
+	* @example
+	* ```ts
+	* if (runtime.isBun) {
+	*   await Bun.write(path, data)
+	* }
+	* ```
+	*/
+	get isBun() {
+		return typeof Bun !== "undefined";
+	}
+	/**
+	* `true` when the current process is running under Deno.
+	*/
+	get isDeno() {
+		return typeof globalThis.Deno !== "undefined";
+	}
+	/**
+	* `true` when the current process is running under Node.
+	*
+	* Bun and Deno are excluded first so a polyfilled `process` does not register as Node.
+	*/
+	get isNode() {
+		return !this.isBun && !this.isDeno && typeof process !== "undefined" && process.versions?.node != null;
+	}
+	/**
+	* Name of the runtime executing the current process.
+	*
+	* @example
+	* ```ts
+	* runtime.name // 'bun' when run with `bun kubb`, 'node' otherwise
+	* ```
+	*/
+	get name() {
+		if (this.isBun) return "bun";
+		if (this.isDeno) return "deno";
+		return "node";
+	}
+	/**
+	* Version of the active runtime, or an empty string when it cannot be read.
+	*
+	* @example
+	* ```ts
+	* runtime.version // '1.3.11' under Bun, '22.22.2' under Node
+	* ```
+	*/
+	get version() {
+		if (this.isBun) return process.versions.bun ?? "";
+		if (this.isDeno) return globalThis.Deno?.version?.deno ?? "";
+		return process.versions?.node ?? "";
+	}
+};
 /**
-* Reads the file at `path` as a UTF-8 string.
-* Uses `Bun.file().text()` when running under Bun, `fs.readFile` otherwise.
-*
-* @example
-* ```ts
-* const source = await read('./src/Pet.ts')
-* ```
+* Shared {@link Runtime} instance describing the JavaScript runtime executing the current process.
 */
-async function read(path) {
-	if (isBun()) return Bun.file(path).text();
-	return readFile(path, { encoding: "utf8" });
-}
+const runtime = new Runtime();
+//#endregion
+//#region ../../internals/utils/src/fs.ts
 /**
 * Writes `data` to `path`, trimming leading/trailing whitespace before saving.
 * Skips the write when the trimmed content is empty or identical to what is already on disk.
@@ -144,7 +182,7 @@ async function write(path, data, options = {}) {
 	const trimmed = data.trim();
 	if (trimmed === "") return null;
 	const resolved = resolve(path);
-	if (isBun()) {
+	if (runtime.isBun) {
 		const file = Bun.file(resolved);
 		if ((await file.exists() ? await file.text() : null) === trimmed) return null;
 		await Bun.write(resolved, trimmed);
@@ -176,8 +214,6 @@ async function clean(path) {
 		force: true
 	});
 }
-//#endregion
-//#region ../../internals/utils/src/path.ts
 /**
 * Converts a filesystem path to use POSIX (`/`) separators.
 *
@@ -195,6 +231,29 @@ async function clean(path) {
 function toPosixPath(filePath) {
 	return filePath.replaceAll("\\", "/");
 }
+/**
+* Builds a nested file path from a dotted name. Splits on dots that precede a letter
+* (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases
+* every earlier segment, applies `caseLast` to the final segment, and joins with `/`.
+*
+* Empty segments are dropped before joining. They arise when the name starts with a dot
+* followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to
+* an empty string). Without this a leading `/` would form, which `path.resolve` reads as an
+* absolute path, letting generated files escape the configured output directory.
+*
+* @example Nested path from a dotted name
+* `toFilePath('pet.petId') // 'pet/petId'`
+*
+* @example PascalCase the final segment
+* `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`
+*
+* @example Suffix applied to the final segment only
+* `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
+*/
+function toFilePath(name, caseLast = camelCase) {
+	const parts = name.split(/\.(?=[a-zA-Z])/);
+	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
+}
 //#endregion
 //#region ../../internals/utils/src/promise.ts
 function* chunks(arr, size) {
@@ -425,99 +484,80 @@ function isIdentifier(name) {
 	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
 //#endregion
-//#region ../../internals/utils/src/urlPath.ts
+//#region ../../internals/utils/src/url.ts
+function transformParam(raw, casing) {
+	const param = isValidVarName(raw) ? raw : camelCase(raw);
+	return casing === "camelcase" ? camelCase(param) : param;
+}
+function toParamsObject(path, { replacer, casing } = {}) {
+	const params = {};
+	for (const match of path.matchAll(/\{([^}]+)\}/g)) {
+		const param = transformParam(match[1], casing);
+		const key = replacer ? replacer(param) : param;
+		params[key] = key;
+	}
+	return Object.keys(params).length > 0 ? params : null;
+}
 /**
-* Parses and transforms an OpenAPI/Swagger path string into various URL formats.
-*
-* @example
-* const p = new URLPath('/pet/{petId}')
-* p.URL      // '/pet/:petId'
-* p.template // '`/pet/${petId}`'
+* Helpers for OpenAPI/Swagger paths, plus a thin wrapper over the native `URL`.
 */
-var URLPath = class {
+var Url = class Url {
 	/**
-	* The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
-	*/
-	path;
-	#options;
-	constructor(path, options = {}) {
-		this.path = path;
-		this.#options = options;
-	}
-	/** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+	* Reports whether `url` is a parseable absolute URL. Delegates to the native `URL.canParse`.
 	*
 	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').URL // '/pet/:petId'
-	* ```
+	* Url.canParse('https://petstore.swagger.io/v2') // true
+	* Url.canParse('/pet/{petId}')                   // false
 	*/
-	get URL() {
-		return this.toURLPath();
+	static canParse(url, base) {
+		return URL.canParse(url, base);
 	}
-	/** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
+	/**
+	* Converts an OpenAPI/Swagger path to Express-style colon syntax.
 	*
 	* @example
-	* ```ts
-	* new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
-	* new URLPath('/pet/{petId}').isURL                       // false
-	* ```
+	* Url.toPath('/pet/{petId}') // '/pet/:petId'
 	*/
-	get isURL() {
-		try {
-			return !!new URL(this.path).href;
-		} catch {
-			return false;
-		}
+	static toPath(path) {
+		return path.replace(/\{([^}]+)\}/g, ":$1");
 	}
 	/**
-	* Converts the OpenAPI path to a TypeScript template literal string.
+	* Converts an OpenAPI/Swagger path to a TypeScript template literal string.
+	* `prefix` is prepended inside the literal, `replacer` transforms each parameter name,
+	* and `casing` controls parameter identifier casing.
 	*
 	* @example
-	* new URLPath('/pet/{petId}').template              // '`/pet/${petId}`'
-	* new URLPath('/account/monetary-accountID').template // '`/account/${monetaryAccountId}`'
-	*/
-	get template() {
-		return this.toTemplateString();
-	}
-	/** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
+	* Url.toTemplateString('/pet/{petId}') // '`/pet/${petId}`'
 	*
 	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').object
-	* // { url: '/pet/:petId', params: { petId: 'petId' } }
-	* ```
+	* Url.toTemplateString('/pet/{petId}', { prefix: 'https://api' }) // '`https://api/pet/${petId}`'
 	*/
-	get object() {
-		return this.toObject();
+	static toTemplateString(path, { prefix, replacer, casing } = {}) {
+		const result = path.split(/\{([^}]+)\}/).map((part, i) => {
+			if (i % 2 === 0) return part;
+			const param = transformParam(part, casing);
+			return `\${${replacer ? replacer(param) : param}}`;
+		}).join("");
+		return `\`${prefix ?? ""}${result}\``;
 	}
-	/** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+	/**
+	* Returns the path and its extracted params as a structured `URLObject`, or as a stringified
+	* expression when `stringify` is set.
 	*
 	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').params // { petId: 'petId' }
-	* new URLPath('/pet').params         // undefined
-	* ```
-	*/
-	get params() {
-		return this.getParams();
-	}
-	#transformParam(raw) {
-		const param = isValidVarName(raw) ? raw : camelCase(raw);
-		return this.#options.casing === "camelcase" ? camelCase(param) : param;
-	}
-	/**
-	* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
+	* Url.toObject('/pet/{petId}')
+	* // { url: '/pet/:petId', params: { petId: 'petId' } }
 	*/
-	#eachParam(fn) {
-		for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
-			const raw = match[1];
-			fn(raw, this.#transformParam(raw));
-		}
-	}
-	toObject({ type = "path", replacer, stringify } = {}) {
+	static toObject(path, { type = "path", replacer, stringify, casing } = {}) {
 		const object = {
-			url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
-			params: this.getParams()
+			url: type === "path" ? Url.toPath(path) : Url.toTemplateString(path, {
+				replacer,
+				casing
+			}),
+			params: toParamsObject(path, {
+				replacer,
+				casing
+			})
 		};
 		if (stringify) {
 			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
@@ -526,50 +566,6 @@ var URLPath = class {
 		}
 		return object;
 	}
-	/**
-	* Converts the OpenAPI path to a TypeScript template literal string.
-	* An optional `replacer` can transform each extracted parameter name before interpolation.
-	*
-	* @example
-	* new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
-	*/
-	toTemplateString({ prefix, replacer } = {}) {
-		const result = this.path.split(/\{([^}]+)\}/).map((part, i) => {
-			if (i % 2 === 0) return part;
-			const param = this.#transformParam(part);
-			return `\${${replacer ? replacer(param) : param}}`;
-		}).join("");
-		return `\`${prefix ?? ""}${result}\``;
-	}
-	/**
-	* Extracts all `{param}` segments from the path and returns them as a key-value map.
-	* An optional `replacer` transforms each parameter name in both key and value positions.
-	* Returns `undefined` when no path parameters are found.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}/tag/{tagId}').getParams()
-	* // { petId: 'petId', tagId: 'tagId' }
-	* ```
-	*/
-	getParams(replacer) {
-		const params = {};
-		this.#eachParam((_raw, param) => {
-			const key = replacer ? replacer(param) : param;
-			params[key] = key;
-		});
-		return Object.keys(params).length > 0 ? params : void 0;
-	}
-	/** Converts the OpenAPI path to Express-style colon syntax.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
-	* ```
-	*/
-	toURLPath() {
-		return this.path.replace(/\{([^}]+)\}/g, ":$1");
-	}
 };
 //#endregion
 //#region src/createAdapter.ts
@@ -607,43 +603,11 @@ function createAdapter(build) {
 	return (options) => build(options ?? {});
 }
 //#endregion
-//#region src/createCache.ts
-/**
-* Defines a custom cache backend. The builder receives user options and returns a
-* {@link Cache}. Reach for this when the filesystem backend doesn't fit, for
-* example to store snapshots in Redis or a database.
-*
-* @example In-memory cache (the built-in implementation)
-* ```ts
-* import { createCache } from '@kubb/core'
-*
-* export const memoryCache = createCache(() => {
-*   const store = new Map<string, CachedSnapshot>()
-*
-*   return {
-*     name: 'memory',
-*     async restore({ key }) {
-*       return store.get(key) ?? null
-*     },
-*     async persist({ key, snapshot }) {
-*       store.set(key, snapshot)
-*     },
-*   }
-* })
-* ```
-*/
-function createCache(build) {
-	return (options) => build(options ?? {});
-}
-//#endregion
-//#region package.json
-var version = "5.0.0-beta.54";
-//#endregion
 //#region src/diagnostics.ts
 /**
 * Docs major, derived from the package version so the link tracks the published major.
 */
-const docsMajor = version.split(".")[0] ?? "5";
+const docsMajor = "5.0.0-beta.55".split(".")[0] ?? "5";
 /**
 * Narrows a {@link Diagnostic} to the variant for `code`, or `null` when it does not match.
 *
@@ -1067,88 +1031,6 @@ var Diagnostics = class Diagnostics {
 	}
 };
 //#endregion
-//#region src/Fingerprint.ts
-/**
-* Computes the cache key for an incremental build. All methods are static, so call them as
-* `Fingerprint.compute(...)` and `Fingerprint.stringify(...)`. The key holds no absolute
-* paths or modification times, so it never depends on where the project lives on disk.
-*/
-var Fingerprint = class Fingerprint {
-	/**
-	* Bumped when the snapshot format or fingerprint inputs change in an incompatible way, so stale
-	* cache entries from older Kubb builds are never reused.
-	*/
-	static version = 1;
-	/**
-	* Deterministically serializes a value to JSON: object keys are sorted recursively and
-	* `undefined` values and functions are dropped. Two structurally equal configs produce the same
-	* string regardless of key order, which keeps the fingerprint stable across machines.
-	*/
-	static stringify(value) {
-		return JSON.stringify(Fingerprint.#normalize(value));
-	}
-	/**
-	* Computes a cache key from everything that affects the generated output: the spec content, the
-	* output-shaping config, each plugin's name and options, the running
-	* `@kubb/core` version, and the cache format version. Returns `null` when the input can't be
-	* fingerprinted (remote URL or no adapter source), which disables caching for that build.
-	*/
-	static async compute({ config, adapterSource, version }) {
-		if (!adapterSource) return null;
-		const spec = await Fingerprint.#readSpec(adapterSource, config.root);
-		if (spec === null) return null;
-		const input = {
-			cacheVersion: Fingerprint.version,
-			version,
-			spec,
-			name: config.name,
-			output: config.output,
-			adapter: config.adapter?.name,
-			parsers: config.parsers.map((parser) => parser.name),
-			plugins: config.plugins.map((plugin) => ({
-				name: plugin.name,
-				options: plugin.options
-			}))
-		};
-		return createHash("sha256").update(Fingerprint.stringify(input)).digest("hex");
-	}
-	static #normalize(value) {
-		if (value === null || typeof value !== "object") return typeof value === "function" ? void 0 : value;
-		if (Array.isArray(value)) return value.map((item) => Fingerprint.#normalize(item));
-		const source = value;
-		const result = {};
-		for (const key of Object.keys(source).sort()) {
-			const normalized = Fingerprint.#normalize(source[key]);
-			if (normalized !== void 0) result[key] = normalized;
-		}
-		return result;
-	}
-	/**
-	* Reads the spec content that feeds the fingerprint. Returns `null` for a remote URL source
-	* (hashing remote content would mean fetching it on every run) or when a file can't be read, so a
-	* missing or virtual spec disables caching instead of failing the build.
-	*/
-	static async #readSpec(source, root) {
-		if (source.type === "data") return {
-			kind: "data",
-			data: typeof source.data === "string" ? source.data : Fingerprint.stringify(source.data)
-		};
-		const paths = source.type === "paths" ? source.paths : [source.path];
-		if (paths.some((path) => new URLPath(path).isURL)) return null;
-		try {
-			return {
-				kind: "path",
-				contents: await Promise.all(paths.map(async (path) => ({
-					path: relative(root, path),
-					content: await readFile(path, "utf8")
-				})))
-			};
-		} catch {
-			return null;
-		}
-	}
-};
-//#endregion
 //#region src/definePlugin.ts
 /**
 * Merges the `output.mode` default into the output config and validates the combination.
@@ -1252,12 +1134,12 @@ function matchesSchemaPattern(node, type, pattern) {
 /**
 * Default name resolver used by `defineResolver`.
 *
-* - `camelCase` for `function` and `file` types.
+* - `camelCase` for `file`, with dotted names split into `/`-joined nested paths.
 * - `PascalCase` for `type`.
-* - `camelCase` for everything else.
+* - `camelCase` for `function` and everything else.
 */
 function defaultResolver(name, type) {
-	if (type === "file" || type === "function") return camelCase(name, { isFile: type === "file" });
+	if (type === "file") return toFilePath(name);
 	if (type === "type") return pascalCase(name);
 	return camelCase(name);
 }
@@ -1676,8 +1558,7 @@ var KubbDriver = class {
 	config;
 	options;
 	/**
-	* The streaming `InputStreamNode` produced by the adapter.
-	* Always set after adapter setup, parse-only adapters are wrapped automatically.
+	* The streaming `InputNode<true>` produced by the adapter.   * Always set after adapter setup, parse-only adapters are wrapped automatically.
 	*/
 	inputNode = null;
 	adapter = null;
@@ -1934,11 +1815,8 @@ var KubbDriver = class {
 			await hooks.emit("kubb:files:processing:start", { files });
 		});
 		const updateBuffer = [];
-		const cacheEnabled = Boolean(config.cache);
-		const snapshotSources = /* @__PURE__ */ new Map();
 		processor.hooks.on("update", (item) => {
 			updateBuffer.push(item);
-			if (cacheEnabled && item.source !== void 0) snapshotSources.set(item.file.path, item.source);
 		});
 		processor.hooks.on("end", async (files) => {
 			await hooks.emit("kubb:files:processing:update", { files: updateBuffer.map((item) => ({
@@ -1954,19 +1832,7 @@ var KubbDriver = class {
 		this.fileManager.hooks.on("upsert", onFileUpsert);
 		return Diagnostics.scope((diagnostic) => diagnostics.push(diagnostic), async () => {
 			try {
-				const cache = config.cache;
 				const outputRoot = resolve(config.root, config.output.path);
-				const cacheKey = cache ? await Fingerprint.compute({
-					config,
-					adapterSource: this.#adapterSource,
-					version
-				}) : null;
-				if (cache && cacheKey && await this.#restoreSnapshot({
-					cache,
-					cacheKey,
-					outputRoot,
-					storage
-				})) return { diagnostics: Diagnostics.dedupe(diagnostics) };
 				await this.#parseInput();
 				await this.emitSetupHooks();
 				if (this.adapter && this.inputNode) await hooks.emit("kubb:build:start", Object.assign({
@@ -2027,12 +1893,6 @@ var KubbDriver = class {
 					config,
 					outputDir: outputRoot
 				});
-				if (cache && cacheKey && !Diagnostics.hasError(diagnostics)) await this.#persistSnapshot({
-					cache,
-					cacheKey,
-					outputRoot,
-					sources: snapshotSources
-				});
 				return { diagnostics: Diagnostics.dedupe(diagnostics) };
 			} catch (caughtError) {
 				diagnostics.push(Diagnostics.from(caughtError));
@@ -2042,43 +1902,6 @@ var KubbDriver = class {
 			}
 		});
 	}
-	/**
-	* Writes a restored snapshot straight to storage and emits `kubb:build:end`. Returns `true` on a
-	* hit (the build is done), `false` on a miss so the caller falls through to a full build.
-	*/
-	async #restoreSnapshot({ cache, cacheKey, outputRoot, storage }) {
-		const snapshot = await cache.restore({ key: cacheKey });
-		if (!snapshot) return false;
-		const queue = [];
-		for (const [relativePath, source] of Object.entries(snapshot.files)) {
-			const absolutePath = join(outputRoot, relativePath);
-			this.fileManager.upsert(createFile({
-				path: absolutePath,
-				baseName: basename(relativePath)
-			}));
-			queue.push(storage.setItem(absolutePath, source));
-			if (queue.length >= 50) await Promise.all(queue.splice(0));
-		}
-		await Promise.all(queue);
-		await this.hooks.emit("kubb:build:end", {
-			files: this.fileManager.files,
-			config: this.config,
-			outputDir: outputRoot
-		});
-		return true;
-	}
-	/**
-	* Stores this run's rendered output, keyed by the input fingerprint, so the next unchanged build
-	* restores it instead of regenerating. `sources` is keyed by absolute path and relativized here.
-	*/
-	async #persistSnapshot({ cache, cacheKey, outputRoot, sources }) {
-		const files = {};
-		for (const [absolutePath, source] of sources) files[relative(outputRoot, absolutePath)] = source;
-		await cache.persist({
-			key: cacheKey,
-			snapshot: { files }
-		});
-	}
 	#filesPayload() {
 		const driver = this;
 		return {
@@ -2462,7 +2285,7 @@ function inputToAdapterSource(config) {
 		type: "data",
 		data: input.data
 	};
-	if (new URLPath(input.path).isURL) return {
+	if (Url.canParse(input.path)) return {
 		type: "path",
 		path: input.path
 	};
@@ -2480,11 +2303,11 @@ function inputToAdapterSource(config) {
 * Keys are resolved against `process.cwd()`, so root-relative paths such as
 * `src/gen/api/getPets.ts` are written to the correct location without extra configuration.
 *
-* Internally uses the `write` utility from `@internals/utils`, which:
-* - trims leading/trailing whitespace before writing
-* - skips the write when file content is already identical (deduplication)
-* - creates missing parent directories automatically
-* - supports Bun's native file API when running under Bun
+* Writes are deduplicated and directory-safe:
+* - leading and trailing whitespace is trimmed before writing
+* - the write is skipped when the file content is already identical
+* - missing parent directories are created automatically
+* - Bun's native file API is used when running under Bun
 *
 * @example
 * ```ts
@@ -2523,7 +2346,7 @@ const fsStorage = createStorage(() => ({
 	},
 	async getKeys(base) {
 		const resolvedBase = resolve(base ?? process.cwd());
-		if (isBun()) {
+		if (runtime.isBun) {
 			const bunGlob = new Bun.Glob("**/*");
 			return Array.fromAsync(bunGlob.scan({
 				cwd: resolvedBase,
@@ -2596,7 +2419,6 @@ function resolveConfig(userConfig) {
 			...userConfig.output
 		},
 		storage: userConfig.storage ?? fsStorage(),
-		cache: userConfig.cache === false ? void 0 : userConfig.cache,
 		reporters: userConfig.reporters ?? [],
 		plugins: userConfig.plugins ?? []
 	};
@@ -3059,130 +2881,6 @@ function defineParser(parser) {
 	return parser;
 }
 //#endregion
-//#region src/caches/fsCache.ts
-/**
-* Reads and prunes the local cache manifest. All methods are static, so call them as
-* `Manifest.read(dir)` and `Manifest.prune(data, ...)`. A damaged manifest reads as empty so the
-* cache degrades to misses instead of throwing. Writing goes through `write` from `@internals/utils`.
-*/
-var Manifest = class Manifest {
-	/**
-	* On-disk layout version for the manifest itself. Bumped when the manifest shape changes; a
-	* mismatch makes the whole local cache read as empty.
-	*/
-	static version = 1;
-	/**
-	* Reads the manifest at `dir/manifest.json`. A missing, corrupt, or version-mismatched file reads
-	* as an empty manifest.
-	*/
-	static async read(dir) {
-		try {
-			const parsed = JSON.parse(await read(join(dir, "manifest.json")));
-			if (parsed.version !== Manifest.version || typeof parsed.entries !== "object") return Manifest.#empty();
-			return parsed;
-		} catch {
-			return Manifest.#empty();
-		}
-	}
-	/**
-	* Selects the keys to evict so the cache stays within `ttlDays` and `maxEntries`. Returns the
-	* surviving manifest plus the evicted keys (the caller deletes their blobs). Pure, does no IO.
-	*/
-	static prune(manifest, { maxEntries, ttlDays, now }) {
-		const ttlMs = ttlDays * 24 * 60 * 60 * 1e3;
-		const removed = [];
-		const kept = [];
-		for (const [key, entry] of Object.entries(manifest.entries)) if (now - entry.lastAccess > ttlMs) removed.push(key);
-		else kept.push([key, entry]);
-		if (kept.length > maxEntries) {
-			kept.sort((a, b) => b[1].lastAccess - a[1].lastAccess);
-			for (const [key] of kept.splice(maxEntries)) removed.push(key);
-		}
-		return {
-			manifest: {
-				version: Manifest.version,
-				entries: Object.fromEntries(kept)
-			},
-			removed
-		};
-	}
-	static #empty() {
-		return {
-			version: Manifest.version,
-			entries: {}
-		};
-	}
-};
-function blobName(relativePath) {
-	return `${createHash("sha256").update(relativePath).digest("hex")}.blob`;
-}
-/**
-* Local filesystem cache. Stores each build snapshot as content blobs plus an index,
-* tracked by a manifest under `node_modules/.cache/kubb/` (the Nx and Vitest
-* convention). Least-recently-used and expired entries are pruned on every persist.
-*
-* @example
-* ```ts
-* import { fsCache } from '@kubb/core'
-*
-* export default defineConfig({
-*   cache: fsCache(),
-* })
-* ```
-*/
-const fsCache = createCache((options = {}) => {
-	const dir = resolve(options.dir ?? join("node_modules", ".cache", "kubb"));
-	const maxEntries = options.maxEntries ?? 50;
-	const ttlDays = options.ttlDays ?? 7;
-	const blobsDir = join(dir, "blobs");
-	const manifestPath = join(dir, "manifest.json");
-	return {
-		name: "fs",
-		async restore({ key }) {
-			const manifest = await Manifest.read(dir);
-			const entry = manifest.entries[key];
-			if (!entry) return null;
-			try {
-				const index = JSON.parse(await read(join(blobsDir, key, "index.json")));
-				const files = {};
-				for (const { path, blob } of index) files[path] = await read(join(blobsDir, key, blob));
-				entry.lastAccess = Date.now();
-				await write(manifestPath, JSON.stringify(manifest)).catch(() => {});
-				return { files };
-			} catch {
-				return null;
-			}
-		},
-		async persist({ key, snapshot }) {
-			const entryDir = join(blobsDir, key);
-			const index = [];
-			for (const [path, source] of Object.entries(snapshot.files)) {
-				const blob = blobName(path);
-				await write(join(entryDir, blob), source);
-				index.push({
-					path,
-					blob
-				});
-			}
-			await write(join(entryDir, "index.json"), JSON.stringify(index));
-			const manifest = await Manifest.read(dir);
-			const now = Date.now();
-			manifest.entries[key] = {
-				files: index.map((item) => item.path),
-				createdAt: now,
-				lastAccess: now
-			};
-			const pruned = Manifest.prune(manifest, {
-				maxEntries,
-				ttlDays,
-				now
-			});
-			await Promise.all(pruned.removed.map((removedKey) => clean(join(blobsDir, removedKey))));
-			await write(manifestPath, JSON.stringify(pruned.manifest));
-		}
-	};
-});
-//#endregion
-export { AsyncEventEmitter, Diagnostics, KubbDriver, URLPath, ast, cliReporter, createAdapter, createCache, createKubb, createRenderer, createReporter, createStorage, defineGenerator, defineParser, definePlugin, defineResolver, fileReporter, fsCache, fsStorage, jsonReporter, logLevel, memoryStorage };
+export { AsyncEventEmitter, Diagnostics, KubbDriver, ast, cliReporter, createAdapter, createKubb, createRenderer, createReporter, createStorage, defineGenerator, defineParser, definePlugin, defineResolver, fileReporter, fsStorage, jsonReporter, logLevel, memoryStorage };
 
 //# sourceMappingURL=index.js.map