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

package/dist/index.cjs

@@ -2,18 +2,17 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_chunk = require("./chunk-MlS0t1Af.cjs");
+const require_chunk = require("./chunk-ByKO4r7w.cjs");
 let node_events = require("node:events");
 let node_fs = require("node:fs");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
 let _kubb_ast = require("@kubb/ast");
-let _kubb_react_fabric = require("@kubb/react-fabric");
-let _kubb_react_fabric_plugins = require("@kubb/react-fabric/plugins");
 let node_perf_hooks = require("node:perf_hooks");
 let fflate = require("fflate");
 let tinyexec = require("tinyexec");
+let _kubb_react_fabric = require("@kubb/react-fabric");
 let _kubb_react_fabric_jsx_runtime = require("@kubb/react-fabric/jsx-runtime");
 let node_process = require("node:process");
 let remeda = require("remeda");
@@ -339,6 +338,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;
+}
+require_chunk.__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`.
 *
@@ -711,78 +728,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 = (0, fflate.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 (0, tinyexec.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;
@@ -910,6 +855,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 = (0, fflate.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 (0, tinyexec.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 = (0, _kubb_ast.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 = (0, _kubb_ast.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.
@@ -976,12 +1109,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;
@@ -1006,7 +1145,6 @@ var PluginDriver = class {
 	getContext(plugin) {
 		const driver = this;
 		const baseContext = {
-			fabric: driver.options.fabric,
 			config: driver.config,
 			get root() {
 				return (0, node_path.resolve)(driver.config.root, driver.config.output.path);
@@ -1020,13 +1158,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;
@@ -1049,10 +1187,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 = {};
@@ -1081,14 +1219,14 @@ var PluginDriver = class {
 			options
 		});
 		if (!path) throw new Error(`Filepath should be defined for resolvedName "${resolvedName}" and pluginName "${pluginName}"`);
-		return {
+		return (0, _kubb_ast.createFile)({
 			path,
 			baseName: (0, node_path.basename)(path),
 			meta: { pluginName },
 			sources: [],
 			imports: [],
 			exports: []
-		};
+		});
 	}
 	/**
 	* @deprecated use resolvers context instead
@@ -1372,19 +1510,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 = (0, _kubb_react_fabric.createReactFabric)();
 	await fabricChild.render(/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.Fabric, { children: result }));
-	fabric.context.fileManager.upsert(...fabricChild.files);
+	driver.fileManager.upsert(...fabricChild.files);
 	fabricChild.unmount();
 }
 //#endregion
@@ -1485,7 +1623,7 @@ const fsStorage = createStorage(() => ({
 }));
 //#endregion
 //#region package.json
-var version = "5.0.0-alpha.31";
+var version = "5.0.0-alpha.32";
 //#endregion
 //#region src/utils/diagnostics.ts
 /**
@@ -1507,7 +1645,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
@@ -1668,36 +1806,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 = (0, _kubb_ast.createFile)({
 			path: (0, node_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((0, _kubb_ast.createExport)({
 					name: [source.name],
 					path: getRelativePath(treeNode.parent?.data.path, item.data.path),
 					isTypeOnly: source.isTypeOnly
-				});
-				barrelFile.sources.push({
+				}));
+				barrelFile.sources.push((0, _kubb_ast.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()];
@@ -1723,7 +1861,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
@@ -1754,7 +1892,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}
@@ -1822,53 +1960,7 @@ async function setup(options) {
 		});
 		await storage?.clear((0, node_path.resolve)(config.root, config.output.path));
 	}
-	const fabric = (0, _kubb_react_fabric.createFabric)();
-	fabric.use(_kubb_react_fabric_plugins.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 = (0, node_path.relative)((0, node_path.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
 	});
@@ -1880,21 +1972,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
 	};
 }
 /**
@@ -1904,7 +1996,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);
@@ -1912,7 +2004,6 @@ async function build(options, overrides) {
 	}
 	return {
 		failedPlugins,
-		fabric,
 		files,
 		driver,
 		pluginTimings,
@@ -1927,15 +2018,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 (0, _kubb_ast.walk)(rootNode, {
+	await (0, _kubb_ast.walk)(inputNode, {
 		depth: "shallow",
 		async schema(node) {
 			if (!plugin.schema) return;
@@ -1947,7 +2038,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 ? (0, _kubb_ast.transform)(node, plugin.transformer) : node;
@@ -1959,24 +2050,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;
@@ -1996,7 +2087,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,
@@ -2050,15 +2141,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 = (0, _kubb_ast.createFile)({
 				path: rootPath,
 				baseName: BARREL_FILENAME,
 				exports: buildBarrelExports({
@@ -2067,26 +2158,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) => (0, _kubb_ast.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,
@@ -2095,7 +2219,6 @@ async function safeBuild(options, overrides) {
 	} catch (error) {
 		return {
 			failedPlugins,
-			fabric,
 			files: [],
 			driver,
 			pluginTimings,
@@ -2116,11 +2239,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 [(0, _kubb_ast.createExport)({
 				name: exportName,
 				path: getRelativePath(rootDir, file.path),
 				isTypeOnly: config.output.barrelType === "all" ? containsOnlyTypes : source.isTypeOnly
-			}];
+			})];
 		});
 	});
 }
@@ -2232,19 +2355,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);
 			}
 		}
 	};
@@ -2267,6 +2390,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.
@@ -2420,7 +2571,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.
 *
@@ -2453,14 +2604,14 @@ function defaultResolveFile({ name, extname, tag, path: groupPath }, context) {
 		tag,
 		path: groupPath
 	}, context);
-	return {
+	return (0, _kubb_ast.createFile)({
 		path: filePath,
 		baseName: node_path.default.basename(filePath),
 		meta: { pluginName: this.pluginName },
 		sources: [],
 		imports: [],
 		exports: []
-	};
+	});
 }
 /**
 * Generates the default "Generated by Kubb" banner from config and optional node metadata.
@@ -2512,13 +2663,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 ... *\/'
 * ```
 *
@@ -2554,7 +2705,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'
 * ```
 */
@@ -2570,7 +2721,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.
@@ -2620,9 +2771,6 @@ function defineResolver(build) {
 	};
 }
 //#endregion
-//#region src/KubbFile.ts
-var KubbFile_exports = /* @__PURE__ */ require_chunk.__exportAll({});
-//#endregion
 //#region src/storages/memoryStorage.ts
 /**
 * In-memory storage driver. Useful for testing and dry-run scenarios where
@@ -2927,12 +3075,6 @@ function satisfiesDependency(dependency, version, cwd) {
 //#endregion
 exports.AsyncEventEmitter = AsyncEventEmitter;
 exports.FunctionParams = FunctionParams;
-Object.defineProperty(exports, "KubbFile", {
-	enumerable: true,
-	get: function() {
-		return KubbFile_exports;
-	}
-});
 exports.PluginDriver = PluginDriver;
 exports.URLPath = URLPath;
 exports.build = build;