@kubb/core 5.0.0-beta.10 → 5.0.0-beta.11

package/dist/{createKubb-ALdb8lmq.d.ts → createKubb-BSfMDBwR.d.ts}

@@ -354,6 +354,88 @@ type DevtoolsOptions = {
   ast?: boolean;
 };
 //#endregion
+//#region src/defineParser.d.ts
+type PrintOptions = {
+  extname?: FileNode['extname'];
+};
+type Parser<TMeta extends object = any> = {
+  name: string;
+  /**
+   * File extensions this parser handles.
+   * Use `undefined` to create a catch-all fallback parser.
+   *
+   * @example Handled extensions
+   * `['.ts', '.js']`
+   */
+  extNames: Array<FileNode['extname']> | undefined;
+  /**
+   * Convert a resolved file to a string.
+   */
+  parse(file: FileNode<TMeta>, options?: PrintOptions): Promise<string> | string;
+};
+/**
+ * Defines a parser with type safety. Creates parsers that transform generated files to strings based on their extension.
+ *
+ * @note Call the returned factory with optional options to instantiate the parser.
+ *
+ * @example
+ * ```ts
+ * import { defineParser } from '@kubb/core'
+ *
+ * export const jsonParser = defineParser({
+ *   name: 'json',
+ *   extNames: ['.json'],
+ *   parse(file) {
+ *     const { extractStringsFromNodes } = await import('@kubb/ast')
+ *     return file.sources.map((s) => extractStringsFromNodes(s.nodes ?? [])).join('\n')
+ *   },
+ * })
+ * ```
+ */
+declare function defineParser<TMeta extends object = any>(parser: Parser<TMeta>): Parser<TMeta>;
+//#endregion
+//#region src/FileProcessor.d.ts
+type ParseOptions = {
+  parsers?: Map<FileNode['extname'], Parser>;
+  extension?: Record<FileNode['extname'], FileNode['extname'] | ''>;
+};
+type RunOptions = ParseOptions & {
+  /**
+   * @default 'sequential'
+   */
+  mode?: 'sequential' | 'parallel';
+};
+type FileProcessorEvents = {
+  start: [files: Array<FileNode>];
+  update: [params: {
+    file: FileNode;
+    source?: string;
+    processed: number;
+    total: number;
+    percentage: number;
+  }];
+  end: [files: Array<FileNode>];
+};
+/**
+ * Converts a single file to a string using the registered parsers.
+ * Falls back to joining source values when no matching parser is found.
+ *
+ * @internal
+ */
+declare class FileProcessor {
+  #private;
+  readonly events: AsyncEventEmitter<FileProcessorEvents>;
+  parse(file: FileNode, {
+    parsers,
+    extension
+  }?: ParseOptions): Promise<string>;
+  run(files: Array<FileNode>, {
+    parsers,
+    mode,
+    extension
+  }?: RunOptions): Promise<Array<FileNode>>;
+}
+//#endregion
 //#region src/defineLogger.d.ts
 type LoggerOptions = {
   /**
@@ -459,46 +541,6 @@ type Middleware = {
  */
 declare function defineMiddleware<TOptions extends object = object>(factory: (options: TOptions) => Middleware): (options?: TOptions) => Middleware;
 //#endregion
-//#region src/defineParser.d.ts
-type PrintOptions = {
-  extname?: FileNode['extname'];
-};
-type Parser<TMeta extends object = any> = {
-  name: string;
-  /**
-   * File extensions this parser handles.
-   * Use `undefined` to create a catch-all fallback parser.
-   *
-   * @example Handled extensions
-   * `['.ts', '.js']`
-   */
-  extNames: Array<FileNode['extname']> | undefined;
-  /**
-   * Convert a resolved file to a string.
-   */
-  parse(file: FileNode<TMeta>, options?: PrintOptions): Promise<string> | string;
-};
-/**
- * Defines a parser with type safety. Creates parsers that transform generated files to strings based on their extension.
- *
- * @note Call the returned factory with optional options to instantiate the parser.
- *
- * @example
- * ```ts
- * import { defineParser } from '@kubb/core'
- *
- * export const jsonParser = defineParser({
- *   name: 'json',
- *   extNames: ['.json'],
- *   parse(file) {
- *     const { extractStringsFromNodes } = await import('@kubb/ast')
- *     return file.sources.map((s) => extractStringsFromNodes(s.nodes ?? [])).join('\n')
- *   },
- * })
- * ```
- */
-declare function defineParser<TMeta extends object = any>(parser: Parser<TMeta>): Parser<TMeta>;
-//#endregion
 //#region src/defineResolver.d.ts
 /**
  * Type/string pattern filter for include/exclude/override matching.
@@ -1093,6 +1135,11 @@ declare class FileManager {
   getByPath(path: string): FileNode | null;
   deleteByPath(path: string): void;
   clear(): void;
+  /**
+   * Releases all stored files. Called by the core after `kubb:build:end` to
+   * free the per-plugin FileNode caches for the rest of the process lifetime.
+   */
+  dispose(): void;
   /**
    * All stored files, sorted by path length (shorter paths first).
    */
@@ -1908,8 +1955,25 @@ type KubbGenerationStartContext = {
 };
 type KubbGenerationEndContext = {
   config: Config;
-  files: Array<FileNode>;
-  sources: Map<string, string>;
+  /**
+   * Read-only view of the files Kubb wrote during this build.
+   *
+   * Keys are scoped to this run; files from earlier builds are not included.
+   * Reads go directly to `config.storage`, so nothing is buffered in memory.
+   *
+   * @example Read a generated file
+   * ```ts
+   * const code = await storage.getItem('/src/gen/pet.ts')
+   * ```
+   *
+   * @example Walk every generated file
+   * ```ts
+   * for (const path of await storage.getKeys()) {
+   *   const code = await storage.getItem(path)
+   * }
+   * ```
+   */
+  storage: Storage;
 };
 type KubbGenerationSummaryContext = {
   config: Config;
@@ -2005,9 +2069,22 @@ type BuildOutput = {
   pluginTimings: Map<string, number>;
   error?: Error;
   /**
-   * Raw generated source, keyed by absolute file path.
+   * Read-only view of every file written during this build.
+   *
+   * Keys are limited to this run. Reads go straight to `config.storage`,
+   * so nothing extra is held in memory.
+   *
+   * @example Read a generated file
+   * ```ts
+   * const code = await buildOutput.storage.getItem('/src/gen/pet.ts')
+   * ```
+   *
+   * @example List all generated file paths
+   * ```ts
+   * const paths = await buildOutput.storage.getKeys()
+   * ```
    */
-  sources: Map<string, string>;
+  storage: Storage;
 };
 /**
  * Kubb code generation instance returned by {@link createKubb}.
@@ -2021,17 +2098,34 @@ type Kubb$1 = {
    */
   readonly hooks: AsyncEventEmitter<KubbHooks>;
   /**
-   * Generated source code keyed by absolute file path. Available after `build()` or `safeBuild()` completes.
+   * Read-only view of the files from the most recent `build()` or `safeBuild()` call.
+   * Only populated after the build completes.
+   *
+   * Keys are scoped to the current run. Reads go straight to `config.storage`,
+   * so nothing extra is held in memory.
+   *
+   * @example Read a generated file
+   * ```ts
+   * const { storage } = await kubb.safeBuild()
+   * const code = await storage.getItem('/src/gen/pet.ts')
+   * ```
+   *
+   * @example Walk every generated file
+   * ```ts
+   * for (const path of await kubb.storage.getKeys()) {
+   *   const code = await kubb.storage.getItem(path)
+   * }
+   * ```
    */
-  readonly sources: Map<string, string>;
+  readonly storage: Storage;
   /**
    * Plugin driver managing all plugins. Available after `setup()` completes.
    */
-  readonly driver: PluginDriver | undefined;
+  readonly driver: PluginDriver;
   /**
    * Resolved configuration with defaults applied. Available after `setup()` completes.
    */
-  readonly config: Config | undefined;
+  readonly config: Config;
   /**
    * Resolves config and initializes the driver. `build()` calls this automatically.
    */
@@ -2061,7 +2155,7 @@ type CreateKubbOptions = {
  * Creates a Kubb instance bound to a single config entry.
  *
  * Accepts a user-facing config shape and resolves it to a full {@link Config} during
- * `setup()`. The instance then holds shared state (`hooks`, `sources`, `driver`, `config`)
+ * `setup()`. The instance then holds shared state (`hooks`, `storage`, `driver`, `config`)
  * across the `setup → build` lifecycle. Attach event listeners to `kubb.hooks` before
  * calling `setup()` or `build()`.
  *
@@ -2078,5 +2172,5 @@ type CreateKubbOptions = {
  */
 declare function createKubb(userConfig: UserConfig, options?: CreateKubbOptions): Kubb$1;
 //#endregion
-export { ResolverPathParams as $, isInputPath as A, KubbPluginSetupContext as B, KubbPluginsEndContext as C, PossibleConfig as D, KubbWarnContext as E, FileManager as F, Plugin as G, NormalizedPlugin as H, Exclude as I, ResolveBannerContext as J, PluginFactoryOptions as K, Group as L, GeneratorContext as M, defineGenerator as N, UserConfig as O, PluginDriver as P, ResolverFileParams as Q, Include as R, KubbLifecycleStartContext as S, KubbVersionNewContext as T, Output as U, KubbPluginStartContext as V, Override as W, Resolver as X, ResolveOptionsContext as Y, ResolverContext as Z, KubbGenerationSummaryContext as _, AdapterFactoryOptions as _t, InputPath as a, Logger as at, KubbHooks as b, logLevel as bt, KubbBuildStartContext as c, UserLogger as ct, KubbErrorContext as d, Storage as dt, defineResolver as et, KubbFileProcessingUpdateContext as f, createStorage as ft, KubbGenerationStartContext as g, Adapter as gt, KubbGenerationEndContext as h, createRenderer as ht, InputData as i, defineMiddleware as it, Generator as j, createKubb as k, KubbConfigEndContext as l, defineLogger as lt, KubbFilesProcessingStartContext as m, RendererFactory as mt, CLIOptions as n, defineParser as nt, Kubb$1 as o, LoggerContext as ot, KubbFilesProcessingEndContext as p, Renderer as pt, definePlugin as q, Config as r, Middleware as rt, KubbBuildEndContext as s, LoggerOptions as st, BuildOutput as t, Parser as tt, KubbDebugContext as u, DevtoolsOptions as ut, KubbHookEndContext as v, AdapterSource as vt, KubbSuccessContext as w, KubbInfoContext as x, AsyncEventEmitter as xt, KubbHookStartContext as y, createAdapter as yt, KubbPluginEndContext as z };
-//# sourceMappingURL=createKubb-ALdb8lmq.d.ts.map
+export { ResolverPathParams as $, isInputPath as A, KubbPluginSetupContext as B, KubbPluginsEndContext as C, AsyncEventEmitter as Ct, PossibleConfig as D, KubbWarnContext as E, FileManager as F, Plugin as G, NormalizedPlugin as H, Exclude as I, ResolveBannerContext as J, PluginFactoryOptions as K, Group as L, GeneratorContext as M, defineGenerator as N, UserConfig as O, PluginDriver as P, ResolverFileParams as Q, Include as R, KubbLifecycleStartContext as S, logLevel as St, KubbVersionNewContext as T, Output as U, KubbPluginStartContext as V, Override as W, Resolver as X, ResolveOptionsContext as Y, ResolverContext as Z, KubbGenerationSummaryContext as _, createRenderer as _t, InputPath as a, LoggerOptions as at, KubbHooks as b, AdapterSource as bt, KubbBuildStartContext as c, FileProcessor as ct, KubbErrorContext as d, defineParser as dt, defineResolver as et, KubbFileProcessingUpdateContext as f, DevtoolsOptions as ft, KubbGenerationStartContext as g, RendererFactory as gt, KubbGenerationEndContext as h, Renderer as ht, InputData as i, LoggerContext as it, Generator as j, createKubb as k, KubbConfigEndContext as l, FileProcessorEvents as lt, KubbFilesProcessingStartContext as m, createStorage as mt, CLIOptions as n, defineMiddleware as nt, Kubb$1 as o, UserLogger as ot, KubbFilesProcessingEndContext as p, Storage as pt, definePlugin as q, Config as r, Logger as rt, KubbBuildEndContext as s, defineLogger as st, BuildOutput as t, Middleware as tt, KubbDebugContext as u, Parser as ut, KubbHookEndContext as v, Adapter as vt, KubbSuccessContext as w, KubbInfoContext as x, createAdapter as xt, KubbHookStartContext as y, AdapterFactoryOptions as yt, KubbPluginEndContext as z };
+//# sourceMappingURL=createKubb-BSfMDBwR.d.ts.map

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_PluginDriver = require("./PluginDriver-Cu1Kj9S-.cjs");
+const require_PluginDriver = require("./PluginDriver-C1OsqGBJ.cjs");
 let node_events = require("node:events");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
@@ -525,7 +525,44 @@ function createAdapter(build) {
 }
 //#endregion
 //#region package.json
-var version = "5.0.0-beta.10";
+var version = "5.0.0-beta.11";
+//#endregion
+//#region src/createStorage.ts
+/**
+* Factory for implementing custom storage backends that control where generated files are written.
+*
+* Takes a builder function `(options: TOptions) => Storage` and returns a factory `(options?: TOptions) => Storage`.
+* Kubb provides filesystem and in-memory implementations out of the box.
+*
+* @note Call the returned factory with optional options to instantiate the storage adapter.
+*
+* @example
+* ```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() },
+*   }
+* })
+*
+* // Instantiate:
+* const storage = memoryStorage()
+* ```
+*/
+function createStorage(build) {
+	return (options) => build(options ?? {});
+}
 //#endregion
 //#region ../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
 var Node = class {
@@ -665,7 +702,8 @@ function joinSources(file) {
 * @internal
 */
 var FileProcessor = class {
-	#limit = pLimit(100);
+	events = new AsyncEventEmitter();
+	#limit = pLimit(16);
 	async parse(file, { parsers, extension } = {}) {
 		const parseExtName = extension?.[file.extname] || void 0;
 		if (!parsers || !file.extname) return joinSources(file);
@@ -673,8 +711,8 @@ var FileProcessor = class {
 		if (!parser) return joinSources(file);
 		return parser.parse(file, { extname: parseExtName });
 	}
-	async run(files, { parsers, mode = "sequential", extension, onStart, onEnd, onUpdate } = {}) {
-		await onStart?.(files);
+	async run(files, { parsers, mode = "sequential", extension } = {}) {
+		await this.events.emit("start", files);
 		const total = files.length;
 		let processed = 0;
 		const processOne = async (file) => {
@@ -684,7 +722,7 @@ var FileProcessor = class {
 			});
 			const currentProcessed = ++processed;
 			const percentage = currentProcessed / total * 100;
-			await onUpdate?.({
+			await this.events.emit("update", {
 				file,
 				source,
 				processed: currentProcessed,
@@ -694,48 +732,11 @@ var FileProcessor = class {
 		};
 		if (mode === "sequential") for (const file of files) await processOne(file);
 		else await Promise.all(files.map((file) => this.#limit(() => processOne(file))));
-		await onEnd?.(files);
+		await this.events.emit("end", files);
 		return files;
 	}
 };
 //#endregion
-//#region src/createStorage.ts
-/**
-* Factory for implementing custom storage backends that control where generated files are written.
-*
-* Takes a builder function `(options: TOptions) => Storage` and returns a factory `(options?: TOptions) => Storage`.
-* Kubb provides filesystem and in-memory implementations out of the box.
-*
-* @note Call the returned factory with optional options to instantiate the storage adapter.
-*
-* @example
-* ```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() },
-*   }
-* })
-*
-* // Instantiate:
-* const storage = memoryStorage()
-* ```
-*/
-function createStorage(build) {
-	return (options) => build(options ?? {});
-}
-//#endregion
 //#region src/storages/fsStorage.ts
 /**
 * Built-in filesystem storage driver.
@@ -811,6 +812,44 @@ const fsStorage = createStorage(() => ({
 }));
 //#endregion
 //#region src/createKubb.ts
+/**
+* Builds a `Storage` view scoped to the file paths produced by the current build.
+*
+* Reads delegate to the underlying `storage` (typically `fsStorage()`) so source bytes
+* stay where they were written instead of being held in an extra in-memory map.
+* Writing via `setItem` stores the content in the underlying storage and registers the
+* key so subsequent reads and `getKeys` are scoped to this build's output.
+*/
+function createSourcesView(storage) {
+	const paths = /* @__PURE__ */ new Set();
+	return createStorage(() => ({
+		name: `${storage.name}:sources`,
+		async hasItem(key) {
+			return paths.has(key) && await storage.hasItem(key);
+		},
+		async getItem(key) {
+			return paths.has(key) ? storage.getItem(key) : null;
+		},
+		async setItem(key, value) {
+			paths.add(key);
+			await storage.setItem(key, value);
+		},
+		async removeItem(key) {
+			paths.delete(key);
+			await storage.removeItem(key);
+		},
+		async getKeys(base) {
+			if (!base) return [...paths];
+			const result = [];
+			for (const key of paths) if (key.startsWith(base)) result.push(key);
+			return result;
+		},
+		async clear() {
+			paths.clear();
+			await storage.clear();
+		}
+	}))();
+}
 async function setup(userConfig, options = {}) {
 	const hooks = options.hooks ?? new AsyncEventEmitter();
 	const config = {
@@ -833,7 +872,7 @@ async function setup(userConfig, options = {}) {
 		plugins: userConfig.plugins ?? []
 	};
 	const driver = new require_PluginDriver.PluginDriver(config, { hooks });
-	const sources = /* @__PURE__ */ new Map();
+	const storage = createSourcesView(config.storage);
 	const diagnosticInfo = getDiagnosticInfo();
 	await hooks.emit("kubb:debug", {
 		date: /* @__PURE__ */ new Date(),
@@ -898,7 +937,7 @@ async function setup(userConfig, options = {}) {
 		config,
 		hooks,
 		driver,
-		sources
+		storage
 	};
 }
 /**
@@ -997,10 +1036,49 @@ async function runPluginAstHooks(plugin, context) {
 	}
 }
 async function safeBuild(setupResult) {
-	const { driver, hooks, sources } = setupResult;
+	const { driver, hooks, storage } = setupResult;
 	const failedPlugins = /* @__PURE__ */ new Set();
 	const pluginTimings = /* @__PURE__ */ new Map();
 	const config = driver.config;
+	const writtenPaths = /* @__PURE__ */ new Set();
+	const parsersMap = /* @__PURE__ */ new Map();
+	for (const parser of config.parsers) if (parser.extNames) for (const extname of parser.extNames) parsersMap.set(extname, parser);
+	const fileProcessor = new FileProcessor();
+	fileProcessor.events.on("start", async (processingFiles) => {
+		await hooks.emit("kubb:files:processing:start", { files: processingFiles });
+	});
+	fileProcessor.events.on("update", async ({ file, source, processed, total, percentage }) => {
+		await hooks.emit("kubb:file:processing:update", {
+			file,
+			source,
+			processed,
+			total,
+			percentage,
+			config
+		});
+		if (source) await storage.setItem(file.path, source);
+	});
+	fileProcessor.events.on("end", async (processed) => {
+		await hooks.emit("kubb:files:processing:end", { files: processed });
+		await hooks.emit("kubb:debug", {
+			date: /* @__PURE__ */ new Date(),
+			logs: [`✓ File write process completed for ${processed.length} files`]
+		});
+	});
+	async function flushPendingFiles() {
+		const files = driver.fileManager.files.filter((f) => !writtenPaths.has(f.path));
+		if (files.length === 0) return;
+		await hooks.emit("kubb:debug", {
+			date: /* @__PURE__ */ new Date(),
+			logs: [`Writing ${files.length} files...`]
+		});
+		await fileProcessor.run(files, {
+			parsers: parsersMap,
+			mode: "parallel",
+			extension: config.output.extension
+		});
+		for (const file of files) writtenPaths.add(file.path);
+	}
 	try {
 		await driver.emitSetupHooks();
 		if (driver.adapter && driver.inputNode) await hooks.emit("kubb:build:start", {
@@ -1036,6 +1114,7 @@ async function safeBuild(setupResult) {
 					},
 					upsertFile: (...files) => driver.fileManager.upsert(...files)
 				});
+				await flushPendingFiles();
 				await hooks.emit("kubb:debug", {
 					date: /* @__PURE__ */ new Date(),
 					logs: [`✓ Plugin started successfully (${formatMs(duration)})`]
@@ -1055,6 +1134,7 @@ async function safeBuild(setupResult) {
 					},
 					upsertFile: (...files) => driver.fileManager.upsert(...files)
 				});
+				await flushPendingFiles();
 				await hooks.emit("kubb:debug", {
 					date: errorTimestamp,
 					logs: [
@@ -1078,43 +1158,8 @@ async function safeBuild(setupResult) {
 			},
 			upsertFile: (...files) => driver.fileManager.upsert(...files)
 		});
+		await flushPendingFiles();
 		const files = driver.fileManager.files;
-		const parsersMap = /* @__PURE__ */ new Map();
-		for (const parser of config.parsers) if (parser.extNames) for (const extname of parser.extNames) parsersMap.set(extname, parser);
-		const fileProcessor = new FileProcessor();
-		await hooks.emit("kubb:debug", {
-			date: /* @__PURE__ */ new Date(),
-			logs: [`Writing ${files.length} files...`]
-		});
-		await fileProcessor.run(files, {
-			parsers: parsersMap,
-			mode: "parallel",
-			extension: config.output.extension,
-			onStart: async (processingFiles) => {
-				await hooks.emit("kubb:files:processing:start", { files: processingFiles });
-			},
-			onUpdate: async ({ file, source, processed, total, percentage }) => {
-				await hooks.emit("kubb:file:processing:update", {
-					file,
-					source,
-					processed,
-					total,
-					percentage,
-					config
-				});
-				if (source) {
-					await config.storage.setItem(file.path, source);
-					sources.set(file.path, source);
-				}
-			},
-			onEnd: async (processedFiles) => {
-				await hooks.emit("kubb:files:processing:end", { files: processedFiles });
-				await hooks.emit("kubb:debug", {
-					date: /* @__PURE__ */ new Date(),
-					logs: [`✓ File write process completed for ${processedFiles.length} files`]
-				});
-			}
-		});
 		await hooks.emit("kubb:build:end", {
 			files,
 			config,
@@ -1125,7 +1170,7 @@ async function safeBuild(setupResult) {
 			files,
 			driver,
 			pluginTimings,
-			sources
+			storage
 		};
 	} catch (error) {
 		return {
@@ -1134,14 +1179,14 @@ async function safeBuild(setupResult) {
 			driver,
 			pluginTimings,
 			error,
-			sources
+			storage
 		};
 	} finally {
 		driver.dispose();
 	}
 }
 async function build(setupResult) {
-	const { files, driver, failedPlugins, pluginTimings, error, sources } = await safeBuild(setupResult);
+	const { files, driver, failedPlugins, pluginTimings, error, storage } = await safeBuild(setupResult);
 	if (error) throw error;
 	if (failedPlugins.size > 0) {
 		const errors = [...failedPlugins].map(({ error }) => error);
@@ -1153,7 +1198,7 @@ async function build(setupResult) {
 		driver,
 		pluginTimings,
 		error: void 0,
-		sources
+		storage
 	};
 }
 /**
@@ -1194,7 +1239,7 @@ function inputToAdapterSource(config) {
 * Creates a Kubb instance bound to a single config entry.
 *
 * Accepts a user-facing config shape and resolves it to a full {@link Config} during
-* `setup()`. The instance then holds shared state (`hooks`, `sources`, `driver`, `config`)
+* `setup()`. The instance then holds shared state (`hooks`, `storage`, `driver`, `config`)
 * across the `setup → build` lifecycle. Attach event listeners to `kubb.hooks` before
 * calling `setup()` or `build()`.
 *
@@ -1216,14 +1261,17 @@ function createKubb(userConfig, options = {}) {
 		get hooks() {
 			return hooks;
 		},
-		get sources() {
-			return setupResult?.sources ?? /* @__PURE__ */ new Map();
+		get storage() {
+			if (!setupResult) throw new Error("[kubb] setup() must be called before accessing storage");
+			return setupResult.storage;
 		},
 		get driver() {
-			return setupResult?.driver;
+			if (!setupResult) throw new Error("[kubb] setup() must be called before accessing driver");
+			return setupResult.driver;
 		},
 		get config() {
-			return setupResult?.config;
+			if (!setupResult) throw new Error("[kubb] setup() must be called before accessing config");
+			return setupResult.config;
 		},
 		async setup() {
 			setupResult = await setup(userConfig, { hooks });