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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/core",
-  "version": "5.0.0-alpha.20",
+  "version": "5.0.0-alpha.21",
   "description": "Core functionality for Kubb's plugin-based code generation system, providing the foundation for transforming OpenAPI specifications.",
   "keywords": [
     "typescript",
@@ -71,7 +71,7 @@
     "remeda": "^2.33.6",
     "semver": "^7.7.4",
     "tinyexec": "^1.0.4",
-    "@kubb/ast": "5.0.0-alpha.20"
+    "@kubb/ast": "5.0.0-alpha.21"
   },
   "devDependencies": {
     "@types/semver": "^7.7.1",

package/src/defineBuilder.ts

@@ -0,0 +1,26 @@
+import type { PluginFactoryOptions } from './types.ts'
+
+/**
+ * Builder type for the plugin-specific builder fields.
+ * `name` is required; all other methods are defined by the concrete plugin builder type.
+ */
+type BuilderBuilder<T extends PluginFactoryOptions> = () => T['builder'] & ThisType<T['builder']>
+
+/**
+ * Defines a builder for a plugin — a named collection of schema-building helpers that
+ * can be exported alongside the plugin and imported by other plugins or generators.
+ *
+ * @example
+ * export const builder = defineBuilder<PluginTs>(() => ({
+ *   name: 'default',
+ *   buildParamsSchema({ params, node, resolver }) {
+ *     return createSchema({ type: 'object', properties: [] })
+ *   },
+ *   buildDataSchemaNode({ node, resolver }) {
+ *     return createSchema({ type: 'object', properties: [] })
+ *   },
+ * }))
+ */
+export function defineBuilder<T extends PluginFactoryOptions>(build: BuilderBuilder<T>): T['builder'] {
+  return build() as T['builder']
+}

package/src/defineGenerator.ts

@@ -10,6 +10,7 @@ export type Version = '1' | '2'
  */
 export type OperationsV2Props<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
   config: Config
+  plugin: Plugin<TPlugin>
   adapter: Adapter
   options: Plugin<TPlugin>['options']
   nodes: Array<OperationNode>
@@ -21,6 +22,7 @@ export type OperationsV2Props<TPlugin extends PluginFactoryOptions = PluginFacto
 export type OperationV2Props<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
   config: Config
   adapter: Adapter
+  plugin: Plugin<TPlugin>
   options: Plugin<TPlugin>['options']
   node: OperationNode
 }
@@ -31,6 +33,7 @@ export type OperationV2Props<TPlugin extends PluginFactoryOptions = PluginFactor
 export type SchemaV2Props<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
   config: Config
   adapter: Adapter
+  plugin: Plugin<TPlugin>
   options: Plugin<TPlugin>['options']
   node: SchemaNode
 }

package/src/definePreset.ts

@@ -1,9 +1,9 @@
 import type { Visitor } from '@kubb/ast/types'
-import type { Preset, Resolver } from './types.ts'
+import type { Generator, Preset, Resolver } from './types.ts'
 
 /**
- * Creates a typed preset object that bundles a name, resolvers, and optional
- * transformers — the building block for composable plugin presets.
+ * Creates a typed preset object that bundles a name, resolvers, optional
+ * transformers, and optional generators — the building block for composable plugin presets.
  *
  * @example
  * import { definePreset } from '@kubb/core'
@@ -14,10 +14,14 @@ import type { Preset, Resolver } from './types.ts'
  * @example
  * // With custom transformers
  * export const myPreset = definePreset('myPreset', { resolvers: [resolverTsLegacy], transformers: [myTransformer] })
+ *
+ * @example
+ * // With generators
+ * export const myPreset = definePreset('myPreset', { resolvers: [resolverTsLegacy], generators: [typeGeneratorLegacy] })
  */
 export function definePreset<TResolver extends Resolver = Resolver, TName extends string = string>(
   name: TName,
-  { resolvers, transformers }: { resolvers: Array<TResolver>; transformers?: Array<Visitor> },
+  { resolvers, transformers, generators }: { resolvers: Array<TResolver>; transformers?: Array<Visitor>; generators?: Array<Generator<any>> },
 ): Preset<TResolver> & { name: TName } {
-  return { name, resolvers, transformers }
+  return { name, resolvers, transformers, generators }
 }

package/src/defineResolver.ts

@@ -1,14 +1,35 @@
+import path from 'node:path'
 import { camelCase, pascalCase } from '@internals/utils'
 import { isOperationNode, isSchemaNode } from '@kubb/ast'
-import type { Node, OperationNode, SchemaNode } from '@kubb/ast/types'
-import type { PluginFactoryOptions, ResolveNameParams, ResolveOptionsContext } from './types.ts'
+import type { Node, OperationNode, RootNode, SchemaNode } from '@kubb/ast/types'
+import type { KubbFile } from '@kubb/fabric-core/types'
+import { getMode } from './PluginDriver.ts'
+import type {
+  Config,
+  PluginFactoryOptions,
+  ResolveBannerContext,
+  ResolveNameParams,
+  ResolveOptionsContext,
+  Resolver,
+  ResolverContext,
+  ResolverFileParams,
+  ResolverPathParams,
+} from './types.ts'
 
 /**
  * Builder type for the plugin-specific resolver fields.
- * `default`, `resolveOptions`, and `name` are optional — built-in fallbacks are used when omitted.
+ *
+ * `default`, `resolveOptions`, `resolvePath`, `resolveFile`, `resolveBanner`, and `resolveFooter`
+ * are optional — built-in fallbacks are injected when omitted.
  */
-type ResolverBuilder<T extends PluginFactoryOptions> = () => Omit<T['resolver'], 'default' | 'resolveOptions' | 'name'> &
-  Partial<Pick<T['resolver'], 'default' | 'resolveOptions'>> & { name: string } & ThisType<T['resolver']>
+type ResolverBuilder<T extends PluginFactoryOptions> = () => Omit<
+  T['resolver'],
+  'default' | 'resolveOptions' | 'resolvePath' | 'resolveFile' | 'resolveBanner' | 'resolveFooter' | 'name' | 'pluginName'
+> &
+  Partial<Pick<T['resolver'], 'default' | 'resolveOptions' | 'resolvePath' | 'resolveFile' | 'resolveBanner' | 'resolveFooter'>> & {
+    name: string
+    pluginName: T['name']
+  } & ThisType<T['resolver']>
 
 /**
  * Checks if an operation matches a pattern for a given filter type (`tag`, `operationId`, `path`, `method`).
@@ -30,6 +51,7 @@ function matchesOperationPattern(node: OperationNode, type: string, pattern: str
 
 /**
  * Checks if a schema matches a pattern for a given filter type (`schemaName`).
+ *
  * Returns `null` when the filter type doesn't apply to schemas.
  */
 function matchesSchemaPattern(node: SchemaNode, type: string, pattern: string | RegExp): boolean | null {
@@ -42,7 +64,11 @@ function matchesSchemaPattern(node: SchemaNode, type: string, pattern: string |
 }
 
 /**
- * Default name resolver — `camelCase` for most types, `PascalCase` for `type`.
+ * Default name resolver used by `defineResolver`.
+ *
+ * - `camelCase` for `function` and `file` types.
+ * - `PascalCase` for `type`.
+ * - `camelCase` for everything else.
  */
 function defaultResolver(name: ResolveNameParams['name'], type: ResolveNameParams['type']): string {
   let resolvedName = camelCase(name)
@@ -61,8 +87,27 @@ function defaultResolver(name: ResolveNameParams['name'], type: ResolveNameParam
 }
 
 /**
- * Default option resolver — applies include/exclude filters and merges any matching override options.
- * Returns `null` when the node is filtered out.
+ * Default option resolver — applies include/exclude filters and merges matching override options.
+ *
+ * Returns `null` when the node is filtered out by an `exclude` rule or not matched by any `include` rule.
+ *
+ * @example Include/exclude filtering
+ * ```ts
+ * const options = defaultResolveOptions(operationNode, {
+ *   options: { output: 'types' },
+ *   exclude: [{ type: 'tag', pattern: 'internal' }],
+ * })
+ * // → null when node has tag 'internal'
+ * ```
+ *
+ * @example Override merging
+ * ```ts
+ * const options = defaultResolveOptions(operationNode, {
+ *   options: { enumType: 'asConst' },
+ *   override: [{ type: 'operationId', pattern: 'listPets', options: { enumType: 'enum' } }],
+ * })
+ * // → { enumType: 'enum' } when operationId matches
+ * ```
  */
 export function defaultResolveOptions<TOptions>(
   node: Node,
@@ -105,27 +150,299 @@ export function defaultResolveOptions<TOptions>(
 }
 
 /**
- * Defines a resolver for a plugin, with built-in defaults for name casing and include/exclude/override filtering.
- * Override `default` or `resolveOptions` in the builder to customize the behavior.
+ * Default path resolver used by `defineResolver`.
+ *
+ * - Returns the output directory in `single` mode.
+ * - Resolves into a tag- or path-based subdirectory when `group` and a `tag`/`path` value are provided.
+ * - Falls back to a flat `output/baseName` path otherwise.
+ *
+ * A custom `group.name` function overrides the default subdirectory naming.
+ * For `tag` groups the default is `${camelCase(tag)}Controller`.
+ * For `path` groups the default is the first path segment after `/`.
+ *
+ * @example Flat output
+ * ```ts
+ * defaultResolvePath({ baseName: 'petTypes.ts' }, { root: '/src', output: { path: 'types' } })
+ * // → '/src/types/petTypes.ts'
+ * ```
+ *
+ * @example Tag-based grouping
+ * ```ts
+ * defaultResolvePath(
+ *   { baseName: 'petTypes.ts', tag: 'pets' },
+ *   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
+ * )
+ * // → '/src/types/petsController/petTypes.ts'
+ * ```
+ *
+ * @example Path-based grouping
+ * ```ts
+ * defaultResolvePath(
+ *   { baseName: 'petTypes.ts', path: '/pets/list' },
+ *   { root: '/src', output: { path: 'types' }, group: { type: 'path' } },
+ * )
+ * // → '/src/types/pets/petTypes.ts'
+ * ```
+ *
+ * @example Single-file mode
+ * ```ts
+ * defaultResolvePath(
+ *   { baseName: 'petTypes.ts', pathMode: 'single' },
+ *   { root: '/src', output: { path: 'types' } },
+ * )
+ * // → '/src/types'
+ * ```
+ */
+export function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }: ResolverPathParams, { root, output, group }: ResolverContext): KubbFile.Path {
+  const mode = pathMode ?? getMode(path.resolve(root, output.path))
+
+  if (mode === 'single') {
+    return path.resolve(root, output.path) as KubbFile.Path
+  }
+
+  if (group && (groupPath || tag)) {
+    const groupName = group.name
+      ? group.name
+      : (ctx: { group: string }) => {
+          if (group.type === 'path') {
+            return `${ctx.group.split('/')[1]}`
+          }
+          return `${camelCase(ctx.group)}Controller`
+        }
+
+    return path.resolve(root, output.path, groupName({ group: group.type === 'path' ? groupPath! : tag! }), baseName) as KubbFile.Path
+  }
+
+  return path.resolve(root, output.path, baseName) as KubbFile.Path
+}
+
+/**
+ * Default file resolver used by `defineResolver`.
+ *
+ * Resolves a `KubbFile.File` 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.
+ *
+ * In `single` mode the name is omitted and the file sits directly in the output directory.
+ *
+ * @example Resolve a schema file
+ * ```ts
+ * const file = defaultResolveFile.call(resolver,
+ *   { name: 'pet', extname: '.ts' },
+ *   { root: '/src', output: { path: 'types' } },
+ * )
+ * // → { baseName: 'pet.ts', path: '/src/types/pet.ts', sources: [], ... }
+ * ```
+ *
+ * @example Resolve an operation file with tag grouping
+ * ```ts
+ * const file = defaultResolveFile.call(resolver,
+ *   { name: 'listPets', extname: '.ts', tag: 'pets' },
+ *   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
+ * )
+ * // → { baseName: 'listPets.ts', path: '/src/types/petsController/listPets.ts', ... }
+ * ```
+ */
+export function defaultResolveFile(this: Resolver, { name, extname, tag, path: groupPath }: ResolverFileParams, context: ResolverContext): KubbFile.File {
+  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 filePath = this.resolvePath({ baseName, pathMode, tag, path: groupPath }, context)
+
+  return {
+    path: filePath,
+    baseName: path.basename(filePath) as KubbFile.BaseName,
+    meta: {
+      pluginName: this.pluginName,
+    },
+    sources: [],
+    imports: [],
+    exports: [],
+  }
+}
+
+/**
+ * Generates the default "Generated by Kubb" banner from config and optional node metadata.
+ */
+export function buildDefaultBanner({
+  title,
+  description,
+  version,
+  config,
+}: {
+  title?: string
+  description?: string
+  version?: string
+  config: Config
+}): string {
+  try {
+    let source = ''
+    if (Array.isArray(config.input)) {
+      const first = config.input[0]
+      if (first && 'path' in first) {
+        source = path.basename(first.path)
+      }
+    } else if ('path' in config.input) {
+      source = path.basename(config.input.path)
+    } else if ('data' in config.input) {
+      source = 'text content'
+    }
+
+    let banner = '/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n'
+
+    if (config.output.defaultBanner === 'simple') {
+      banner += '*/\n'
+      return banner
+    }
+
+    if (source) {
+      banner += `* Source: ${source}\n`
+    }
+
+    if (title) {
+      banner += `* Title: ${title}\n`
+    }
+
+    if (description) {
+      const formattedDescription = description.replace(/\n/gm, '\n* ')
+      banner += `* Description: ${formattedDescription}\n`
+    }
+
+    if (version) {
+      banner += `* OpenAPI spec version: ${version}\n`
+    }
+
+    banner += '*/\n'
+    return banner
+  } catch (_error) {
+    return '/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n*/'
+  }
+}
+
+/**
+ * Default banner resolver — returns the banner string for a generated file.
  *
- * @example
+ * - When `output.banner` is a function and `node` is provided, calls it with the node.
+ * - When `output.banner` is a function and `node` is absent, falls back to the default Kubb banner.
+ * - When `output.banner` is a string, returns it directly.
+ * - When `config.output.defaultBanner` is `false`, returns `undefined`.
+ * - Otherwise returns the default "Generated by Kubb" banner.
+ *
+ * @example String banner
+ * ```ts
+ * defaultResolveBanner(undefined, { output: { banner: '// my banner' }, config })
+ * // → '// my banner'
+ * ```
+ *
+ * @example Function banner with node
+ * ```ts
+ * defaultResolveBanner(rootNode, { output: { banner: (node) => `// v${node.version}` }, config })
+ * // → '// v3.0.0'
+ * ```
+ *
+ * @example Disabled banner
+ * ```ts
+ * defaultResolveBanner(undefined, { config: { output: { defaultBanner: false }, ...config } })
+ * // → undefined
+ * ```
+ */
+export function defaultResolveBanner(node: RootNode | undefined, { output, config }: ResolveBannerContext): string | undefined {
+  if (typeof output?.banner === 'function') {
+    return node ? output.banner(node) : buildDefaultBanner({ config })
+  }
+  if (typeof output?.banner === 'string') {
+    return output.banner
+  }
+  if (config.output.defaultBanner === false) {
+    return undefined
+  }
+  return buildDefaultBanner({ config })
+}
+
+/**
+ * Default footer resolver — returns the footer string for a generated file.
+ *
+ * - When `output.footer` is a function and `node` is provided, calls it with the node.
+ * - When `output.footer` is a function and `node` is absent, returns `undefined`.
+ * - When `output.footer` is a string, returns it directly.
+ * - Otherwise returns `undefined`.
+ *
+ * @example String footer
+ * ```ts
+ * defaultResolveFooter(undefined, { output: { footer: '// end of file' }, config })
+ * // → '// end of file'
+ * ```
+ *
+ * @example Function footer with node
+ * ```ts
+ * defaultResolveFooter(rootNode, { output: { footer: (node) => `// ${node.title}` }, config })
+ * // → '// Pet Store'
+ * ```
+ */
+export function defaultResolveFooter(node: RootNode | undefined, { output }: ResolveBannerContext): string | undefined {
+  if (typeof output?.footer === 'function') {
+    return node ? output.footer(node) : undefined
+  }
+  if (typeof output?.footer === 'string') {
+    return output.footer
+  }
+  return undefined
+}
+
+/**
+ * Defines a resolver for a plugin, injecting built-in defaults for name casing,
+ * include/exclude/override filtering, path resolution, and file construction.
+ *
+ * All four defaults can be overridden by providing them in the builder function:
+ * - `default` — name casing strategy (camelCase / PascalCase)
+ * - `resolveOptions` — include/exclude/override filtering
+ * - `resolvePath` — output path computation
+ * - `resolveFile` — full `KubbFile.File` construction
+ *
+ * Methods in the builder have access to `this` (the full resolver object), so they
+ * can call other resolver methods without circular imports.
+ *
+ * @example Basic resolver with naming helpers
+ * ```ts
  * export const resolver = defineResolver<PluginTs>(() => ({
  *   name: 'default',
- *   resolveName(name) {
- *     return this.default(name, 'function')
+ *   resolveName(node) {
+ *     return this.default(node.name, 'function')
+ *   },
+ *   resolveTypedName(node) {
+ *     return this.default(node.name, 'type')
  *   },
- *   resolveTypedName(name) {
- *     return this.default(name, 'type')
+ * }))
+ * ```
+ *
+ * @example Override resolvePath for a custom output structure
+ * ```ts
+ * export const resolver = defineResolver<PluginTs>(() => ({
+ *   name: 'custom',
+ *   resolvePath({ baseName }, { root, output }) {
+ *     return path.resolve(root, output.path, 'generated', baseName)
  *   },
+ * }))
+ * ```
+ *
+ * @example Use this.default inside a helper
+ * ```ts
+ * export const resolver = defineResolver<PluginTs>(() => ({
+ *   name: 'default',
  *   resolveParamName(node, param) {
- *     return this.resolveName(`${node.operationId} ${param.in} ${param.name}`)
+ *     return this.default(`${node.operationId} ${param.in} ${param.name}`, 'type')
  *   },
  * }))
+ * ```
  */
 export function defineResolver<T extends PluginFactoryOptions>(build: ResolverBuilder<T>): T['resolver'] {
   return {
     default: defaultResolver,
     resolveOptions: defaultResolveOptions,
+    resolvePath: defaultResolvePath,
+    resolveFile: defaultResolveFile,
+    resolveBanner: defaultResolveBanner,
+    resolveFooter: defaultResolveFooter,
     ...build(),
   } as T['resolver']
 }

package/src/hooks/index.ts

@@ -1,4 +1,3 @@
-export { useKubb } from './useKubb.ts'
+export { useDriver } from './useDriver.ts'
 export { useMode } from './useMode.ts'
 export { usePlugin } from './usePlugin.ts'
-export { usePluginDriver } from './usePluginDriver.ts'

package/src/hooks/{usePluginDriver.ts → useDriver.ts}

@@ -1,10 +1,7 @@
 import { useFabric } from '@kubb/react-fabric'
 import type { PluginDriver } from '../PluginDriver.ts'
 
-/**
- * @deprecated use `useKubb` instead
- */
-export function usePluginDriver(): PluginDriver {
+export function useDriver(): PluginDriver {
   const { meta } = useFabric<{ driver: PluginDriver }>()
 
   return meta.driver

package/src/hooks/useMode.ts

@@ -2,7 +2,7 @@ import type { KubbFile } from '@kubb/fabric-core/types'
 import { useFabric } from '@kubb/react-fabric'
 
 /**
- * @deprecated use `useKubb` instead
+ * @deprecated use `mode` from the generator component props instead
  */
 export function useMode(): KubbFile.Mode {
   const { meta } = useFabric<{ mode: KubbFile.Mode }>()

package/src/hooks/usePlugin.ts

@@ -2,7 +2,7 @@ import { useFabric } from '@kubb/react-fabric'
 import type { Plugin, PluginFactoryOptions } from '../types.ts'
 
 /**
- * @deprecated use useKubb instead
+ * @deprecated use `plugin` from the generator component props instead
  */
 export function usePlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(): Plugin<TOptions> {
   const { meta } = useFabric<{ plugin: Plugin<TOptions> }>()

package/src/index.ts

@@ -6,11 +6,20 @@ export { formatters, linters, logLevel } from './constants.ts'
 export { createAdapter } from './createAdapter.ts'
 export { createPlugin } from './createPlugin.ts'
 export { createStorage } from './createStorage.ts'
+export { defineBuilder } from './defineBuilder.ts'
 export { defineGenerator } from './defineGenerator.ts'
 export { defineLogger } from './defineLogger.ts'
 export { definePreset } from './definePreset.ts'
 export { definePresets } from './definePresets.ts'
-export { defaultResolveOptions, defineResolver } from './defineResolver.ts'
+export {
+  buildDefaultBanner,
+  defaultResolveBanner,
+  defaultResolveFile,
+  defaultResolveFooter,
+  defaultResolveOptions,
+  defaultResolvePath,
+  defineResolver,
+} from './defineResolver.ts'
 export { getMode, PluginDriver } from './PluginDriver.ts'
 export { renderOperation, renderOperations, renderSchema } from './renderNode.tsx'
 export { fsStorage } from './storages/fsStorage.ts'

package/src/renderNode.tsx

@@ -1,5 +1,4 @@
 import type { OperationNode, SchemaNode } from '@kubb/ast/types'
-import type { KubbFile } from '@kubb/fabric-core/types'
 import { createReactFabric, Fabric } from '@kubb/react-fabric'
 import type { Fabric as FabricType } from '@kubb/react-fabric/types'
 import type { PluginDriver } from './PluginDriver.ts'
@@ -12,7 +11,6 @@ type BuildOperationsV2Options<TOptions extends PluginFactoryOptions> = {
   Component: ReactGeneratorV2<TOptions>['Operations'] | undefined
   adapter: Adapter
   driver: PluginDriver
-  mode: KubbFile.Mode
   options: TOptions['resolvedOptions']
 }
 
@@ -23,7 +21,7 @@ export async function renderOperations<TOptions extends PluginFactoryOptions>(
   nodes: Array<OperationNode>,
   options: BuildOperationsV2Options<TOptions>,
 ): Promise<void> {
-  const { config, fabric, plugin, Component, adapter } = options
+  const { config, fabric, plugin, Component, driver, adapter } = options
 
   if (!Component) {
     return undefined
@@ -32,8 +30,8 @@ export async function renderOperations<TOptions extends PluginFactoryOptions>(
   const fabricChild = createReactFabric()
 
   await fabricChild.render(
-    <Fabric meta={{ plugin }}>
-      <Component config={config} adapter={adapter} nodes={nodes} options={options.options} />
+    <Fabric meta={{ plugin, driver }}>
+      <Component config={config} plugin={plugin} adapter={adapter} nodes={nodes} options={options.options} />
     </Fabric>,
   )
 
@@ -48,7 +46,6 @@ type BuildOperationV2Options<TOptions extends PluginFactoryOptions> = {
   Component: ReactGeneratorV2<TOptions>['Operation'] | undefined
   adapter: Adapter
   driver: PluginDriver
-  mode: KubbFile.Mode
   options: TOptions['resolvedOptions']
 }
 
@@ -56,7 +53,7 @@ type BuildOperationV2Options<TOptions extends PluginFactoryOptions> = {
  * Renders a React component for a single operation node (V2 generators).
  */
 export async function renderOperation<TOptions extends PluginFactoryOptions>(node: OperationNode, options: BuildOperationV2Options<TOptions>): Promise<void> {
-  const { config, fabric, plugin, Component, adapter, driver, mode } = options
+  const { config, fabric, plugin, Component, adapter, driver } = options
 
   if (!Component) {
     return undefined
@@ -65,8 +62,8 @@ export async function renderOperation<TOptions extends PluginFactoryOptions>(nod
   const fabricChild = createReactFabric()
 
   await fabricChild.render(
-    <Fabric meta={{ plugin, driver, mode }}>
-      <Component config={config} adapter={adapter} node={node} options={options.options} />
+    <Fabric meta={{ plugin, driver }}>
+      <Component config={config} plugin={plugin} adapter={adapter} node={node} options={options.options} />
     </Fabric>,
   )
 
@@ -81,7 +78,6 @@ type BuildSchemaV2Options<TOptions extends PluginFactoryOptions> = {
   Component: ReactGeneratorV2<TOptions>['Schema'] | undefined
   adapter: Adapter
   driver: PluginDriver
-  mode: KubbFile.Mode
   options: TOptions['resolvedOptions']
 }
 
@@ -89,7 +85,7 @@ type BuildSchemaV2Options<TOptions extends PluginFactoryOptions> = {
  * Renders a React component for a single schema node (V2 generators).
  */
 export async function renderSchema<TOptions extends PluginFactoryOptions>(node: SchemaNode, options: BuildSchemaV2Options<TOptions>): Promise<void> {
-  const { config, fabric, plugin, Component, adapter, driver, mode } = options
+  const { config, fabric, plugin, Component, adapter, driver } = options
 
   if (!Component) {
     return undefined
@@ -98,11 +94,12 @@ export async function renderSchema<TOptions extends PluginFactoryOptions>(node:
   const fabricChild = createReactFabric()
 
   await fabricChild.render(
-    <Fabric meta={{ plugin, driver, mode }}>
-      <Component config={config} adapter={adapter} node={node} options={options.options} />
+    <Fabric meta={{ plugin, driver }}>
+      <Component config={config} plugin={plugin} adapter={adapter} node={node} options={options.options} />
     </Fabric>,
   )
 
   fabric.context.fileManager.upsert(...fabricChild.files)
+
   fabricChild.unmount()
 }