@kubb/core 5.0.0-alpha.31 → 5.0.0-alpha.32

package/dist/index.js

@@ -1,14 +1,13 @@
-import { t as __exportAll } from "./chunk-O_arW02_.js";
+import { t as __name } from "./chunk--u3MIqq1.js";
 import { EventEmitter } from "node:events";
 import { readFileSync } from "node:fs";
 import { access, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
-import path, { basename, dirname, extname, join, posix, relative, resolve } from "node:path";
-import { composeTransformers, composeTransformers as composeTransformers$1, definePrinter, isOperationNode, isSchemaNode, transform, walk } from "@kubb/ast";
-import { Fabric, createFabric, createReactFabric } from "@kubb/react-fabric";
-import { fsPlugin } from "@kubb/react-fabric/plugins";
+import path, { basename, dirname, extname, join, posix, resolve } from "node:path";
+import { composeTransformers, composeTransformers as composeTransformers$1, createExport, createFile, createSource, definePrinter, isOperationNode, isSchemaNode, transform, walk } from "@kubb/ast";
 import { performance } from "node:perf_hooks";
 import { deflateSync } from "fflate";
 import { x } from "tinyexec";
+import { Fabric, createReactFabric } from "@kubb/react-fabric";
 import { jsx } from "@kubb/react-fabric/jsx-runtime";
 import { version } from "node:process";
 import { sortBy } from "remeda";
@@ -333,6 +332,24 @@ async function clean(path) {
 	});
 }
 //#endregion
+//#region ../../internals/utils/src/string.ts
+/**
+* Strips the file extension from a path or file name.
+* Only removes the last `.ext` segment when the dot is not part of a directory name.
+*
+* @example
+* trimExtName('petStore.ts')             // 'petStore'
+* trimExtName('/src/models/pet.ts')      // '/src/models/pet'
+* trimExtName('/project.v2/gen/pet.ts')  // '/project.v2/gen/pet'
+* trimExtName('noExtension')             // 'noExtension'
+*/
+function trimExtName$1(text) {
+	const dotIndex = text.lastIndexOf(".");
+	if (dotIndex > 0 && !text.includes("/", dotIndex)) return text.slice(0, dotIndex);
+	return text;
+}
+__name(trimExtName$1, "trimExtName");
+//#endregion
 //#region ../../internals/utils/src/promise.ts
 /** Returns `true` when `result` is a rejected `Promise.allSettled` result with a typed `reason`.
 *
@@ -705,78 +722,6 @@ const formatters = {
 	}
 };
 //#endregion
-//#region src/defineParser.ts
-/**
-* Defines a parser with type safety.
-*
-* Use this function to create parsers that transform generated files to strings
-* based on their extension.
-*
-* @example
-* ```ts
-* import { defineParser } from '@kubb/core'
-*
-* export const jsonParser = defineParser({
-*   name: 'json',
-*   extNames: ['.json'],
-*   parse(file) {
-*     return file.sources.map((s) => s.value).join('\n')
-*   },
-* })
-* ```
-*/
-function defineParser(parser) {
-	return {
-		install() {},
-		type: "parser",
-		...parser
-	};
-}
-//#endregion
-//#region src/devtools.ts
-/**
-* Encodes a `RootNode` 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.
-*
-* Use {@link decodeAst} to reverse.
-*/
-function encodeAst(root) {
-	const compressed = deflateSync(new TextEncoder().encode(JSON.stringify(root)));
-	return Buffer.from(compressed).toString("base64url");
-}
-/**
-* Constructs the Kubb Studio URL for the given `RootNode`.
-* When `options.ast` is `true`, navigates to the AST inspector (`/ast`).
-* The `root` 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(root, studioUrl, options = {}) {
-	return `${studioUrl.replace(/\/$/, "")}${options.ast ? "/ast" : ""}?root=${encodeAst(root)}`;
-}
-/**
-* Opens the Kubb Studio URL for the given `RootNode` in the default browser —
-*
-* Falls back to printing the URL if the browser cannot be launched.
-*/
-async function openInStudio(root, studioUrl, options = {}) {
-	const url = getStudioUrl(root, 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 ../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
 var Node = class {
 	value;
@@ -904,6 +849,194 @@ function validateConcurrency(concurrency) {
 	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) throw new TypeError("Expected `concurrency` to be a number from 1 and up");
 }
 //#endregion
+//#region src/FileProcessor.ts
+function joinSources(file) {
+	return file.sources.map((item) => item.value).filter((value) => value != null).join("\n\n");
+}
+/**
+* Converts a single file to a string using the registered parsers.
+* Falls back to joining source values when no matching parser is found.
+*/
+var FileProcessor = class {
+	#limit = pLimit(100);
+	async parse(file, { parsers, extension } = {}) {
+		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 run(files, { parsers, mode = "sequential", extension, onStart, onEnd, onUpdate } = {}) {
+		await onStart?.(files);
+		const total = files.length;
+		let processed = 0;
+		const processOne = async (file) => {
+			const source = await this.parse(file, {
+				extension,
+				parsers
+			});
+			const currentProcessed = ++processed;
+			const percentage = currentProcessed / total * 100;
+			await onUpdate?.({
+				file,
+				source,
+				processed: currentProcessed,
+				percentage,
+				total
+			});
+		};
+		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);
+		return files;
+	}
+};
+//#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.
+*
+* Use {@link decodeAst} to reverse.
+*/
+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 {
+		...a,
+		sources: [...a.sources || [], ...b.sources || []],
+		imports: [...a.imports || [], ...b.imports || []],
+		exports: [...a.exports || [], ...b.exports || []]
+	};
+}
+/**
+* In-memory file store for generated files.
+*
+* Files with the same `path` are merged — sources, imports, and exports are concatenated.
+* The `files` getter returns all stored files sorted by path length (shortest first).
+*
+* @example
+* ```ts
+* import { FileManager } from '@kubb/core'
+*
+* const manager = new FileManager()
+* manager.upsert(myFile)
+* console.log(manager.files) // all stored files
+* ```
+*/
+var FileManager = class {
+	#cache = /* @__PURE__ */ new Map();
+	#filesCache = null;
+	/**
+	* Adds one or more files. Files with the same path are merged — sources, imports,
+	* and exports from all calls with the same path are concatenated together.
+	*/
+	add(...files) {
+		const resolvedFiles = [];
+		const mergedFiles = /* @__PURE__ */ new Map();
+		files.forEach((file) => {
+			const existing = mergedFiles.get(file.path);
+			if (existing) mergedFiles.set(file.path, mergeFile(existing, file));
+			else mergedFiles.set(file.path, file);
+		});
+		for (const file of mergedFiles.values()) {
+			const resolvedFile = createFile(file);
+			this.#cache.set(resolvedFile.path, resolvedFile);
+			this.#filesCache = null;
+			resolvedFiles.push(resolvedFile);
+		}
+		return resolvedFiles;
+	}
+	/**
+	* Adds or merges one or more files.
+	* If a file with the same path already exists, its sources/imports/exports are merged together.
+	*/
+	upsert(...files) {
+		const resolvedFiles = [];
+		const mergedFiles = /* @__PURE__ */ new Map();
+		files.forEach((file) => {
+			const existing = mergedFiles.get(file.path);
+			if (existing) mergedFiles.set(file.path, mergeFile(existing, file));
+			else mergedFiles.set(file.path, file);
+		});
+		for (const file of mergedFiles.values()) {
+			const existing = this.#cache.get(file.path);
+			const resolvedFile = createFile(existing ? mergeFile(existing, file) : file);
+			this.#cache.set(resolvedFile.path, resolvedFile);
+			this.#filesCache = null;
+			resolvedFiles.push(resolvedFile);
+		}
+		return resolvedFiles;
+	}
+	getByPath(path) {
+		return this.#cache.get(path) ?? null;
+	}
+	deleteByPath(path) {
+		this.#cache.delete(path);
+		this.#filesCache = null;
+	}
+	clear() {
+		this.#cache.clear();
+		this.#filesCache = null;
+	}
+	/**
+	* All stored files, sorted by path length (shorter paths first).
+	* Barrel/index files (e.g. index.ts) are sorted last within each length bucket.
+	*/
+	get files() {
+		if (this.#filesCache) return this.#filesCache;
+		const keys = [...this.#cache.keys()].sort((a, b) => {
+			if (a.length !== b.length) return a.length - b.length;
+			const aIsIndex = trimExtName$1(a).endsWith("index");
+			if (aIsIndex !== trimExtName$1(b).endsWith("index")) return aIsIndex ? 1 : -1;
+			return 0;
+		});
+		const files = [];
+		for (const key of keys) {
+			const file = this.#cache.get(key);
+			if (file) files.push(file);
+		}
+		this.#filesCache = files;
+		return files;
+	}
+};
+//#endregion
 //#region src/utils/executeStrategies.ts
 /**
 * Runs promise functions in sequence, threading each result into the next call.
@@ -970,12 +1103,18 @@ var PluginDriver = class {
 	config;
 	options;
 	/**
-	* The universal `@kubb/ast` `RootNode` produced by the adapter, set by
+	* The universal `@kubb/ast` `InputNode` produced by the adapter, set by
 	* the build pipeline after the adapter's `parse()` resolves.
 	*/
-	rootNode = void 0;
+	inputNode = void 0;
 	adapter = void 0;
 	#studioIsOpen = false;
+	/**
+	* Central file store for all generated files.
+	* Plugins should use `this.addFile()` / `this.upsertFile()` (via their context) to
+	* add files; this property gives direct read/write access when needed.
+	*/
+	fileManager = new FileManager();
 	plugins = /* @__PURE__ */ new Map();
 	constructor(config, options) {
 		this.config = config;
@@ -1000,7 +1139,6 @@ var PluginDriver = class {
 	getContext(plugin) {
 		const driver = this;
 		const baseContext = {
-			fabric: driver.options.fabric,
 			config: driver.config,
 			get root() {
 				return resolve(driver.config.root, driver.config.output.path);
@@ -1014,13 +1152,13 @@ var PluginDriver = class {
 			requirePlugin: driver.requirePlugin.bind(driver),
 			driver,
 			addFile: async (...files) => {
-				await this.options.fabric.addFile(...files);
+				driver.fileManager.add(...files);
 			},
 			upsertFile: async (...files) => {
-				await this.options.fabric.upsertFile(...files);
+				driver.fileManager.upsert(...files);
 			},
-			get rootNode() {
-				return driver.rootNode;
+			get inputNode() {
+				return driver.inputNode;
 			},
 			get adapter() {
 				return driver.adapter;
@@ -1043,10 +1181,10 @@ var PluginDriver = class {
 			openInStudio(options) {
 				if (!driver.config.devtools || driver.#studioIsOpen) return;
 				if (typeof driver.config.devtools !== "object") throw new Error("Devtools must be an object");
-				if (!driver.rootNode || !driver.adapter) throw new Error("adapter is not defined, make sure you have set the parser in kubb.config.ts");
+				if (!driver.inputNode || !driver.adapter) throw new Error("adapter is not defined, make sure you have set the parser in kubb.config.ts");
 				driver.#studioIsOpen = true;
 				const studioUrl = driver.config.devtools?.studioUrl ?? "https://studio.kubb.dev";
-				return openInStudio(driver.rootNode, studioUrl, options);
+				return openInStudio(driver.inputNode, studioUrl, options);
 			}
 		};
 		const mergedExtras = {};
@@ -1075,14 +1213,14 @@ var PluginDriver = class {
 			options
 		});
 		if (!path) throw new Error(`Filepath should be defined for resolvedName "${resolvedName}" and pluginName "${pluginName}"`);
-		return {
+		return createFile({
 			path,
 			baseName: basename(path),
 			meta: { pluginName },
 			sources: [],
 			imports: [],
 			exports: []
-		};
+		});
 	}
 	/**
 	* @deprecated use resolvers context instead
@@ -1366,19 +1504,19 @@ var PluginDriver = class {
 /**
 * Handles the return value of a plugin AST hook or generator method.
 *
-* - React element → rendered via an isolated react-fabric context, files merged into `fabric`
-* - `Array<KubbFile.File>` → upserted directly into `fabric`
+* - React element → rendered via an isolated react-fabric context, files stored in `driver.fileManager`
+* - `Array<FileNode>` → upserted directly into `driver.fileManager`
 * - `void` / `null` / `undefined` → no-op (plugin handled it via `this.upsertFile`)
 */
-async function applyHookResult(result, fabric) {
+async function applyHookResult(result, driver) {
 	if (!result) return;
 	if (Array.isArray(result)) {
-		await fabric.upsertFile(...result);
+		driver.fileManager.upsert(...result);
 		return;
 	}
 	const fabricChild = createReactFabric();
 	await fabricChild.render(/* @__PURE__ */ jsx(Fabric, { children: result }));
-	fabric.context.fileManager.upsert(...fabricChild.files);
+	driver.fileManager.upsert(...fabricChild.files);
 	fabricChild.unmount();
 }
 //#endregion
@@ -1479,7 +1617,7 @@ const fsStorage = createStorage(() => ({
 }));
 //#endregion
 //#region package.json
-var version$1 = "5.0.0-alpha.31";
+var version$1 = "5.0.0-alpha.32";
 //#endregion
 //#region src/utils/diagnostics.ts
 /**
@@ -1501,7 +1639,7 @@ function getDiagnosticInfo() {
 //#region src/utils/TreeNode.ts
 /**
 * Tree structure used to build per-directory barrel (`index.ts`) files from a
-* flat list of generated {@link KubbFile.File} entries.
+* flat list of generated {@link FileNode} entries.
 *
 * Each node represents either a directory or a file within the output tree.
 * Use {@link TreeNode.build} to construct a root node from a file list, then
@@ -1662,36 +1800,36 @@ function getBarrelFilesByRoot(root, files) {
 	const cachedFiles = /* @__PURE__ */ new Map();
 	TreeNode.build(files, root)?.forEach((treeNode) => {
 		if (!treeNode?.children || !treeNode.parent?.data.path) return;
-		const barrelFile = {
+		const barrelFile = createFile({
 			path: join(treeNode.parent?.data.path, "index.ts"),
 			baseName: "index.ts",
 			exports: [],
 			imports: [],
 			sources: []
-		};
+		});
 		const previousBarrelFile = cachedFiles.get(barrelFile.path);
 		treeNode.leaves.forEach((item) => {
 			if (!item.data.name) return;
 			(item.data.file?.sources || []).forEach((source) => {
 				if (!item.data.file?.path || !source.isIndexable || !source.name) return;
 				if (previousBarrelFile?.sources.some((item) => item.name === source.name && item.isTypeOnly === source.isTypeOnly)) return;
-				barrelFile.exports.push({
+				barrelFile.exports.push(createExport({
 					name: [source.name],
 					path: getRelativePath(treeNode.parent?.data.path, item.data.path),
 					isTypeOnly: source.isTypeOnly
-				});
-				barrelFile.sources.push({
+				}));
+				barrelFile.sources.push(createSource({
 					name: source.name,
 					isTypeOnly: source.isTypeOnly,
 					value: "",
 					isExportable: false,
 					isIndexable: false
-				});
+				}));
 			});
 		});
 		if (previousBarrelFile) {
 			previousBarrelFile.sources.push(...barrelFile.sources);
-			previousBarrelFile.exports?.push(...barrelFile.exports || []);
+			previousBarrelFile.exports.push(...barrelFile.exports);
 		} else cachedFiles.set(barrelFile.path, barrelFile);
 	});
 	return [...cachedFiles.values()];
@@ -1717,7 +1855,7 @@ async function getBarrelFiles(files, { type, meta = {}, root, output }) {
 	if (type === "all") return barrelFiles.map((file) => {
 		return {
 			...file,
-			exports: file.exports?.map((exportItem) => {
+			exports: file.exports.map((exportItem) => {
 				return {
 					...exportItem,
 					name: void 0
@@ -1748,7 +1886,7 @@ function isInputPath(config) {
 * - Validates the input path (when applicable).
 * - Applies config defaults (`root`, `output.*`, `devtools`).
 * - Creates the Fabric instance and wires storage, format, and lint hooks.
-* - Runs the adapter (if configured) to produce the universal `RootNode`.
+* - Runs the adapter (if configured) to produce the universal `InputNode`.
 *   When no adapter is supplied and `@kubb/adapter-oas` is installed as an
 *
 * Pass the returned {@link SetupResult} directly to {@link safeBuild} or {@link build}
@@ -1816,53 +1954,7 @@ async function setup(options) {
 		});
 		await storage?.clear(resolve(config.root, config.output.path));
 	}
-	const fabric = createFabric();
-	fabric.use(fsPlugin);
-	for (const parser of config.parsers) fabric.use(parser);
-	fabric.use(defineParser({
-		name: "fallback",
-		extNames: void 0,
-		parse(file) {
-			return file.sources.map((item) => item.value).filter((value) => value != null).join("\n\n");
-		}
-	}));
-	fabric.context.on("files:processing:start", (files) => {
-		events.emit("files:processing:start", files);
-		events.emit("debug", {
-			date: /* @__PURE__ */ new Date(),
-			logs: [`Writing ${files.length} files...`]
-		});
-	});
-	fabric.context.on("file:processing:update", async (params) => {
-		const { file, source } = params;
-		await events.emit("file:processing:update", {
-			...params,
-			config,
-			source
-		});
-		if (source) {
-			const key = relative(resolve(config.root), file.path);
-			await storage?.setItem(key, source);
-			sources.set(file.path, source);
-		}
-	});
-	fabric.context.on("files:processing:end", async (files) => {
-		await events.emit("files:processing:end", files);
-		await events.emit("debug", {
-			date: /* @__PURE__ */ new Date(),
-			logs: [`✓ File write process completed for ${files.length} files`]
-		});
-	});
-	await events.emit("debug", {
-		date: /* @__PURE__ */ new Date(),
-		logs: [
-			"✓ Fabric initialized",
-			`  • Storage: ${storage ? storage.name : "disabled (dry-run)"}`,
-			`  • Barrel type: ${config.output.barrelType || "none"}`
-		]
-	});
 	const driver = new PluginDriver(config, {
-		fabric,
 		events,
 		concurrency: 15
 	});
@@ -1874,21 +1966,21 @@ async function setup(options) {
 		logs: [`Running adapter: ${adapter.name}`]
 	});
 	driver.adapter = adapter;
-	driver.rootNode = await adapter.parse(source);
+	driver.inputNode = await adapter.parse(source);
 	await events.emit("debug", {
 		date: /* @__PURE__ */ new Date(),
 		logs: [
-			`✓ Adapter '${adapter.name}' resolved RootNode`,
-			`  • Schemas: ${driver.rootNode.schemas.length}`,
-			`  • Operations: ${driver.rootNode.operations.length}`
+			`✓ Adapter '${adapter.name}' resolved InputNode`,
+			`  • Schemas: ${driver.inputNode.schemas.length}`,
+			`  • Operations: ${driver.inputNode.operations.length}`
 		]
 	});
 	return {
 		config,
 		events,
-		fabric,
 		driver,
-		sources
+		sources,
+		storage
 	};
 }
 /**
@@ -1898,7 +1990,7 @@ async function setup(options) {
 * Pass an existing {@link SetupResult} via `overrides` to skip the setup phase.
 */
 async function build(options, overrides) {
-	const { fabric, files, driver, failedPlugins, pluginTimings, error, sources } = await safeBuild(options, overrides);
+	const { files, driver, failedPlugins, pluginTimings, error, sources } = await safeBuild(options, overrides);
 	if (error) throw error;
 	if (failedPlugins.size > 0) {
 		const errors = [...failedPlugins].map(({ error }) => error);
@@ -1906,7 +1998,6 @@ async function build(options, overrides) {
 	}
 	return {
 		failedPlugins,
-		fabric,
 		files,
 		driver,
 		pluginTimings,
@@ -1921,15 +2012,15 @@ async function build(options, overrides) {
 * - Each hook accepts a single handler **or an array** — all entries are called in sequence.
 * - Nodes that are excluded by `exclude`/`include` plugin options are skipped automatically.
 * - Return values are handled via `applyHookResult`: React elements are rendered,
-*   `KubbFile.File[]` are written via upsert, and `void` is a no-op (manual handling).
+*   `FileNode[]` are written via upsert, and `void` is a no-op (manual handling).
 * - Barrel files are generated automatically when `output.barrelType` is set.
 */
 async function runPluginAstHooks(plugin, context) {
-	const { adapter, rootNode, resolver, fabric } = context;
+	const { adapter, inputNode, resolver, driver } = context;
 	const { exclude, include, override } = plugin.options;
-	if (!adapter || !rootNode) throw new Error(`[${plugin.name}] No adapter found. Add an OAS adapter (e.g. pluginOas()) before this plugin in your Kubb config.`);
+	if (!adapter || !inputNode) throw new Error(`[${plugin.name}] No adapter found. Add an OAS adapter (e.g. pluginOas()) before this plugin in your Kubb config.`);
 	const collectedOperations = [];
-	await walk(rootNode, {
+	await walk(inputNode, {
 		depth: "shallow",
 		async schema(node) {
 			if (!plugin.schema) return;
@@ -1941,7 +2032,7 @@ async function runPluginAstHooks(plugin, context) {
 				override
 			});
 			if (options === null) return;
-			await applyHookResult(await plugin.schema.call(context, transformedNode, options), fabric);
+			await applyHookResult(await plugin.schema.call(context, transformedNode, options), driver);
 		},
 		async operation(node) {
 			const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
@@ -1953,24 +2044,24 @@ async function runPluginAstHooks(plugin, context) {
 			});
 			if (options !== null) {
 				collectedOperations.push(transformedNode);
-				if (plugin.operation) await applyHookResult(await plugin.operation.call(context, transformedNode, options), fabric);
+				if (plugin.operation) await applyHookResult(await plugin.operation.call(context, transformedNode, options), driver);
 			}
 		}
 	});
-	if (plugin.operations && collectedOperations.length > 0) await applyHookResult(await plugin.operations.call(context, collectedOperations, plugin.options), fabric);
+	if (plugin.operations && collectedOperations.length > 0) await applyHookResult(await plugin.operations.call(context, collectedOperations, plugin.options), driver);
 }
 /**
 * Runs a full Kubb build and captures errors instead of throwing.
 *
 * - Installs each plugin in order, recording failures in `failedPlugins`.
 * - Generates the root barrel file when `output.barrelType` is set.
-* - Writes all files through Fabric.
+* - Writes all files through the driver's FileManager and FileProcessor.
 *
 * Returns a {@link BuildOutput} even on failure — inspect `error` and
 * `failedPlugins` to determine whether the build succeeded.
 */
 async function safeBuild(options, overrides) {
-	const { fabric, driver, events, sources } = overrides ? overrides : await setup(options);
+	const { driver, events, sources, storage } = overrides ? overrides : await setup(options);
 	const failedPlugins = /* @__PURE__ */ new Set();
 	const pluginTimings = /* @__PURE__ */ new Map();
 	const config = driver.config;
@@ -1990,7 +2081,7 @@ async function safeBuild(options, overrides) {
 				await plugin.buildStart.call(context);
 				if (plugin.schema || plugin.operation || plugin.operations) await runPluginAstHooks(plugin, context);
 				if (output) {
-					const barrelFiles = await getBarrelFiles(fabric.files, {
+					const barrelFiles = await getBarrelFiles(driver.fileManager.files, {
 						type: output.barrelType ?? "named",
 						root,
 						output,
@@ -2044,15 +2135,15 @@ async function safeBuild(options, overrides) {
 					`  • Path: ${rootPath}`
 				]
 			});
-			const barrelFiles = fabric.files.filter((file) => {
+			const barrelFiles = driver.fileManager.files.filter((file) => {
 				return file.sources.some((source) => source.isIndexable);
 			});
 			await events.emit("debug", {
 				date: /* @__PURE__ */ new Date(),
 				logs: [`Found ${barrelFiles.length} indexable files for barrel export`]
 			});
-			const existingBarrel = fabric.files.find((f) => f.path === rootPath);
-			const rootFile = {
+			const existingBarrel = driver.fileManager.files.find((f) => f.path === rootPath);
+			const rootFile = createFile({
 				path: rootPath,
 				baseName: BARREL_FILENAME,
 				exports: buildBarrelExports({
@@ -2061,26 +2152,59 @@ async function safeBuild(options, overrides) {
 					existingExports: new Set(existingBarrel?.exports?.flatMap((e) => Array.isArray(e.name) ? e.name : [e.name]).filter((n) => Boolean(n)) ?? []),
 					config,
 					driver
-				}),
+				}).map((e) => createExport(e)),
 				sources: [],
 				imports: [],
 				meta: {}
-			};
-			await fabric.upsertFile(rootFile);
+			});
+			driver.fileManager.upsert(rootFile);
 			await events.emit("debug", {
 				date: /* @__PURE__ */ new Date(),
 				logs: [`✓ Generated barrel file (${rootFile.exports?.length || 0} exports)`]
 			});
 		}
-		const files = [...fabric.files];
-		await fabric.write({ extension: config.output.extension });
+		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 events.emit("debug", {
+			date: /* @__PURE__ */ new Date(),
+			logs: [`Writing ${files.length} files...`]
+		});
+		await fileProcessor.run(files, {
+			parsers: parsersMap,
+			extension: config.output.extension,
+			onStart: async (processingFiles) => {
+				await events.emit("files:processing:start", processingFiles);
+			},
+			onUpdate: async ({ file, source, processed, total, percentage }) => {
+				await events.emit("file:processing:update", {
+					file,
+					source,
+					processed,
+					total,
+					percentage,
+					config
+				});
+				if (source) {
+					await storage?.setItem(file.path, source);
+					sources.set(file.path, source);
+				}
+			},
+			onEnd: async (processedFiles) => {
+				await events.emit("files:processing:end", processedFiles);
+				await events.emit("debug", {
+					date: /* @__PURE__ */ new Date(),
+					logs: [`✓ File write process completed for ${processedFiles.length} files`]
+				});
+			}
+		});
 		for (const plugin of driver.plugins.values()) if (plugin.buildEnd) {
 			const context = driver.getContext(plugin);
 			await plugin.buildEnd.call(context);
 		}
 		return {
 			failedPlugins,
-			fabric,
 			files,
 			driver,
 			pluginTimings,
@@ -2089,7 +2213,6 @@ async function safeBuild(options, overrides) {
 	} catch (error) {
 		return {
 			failedPlugins,
-			fabric,
 			files: [],
 			driver,
 			pluginTimings,
@@ -2110,11 +2233,11 @@ function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, dri
 			if (!pluginOptions || pluginOptions.output?.barrelType === false) return [];
 			const exportName = config.output.barrelType === "all" ? void 0 : source.name ? [source.name] : void 0;
 			if (exportName?.some((n) => existingExports.has(n))) return [];
-			return [{
+			return [createExport({
 				name: exportName,
 				path: getRelativePath(rootDir, file.path),
 				isTypeOnly: config.output.barrelType === "all" ? containsOnlyTypes : source.isTypeOnly
-			}];
+			})];
 		});
 	});
 }
@@ -2226,19 +2349,19 @@ function mergeGenerators(generators) {
 		async schema(node, options) {
 			for (const gen of generators) {
 				if (!gen.schema) continue;
-				await applyHookResult(await gen.schema.call(this, node, options), this.fabric);
+				await applyHookResult(await gen.schema.call(this, node, options), this.driver);
 			}
 		},
 		async operation(node, options) {
 			for (const gen of generators) {
 				if (!gen.operation) continue;
-				await applyHookResult(await gen.operation.call(this, node, options), this.fabric);
+				await applyHookResult(await gen.operation.call(this, node, options), this.driver);
 			}
 		},
 		async operations(nodes, options) {
 			for (const gen of generators) {
 				if (!gen.operations) continue;
-				await applyHookResult(await gen.operations.call(this, nodes, options), this.fabric);
+				await applyHookResult(await gen.operations.call(this, nodes, options), this.driver);
 			}
 		}
 	};
@@ -2261,6 +2384,34 @@ function defineLogger(logger) {
 	return logger;
 }
 //#endregion
+//#region src/defineParser.ts
+/**
+* Defines a parser with type safety.
+*
+* Use this function to create parsers that transform generated files to strings
+* based on their extension.
+*
+* @example
+* ```ts
+* import { defineParser } from '@kubb/core'
+*
+* export const jsonParser = defineParser({
+*   name: 'json',
+*   extNames: ['.json'],
+*   parse(file) {
+*     return file.sources.map((s) => s.value).join('\n')
+*   },
+* })
+* ```
+*/
+function defineParser(parser) {
+	return {
+		install() {},
+		type: "parser",
+		...parser
+	};
+}
+//#endregion
 //#region src/definePresets.ts
 /**
 * Creates a typed presets registry object — a named collection of {@link Preset} entries.
@@ -2414,7 +2565,7 @@ function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }, { root
 /**
 * Default file resolver used by `defineResolver`.
 *
-* Resolves a `KubbFile.File` by combining name resolution (`resolver.default`) with
+* Resolves a `FileNode` by combining name resolution (`resolver.default`) with
 * path resolution (`resolver.resolvePath`). The resolved file always has empty
 * `sources`, `imports`, and `exports` arrays — consumers populate those separately.
 *
@@ -2447,14 +2598,14 @@ function defaultResolveFile({ name, extname, tag, path: groupPath }, context) {
 		tag,
 		path: groupPath
 	}, context);
-	return {
+	return createFile({
 		path: filePath,
 		baseName: path.basename(filePath),
 		meta: { pluginName: this.pluginName },
 		sources: [],
 		imports: [],
 		exports: []
-	};
+	});
 }
 /**
 * Generates the default "Generated by Kubb" banner from config and optional node metadata.
@@ -2506,13 +2657,13 @@ function buildDefaultBanner({ title, description, version, config }) {
 *
 * @example Function banner with node
 * ```ts
-* defaultResolveBanner(rootNode, { output: { banner: (node) => `// v${node.version}` }, config })
+* defaultResolveBanner(inputNode, { output: { banner: (node) => `// v${node.version}` }, config })
 * // → '// v3.0.0'
 * ```
 *
 * @example No user banner — Kubb notice with OAS metadata
 * ```ts
-* defaultResolveBanner(rootNode, { config })
+* defaultResolveBanner(inputNode, { config })
 * // → '/** Generated by Kubb ... Title: Pet Store ... *\/'
 * ```
 *
@@ -2548,7 +2699,7 @@ function defaultResolveBanner(node, { output, config }) {
 *
 * @example Function footer with node
 * ```ts
-* defaultResolveFooter(rootNode, { output: { footer: (node) => `// ${node.title}` }, config })
+* defaultResolveFooter(inputNode, { output: { footer: (node) => `// ${node.title}` }, config })
 * // → '// Pet Store'
 * ```
 */
@@ -2564,7 +2715,7 @@ function defaultResolveFooter(node, { output }) {
 * - `default` — name casing strategy (camelCase / PascalCase)
 * - `resolveOptions` — include/exclude/override filtering
 * - `resolvePath` — output path computation
-* - `resolveFile` — full `KubbFile.File` construction
+* - `resolveFile` — full `FileNode` construction
 *
 * Methods in the builder have access to `this` (the full resolver object), so they
 * can call other resolver methods without circular imports.
@@ -2614,9 +2765,6 @@ function defineResolver(build) {
 	};
 }
 //#endregion
-//#region src/KubbFile.ts
-var KubbFile_exports = /* @__PURE__ */ __exportAll({});
-//#endregion
 //#region src/storages/memoryStorage.ts
 /**
 * In-memory storage driver. Useful for testing and dry-run scenarios where
@@ -2919,6 +3067,6 @@ function satisfiesDependency(dependency, version, cwd) {
 	return satisfies(semVer, version);
 }
 //#endregion
-export { AsyncEventEmitter, FunctionParams, KubbFile_exports as KubbFile, PluginDriver, URLPath, build, build as default, buildDefaultBanner, composeTransformers, createAdapter, createPlugin, createStorage, defaultResolveBanner, defaultResolveFile, defaultResolveFooter, defaultResolveOptions, defaultResolvePath, defineConfig, defineGenerator, defineLogger, defineParser, definePresets, definePrinter, defineResolver, detectFormatter, detectLinter, formatters, fsStorage, getBarrelFiles, getConfigs, getMode, getPreset, isInputPath, linters, logLevel, memoryStorage, mergeGenerators, safeBuild, satisfiesDependency, setup };
+export { AsyncEventEmitter, FunctionParams, PluginDriver, URLPath, build, build as default, buildDefaultBanner, composeTransformers, createAdapter, createPlugin, createStorage, defaultResolveBanner, defaultResolveFile, defaultResolveFooter, defaultResolveOptions, defaultResolvePath, defineConfig, defineGenerator, defineLogger, defineParser, definePresets, definePrinter, defineResolver, detectFormatter, detectLinter, formatters, fsStorage, getBarrelFiles, getConfigs, getMode, getPreset, isInputPath, linters, logLevel, memoryStorage, mergeGenerators, safeBuild, satisfiesDependency, setup };
 
 //# sourceMappingURL=index.js.map