@kubb/core 5.0.0-beta.84 → 5.0.0-beta.86

package/dist/{memoryStorage-BjUIqpYE.js → usingCtx-Cnrm3TcM.js}

@@ -1,8 +1,35 @@
 import "./rolldown-runtime-C0LytTxp.js";
-import { EventEmitter } from "node:events";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { ast, extractStringsFromNodes } from "@kubb/ast";
+import { EventEmitter } from "node:events";
+//#region ../../internals/utils/src/casing.ts
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Converts `text` to camelCase.
+*
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
+*
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
+*/
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+//#endregion
 //#region ../../internals/utils/src/errors.ts
 /**
 * Thrown when one or more errors occur during a Kubb build.
@@ -48,152 +75,6 @@ function getErrorMessage(value) {
 	return value instanceof Error ? value.message : String(value);
 }
 //#endregion
-//#region ../../internals/utils/src/asyncEventEmitter.ts
-/**
-* Typed `EventEmitter` that awaits all async listeners before resolving.
-* Wraps Node's `EventEmitter` with full TypeScript event-map inference.
-*
-* @example
-* ```ts
-* const emitter = new AsyncEventEmitter<{ build: [name: string] }>()
-* emitter.on('build', async (name) => { console.log(name) })
-* await emitter.emit('build', 'petstore') // all listeners awaited
-* ```
-*/
-var AsyncEventEmitter = class {
-	/**
-	* Maximum number of listeners per event before Node emits a memory-leak warning.
-	* @default 10
-	*/
-	constructor(maxListener = 10) {
-		this.#emitter.setMaxListeners(maxListener);
-	}
-	#emitter = new EventEmitter();
-	/**
-	* Emits `eventName` and awaits all registered listeners sequentially.
-	* Throws if any listener rejects, wrapping the cause with the event name and serialized arguments.
-	*
-	* @example
-	* ```ts
-	* await emitter.emit('build', 'petstore')
-	* ```
-	*/
-	emit(eventName, ...eventArgs) {
-		const listeners = this.#emitter.listeners(eventName);
-		if (listeners.length === 0) return;
-		return this.#emitAll(eventName, listeners, eventArgs);
-	}
-	async #emitAll(eventName, listeners, eventArgs) {
-		for (const listener of listeners) try {
-			await listener(...eventArgs);
-		} catch (err) {
-			let serializedArgs;
-			try {
-				serializedArgs = JSON.stringify(eventArgs);
-			} catch {
-				serializedArgs = String(eventArgs);
-			}
-			throw new Error(`Error in async listener for "${eventName}" with eventArgs ${serializedArgs}`, { cause: toError(err) });
-		}
-	}
-	/**
-	* Registers a persistent listener for `eventName`.
-	*
-	* @example
-	* ```ts
-	* emitter.on('build', async (name) => { console.log(name) })
-	* ```
-	*/
-	on(eventName, handler) {
-		this.#emitter.on(eventName, handler);
-	}
-	/**
-	* Removes a previously registered listener.
-	*
-	* @example
-	* ```ts
-	* emitter.off('build', handler)
-	* ```
-	*/
-	off(eventName, handler) {
-		this.#emitter.off(eventName, handler);
-	}
-	/**
-	* Returns the number of listeners registered for `eventName`.
-	*
-	* @example
-	* ```ts
-	* emitter.on('build', handler)
-	* emitter.listenerCount('build') // 1
-	* ```
-	*/
-	listenerCount(eventName) {
-		return this.#emitter.listenerCount(eventName);
-	}
-	/**
-	* Raises or lowers the per-event listener ceiling before Node warns about a memory leak.
-	* Set this above the expected listener count when many listeners attach by design.
-	*
-	* @example
-	* ```ts
-	* emitter.setMaxListeners(40)
-	* ```
-	*/
-	setMaxListeners(max) {
-		this.#emitter.setMaxListeners(max);
-	}
-	/**
-	* Removes all listeners from every event channel.
-	*
-	* @example
-	* ```ts
-	* emitter.removeAll()
-	* ```
-	*/
-	removeAll() {
-		this.#emitter.removeAllListeners();
-	}
-};
-//#endregion
-//#region ../../internals/utils/src/casing.ts
-/**
-* Shared implementation for camelCase and PascalCase conversion.
-* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
-* and capitalizes each word according to `pascal`.
-*
-* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
-*/
-function toCamelOrPascal(text, pascal) {
-	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
-		if (word.length > 1 && word === word.toUpperCase()) return word;
-		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
-	}).join("").replace(/[^a-zA-Z0-9]/g, "");
-}
-/**
-* Converts `text` to camelCase.
-*
-* @example Word boundaries
-* `camelCase('hello-world') // 'helloWorld'`
-*
-* @example With a prefix
-* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
-*/
-function camelCase(text, { prefix = "", suffix = "" } = {}) {
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
-}
-/**
-* Converts `text` to PascalCase.
-*
-* @example Word boundaries
-* `pascalCase('hello-world') // 'HelloWorld'`
-*
-* @example With a suffix
-* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
-*/
-function pascalCase(text, { prefix = "", suffix = "" } = {}) {
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
-}
-//#endregion
 //#region ../../internals/utils/src/runtime.ts
 /**
 * Detects the JavaScript runtime executing the current process and exposes its name and version.
@@ -368,151 +249,148 @@ function toFilePath(name, caseLast = camelCase) {
 	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
 }
 //#endregion
-//#region src/constants.ts
-/**
-* 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
-* of schemas they reach, so unreachable schemas can be pruned for that plugin.
-*/
-const OPERATION_FILTER_TYPES = /* @__PURE__ */ new Set([
-	"tag",
-	"operationId",
-	"path",
-	"method",
-	"contentType"
-]);
+//#region src/Hookable.ts
 /**
-* 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.
+* Typed hook emitter that awaits all async listeners before resolving.
+* Wraps Node's `EventEmitter` with full TypeScript hook-map inference.
+*
+* @example
+* ```ts
+* const hooks = new Hookable<{ build: [name: string] }>()
+* hooks.hook('build', async (name) => { console.log(name) })
+* await hooks.callHook('build', 'petstore') // all listeners awaited
+* ```
 */
-const diagnosticCode = {
-	/**
-	* Fallback for an unstructured error with no specific code.
-	*/
-	unknown: "KUBB_UNKNOWN",
-	/**
-	* The `input.path` file or URL could not be read.
-	*/
-	inputNotFound: "KUBB_INPUT_NOT_FOUND",
-	/**
-	* An adapter was configured without an `input`.
-	*/
-	inputRequired: "KUBB_INPUT_REQUIRED",
-	/**
-	* A `$ref` (or equivalent reference) could not be resolved in the source document.
-	*/
-	refNotFound: "KUBB_REF_NOT_FOUND",
-	/**
-	* A server variable value is not allowed by its `enum`.
-	*/
-	invalidServerVariable: "KUBB_INVALID_SERVER_VARIABLE",
-	/**
-	* A required plugin is missing from the config.
-	*/
-	pluginNotFound: "KUBB_PLUGIN_NOT_FOUND",
-	/**
-	* A plugin threw while generating.
-	*/
-	pluginFailed: "KUBB_PLUGIN_FAILED",
-	/**
-	* A plugin reported a non-fatal warning through `ctx.warn`.
-	*/
-	pluginWarning: "KUBB_PLUGIN_WARNING",
+var Hookable = class {
 	/**
-	* A plugin reported an informational message through `ctx.info`.
-	*/
-	pluginInfo: "KUBB_PLUGIN_INFO",
-	/**
-	* A schema uses a `format` Kubb does not map to a specific type. Reserved for
-	* adapters to emit as a `warning`.
-	*/
-	unsupportedFormat: "KUBB_UNSUPPORTED_FORMAT",
-	/**
-	* A referenced schema or operation is marked `deprecated`. Reserved for adapters
-	* to emit as an `info`.
-	*/
-	deprecated: "KUBB_DEPRECATED",
-	/**
-	* An adapter is required but the config has none. The build cannot read the input
-	* without one.
+	* Maximum number of listeners per hook before Node emits a memory-leak warning.
+	* @default 10
 	*/
-	adapterRequired: "KUBB_ADAPTER_REQUIRED",
+	constructor(maxListener = 10) {
+		this.#emitter.setMaxListeners(maxListener);
+	}
+	#emitter = new EventEmitter();
 	/**
-	* A resolved output path escapes the output directory, which can stem from a path
-	* traversal in the spec or a misconfigured `group.name`.
+	* Calls `hookName` and awaits all registered listeners sequentially.
+	* Throws if any listener rejects, wrapping the cause with the hook name and serialized arguments.
+	*
+	* @example
+	* ```ts
+	* await hooks.callHook('build', 'petstore')
+	* ```
 	*/
-	pathTraversal: "KUBB_PATH_TRAVERSAL",
+	callHook(hookName, ...hookArgs) {
+		const listeners = this.#emitter.listeners(hookName);
+		if (listeners.length === 0) return;
+		return this.#emitAll(hookName, listeners, hookArgs);
+	}
+	async #emitAll(hookName, listeners, hookArgs) {
+		for (const listener of listeners) try {
+			await listener(...hookArgs);
+		} catch (err) {
+			let serializedArgs;
+			try {
+				serializedArgs = JSON.stringify(hookArgs);
+			} catch {
+				serializedArgs = String(hookArgs);
+			}
+			throw new Error(`Error in async listener for "${hookName}" with hookArgs ${serializedArgs}`, { cause: toError(err) });
+		}
+	}
 	/**
-	* A plugin's options are invalid, for example `output.mode: 'file'` paired with a `group` option.
+	* Registers a persistent listener for `hookName` and returns a function that removes it.
+	*
+	* @example
+	* ```ts
+	* const unhook = hooks.hook('build', async (name) => { console.log(name) })
+	* unhook() // removes it
+	* ```
 	*/
-	invalidPluginOptions: "KUBB_INVALID_PLUGIN_OPTIONS",
+	hook(hookName, handler) {
+		this.#emitter.on(hookName, handler);
+		return () => this.removeHook(hookName, handler);
+	}
 	/**
-	* A post-generate shell hook (`hooks.done`) exited with a failure.
+	* Registers every handler in `configHooks` at once and returns a function that removes them
+	* all. Undefined entries are skipped, so a partial hook object registers only its present keys.
+	*
+	* @example
+	* ```ts
+	* const unhook = hooks.addHooks({ build: onBuild, done: onDone })
+	* unhook() // removes both
+	* ```
 	*/
-	hookFailed: "KUBB_HOOK_FAILED",
+	addHooks(configHooks) {
+		const unhooks = Object.keys(configHooks).filter((name) => configHooks[name]).map((name) => this.hook(name, configHooks[name]));
+		return () => {
+			for (const unhook of unhooks) unhook();
+		};
+	}
 	/**
-	* The formatter pass over the generated files failed.
+	* Removes a previously registered listener.
+	*
+	* @example
+	* ```ts
+	* hooks.removeHook('build', handler)
+	* ```
 	*/
-	formatFailed: "KUBB_FORMAT_FAILED",
+	removeHook(hookName, handler) {
+		this.#emitter.off(hookName, handler);
+	}
 	/**
-	* The linter pass over the generated files failed.
+	* Returns the number of listeners registered for `hookName`.
+	*
+	* @example
+	* ```ts
+	* hooks.hook('build', handler)
+	* hooks.listenerCount('build') // 1
+	* ```
 	*/
-	lintFailed: "KUBB_LINT_FAILED",
+	listenerCount(hookName) {
+		return this.#emitter.listenerCount(hookName);
+	}
 	/**
-	* Not a failure. Carries a plugin's elapsed time, summed into the run total.
+	* Raises or lowers the per-hook listener ceiling before Node warns about a memory leak.
+	* Set this above the expected listener count when many listeners attach by design.
+	*
+	* @example
+	* ```ts
+	* hooks.setMaxListeners(40)
+	* ```
 	*/
-	performance: "KUBB_PERFORMANCE",
+	setMaxListeners(max) {
+		this.#emitter.setMaxListeners(max);
+	}
 	/**
-	* Not a failure. A newer Kubb version is available on npm.
+	* Removes all listeners from every hook channel.
+	*
+	* @example
+	* ```ts
+	* hooks.removeAllHooks()
+	* ```
 	*/
-	updateAvailable: "KUBB_UPDATE_AVAILABLE"
+	removeAllHooks() {
+		this.#emitter.removeAllListeners();
+	}
 };
 //#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. A custom backend writes generated files elsewhere, such as cloud
-* storage or a database.
-*
-* @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/FileManager.ts
+function joinSources(file) {
+	return file.sources.map((source) => extractStringsFromNodes(source.nodes)).filter(Boolean).join("\n\n");
+}
+async function parseCopy(file) {
+	let content;
+	try {
+		content = await read(file.copy);
+	} catch (err) {
+		throw new Error(`[kubb] Could not copy file into output: ${file.copy}`, { cause: err });
+	}
+	return [
+		file.banner,
+		content,
+		file.footer
+	].filter((segment) => Boolean(segment)).map((segment) => segment.trimEnd()).join("\n");
+}
 function mergeFile(a, b) {
 	return {
 		...a,
@@ -537,23 +415,21 @@ function compareFiles(a, b) {
 	return 0;
 }
 /**
-* In-memory file store for generated files. Files sharing a `path` are merged
-* (sources/imports/exports concatenated). The `files` getter is sorted by
-* path length (barrel `index.ts` last within a bucket).
+* In-memory file store for generated files, and the writer that turns them into source
+* strings on `storage`. Files sharing a `path` are merged (sources/imports/exports
+* concatenated). The `files` getter is sorted by path length (barrel `index.ts` last
+* within a bucket).
 *
 * @example
 * ```ts
 * const manager = new FileManager()
 * manager.upsert(myFile)
 * manager.files // sorted view
+* await manager.write(manager.files, { storage: fsStorage() })
 * ```
 */
 var FileManager = class {
-	/**
-	* Subscribe to file-store changes. Listeners on `upsert` see each resolved file as it lands
-	* through `add` or `upsert`.
-	*/
-	hooks = new AsyncEventEmitter();
+	hooks = new Hookable();
 	#cache = /* @__PURE__ */ new Map();
 	#sorted = null;
 	add(...files) {
@@ -570,7 +446,6 @@ var FileManager = class {
 			const merged = existing && mergeExisting ? ast.factory.createFile(mergeFile(existing, file)) : ast.factory.createFile(file);
 			this.#cache.set(merged.path, merged);
 			resolved.push(merged);
-			this.hooks.emit("upsert", merged);
 		}
 		if (resolved.length > 0) this.#sorted = null;
 		return resolved;
@@ -583,13 +458,6 @@ var FileManager = class {
 		}
 		return [...seen.values()];
 	}
-	getByPath(path) {
-		return this.#cache.get(path) ?? null;
-	}
-	deleteByPath(path) {
-		if (!this.#cache.delete(path)) return;
-		this.#sorted = null;
-	}
 	clear() {
 		this.#cache.clear();
 		this.#sorted = null;
@@ -600,10 +468,7 @@ var FileManager = class {
 	*/
 	dispose() {
 		this.clear();
-		this.hooks.removeAll();
-	}
-	[Symbol.dispose]() {
-		this.dispose();
+		this.hooks.removeAllHooks();
 	}
 	/**
 	* All stored files in stable sort order (shortest path first, barrel files
@@ -612,163 +477,46 @@ var FileManager = class {
 	get files() {
 		return this.#sorted ??= [...this.#cache.values()].sort(compareFiles);
 	}
-};
-//#endregion
-//#region src/FileProcessor.ts
-function joinSources(file) {
-	const sources = file.sources;
-	if (sources.length === 0) return "";
-	const parts = [];
-	for (const source of sources) {
-		const text = extractStringsFromNodes(source.nodes);
-		if (text) parts.push(text);
-	}
-	return parts.join("\n\n");
-}
-async function parseCopy(file) {
-	let content;
-	try {
-		content = await read(file.copy);
-	} catch (err) {
-		throw new Error(`[kubb] Could not copy file into output: ${file.copy}`, { cause: err });
-	}
-	return [
-		file.banner,
-		content,
-		file.footer
-	].filter((segment) => Boolean(segment)).map((segment) => segment.trimEnd()).join("\n");
-}
-/**
-* Turns `FileNode`s into source strings and writes them to storage.
-*
-* Two modes share the same instance. Stateless mode (`parse`, `stream`, `run`) just runs the
-* conversion. Queue mode (`enqueue`, `flush`, `drain`) buffers files deduped by path and
-* writes each batch through storage with up to `STREAM_FLUSH_EVERY` requests in flight.
-*
-* `flush` does not wait for its batch to finish, so dispatch can overlap with IO. The next
-* `flush` or `drain` picks the in-flight batch up. `drain` blocks until everything has been
-* written and is meant for the end of a build.
-*
-* To surface build-level hook signals (`kubb:files:processing:*` and friends) subscribe to
-* `hooks` and re-emit on the kubb bus.
-*/
-var FileProcessor = class {
-	hooks = new AsyncEventEmitter();
-	#parsers;
-	#storage;
-	#extension;
-	#pending = /* @__PURE__ */ new Map();
-	#runningFlush = null;
-	constructor(options) {
-		this.#parsers = options.parsers ?? null;
-		this.#storage = options.storage;
-		this.#extension = options.extension ?? null;
-	}
 	/**
-	* Files waiting in the queue.
+	* Converts a file's AST sources (or its `copy` source) into the final on-disk string.
 	*/
-	get size() {
-		return this.#pending.size;
-	}
-	async parse(file) {
+	async parse(file, { parsers, extension } = {}) {
 		if (file.copy) return parseCopy(file);
-		const parsers = this.#parsers;
-		const parseExtName = this.#extension?.[file.extname] || void 0;
+		const parseExtName = extension?.[file.extname] || void 0;
 		if (!parsers || !file.extname) return joinSources(file);
 		const parser = parsers.get(file.extname);
 		if (!parser) return joinSources(file);
 		return parser.parse(file, { extname: parseExtName });
 	}
-	async *stream(files) {
+	/**
+	* Converts and writes every file at once, letting `storage.setItem` decide how much of
+	* that runs concurrently.
+	*/
+	async write(files, { storage, parsers, extension }) {
+		if (files.length === 0) return;
+		await this.hooks.callHook("start", files);
 		const total = files.length;
-		if (total === 0) return;
 		let processed = 0;
-		for (const file of files) {
-			const source = await this.parse(file);
+		await Promise.all(files.map(async (file) => {
+			const source = await this.parse(file, {
+				parsers,
+				extension
+			});
 			processed++;
-			yield {
+			await this.hooks.callHook("update", {
 				file,
 				source,
 				processed,
 				total,
 				percentage: processed / total * 100
-			};
-		}
-	}
-	async run(files) {
-		await this.hooks.emit("start", files);
-		for await (const { file, source, processed, total, percentage } of this.stream(files)) await this.hooks.emit("update", {
-			file,
-			source,
-			processed,
-			percentage,
-			total
-		});
-		await this.hooks.emit("end", files);
-		return files;
-	}
-	/**
-	* Adds a file to the next flush. A later `enqueue` for the same path replaces the previous
-	* entry, matching `FileManager.upsert`. Fires the `enqueue` event.
-	*/
-	enqueue(file) {
-		this.#pending.set(file.path, file);
-		this.hooks.emit("enqueue", file);
-	}
-	/**
-	* Starts processing the queued files. Waits for any previous flush to finish (so two
-	* batches never run together) and then returns without waiting for the new one. The next
-	* `flush` or `drain` picks up the in-flight task.
-	*/
-	async flush() {
-		if (this.#runningFlush) await this.#runningFlush;
-		if (this.#pending.size === 0) return;
-		const batch = [...this.#pending.values()];
-		this.#pending.clear();
-		this.#runningFlush = this.#processAndWrite(batch).finally(() => {
-			this.#runningFlush = null;
-		});
-	}
-	/**
-	* Waits for the in-flight flush and writes any files still queued. Fires the `drain` event
-	* when both are done.
-	*/
-	async drain() {
-		if (this.#runningFlush) await this.#runningFlush;
-		if (this.#pending.size > 0) {
-			const batch = [...this.#pending.values()];
-			this.#pending.clear();
-			await this.#processAndWrite(batch);
-		}
-		await this.hooks.emit("drain");
-	}
-	async #processAndWrite(files) {
-		const storage = this.#storage;
-		await this.hooks.emit("start", files);
-		const queue = [];
-		for await (const item of this.stream(files)) {
-			await this.hooks.emit("update", item);
-			if (item.source) {
-				queue.push(storage.setItem(item.file.path, item.source));
-				if (queue.length >= 50) await Promise.all(queue.splice(0));
-			}
-		}
-		await Promise.all(queue);
-		await this.hooks.emit("end", files);
-	}
-	/**
-	* Clears every listener and the pending queue.
-	*/
-	dispose() {
-		this.hooks.removeAll();
-		this.#pending.clear();
-	}
-	[Symbol.dispose]() {
-		this.dispose();
+			});
+			if (source) await storage.setItem(file.path, source);
+		}));
+		await this.hooks.callHook("end", files);
 	}
 };
 //#endregion
-//#region \0@oxc-project+runtime@0.137.0/helpers/esm/usingCtx.js
+//#region \0@oxc-project+runtime@0.138.0/helpers/esm/usingCtx.js
 function _usingCtx() {
 	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
 		var n = Error();
@@ -828,56 +576,6 @@ function _usingCtx() {
 	};
 }
 //#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
-export { getErrorMessage as _, createStorage as a, clean as c, write as d, runtime as f, BuildError as g, AsyncEventEmitter as h, FileManager as i, toFilePath as l, pascalCase as m, _usingCtx as n, OPERATION_FILTER_TYPES as o, camelCase as p, FileProcessor as r, diagnosticCode as s, memoryStorage as t, toPosixPath as u };
+export { toFilePath as a, BuildError as c, camelCase as d, clean as i, getErrorMessage as l, FileManager as n, toPosixPath as o, Hookable as r, write as s, _usingCtx as t, toError as u };
 
-//# sourceMappingURL=memoryStorage-BjUIqpYE.js.map
+//# sourceMappingURL=usingCtx-Cnrm3TcM.js.map