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

package/dist/index.js

@@ -1,15 +1,14 @@
-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, extractStringsFromNodes, isOperationNode, isSchemaNode, transform, walk } from "@kubb/ast";
 import { performance } from "node:perf_hooks";
 import { deflateSync } from "fflate";
 import { x } from "tinyexec";
-import { jsx } from "@kubb/react-fabric/jsx-runtime";
+import { createRenderer } from "@kubb/renderer-jsx";
+import { Fragment, jsx } from "@kubb/renderer-jsx/jsx-runtime";
 import { version } from "node:process";
 import { sortBy } from "remeda";
 import * as pkg from "empathic/package";
@@ -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) => extractStringsFromNodes(item.nodes)).filter(Boolean).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,20 +1504,20 @@ 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 renderer-jsx, 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);
-	fabricChild.unmount();
+	const renderer = createRenderer();
+	await renderer.render(/* @__PURE__ */ jsx(Fragment, { children: result }));
+	driver.fileManager.upsert(...renderer.files);
+	renderer.unmount();
 }
 //#endregion
 //#region src/createStorage.ts
@@ -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.33";
 //#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,35 @@ 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 +1854,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
@@ -1747,8 +1884,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 +1952,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 +1964,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 +1988,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 +1996,6 @@ async function build(options, overrides) {
 	}
 	return {
 		failedPlugins,
-		fabric,
 		files,
 		driver,
 		pluginTimings,
@@ -1921,15 +2010,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 +2030,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 +2042,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 +2079,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 +2133,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 +2150,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 +2211,6 @@ async function safeBuild(options, overrides) {
 	} catch (error) {
 		return {
 			failedPlugins,
-			fabric,
 			files: [],
 			driver,
 			pluginTimings,
@@ -2110,11 +2231,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 +2347,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 +2382,31 @@ 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) {
+*     const { extractStringsFromNodes } = await import('@kubb/ast')
+*     return file.sources.map((s) => extractStringsFromNodes(s.nodes ?? [])).join('\n')
+*   },
+* })
+* ```
+*/
+function defineParser(parser) {
+	return parser;
+}
+//#endregion
 //#region src/definePresets.ts
 /**
 * Creates a typed presets registry object — a named collection of {@link Preset} entries.
@@ -2414,7 +2560,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 +2593,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 +2652,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 +2694,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 +2710,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 +2760,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
@@ -2665,82 +2808,6 @@ const memoryStorage = createStorage(() => {
 	};
 });
 //#endregion
-//#region src/utils/FunctionParams.ts
-/**
-* @deprecated use ast package instead
-*/
-var FunctionParams = class FunctionParams {
-	#items = [];
-	get items() {
-		return this.#items.flat();
-	}
-	add(item) {
-		if (!item) return this;
-		if (Array.isArray(item)) {
-			item.filter((x) => x !== void 0).forEach((it) => {
-				this.#items.push(it);
-			});
-			return this;
-		}
-		this.#items.push(item);
-		return this;
-	}
-	static #orderItems(items) {
-		return sortBy(items.filter(Boolean), [(item) => Array.isArray(item), "desc"], [(item) => !Array.isArray(item) && item.default !== void 0, "asc"], [(item) => Array.isArray(item) || (item.required ?? true), "desc"]);
-	}
-	static #addParams(acc, item) {
-		const { enabled = true, name, type, required = true, ...rest } = item;
-		if (!enabled) return acc;
-		if (!name) {
-			acc.push(`${type}${rest.default ? ` = ${rest.default}` : ""}`);
-			return acc;
-		}
-		const parameterName = name.startsWith("{") ? name : camelCase(name);
-		if (type) if (required) acc.push(`${parameterName}: ${type}${rest.default ? ` = ${rest.default}` : ""}`);
-		else acc.push(`${parameterName}?: ${type}`);
-		else acc.push(`${parameterName}`);
-		return acc;
-	}
-	static toObject(items) {
-		let type = [];
-		let name = [];
-		const enabled = items.every((item) => item.enabled) ? items.at(0)?.enabled : true;
-		const required = items.every((item) => item.required) ?? true;
-		items.forEach((item) => {
-			name = FunctionParams.#addParams(name, {
-				...item,
-				type: void 0
-			});
-			if (items.some((item) => item.type)) type = FunctionParams.#addParams(type, item);
-		});
-		return {
-			name: `{ ${name.join(", ")} }`,
-			type: type.length ? `{ ${type.join("; ")} }` : void 0,
-			enabled,
-			required
-		};
-	}
-	toObject() {
-		const items = FunctionParams.#orderItems(this.#items).flat();
-		return FunctionParams.toObject(items);
-	}
-	static toString(items) {
-		return FunctionParams.#orderItems(items).reduce((acc, item) => {
-			if (Array.isArray(item)) {
-				if (item.length <= 0) return acc;
-				const subItems = FunctionParams.#orderItems(item);
-				const objectItem = FunctionParams.toObject(subItems);
-				return FunctionParams.#addParams(acc, objectItem);
-			}
-			return FunctionParams.#addParams(acc, item);
-		}, []).join(", ");
-	}
-	toString() {
-		const items = FunctionParams.#orderItems(this.#items);
-		return FunctionParams.toString(items);
-	}
-};
-//#endregion
 //#region src/utils/formatters.ts
 /**
 * Returns `true` when the given formatter is installed and callable.
@@ -2796,6 +2863,124 @@ async function getConfigs(config, args) {
 	}));
 }
 //#endregion
+//#region src/utils/getFunctionParams.ts
+function order(items) {
+	return sortBy(items.filter(Boolean), ([_key, item]) => {
+		if (item?.children) return 0;
+		if (item?.optional) return 1;
+		if (item?.default) return 2;
+		return 0;
+	});
+}
+function parseChild(key, item, options) {
+	const entries = order(Object.entries(item.children));
+	const types = [];
+	const names = [];
+	const optional = entries.every(([_key, item]) => item?.optional || !!item?.default);
+	entries.forEach(([key, entryItem]) => {
+		if (entryItem) {
+			const name = parseItem(key, {
+				...entryItem,
+				type: void 0
+			}, options);
+			if (entryItem.children) {
+				const subTypes = Object.entries(entryItem.children).map(([key]) => {
+					return key;
+				}).join(", ");
+				if (subTypes) names.push(`${name}: { ${subTypes} }`);
+				else names.push(name);
+			} else if (options.type === "call" && options.transformName) names.push(`${key}: ${name}`);
+			else names.push(name);
+			if (entries.some(([_key, item]) => item?.type)) types.push(parseItem(key, {
+				...entryItem,
+				default: void 0
+			}, options));
+		}
+	});
+	const name = item.mode === "inline" ? key : names.length ? `{ ${names.join(", ")} }` : void 0;
+	const type = item.type ? item.type : types.length ? `{ ${types.join("; ")} }` : void 0;
+	if (!name) return null;
+	return parseItem(name, {
+		type,
+		default: item.default,
+		optional: !item.default ? optional : void 0
+	}, options);
+}
+function parseItem(name, item, options) {
+	const acc = [];
+	const transformedName = options.transformName ? options.transformName(name) : name;
+	const transformedType = options.transformType && item.type ? options.transformType(item.type) : item.type;
+	if (options.type === "object") return transformedName;
+	if (options.type === "objectValue") return item.value ? `${transformedName}: ${item.value}` : transformedName;
+	if (item.type && options.type === "constructor") if (item.optional) if (transformedName.startsWith("{")) acc.push(`${transformedName}: ${transformedType} = {}`);
+	else acc.push(`${transformedName}?: ${transformedType}`);
+	else acc.push(`${transformedName}: ${transformedType}${item.default ? ` = ${item.default}` : ""}`);
+	else if (item.default && options.type === "constructor") acc.push(`${transformedName} = ${item.default}`);
+	else if (item.value) acc.push(`${transformedName} : ${item.value}`);
+	else if (item.mode === "inlineSpread") acc.push(`... ${transformedName}`);
+	else acc.push(transformedName);
+	return acc[0];
+}
+function getFunctionParams(params, options) {
+	return order(Object.entries(params)).reduce((acc, [key, item]) => {
+		if (!item) return acc;
+		if (item.children) {
+			if (Object.keys(item.children).length === 0) return acc;
+			if (item.mode === "inlineSpread") return [...acc, getFunctionParams(item.children, options)];
+			const parsedItem = parseChild(key, item, options);
+			if (!parsedItem) return acc;
+			return [...acc, parsedItem];
+		}
+		const parsedItem = parseItem(key, item, options);
+		return [...acc, parsedItem];
+	}, []).join(", ");
+}
+/**
+* @deprecated use @kubb/ast
+*/
+function createFunctionParams(params) {
+	return params;
+}
+/**
+* @deprecated use @kubb/ast
+*/
+var FunctionParams = class FunctionParams {
+	#params;
+	static factory(params) {
+		return new FunctionParams(params);
+	}
+	constructor(params) {
+		this.#params = params;
+	}
+	get params() {
+		return this.#params;
+	}
+	get flatParams() {
+		const flatter = (acc, [key, item]) => {
+			if (item?.children) return Object.entries(item.children).reduce(flatter, acc);
+			if (item) acc[key] = item;
+			return acc;
+		};
+		return Object.entries(this.#params).reduce(flatter, {});
+	}
+	toCall({ transformName, transformType } = {}) {
+		return getFunctionParams(this.#params, {
+			type: "call",
+			transformName,
+			transformType
+		});
+	}
+	toObject() {
+		return getFunctionParams(this.#params, { type: "object" });
+	}
+	toObjectValue() {
+		return getFunctionParams(this.#params, { type: "objectValue" });
+	}
+	toConstructor() {
+		return getFunctionParams(this.#params, { type: "constructor" });
+	}
+};
+//#endregion
 //#region src/utils/getPreset.ts
 /**
 * Returns a copy of `defaults` where each function in `userOverrides` is wrapped
@@ -2919,6 +3104,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, createFunctionParams, createPlugin, createStorage, defaultResolveBanner, defaultResolveFile, defaultResolveFooter, defaultResolveOptions, defaultResolvePath, defineConfig, defineGenerator, defineLogger, defineParser, definePresets, definePrinter, defineResolver, detectFormatter, detectLinter, formatters, fsStorage, getBarrelFiles, getConfigs, getFunctionParams, getMode, getPreset, isInputPath, linters, logLevel, memoryStorage, mergeGenerators, safeBuild, satisfiesDependency, setup };
 
 //# sourceMappingURL=index.js.map