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

package/src/build.ts

@@ -1,13 +1,10 @@
-import { dirname, relative, resolve } from 'node:path'
+import { dirname, resolve } from 'node:path'
 import { AsyncEventEmitter, BuildError, exists, formatMs, getElapsedMs, getRelativePath, URLPath } from '@internals/utils'
-import { transform, walk } from '@kubb/ast'
-import type { OperationNode } from '@kubb/ast/types'
-import type { Fabric as FabricType } from '@kubb/fabric-core/types'
-import { createFabric } from '@kubb/react-fabric'
-import { fsPlugin } from '@kubb/react-fabric/plugins'
+import { createExport, createFile, transform, walk } from '@kubb/ast'
+import type { ExportNode, FileNode, OperationNode } from '@kubb/ast/types'
 import { BARREL_FILENAME, DEFAULT_BANNER, DEFAULT_CONCURRENCY, DEFAULT_EXTENSION, DEFAULT_STUDIO_URL } from './constants.ts'
-import { defineParser } from './defineParser.ts'
-import type * as KubbFile from './KubbFile.ts'
+import type { Parser } from './defineParser.ts'
+import { FileProcessor } from './FileProcessor.ts'
 import { PluginDriver } from './PluginDriver.ts'
 import { applyHookResult } from './renderNode.tsx'
 import { fsStorage } from './storages/fsStorage.ts'
@@ -30,8 +27,7 @@ type BuildOutput = {
    * Plugins that threw during installation, paired with the caught error.
    */
   failedPlugins: Set<{ plugin: Plugin; error: Error }>
-  fabric: FabricType
-  files: Array<KubbFile.ResolvedFile>
+  files: Array<FileNode>
   driver: PluginDriver
   /**
    * Elapsed time in milliseconds for each plugin, keyed by plugin name.
@@ -41,7 +37,7 @@ type BuildOutput = {
   /**
    * Raw generated source, keyed by absolute file path.
    */
-  sources: Map<KubbFile.Path, string>
+  sources: Map<string, string>
 }
 
 /**
@@ -49,10 +45,10 @@ type BuildOutput = {
  */
 type SetupResult = {
   events: AsyncEventEmitter<KubbEvents>
-  fabric: FabricType
   driver: PluginDriver
-  sources: Map<KubbFile.Path, string>
+  sources: Map<string, string>
   config: Config
+  storage: Storage | null
 }
 
 /**
@@ -61,7 +57,7 @@ type SetupResult = {
  * - 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}
@@ -70,7 +66,7 @@ type SetupResult = {
 export async function setup(options: BuildOptions): Promise<SetupResult> {
   const { config: userConfig, events = new AsyncEventEmitter<KubbEvents>() } = options
 
-  const sources: Map<KubbFile.Path, string> = new Map<KubbFile.Path, string>()
+  const sources: Map<string, string> = new Map<string, string>()
   const diagnosticInfo = getDiagnosticInfo()
 
   if (Array.isArray(userConfig.input)) {
@@ -145,8 +141,8 @@ export async function setup(options: BuildOptions): Promise<SetupResult> {
 
   // write: false is the explicit dry-run opt-out; otherwise use the provided
   // storage or fall back to fsStorage (backwards-compatible default).
-  // Keys are root-relative (e.g. `src/gen/api/getPets.ts`) so fsStorage()
-  // needs no configuration — it resolves them against process.cwd().
+  // Storage keys are the absolute file.path values so fsStorage() resolves
+  // them correctly regardless of the current working directory.
   const storage: Storage | null = config.output.write === false ? null : (config.output.storage ?? fsStorage())
 
   if (config.output.clean) {
@@ -157,70 +153,12 @@ export async function setup(options: BuildOptions): Promise<SetupResult> {
     await storage?.clear(resolve(config.root, config.output.path))
   }
 
-  const fabric = createFabric()
-  fabric.use(fsPlugin)
-
-  for (const parser of config.parsers) {
-    fabric.use(parser)
-  }
-  // Catch-all fallback: joins all source values for any unhandled extension
-  fabric.use(
-    defineParser({
-      name: 'fallback',
-      extNames: undefined,
-      parse(file) {
-        return file.sources
-          .map((item) => item.value)
-          .filter((value): value is string => value != null)
-          .join('\n\n')
-      },
-    }),
-  )
-
-  fabric.context.on('files:processing:start', (files) => {
-    events.emit('files:processing:start', files)
-    events.emit('debug', {
-      date: 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: config,
-      source,
-    })
-
-    if (source) {
-      // Key is root-relative so it's meaningful for any backend (fs, S3, Redis…)
-      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: new Date(),
-      logs: [`✓ File write process completed for ${files.length} files`],
-    })
-  })
-
-  await events.emit('debug', {
-    date: 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: DEFAULT_CONCURRENCY,
   })
 
-  // Run the adapter to produce the universal RootNode.
+  // Run the adapter to produce the universal InputNode.
 
   const adapter = config.adapter
   if (!adapter) {
@@ -234,23 +172,23 @@ export async function setup(options: BuildOptions): Promise<SetupResult> {
   })
 
   driver.adapter = adapter
-  driver.rootNode = await adapter.parse(source)
+  driver.inputNode = await adapter.parse(source)
 
   await events.emit('debug', {
     date: 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,
+    storage,
   }
 }
 
@@ -261,7 +199,7 @@ export async function setup(options: BuildOptions): Promise<SetupResult> {
  * Pass an existing {@link SetupResult} via `overrides` to skip the setup phase.
  */
 export async function build(options: BuildOptions, overrides?: SetupResult): Promise<BuildOutput> {
-  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
@@ -275,7 +213,6 @@ export async function build(options: BuildOptions, overrides?: SetupResult): Pro
 
   return {
     failedPlugins,
-    fabric,
     files,
     driver,
     pluginTimings,
@@ -291,20 +228,20 @@ export async function build(options: BuildOptions, overrides?: SetupResult): Pro
  * - 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: Plugin, context: PluginContext): Promise<void> {
-  const { adapter, rootNode, resolver, fabric } = context
+  const { adapter, inputNode, resolver, driver } = context
   const { exclude, include, override } = plugin.options
 
-  if (!adapter || !rootNode) {
+  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: Array<OperationNode> = []
 
-  await walk(rootNode, {
+  await walk(inputNode, {
     depth: 'shallow',
     async schema(node) {
       if (!plugin.schema) return
@@ -313,7 +250,7 @@ async function runPluginAstHooks(plugin: Plugin, context: PluginContext): Promis
       if (options === null) return
       const result = await plugin.schema.call(context, transformedNode, options)
 
-      await applyHookResult(result, fabric)
+      await applyHookResult(result, driver)
     },
     async operation(node) {
       const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
@@ -322,7 +259,7 @@ async function runPluginAstHooks(plugin: Plugin, context: PluginContext): Promis
         collectedOperations.push(transformedNode)
         if (plugin.operation) {
           const result = await plugin.operation.call(context, transformedNode, options)
-          await applyHookResult(result, fabric)
+          await applyHookResult(result, driver)
         }
       }
     },
@@ -331,7 +268,7 @@ async function runPluginAstHooks(plugin: Plugin, context: PluginContext): Promis
   if (plugin.operations && collectedOperations.length > 0) {
     const result = await plugin.operations.call(context, collectedOperations, plugin.options)
 
-    await applyHookResult(result, fabric)
+    await applyHookResult(result, driver)
   }
 }
 
@@ -340,13 +277,14 @@ async function runPluginAstHooks(plugin: Plugin, context: PluginContext): Promis
  *
  * - 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.
  */
 export async function safeBuild(options: BuildOptions, overrides?: SetupResult): Promise<BuildOutput> {
-  const { fabric, driver, events, sources } = overrides ? overrides : await setup(options)
+  const setupResult = overrides ? overrides : await setup(options)
+  const { driver, events, sources, storage } = setupResult
 
   const failedPlugins = new Set<{ plugin: Plugin; error: Error }>()
   // in ms
@@ -379,7 +317,7 @@ export async function safeBuild(options: BuildOptions, overrides?: SetupResult):
         }
 
         if (output) {
-          const barrelFiles = await getBarrelFiles(fabric.files, {
+          const barrelFiles = await getBarrelFiles(driver.fileManager.files, {
             type: output.barrelType ?? 'named',
             root,
             output,
@@ -433,7 +371,7 @@ export async function safeBuild(options: BuildOptions, overrides?: SetupResult):
         logs: ['Generating barrel file', `  • Type: ${config.output.barrelType}`, `  • Path: ${rootPath}`],
       })
 
-      const barrelFiles = fabric.files.filter((file) => {
+      const barrelFiles = driver.fileManager.files.filter((file) => {
         return file.sources.some((source) => source.isIndexable)
       })
 
@@ -442,21 +380,21 @@ export async function safeBuild(options: BuildOptions, overrides?: SetupResult):
         logs: [`Found ${barrelFiles.length} indexable files for barrel export`],
       })
 
-      const existingBarrel = fabric.files.find((f) => f.path === rootPath)
+      const existingBarrel = driver.fileManager.files.find((f) => f.path === rootPath)
       const existingExports = new Set(
         existingBarrel?.exports?.flatMap((e) => (Array.isArray(e.name) ? e.name : [e.name])).filter((n): n is string => Boolean(n)) ?? [],
       )
 
-      const rootFile: KubbFile.File = {
+      const rootFile = createFile<object>({
         path: rootPath,
         baseName: BARREL_FILENAME,
-        exports: buildBarrelExports({ barrelFiles, rootDir, existingExports, config, driver }),
+        exports: buildBarrelExports({ barrelFiles, rootDir, existingExports, config, driver }).map((e) => createExport(e)),
         sources: [],
         imports: [],
         meta: {},
-      }
+      })
 
-      await fabric.upsertFile(rootFile)
+      driver.fileManager.upsert(rootFile)
 
       await events.emit('debug', {
         date: new Date(),
@@ -464,9 +402,55 @@ export async function safeBuild(options: BuildOptions, overrides?: SetupResult):
       })
     }
 
-    const files = [...fabric.files]
+    const files = driver.fileManager.files
+
+    // Build a parsers map from config.parsers
+    const parsersMap = new Map<FileNode['extname'], Parser>()
+    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: new Date(),
+      logs: [`Writing ${files.length} files...`],
+    })
 
-    await fabric.write({ extension: config.output.extension })
+    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) {
+          // Use the absolute file.path as the storage key so fsStorage resolves
+          // it correctly regardless of the current working directory.
+          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: new Date(),
+          logs: [`✓ File write process completed for ${processedFiles.length} files`],
+        })
+      },
+    })
 
     // Call buildEnd() on each plugin after all files are written
     for (const plugin of driver.plugins.values()) {
@@ -478,7 +462,6 @@ export async function safeBuild(options: BuildOptions, overrides?: SetupResult):
 
     return {
       failedPlugins,
-      fabric,
       files,
       driver,
       pluginTimings,
@@ -487,7 +470,6 @@ export async function safeBuild(options: BuildOptions, overrides?: SetupResult):
   } catch (error) {
     return {
       failedPlugins,
-      fabric,
       files: [],
       driver,
       pluginTimings,
@@ -498,14 +480,14 @@ export async function safeBuild(options: BuildOptions, overrides?: SetupResult):
 }
 
 type BuildBarrelExportsParams = {
-  barrelFiles: KubbFile.ResolvedFile[]
+  barrelFiles: FileNode[]
   rootDir: string
   existingExports: Set<string>
   config: Config
   driver: PluginDriver
 }
 
-function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, driver }: BuildBarrelExportsParams): KubbFile.Export[] {
+function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, driver }: BuildBarrelExportsParams): ExportNode[] {
   const pluginNameMap = new Map<string, Plugin>()
   for (const plugin of driver.plugins.values()) {
     pluginNameMap.set(plugin.name, plugin)
@@ -533,11 +515,11 @@ function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, dri
       }
 
       return [
-        {
+        createExport({
           name: exportName,
           path: getRelativePath(rootDir, file.path),
           isTypeOnly: config.output.barrelType === 'all' ? containsOnlyTypes : source.isTypeOnly,
-        } satisfies KubbFile.Export,
+        }),
       ]
     })
   })

package/src/constants.ts

@@ -1,4 +1,4 @@
-import type * as KubbFile from './KubbFile.ts'
+import type { FileNode } from '@kubb/ast/types'
 
 /**
  * Base URL for the Kubb Studio web app.
@@ -10,6 +10,11 @@ export const DEFAULT_STUDIO_URL = 'https://studio.kubb.dev' as const
  */
 export const DEFAULT_CONCURRENCY = 15
 
+/**
+ * Maximum number of files processed in parallel by FileProcessor.
+ */
+export const PARALLEL_CONCURRENCY_LIMIT = 100
+
 /**
  * File name used for generated barrel (index) files.
  */
@@ -23,7 +28,7 @@ export const DEFAULT_BANNER = 'simple' as const
 /**
  * Default file-extension mapping used when no explicit mapping is configured.
  */
-export const DEFAULT_EXTENSION: Record<KubbFile.Extname, KubbFile.Extname | ''> = { '.ts': '.ts' }
+export const DEFAULT_EXTENSION: Record<FileNode['extname'], FileNode['extname'] | ''> = { '.ts': '.ts' }
 
 /**
  * Characters recognized as path separators on both POSIX and Windows.

package/src/defineGenerator.ts

@@ -1,7 +1,6 @@
 import type { PossiblePromise } from '@internals/utils'
-import type { OperationNode, SchemaNode } from '@kubb/ast/types'
+import type { FileNode, OperationNode, SchemaNode } from '@kubb/ast/types'
 import type { FabricReactNode } from '@kubb/react-fabric/types'
-import type * as KubbFile from './KubbFile.ts'
 import { applyHookResult } from './renderNode.tsx'
 import type { GeneratorContext, PluginFactoryOptions } from './types.ts'
 
@@ -10,10 +9,10 @@ export type { GeneratorContext } from './types.ts'
 /**
  * A generator is a named object with optional `schema`, `operation`, and `operations`
  * methods. Each method is called with `this = PluginContext` of the parent plugin,
- * giving full access to `this.config`, `this.resolver`, `this.adapter`, `this.fabric`,
+ * giving full access to `this.config`, `this.resolver`, `this.adapter`,
  * `this.driver`, etc.
  *
- * Return a React element, an array of `KubbFile.File`, or `void` to handle file
+ * Return a React element, an array of `FileNode`, or `void` to handle file
  * writing manually via `this.upsertFile`. Both React and core (non-React) generators
  * use the same method signatures — the return type determines how output is handled.
  *
@@ -36,32 +35,32 @@ export type Generator<TOptions extends PluginFactoryOptions = PluginFactoryOptio
   name: string
   /**
    * Called for each schema node in the AST walk.
-   * `this` is the parent plugin's context with `adapter` and `rootNode` guaranteed present.
+   * `this` is the parent plugin's context with `adapter` and `inputNode` guaranteed present.
    * `options` contains the per-node resolved options (after exclude/include/override).
    */
   schema?: (
     this: GeneratorContext<TOptions>,
     node: SchemaNode,
     options: TOptions['resolvedOptions'],
-  ) => PossiblePromise<FabricReactNode | Array<KubbFile.File> | void>
+  ) => PossiblePromise<FabricReactNode | Array<FileNode> | void>
   /**
    * Called for each operation node in the AST walk.
-   * `this` is the parent plugin's context with `adapter` and `rootNode` guaranteed present.
+   * `this` is the parent plugin's context with `adapter` and `inputNode` guaranteed present.
    */
   operation?: (
     this: GeneratorContext<TOptions>,
     node: OperationNode,
     options: TOptions['resolvedOptions'],
-  ) => PossiblePromise<FabricReactNode | Array<KubbFile.File> | void>
+  ) => PossiblePromise<FabricReactNode | Array<FileNode> | void>
   /**
    * Called once after all operations have been walked.
-   * `this` is the parent plugin's context with `adapter` and `rootNode` guaranteed present.
+   * `this` is the parent plugin's context with `adapter` and `inputNode` guaranteed present.
    */
   operations?: (
     this: GeneratorContext<TOptions>,
     nodes: Array<OperationNode>,
     options: TOptions['resolvedOptions'],
-  ) => PossiblePromise<FabricReactNode | Array<KubbFile.File> | void>
+  ) => PossiblePromise<FabricReactNode | Array<FileNode> | void>
 }
 
 /**
@@ -103,7 +102,7 @@ export function mergeGenerators<TOptions extends PluginFactoryOptions = PluginFa
         if (!gen.schema) continue
         const result = await gen.schema.call(this, node, options)
 
-        await applyHookResult(result, this.fabric)
+        await applyHookResult(result, this.driver)
       }
     },
     async operation(node, options) {
@@ -111,7 +110,7 @@ export function mergeGenerators<TOptions extends PluginFactoryOptions = PluginFa
         if (!gen.operation) continue
         const result = await gen.operation.call(this, node, options)
 
-        await applyHookResult(result, this.fabric)
+        await applyHookResult(result, this.driver)
       }
     },
     async operations(nodes, options) {
@@ -119,7 +118,7 @@ export function mergeGenerators<TOptions extends PluginFactoryOptions = PluginFa
         if (!gen.operations) continue
         const result = await gen.operations.call(this, nodes, options)
 
-        await applyHookResult(result, this.fabric)
+        await applyHookResult(result, this.driver)
       }
     },
   }

package/src/defineParser.ts

@@ -1,7 +1,7 @@
-import type * as KubbFile from './KubbFile.ts'
+import type { FileNode } from '@kubb/ast/types'
 
 type PrintOptions = {
-  extname?: KubbFile.Extname
+  extname?: FileNode['extname']
 }
 
 export type Parser<TMeta extends object = any> = {
@@ -13,7 +13,7 @@ export type Parser<TMeta extends object = any> = {
    *
    * @example ['.ts', '.js']
    */
-  extNames: Array<KubbFile.Extname> | undefined
+  extNames: Array<FileNode['extname']> | undefined
   /**
    * @deprecated Will be removed once Fabric no longer requires it.
    * @default () => {}
@@ -22,7 +22,7 @@ export type Parser<TMeta extends object = any> = {
   /**
    * Convert a resolved file to a string.
    */
-  parse(file: KubbFile.ResolvedFile<TMeta>, options?: PrintOptions): Promise<string> | string
+  parse(file: FileNode<TMeta>, options?: PrintOptions): Promise<string> | string
 }
 
 export type UserParser<TMeta extends object = any> = Omit<Parser<TMeta>, 'type' | 'install'> & {

package/src/defineResolver.ts

@@ -1,8 +1,7 @@
 import path from 'node:path'
 import { camelCase, pascalCase } from '@internals/utils'
-import { isOperationNode, isSchemaNode } from '@kubb/ast'
-import type { Node, OperationNode, RootNode, SchemaNode } from '@kubb/ast/types'
-import type * as KubbFile from './KubbFile.ts'
+import { createFile, isOperationNode, isSchemaNode } from '@kubb/ast'
+import type { FileNode, InputNode, Node, OperationNode, SchemaNode } from '@kubb/ast/types'
 import { getMode } from './PluginDriver.ts'
 import type {
   Config,
@@ -195,24 +194,24 @@ export function defaultResolveOptions<TOptions>(
  * // → '/src/types'
  * ```
  */
-export function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }: ResolverPathParams, { root, output, group }: ResolverContext): KubbFile.Path {
+export function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }: ResolverPathParams, { root, output, group }: ResolverContext): string {
   const mode = pathMode ?? getMode(path.resolve(root, output.path))
 
   if (mode === 'single') {
-    return path.resolve(root, output.path) as KubbFile.Path
+    return path.resolve(root, output.path)
   }
 
   if (group && (groupPath || tag)) {
-    return path.resolve(root, output.path, group.name({ group: group.type === 'path' ? groupPath! : tag! }), baseName) as KubbFile.Path
+    return path.resolve(root, output.path, group.name({ group: group.type === 'path' ? groupPath! : tag! }), baseName)
   }
 
-  return path.resolve(root, output.path, baseName) as KubbFile.Path
+  return path.resolve(root, output.path, baseName)
 }
 
 /**
  * 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.
  *
@@ -236,22 +235,22 @@ export function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }:
  * // → { baseName: 'listPets.ts', path: '/src/types/petsController/listPets.ts', ... }
  * ```
  */
-export function defaultResolveFile(this: Resolver, { name, extname, tag, path: groupPath }: ResolverFileParams, context: ResolverContext): KubbFile.File {
+export function defaultResolveFile(this: Resolver, { name, extname, tag, path: groupPath }: ResolverFileParams, context: ResolverContext): FileNode {
   const pathMode = getMode(path.resolve(context.root, context.output.path))
   const resolvedName = pathMode === 'single' ? '' : this.default(name, 'file')
-  const baseName = `${resolvedName}${extname}` as KubbFile.BaseName
+  const baseName = `${resolvedName}${extname}` as FileNode['baseName']
   const filePath = this.resolvePath({ baseName, pathMode, tag, path: groupPath }, context)
 
-  return {
+  return createFile({
     path: filePath,
-    baseName: path.basename(filePath) as KubbFile.BaseName,
+    baseName: path.basename(filePath) as `${string}.${string}`,
     meta: {
       pluginName: this.pluginName,
     },
     sources: [],
     imports: [],
     exports: [],
-  }
+  })
 }
 
 /**
@@ -333,13 +332,13 @@ export function buildDefaultBanner({
  *
  * @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 ... *\/'
  * ```
  *
@@ -349,7 +348,7 @@ export function buildDefaultBanner({
  * // → undefined
  * ```
  */
-export function defaultResolveBanner(node: RootNode | undefined, { output, config }: ResolveBannerContext): string | undefined {
+export function defaultResolveBanner(node: InputNode | undefined, { output, config }: ResolveBannerContext): string | undefined {
   if (typeof output?.banner === 'function') {
     return output.banner(node)
   }
@@ -381,11 +380,11 @@ export function defaultResolveBanner(node: RootNode | undefined, { output, confi
  *
  * @example Function footer with node
  * ```ts
- * defaultResolveFooter(rootNode, { output: { footer: (node) => `// ${node.title}` }, config })
+ * defaultResolveFooter(inputNode, { output: { footer: (node) => `// ${node.title}` }, config })
  * // → '// Pet Store'
  * ```
  */
-export function defaultResolveFooter(node: RootNode | undefined, { output }: ResolveBannerContext): string | undefined {
+export function defaultResolveFooter(node: InputNode | undefined, { output }: ResolveBannerContext): string | undefined {
   if (typeof output?.footer === 'function') {
     return node ? output.footer(node) : undefined
   }
@@ -403,7 +402,7 @@ export function defaultResolveFooter(node: RootNode | undefined, { output }: Res
  * - `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.