@kubb/core 5.0.0-alpha.2 → 5.0.0-alpha.20

package/src/types.ts

@@ -1,11 +1,10 @@
 import type { AsyncEventEmitter, PossiblePromise } from '@internals/utils'
-import type { RootNode } from '@kubb/ast/types'
-import type { KubbFile } from '@kubb/fabric-core/types'
-import type { Fabric } from '@kubb/react-fabric'
+import type { Node, RootNode, SchemaNode, Visitor } from '@kubb/ast/types'
+import type { Fabric as FabricType, KubbFile } from '@kubb/fabric-core/types'
 import type { DEFAULT_STUDIO_URL, logLevel } from './constants.ts'
-import type { DefineStorage } from './defineStorage.ts'
+import type { Storage } from './createStorage.ts'
 import type { KubbEvents } from './Kubb.ts'
-import type { PluginManager } from './PluginManager.ts'
+import type { PluginDriver } from './PluginDriver.ts'
 
 export type { Printer, PrinterFactoryOptions } from '@kubb/ast/types'
 
@@ -33,7 +32,7 @@ export type UserConfig<TInput = Input> = Omit<Config<TInput>, 'root' | 'plugins'
   /**
    * An array of Kubb plugins used for generation. Each plugin may have additional configurable options (defined within the plugin itself). If a plugin relies on another plugin, an error will occur if the required dependency is missing. Refer to “pre” for more details.
    */
-  // inject needs to be omitted because else we have a clash with the PluginManager instance
+  // inject needs to be omitted because else we have a clash with the PluginDriver instance
   plugins?: Array<Omit<UnknownUserPlugin, 'inject'>>
 }
 
@@ -66,11 +65,18 @@ export type AdapterSource = { type: 'path'; path: string } | { type: 'data'; dat
  * - `TName` — unique string identifier (e.g. `'oas'`, `'asyncapi'`)
  * - `TOptions` — raw user-facing options passed to the adapter factory
  * - `TResolvedOptions` — defaults applied; what the adapter stores as `options`
+ * - `TDocument` — type of the raw source document exposed by the adapter after `parse()`
  */
-export type AdapterFactoryOptions<TName extends string = string, TOptions extends object = object, TResolvedOptions extends object = TOptions> = {
+export type AdapterFactoryOptions<
+  TName extends string = string,
+  TOptions extends object = object,
+  TResolvedOptions extends object = TOptions,
+  TDocument = unknown,
+> = {
   name: TName
   options: TOptions
   resolvedOptions: TResolvedOptions
+  document: TDocument
 }
 
 /**
@@ -92,12 +98,31 @@ export type AdapterFactoryOptions<TName extends string = string, TOptions extend
  * ```
  */
 export type Adapter<TOptions extends AdapterFactoryOptions = AdapterFactoryOptions> = {
-  /** Human-readable identifier, e.g. `'oas'`, `'drizzle'`, `'asyncapi'`. */
+  /**
+   * Human-readable identifier, e.g. `'oas'`, `'drizzle'`, `'asyncapi'`.
+   */
   name: TOptions['name']
-  /** Resolved options (after defaults have been applied). */
+  /**
+   * Resolved options (after defaults have been applied).
+   */
   options: TOptions['resolvedOptions']
-  /** Convert the raw source into a universal `RootNode`. */
+  /**
+   * The raw source document produced after the first `parse()` call.
+   * `undefined` before parsing; typed by the adapter's `TDocument` generic.
+   */
+  document?: TOptions['document']
+  /**
+   * Convert the raw source into a universal `RootNode`.
+   */
   parse: (source: AdapterSource) => PossiblePromise<RootNode>
+  /**
+   * Extracts `KubbFile.Import` entries needed by a `SchemaNode` tree.
+   * Populated after the first `parse()` call. Returns an empty array before that.
+   *
+   * The `resolve` callback receives the collision-corrected schema name and must
+   * return the `{ name, path }` pair for the import, or `undefined` to skip it.
+   */
+  getImports: (node: SchemaNode, resolve: (schemaName: string) => { name: string; path: string }) => Array<KubbFile.Import>
 }
 
 export type BarrelType = 'all' | 'named' | 'propagate'
@@ -165,16 +190,16 @@ export type Config<TInput = Input> = {
     /**
      * Storage backend for generated files.
      * Defaults to `fsStorage()` — the built-in filesystem driver.
-     * Accepts any object implementing the {@link DefineStorage} interface.
+     * Accepts any object implementing the {@link Storage} interface.
      * Keys are root-relative paths (e.g. `src/gen/api/getPets.ts`).
      * @default fsStorage()
      * @example
      * ```ts
-     * import { defineStorage, fsStorage } from '@kubb/core'
-     * storage: defineStorage(fsStorage())
+     * import { memoryStorage } from '@kubb/core'
+     * storage: memoryStorage()
      * ```
      */
-    storage?: DefineStorage
+    storage?: Storage
     /**
      * Specifies the formatting tool to be used.
      * - 'auto' automatically detects and uses biome or prettier (in that order of preference).
@@ -253,6 +278,45 @@ export type Config<TInput = Input> = {
 
 // plugin
 
+type PatternFilter = {
+  type: string
+  pattern: string | RegExp
+}
+
+type PatternOverride<TOptions> = PatternFilter & {
+  options: Omit<Partial<TOptions>, 'override'>
+}
+
+export type ResolveOptionsContext<TOptions> = {
+  options: TOptions
+  exclude?: Array<PatternFilter>
+  include?: Array<PatternFilter>
+  override?: Array<PatternOverride<TOptions>>
+}
+
+/**
+ * Base constraint for all plugin resolver objects.
+ *
+ * `default` and `resolveOptions` are injected automatically by `defineResolver` — plugin
+ * authors may override them but never need to implement them from scratch.
+ * Concrete plugin resolver types extend this with their own helper methods.
+ */
+export type Resolver = {
+  name: string
+  default(name: ResolveNameParams['name'], type?: ResolveNameParams['type']): string
+  resolveOptions<TOptions>(node: Node, context: ResolveOptionsContext<TOptions>): TOptions | null
+}
+
+/**
+ * The user-facing subset of a `Resolver` — everything except the methods injected by
+ * `defineResolver` (`default` and `resolveOptions`).
+ *
+ * When you pass a `UserResolver` to `defineResolver`, the standard `default` and
+ * `resolveOptions` implementations are injected automatically so plugin authors never
+ * need to define them by hand. Both can still be overridden by providing them explicitly.
+ */
+export type UserResolver = Omit<Resolver, 'default' | 'resolveOptions'>
+
 export type PluginFactoryOptions<
   /**
    * Name to be used for the plugin.
@@ -274,16 +338,20 @@ export type PluginFactoryOptions<
    * When calling `resolvePath` you can specify better types.
    */
   TResolvePathOptions extends object = object,
+  /**
+   * Resolver object that encapsulates the naming and path-resolution helpers used by this plugin.
+   * Use `defineResolver` to define the resolver object and export it alongside the plugin.
+   */
+  TResolver extends Resolver = Resolver,
 > = {
   name: TName
   options: TOptions
   resolvedOptions: TResolvedOptions
   context: TContext
   resolvePathOptions: TResolvePathOptions
+  resolver: TResolver
 }
 
-export type GetPluginFactoryOptions<TPlugin extends UserPlugin> = TPlugin extends UserPlugin<infer X> ? X : never
-
 export type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
    * Unique name used for the plugin
@@ -309,7 +377,7 @@ export type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOpti
 
 export type UserPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = UserPlugin<TOptions> & PluginLifecycle<TOptions>
 
-export type UnknownUserPlugin = UserPlugin<PluginFactoryOptions<any, any, any, any, any>>
+type UnknownUserPlugin = UserPlugin<PluginFactoryOptions<string, object, object, unknown, object>>
 
 export type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
@@ -333,7 +401,7 @@ export type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
 
   install: (this: PluginContext<TOptions>, context: PluginContext<TOptions>) => PossiblePromise<void>
   /**
-   * Define a context that can be used by other plugins, see `PluginManager' where we convert from `UserPlugin` to `Plugin`(used when calling `definePlugin`).
+   * Defines a context that can be used by other plugins, see `PluginDriver` where we convert from `UserPlugin` to `Plugin` (used when calling `createPlugin`).
    */
   inject: (this: PluginContext<TOptions>, context: PluginContext<TOptions>) => TOptions['context']
 }
@@ -391,9 +459,9 @@ export type ResolveNameParams = {
 }
 
 export type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
-  fabric: Fabric
+  fabric: FabricType
   config: Config
-  pluginManager: PluginManager
+  driver: PluginDriver
   /**
    * Only add when the file does not exist yet
    */
@@ -408,18 +476,31 @@ export type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryO
    * Current plugin
    */
   plugin: Plugin<TOptions>
-  /**
-   * Returns the universal `@kubb/ast` `RootNode` produced by the configured adapter.
-   * Returns `undefined` when no adapter was set (legacy OAS-only usage).
-   */
-  rootNode: RootNode | undefined
+
   /**
    * Opens the Kubb Studio URL for the current `rootNode` in the default browser.
    * Falls back to printing the URL if the browser cannot be launched.
    * No-ops silently when no adapter has set a `rootNode`.
    */
   openInStudio: (options?: DevtoolsOptions) => Promise<void>
-} & Kubb.PluginContext
+} & (
+  | {
+      /**
+       * Returns the universal `@kubb/ast` `RootNode` produced by the configured adapter.
+       * Returns `undefined` when no adapter was set (legacy OAS-only usage).
+       */
+      rootNode: RootNode
+      /**
+       * Return the adapter from `@kubb/ast`
+       */
+      adapter: Adapter
+    }
+  | {
+      rootNode?: never
+      adapter?: never
+    }
+) &
+  Kubb.PluginContext
 /**
  * Specify the export location for the files and define the behavior of the output
  */
@@ -448,10 +529,6 @@ export type Output<TOptions> = {
   override?: boolean
 }
 
-type GroupContext = {
-  group: string
-}
-
 export type Group = {
   /**
    * Defines the type where to group the files.
@@ -461,9 +538,9 @@ export type Group = {
    */
   type: 'tag' | 'path'
   /**
-   * Return the name of a group based on the group name, this used for the file and name generation
+   * Return the name of a group based on the group name, this is used for the file and name generation.
    */
-  name?: (context: GroupContext) => string
+  name?: (context: { group: string }) => string
 }
 
 export type LoggerOptions = {
@@ -476,16 +553,51 @@ export type LoggerOptions = {
 /**
  * Shared context passed to all plugins, parsers, and Fabric internals.
  */
-export interface LoggerContext extends AsyncEventEmitter<KubbEvents> {}
-
-type Install<TOptions = unknown> = (context: LoggerContext, options?: TOptions) => void | Promise<void>
+export type LoggerContext = AsyncEventEmitter<KubbEvents>
 
 export type Logger<TOptions extends LoggerOptions = LoggerOptions> = {
   name: string
-  install: Install<TOptions>
+  install: (context: LoggerContext, options?: TOptions) => void | Promise<void>
 }
 
-export type UserLogger<TOptions extends LoggerOptions = LoggerOptions> = Omit<Logger<TOptions>, 'logLevel'>
+export type UserLogger<TOptions extends LoggerOptions = LoggerOptions> = Logger<TOptions>
 
-export type { DefineStorage } from './defineStorage.ts'
+/**
+ * Compatibility preset for code generation tools.
+ * - `'default'` – no compatibility adjustments (default behavior).
+ * - `'kubbV4'` – align generated names and structures with Kubb v4 output.
+ */
+export type CompatibilityPreset = 'default' | 'kubbV4'
+
+export type { Storage } from './createStorage.ts'
+export type { CoreGeneratorV2, Generator, ReactGeneratorV2 } from './defineGenerator.ts'
 export type { KubbEvents } from './Kubb.ts'
+
+/**
+ * A preset bundles a name, one or more resolvers, and optional AST transformers
+ * into a single reusable configuration object.
+ *
+ * @template TResolver - The concrete resolver type for this preset.
+ */
+export type Preset<TResolver extends Resolver = Resolver> = {
+  /**
+   * Unique identifier for this preset.
+   */
+  name: string
+  /**
+   * Ordered list of resolvers applied by this preset (last entry wins on merge).
+   */
+  resolvers: Array<TResolver>
+  /**
+   * Optional AST visitors / transformers applied after resolving.
+   */
+  transformers?: Array<Visitor>
+}
+
+/**
+ * A named registry of presets, keyed by preset name.
+ *
+ * @template TResolver - The concrete resolver type shared by all presets in this registry.
+ * @template TName - The union of valid preset name keys.
+ */
+export type Presets<TResolver extends Resolver = Resolver> = Record<CompatibilityPreset, Preset<TResolver>>

package/src/utils/FunctionParams.ts

@@ -30,12 +30,12 @@ type FunctionParamsASTWithType = {
   default?: string
 }
 /**
- * @deprecated
+ * @deprecated use ast package instead
  */
 export type FunctionParamsAST = FunctionParamsASTWithoutType | FunctionParamsASTWithType
 
 /**
- * @deprecated
+ * @deprecated use ast package instead
  */
 export class FunctionParams {
   #items: Array<FunctionParamsAST | FunctionParamsAST[]> = []

package/src/utils/TreeNode.ts

@@ -1,6 +1,6 @@
 import path from 'node:path'
 import type { KubbFile } from '@kubb/fabric-core/types'
-import { getMode } from '../PluginManager.ts'
+import { getMode } from '../PluginDriver.ts'
 
 type BarrelData = {
   file?: KubbFile.File
@@ -12,6 +12,15 @@ type BarrelData = {
   name: string
 }
 
+/**
+ * Tree structure used to build per-directory barrel (`index.ts`) files from a
+ * flat list of generated {@link KubbFile.File} 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
+ * traverse with {@link TreeNode.forEach}, {@link TreeNode.leaves}, or the
+ * `*Deep` helpers.
+ */
 export class TreeNode {
   data: BarrelData
   parent?: TreeNode
@@ -32,6 +41,9 @@ export class TreeNode {
     return child
   }
 
+  /**
+   * Returns the root ancestor of this node, walking up via `parent` links.
+   */
   get root(): TreeNode {
     if (!this.parent) {
       return this
@@ -39,6 +51,11 @@ export class TreeNode {
     return this.parent.root
   }
 
+  /**
+   * Returns all leaf descendants (nodes with no children) of this node.
+   *
+   * Results are cached after the first traversal.
+   */
   get leaves(): Array<TreeNode> {
     if (!this.children || this.children.length === 0) {
       // this is a leaf
@@ -105,6 +122,12 @@ export class TreeNode {
     return this.leaves.map(callback)
   }
 
+  /**
+   * Builds a {@link TreeNode} tree from a flat list of files.
+   *
+   * - Filters to files under `root` (when provided) and skips `.json` files.
+   * - Returns `null` when no files match.
+   */
   public static build(files: KubbFile.File[], root?: string): TreeNode | null {
     try {
       const filteredTree = buildDirectoryTree(files, root)

package/src/utils/diagnostics.ts

@@ -2,7 +2,10 @@ import { version as nodeVersion } from 'node:process'
 import { version as KubbVersion } from '../../package.json'
 
 /**
- * Get diagnostic information for debugging
+ * Returns a snapshot of the current runtime environment.
+ *
+ * Useful for attaching context to debug logs and error reports so that
+ * issues can be reproduced without manual information gathering.
  */
 export function getDiagnosticInfo() {
   return {

package/src/utils/executeStrategies.ts

@@ -7,7 +7,11 @@ type ValueOfPromiseFuncArray<TInput extends Array<unknown>> = TInput extends Arr
 type SeqOutput<TInput extends Array<PromiseFunc<TValue, null>>, TValue> = Promise<Array<Awaited<ValueOfPromiseFuncArray<TInput>>>>
 
 /**
- * Chains promises
+ * Runs promise functions in sequence, threading each result into the next call.
+ *
+ * - Each function receives the accumulated state from the previous call.
+ * - Skips functions that return a falsy value (acts as a no-op for that step).
+ * - Returns an array of all individual results.
  */
 export function hookSeq<TInput extends Array<PromiseFunc<TValue, null>>, TValue, TOutput = SeqOutput<TInput, TValue>>(promises: TInput): TOutput {
   return promises.filter(Boolean).reduce(
@@ -33,7 +37,10 @@ export function hookSeq<TInput extends Array<PromiseFunc<TValue, null>>, TValue,
 type HookFirstOutput<TInput extends Array<PromiseFunc<TValue, null>>, TValue = unknown> = ValueOfPromiseFuncArray<TInput>
 
 /**
- * Chains promises, first non-null result stops and returns
+ * Runs promise functions in sequence and returns the first non-null result.
+ *
+ * - Stops as soon as `nullCheck` passes for a result (default: `!== null`).
+ * - Subsequent functions are skipped once a match is found.
  */
 export function hookFirst<TInput extends Array<PromiseFunc<TValue, null>>, TValue = unknown, TOutput = HookFirstOutput<TInput, TValue>>(
   promises: TInput,
@@ -57,7 +64,10 @@ export function hookFirst<TInput extends Array<PromiseFunc<TValue, null>>, TValu
 type HookParallelOutput<TInput extends Array<PromiseFunc<TValue, null>>, TValue> = Promise<PromiseSettledResult<Awaited<ValueOfPromiseFuncArray<TInput>>>[]>
 
 /**
- * Runs an array of promise functions with optional concurrency limit.
+ * Runs promise functions concurrently and returns all settled results.
+ *
+ * - Limits simultaneous executions to `concurrency` (default: unlimited).
+ * - Uses `Promise.allSettled` so individual failures do not cancel other tasks.
  */
 export function hookParallel<TInput extends Array<PromiseFunc<TValue, null>>, TValue = unknown, TOutput = HookParallelOutput<TInput, TValue>>(
   promises: TInput,
@@ -70,12 +80,15 @@ export function hookParallel<TInput extends Array<PromiseFunc<TValue, null>>, TV
   return Promise.allSettled(tasks) as TOutput
 }
 
+/**
+ * Execution strategy used when dispatching plugin hook calls.
+ */
 export type Strategy = 'seq' | 'first' | 'parallel'
 
-export type StrategySwitch<TStrategy extends Strategy, TInput extends Array<PromiseFunc<TValue, null>>, TValue> = TStrategy extends 'first'
-  ? HookFirstOutput<TInput, TValue>
-  : TStrategy extends 'seq'
-    ? SeqOutput<TInput, TValue>
-    : TStrategy extends 'parallel'
-      ? HookParallelOutput<TInput, TValue>
-      : never
+type StrategyOutputMap<TInput extends Array<PromiseFunc<TValue, null>>, TValue> = {
+  first: HookFirstOutput<TInput, TValue>
+  seq: SeqOutput<TInput, TValue>
+  parallel: HookParallelOutput<TInput, TValue>
+}
+
+export type StrategySwitch<TStrategy extends Strategy, TInput extends Array<PromiseFunc<TValue, null>>, TValue> = StrategyOutputMap<TInput, TValue>[TStrategy]

package/src/utils/formatters.ts

@@ -4,18 +4,13 @@ import type { formatters } from '../constants.ts'
 type Formatter = keyof typeof formatters
 
 /**
- * Check if a formatter command is available in the system.
+ * Returns `true` when the given formatter is installed and callable.
  *
- * @param formatter - The formatter to check ('biome', 'prettier', or 'oxfmt')
- * @returns Promise that resolves to true if the formatter is available, false otherwise
- *
- * @remarks
- * This function checks availability by running `<formatter> --version` command.
- * All supported formatters (biome, prettier, oxfmt) implement the --version flag.
+ * Availability is detected by running `<formatter> --version` and checking
+ * that the process exits without error.
  */
 async function isFormatterAvailable(formatter: Formatter): Promise<boolean> {
   try {
-    // Try to get the version of the formatter to check if it's installed
     await x(formatter, ['--version'], { nodeOptions: { stdio: 'ignore' } })
     return true
   } catch {
@@ -24,27 +19,21 @@ async function isFormatterAvailable(formatter: Formatter): Promise<boolean> {
 }
 
 /**
- * Detect which formatter is available in the system.
- *
- * @returns Promise that resolves to the first available formatter or undefined if none are found
+ * Detects the first available code formatter on the current system.
  *
- * @remarks
- * Checks in order of preference: biome, oxfmt, prettier.
- * Uses the `--version` flag to detect if each formatter command is available.
- * This is a reliable method as all supported formatters implement this flag.
+ * - Checks in preference order: `biome`, `oxfmt`, `prettier`.
+ * - Returns `null` when none are found.
  *
  * @example
- * ```typescript
+ * ```ts
  * const formatter = await detectFormatter()
  * if (formatter) {
  *   console.log(`Using ${formatter} for formatting`)
- * } else {
- *   console.log('No formatter found')
  * }
  * ```
  */
-export async function detectFormatter(): Promise<Formatter | undefined> {
-  const formatterNames: Formatter[] = ['biome', 'oxfmt', 'prettier']
+export async function detectFormatter(): Promise<Formatter | null> {
+  const formatterNames = new Set(['biome', 'oxfmt', 'prettier'] as const)
 
   for (const formatter of formatterNames) {
     if (await isFormatterAvailable(formatter)) {
@@ -52,5 +41,5 @@ export async function detectFormatter(): Promise<Formatter | undefined> {
     }
   }
 
-  return undefined
+  return null
 }

package/src/utils/getBarrelFiles.ts

@@ -1,7 +1,9 @@
+/** biome-ignore-all lint/suspicious/useIterableCallbackReturn: not needed */
 import { join } from 'node:path'
+import { getRelativePath } from '@internals/utils'
 import type { KubbFile } from '@kubb/fabric-core/types'
-import { BarrelManager } from '../BarrelManager.ts'
 import type { BarrelType } from '../types.ts'
+import { TreeNode } from './TreeNode.ts'
 
 export type FileMetaBase = {
   pluginName?: string
@@ -27,6 +29,72 @@ type AddIndexesProps = {
   meta?: FileMetaBase
 }
 
+function getBarrelFilesByRoot(root: string | undefined, files: Array<KubbFile.ResolvedFile>): Array<KubbFile.File> {
+  const cachedFiles = new Map<KubbFile.Path, KubbFile.File>()
+
+  TreeNode.build(files, root)?.forEach((treeNode) => {
+    if (!treeNode || !treeNode.children || !treeNode.parent?.data.path) {
+      return
+    }
+
+    const barrelFilePath = join(treeNode.parent?.data.path, 'index.ts') as KubbFile.Path
+    const barrelFile: KubbFile.File = {
+      path: barrelFilePath,
+      baseName: 'index.ts',
+      exports: [],
+      imports: [],
+      sources: [],
+    }
+    const previousBarrelFile = cachedFiles.get(barrelFile.path)
+    const leaves = treeNode.leaves
+
+    leaves.forEach((item) => {
+      if (!item.data.name) {
+        return
+      }
+
+      const sources = item.data.file?.sources || []
+
+      sources.forEach((source) => {
+        if (!item.data.file?.path || !source.isIndexable || !source.name) {
+          return
+        }
+        const alreadyContainInPreviousBarrelFile = previousBarrelFile?.sources.some(
+          (item) => item.name === source.name && item.isTypeOnly === source.isTypeOnly,
+        )
+
+        if (alreadyContainInPreviousBarrelFile) {
+          return
+        }
+
+        barrelFile.exports!.push({
+          name: [source.name],
+          path: getRelativePath(treeNode.parent?.data.path, item.data.path),
+          isTypeOnly: source.isTypeOnly,
+        })
+
+        barrelFile.sources.push({
+          name: source.name,
+          isTypeOnly: source.isTypeOnly,
+          //TODO use parser to generate import
+          value: '',
+          isExportable: false,
+          isIndexable: false,
+        })
+      })
+    })
+
+    if (previousBarrelFile) {
+      previousBarrelFile.sources.push(...barrelFile.sources)
+      previousBarrelFile.exports?.push(...(barrelFile.exports || []))
+    } else {
+      cachedFiles.set(barrelFile.path, barrelFile)
+    }
+  })
+
+  return [...cachedFiles.values()]
+}
+
 function trimExtName(text: string): string {
   const dotIndex = text.lastIndexOf('.')
   // Only strip when the dot is found and no path separator follows it
@@ -37,24 +105,26 @@ function trimExtName(text: string): string {
   return text
 }
 
-export async function getBarrelFiles(files: Array<KubbFile.ResolvedFile>, { type, meta = {}, root, output }: AddIndexesProps): Promise<KubbFile.File[]> {
+/**
+ * Generates `index.ts` barrel files for all directories under `root/output.path`.
+ *
+ * - Returns an empty array when `type` is falsy or `'propagate'`.
+ * - Skips generation when the output path itself ends with `index` (already a barrel).
+ * - When `type` is `'all'`, strips named exports so every re-export becomes a wildcard (`export * from`).
+ * - Attaches `meta` to each barrel file for downstream plugin identification.
+ */
+export async function getBarrelFiles(files: Array<KubbFile.ResolvedFile>, { type, meta = {}, root, output }: AddIndexesProps): Promise<Array<KubbFile.File>> {
   if (!type || type === 'propagate') {
     return []
   }
 
-  const barrelManager = new BarrelManager()
-
   const pathToBuildFrom = join(root, output.path)
 
   if (trimExtName(pathToBuildFrom).endsWith('index')) {
     return []
   }
 
-  const barrelFiles = barrelManager.getFiles({
-    files,
-    root: pathToBuildFrom,
-    meta,
-  })
+  const barrelFiles = getBarrelFilesByRoot(pathToBuildFrom, files)
 
   if (type === 'all') {
     return barrelFiles.map((file) => {