@kubb/core 4.34.0 → 4.35.0

package/dist/{types-DfjjJb2r.d.ts → types-7DgxNmCG.d.ts}

@@ -2,6 +2,7 @@ import { t as __name } from "./chunk--u3MIqq1.js";
 import { EventEmitter } from "node:events";
 import { Fabric } from "@kubb/react-fabric";
 import { KubbFile } from "@kubb/fabric-core/types";
+import { Printer, RootNode } from "@kubb/ast/types";
 
 //#region ../../internals/utils/dist/index.d.ts
 /**
@@ -24,6 +25,7 @@ declare var AsyncEventEmitter: {
 };
 //#endregion
 //#region src/constants.d.ts
+declare const DEFAULT_STUDIO_URL: "https://studio.kubb.dev";
 declare const logLevel: {
   readonly silent: number;
   readonly error: 0;
@@ -95,6 +97,11 @@ declare class PluginManager {
   #private;
   readonly config: Config;
   readonly options: Options;
+  /**
+   * The universal `@kubb/ast` `RootNode` produced by the adapter, set by
+   * the build pipeline after the adapter's `parse()` resolves.
+   */
+  rootNode: RootNode | undefined;
   constructor(config: Config, options: Options);
   get events(): AsyncEventEmitter<KubbEvents>;
   getContext<TOptions extends PluginFactoryOptions>(plugin: Plugin<TOptions>): PluginContext<TOptions> & Record<string, unknown>;
@@ -437,7 +444,65 @@ type InputData = {
   data: string | unknown;
 };
 type Input = InputPath | InputData | Array<InputPath>;
+/**
+ * The raw source passed to an adapter's `parse` function.
+ * Mirrors the shape of `Config['input']` with paths already resolved to absolute.
+ */
+type AdapterSource = {
+  type: 'path';
+  path: string;
+} | {
+  type: 'data';
+  data: string | unknown;
+} | {
+  type: 'paths';
+  paths: Array<string>;
+};
+/**
+ * Type parameters for an adapter definition.
+ *
+ * Mirrors `PluginFactoryOptions` but scoped to the adapter lifecycle:
+ * - `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`
+ */
+type AdapterFactoryOptions<TName extends string = string, TOptions extends object = object, TResolvedOptions extends object = TOptions> = {
+  name: TName;
+  options: TOptions;
+  resolvedOptions: TResolvedOptions;
+};
+/**
+ * An adapter converts a source file or data into a `@kubb/ast` `RootNode`.
+ *
+ * Adapters are the single entry-point for different schema formats
+ * (OpenAPI, AsyncAPI, Drizzle, …) and produce the universal `RootNode`
+ * that all Kubb plugins consume.
+ *
+ * @example
+ * ```ts
+ * import { oasAdapter } from '@kubb/adapter-oas'
+ *
+ * export default defineConfig({
+ *   adapter: adapterOas(),         // default — OpenAPI / Swagger
+ *   input:   { path: './openapi.yaml' },
+ *   plugins: [pluginTs(), pluginZod()],
+ * })
+ * ```
+ */
+type Adapter<TOptions extends AdapterFactoryOptions = AdapterFactoryOptions> = {
+  /** Human-readable identifier, e.g. `'oas'`, `'drizzle'`, `'asyncapi'`. */name: TOptions['name']; /** Resolved options (after defaults have been applied). */
+  options: TOptions['resolvedOptions']; /** Convert the raw source into a universal `RootNode`. */
+  parse: (source: AdapterSource) => PossiblePromise<RootNode>;
+};
 type BarrelType = 'all' | 'named' | 'propagate';
+type DevtoolsOptions = {
+  /**
+   * Open the AST inspector view (`/ast`) in Kubb Studio.
+   * When `false`, opens the main Studio page instead.
+   * @default false
+   */
+  ast?: boolean;
+};
 /**
  * @private
  */
@@ -451,6 +516,24 @@ type Config<TInput = Input> = {
    * @default process.cwd()
    */
   root: string;
+  /**
+   * Adapter that converts the input file into a `@kubb/ast` `RootNode` — the universal
+   * intermediate representation consumed by all Kubb plugins.
+   *
+   * - Omit (or pass `undefined`) to use the built-in OpenAPI/Swagger adapter.
+   * - Use `@kubb/adapter-oas` for explicit OpenAPI configuration (validate, contentType, …).
+   * - Use `@kubb/adapter-drizzle` or `@kubb/adapter-asyncapi` for other formats.
+   *
+   * @example
+   * ```ts
+   * import { drizzleAdapter } from '@kubb/adapter-drizzle'
+   * export default defineConfig({
+   *   adapter: drizzleAdapter(),
+   *   input: { path: './src/schema.ts' },
+   * })
+   * ```
+   */
+  adapter?: Adapter;
   /**
    * You can use either `input.path` or `input.data`, depending on your specific needs.
    */
@@ -522,6 +605,16 @@ type Config<TInput = Input> = {
    * If a plugin depends on another plugin, an error is returned if the required dependency is missing. See pre for more details.
    */
   plugins?: Array<Plugin>;
+  /**
+   * Devtools configuration for Kubb Studio integration.
+   */
+  devtools?: true | {
+    /**
+     * Override the Kubb Studio base URL.
+     * @default 'https://studio.kubb.dev'
+     */
+    studioUrl?: typeof DEFAULT_STUDIO_URL | (string & {});
+  };
   /**
    * Hooks triggered when a specific action occurs in Kubb.
    */
@@ -684,6 +777,17 @@ type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
    * 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;
 /**
  * Specify the export location for the files and define the behavior of the output
@@ -745,5 +849,5 @@ type Logger<TOptions extends LoggerOptions = LoggerOptions> = {
 };
 type UserLogger<TOptions extends LoggerOptions = LoggerOptions> = Omit<Logger<TOptions>, 'logLevel'>;
 //#endregion
-export { linters as A, UserLogger as C, PluginManager as D, KubbEvents as E, AsyncEventEmitter as M, getMode as O, UserConfig as S, UserPluginWithLifeCycle as T, PluginParameter as _, InputData as a, ResolvePathParams as b, LoggerContext as c, Plugin as d, PluginContext as f, PluginLifecycleHooks as g, PluginLifecycle as h, Group as i, logLevel as j, formatters as k, LoggerOptions as l, PluginKey as m, Config as n, InputPath as o, PluginFactoryOptions as p, GetPluginFactoryOptions as r, Logger as s, BarrelType as t, Output as u, PluginWithLifeCycle as v, UserPlugin as w, UnknownUserPlugin as x, ResolveNameParams as y };
-//# sourceMappingURL=types-DfjjJb2r.d.ts.map
+export { UserPluginWithLifeCycle as A, Printer as C, UserConfig as D, UnknownUserPlugin as E, linters as F, logLevel as I, AsyncEventEmitter as L, PluginManager as M, getMode as N, UserLogger as O, formatters as P, PluginWithLifeCycle as S, ResolvePathParams as T, PluginFactoryOptions as _, Config as a, PluginLifecycleHooks as b, Group as c, Logger as d, LoggerContext as f, PluginContext as g, Plugin as h, BarrelType as i, KubbEvents as j, UserPlugin as k, InputData as l, Output as m, AdapterFactoryOptions as n, DevtoolsOptions as o, LoggerOptions as p, AdapterSource as r, GetPluginFactoryOptions as s, Adapter as t, InputPath as u, PluginKey as v, ResolveNameParams as w, PluginParameter as x, PluginLifecycle as y };
+//# sourceMappingURL=types-7DgxNmCG.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/core",
-  "version": "4.34.0",
+  "version": "4.35.0",
   "description": "Core functionality for Kubb's plugin-based code generation system, providing the foundation for transforming OpenAPI specifications.",
   "keywords": [
     "typescript",
@@ -67,9 +67,11 @@
     "@kubb/fabric-core": "0.13.3",
     "@kubb/react-fabric": "0.13.3",
     "empathic": "^2.0.0",
+    "fflate": "^0.8.2",
     "remeda": "^2.33.6",
     "semver": "^7.7.4",
-    "tinyexec": "^1.0.2"
+    "tinyexec": "^1.0.4",
+    "@kubb/ast": "4.35.0"
   },
   "devDependencies": {
     "@types/semver": "^7.7.1",
@@ -90,8 +92,8 @@
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "inlinedDependencies": {
-    "yocto-queue": "1.2.2",
-    "p-limit": "7.3.0"
+    "p-limit": "7.3.0",
+    "yocto-queue": "1.2.2"
   },
   "scripts": {
     "build": "tsdown && size-limit",

package/src/PluginManager.ts

@@ -2,13 +2,16 @@ import path from 'node:path'
 import { performance } from 'node:perf_hooks'
 import type { AsyncEventEmitter } from '@internals/utils'
 import { setUniqueName, transformReservedWord } 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 { CORE_PLUGIN_NAME } from './constants.ts'
+import { CORE_PLUGIN_NAME, DEFAULT_STUDIO_URL } from './constants.ts'
+import { openInStudio as openInStudioFn } from './devtools.ts'
 import { ValidationPluginError } from './errors.ts'
 import { isPromiseRejectedResult, PromiseManager } from './PromiseManager.ts'
 import type {
   Config,
+  DevtoolsOptions,
   KubbEvents,
   Plugin,
   PluginContext,
@@ -63,6 +66,13 @@ export class PluginManager {
   readonly config: Config
   readonly options: Options
 
+  /**
+   * The universal `@kubb/ast` `RootNode` produced by the adapter, set by
+   * the build pipeline after the adapter's `parse()` resolves.
+   */
+  rootNode: RootNode | undefined = undefined
+  #studioIsOpen = false
+
   readonly #plugins = new Set<Plugin>()
   readonly #usedPluginNames: Record<string, number> = {}
   readonly #promiseManager
@@ -86,6 +96,8 @@ export class PluginManager {
 
   getContext<TOptions extends PluginFactoryOptions>(plugin: Plugin<TOptions>): PluginContext<TOptions> & Record<string, unknown> {
     const plugins = [...this.#plugins]
+    const pluginManager = this
+
     const baseContext = {
       fabric: this.options.fabric,
       config: this.config,
@@ -99,6 +111,28 @@ export class PluginManager {
       upsertFile: async (...files: Array<KubbFile.File>) => {
         await this.options.fabric.upsertFile(...files)
       },
+      get rootNode(): RootNode | undefined {
+        return pluginManager.rootNode
+      },
+      openInStudio(options?: DevtoolsOptions) {
+        if (typeof pluginManager.config.devtools !== 'object') {
+          throw new Error('Devtools must be an object')
+        }
+
+        if (!pluginManager.rootNode) {
+          throw new Error('RootNode is not defined, make sure you have set the parser in kubb.config.ts')
+        }
+
+        if (pluginManager.#studioIsOpen) {
+          return
+        }
+
+        pluginManager.#studioIsOpen = true
+
+        const studioUrl = pluginManager.config.devtools?.studioUrl ?? DEFAULT_STUDIO_URL
+
+        return openInStudioFn(pluginManager.rootNode, studioUrl, options)
+      },
     } as unknown as PluginContext<TOptions>
 
     const mergedExtras: Record<string, unknown> = {}

package/src/build.ts

@@ -6,10 +6,10 @@ import { createFabric } from '@kubb/react-fabric'
 import { typescriptParser } from '@kubb/react-fabric/parsers'
 import { fsPlugin } from '@kubb/react-fabric/plugins'
 import { isInputPath } from './config.ts'
-import { BARREL_FILENAME, DEFAULT_BANNER, DEFAULT_CONCURRENCY, DEFAULT_EXTENSION } from './constants.ts'
+import { BARREL_FILENAME, DEFAULT_BANNER, DEFAULT_CONCURRENCY, DEFAULT_EXTENSION, DEFAULT_STUDIO_URL } from './constants.ts'
 import { BuildError } from './errors.ts'
 import { PluginManager } from './PluginManager.ts'
-import type { Config, KubbEvents, Output, Plugin, UserConfig } from './types.ts'
+import type { AdapterSource, Config, KubbEvents, Output, Plugin, UserConfig } from './types.ts'
 import { getDiagnosticInfo } from './utils/diagnostics.ts'
 import type { FileMetaBase } from './utils/getBarrelFiles.ts'
 
@@ -96,6 +96,12 @@ export async function setup(options: BuildOptions): Promise<SetupResult> {
       defaultBanner: DEFAULT_BANNER,
       ...userConfig.output,
     },
+    devtools: userConfig.devtools
+      ? {
+          studioUrl: DEFAULT_STUDIO_URL,
+          ...(typeof userConfig.devtools === 'boolean' ? {} : userConfig.devtools),
+        }
+      : undefined,
     plugins: userConfig.plugins as Config['plugins'],
   }
 
@@ -159,6 +165,27 @@ export async function setup(options: BuildOptions): Promise<SetupResult> {
     concurrency: DEFAULT_CONCURRENCY,
   })
 
+  // Run the adapter (if provided) to produce the universal RootNode
+  if (definedConfig.adapter) {
+    const source = inputToAdapterSource(definedConfig)
+
+    await events.emit('debug', {
+      date: new Date(),
+      logs: [`Running adapter: ${definedConfig.adapter.name}`],
+    })
+
+    pluginManager.rootNode = await definedConfig.adapter.parse(source)
+
+    await events.emit('debug', {
+      date: new Date(),
+      logs: [
+        `✓ Adapter '${definedConfig.adapter.name}' resolved RootNode`,
+        `  • Schemas: ${pluginManager.rootNode.schemas.length}`,
+        `  • Operations: ${pluginManager.rootNode.operations.length}`,
+      ],
+    })
+  }
+
   return {
     events,
     fabric,
@@ -364,3 +391,23 @@ function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, plu
     })
   })
 }
+
+/**
+ * Maps the resolved `Config['input']` shape into an `AdapterSource` that
+ * the adapter's `parse()` can consume.
+ */
+function inputToAdapterSource(config: Config): AdapterSource {
+  if (Array.isArray(config.input)) {
+    return {
+      type: 'paths',
+      paths: config.input.map((i) => resolve(config.root, i.path)),
+    }
+  }
+
+  if ('data' in config.input) {
+    return { type: 'data', data: config.input.data }
+  }
+
+  const resolved = resolve(config.root, config.input.path)
+  return { type: 'path', path: resolved }
+}

package/src/constants.ts

@@ -1,5 +1,7 @@
 import type { KubbFile } from '@kubb/fabric-core/types'
 
+export const DEFAULT_STUDIO_URL = 'https://studio.kubb.dev' as const
+
 export const CORE_PLUGIN_NAME = 'core' as const
 
 export const DEFAULT_MAX_LISTENERS = 100

package/src/defineAdapter.ts

@@ -0,0 +1,22 @@
+import type { Adapter, AdapterFactoryOptions } from './types.ts'
+
+type AdapterBuilder<T extends AdapterFactoryOptions> = (options: T['options']) => Adapter<T>
+
+/**
+ * Wraps an adapter builder to make the options parameter optional.
+ *
+ * @example
+ * ```ts
+ * export const adapterOas = defineAdapter<OasAdapter>((options) => {
+ *   const { validate = true, dateType = 'string' } = options
+ *   return {
+ *     name: adapterOasName,
+ *     options: { validate, dateType, ... },
+ *     parse(source) { ... },
+ *   }
+ * })
+ * ```
+ */
+export function defineAdapter<T extends AdapterFactoryOptions = AdapterFactoryOptions>(build: AdapterBuilder<T>): (options?: T['options']) => Adapter<T> {
+  return (options) => build(options ?? ({} as T['options']))
+}

package/src/devtools.ts

@@ -0,0 +1,59 @@
+import type { RootNode } from '@kubb/ast/types'
+import { deflateSync, inflateSync } from 'fflate'
+import { x } from 'tinyexec'
+import type { DevtoolsOptions } from './types.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.
+ */
+export function encodeAst(root: RootNode): string {
+  const compressed = deflateSync(new TextEncoder().encode(JSON.stringify(root)))
+  return Buffer.from(compressed).toString('base64url')
+}
+
+/**
+ * Decodes a `RootNode` from a string produced by {@link encodeAst}.
+ *
+ * Works in both Node.js and the browser — no streaming APIs required.
+ */
+export function decodeAst(encoded: string): RootNode {
+  const bytes = Buffer.from(encoded, 'base64url')
+  return JSON.parse(new TextDecoder().decode(inflateSync(bytes))) as RootNode
+}
+
+/**
+ * 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.
+ */
+export function getStudioUrl(root: RootNode, studioUrl: string, options: DevtoolsOptions = {}): string {
+  const baseUrl = studioUrl.replace(/\/$/, '')
+  const path = options.ast ? '/ast' : ''
+
+  return `${baseUrl}${path}?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.
+ */
+export async function openInStudio(root: RootNode, studioUrl: string, options: DevtoolsOptions = {}): Promise<void> {
+  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`)
+  }
+}

package/src/index.ts

@@ -1,6 +1,9 @@
+export { AsyncEventEmitter } from '@internals/utils'
+export { definePrinter } from '@kubb/ast'
 export { build, build as default, safeBuild, setup } from './build.ts'
 export { type CLIOptions, type ConfigInput, defineConfig, isInputPath } from './config.ts'
 export { formatters, linters, logLevel } from './constants.ts'
+export { defineAdapter } from './defineAdapter.ts'
 export { defineLogger } from './defineLogger.ts'
 export { definePlugin } from './definePlugin.ts'
 export { PackageManager } from './PackageManager.ts'

package/src/types.ts

@@ -1,10 +1,13 @@
 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 { logLevel } from './constants.ts'
+import type { DEFAULT_STUDIO_URL, logLevel } from './constants.ts'
 import type { KubbEvents } from './Kubb.ts'
 import type { PluginManager } from './PluginManager.ts'
 
+export type { Printer } from '@kubb/ast/types'
+
 declare global {
   namespace Kubb {
     interface PluginContext {}
@@ -49,8 +52,64 @@ export type InputData = {
 
 type Input = InputPath | InputData | Array<InputPath>
 
+/**
+ * The raw source passed to an adapter's `parse` function.
+ * Mirrors the shape of `Config['input']` with paths already resolved to absolute.
+ */
+export type AdapterSource = { type: 'path'; path: string } | { type: 'data'; data: string | unknown } | { type: 'paths'; paths: Array<string> }
+
+/**
+ * Type parameters for an adapter definition.
+ *
+ * Mirrors `PluginFactoryOptions` but scoped to the adapter lifecycle:
+ * - `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`
+ */
+export type AdapterFactoryOptions<TName extends string = string, TOptions extends object = object, TResolvedOptions extends object = TOptions> = {
+  name: TName
+  options: TOptions
+  resolvedOptions: TResolvedOptions
+}
+
+/**
+ * An adapter converts a source file or data into a `@kubb/ast` `RootNode`.
+ *
+ * Adapters are the single entry-point for different schema formats
+ * (OpenAPI, AsyncAPI, Drizzle, …) and produce the universal `RootNode`
+ * that all Kubb plugins consume.
+ *
+ * @example
+ * ```ts
+ * import { oasAdapter } from '@kubb/adapter-oas'
+ *
+ * export default defineConfig({
+ *   adapter: adapterOas(),         // default — OpenAPI / Swagger
+ *   input:   { path: './openapi.yaml' },
+ *   plugins: [pluginTs(), pluginZod()],
+ * })
+ * ```
+ */
+export type Adapter<TOptions extends AdapterFactoryOptions = AdapterFactoryOptions> = {
+  /** Human-readable identifier, e.g. `'oas'`, `'drizzle'`, `'asyncapi'`. */
+  name: TOptions['name']
+  /** Resolved options (after defaults have been applied). */
+  options: TOptions['resolvedOptions']
+  /** Convert the raw source into a universal `RootNode`. */
+  parse: (source: AdapterSource) => PossiblePromise<RootNode>
+}
+
 export type BarrelType = 'all' | 'named' | 'propagate'
 
+export type DevtoolsOptions = {
+  /**
+   * Open the AST inspector view (`/ast`) in Kubb Studio.
+   * When `false`, opens the main Studio page instead.
+   * @default false
+   */
+  ast?: boolean
+}
+
 /**
  * @private
  */
@@ -64,6 +123,24 @@ export type Config<TInput = Input> = {
    * @default process.cwd()
    */
   root: string
+  /**
+   * Adapter that converts the input file into a `@kubb/ast` `RootNode` — the universal
+   * intermediate representation consumed by all Kubb plugins.
+   *
+   * - Omit (or pass `undefined`) to use the built-in OpenAPI/Swagger adapter.
+   * - Use `@kubb/adapter-oas` for explicit OpenAPI configuration (validate, contentType, …).
+   * - Use `@kubb/adapter-drizzle` or `@kubb/adapter-asyncapi` for other formats.
+   *
+   * @example
+   * ```ts
+   * import { drizzleAdapter } from '@kubb/adapter-drizzle'
+   * export default defineConfig({
+   *   adapter: drizzleAdapter(),
+   *   input: { path: './src/schema.ts' },
+   * })
+   * ```
+   */
+  adapter?: Adapter
   /**
    * You can use either `input.path` or `input.data`, depending on your specific needs.
    */
@@ -135,6 +212,18 @@ export type Config<TInput = Input> = {
    * If a plugin depends on another plugin, an error is returned if the required dependency is missing. See pre for more details.
    */
   plugins?: Array<Plugin>
+  /**
+   * Devtools configuration for Kubb Studio integration.
+   */
+  devtools?:
+    | true
+    | {
+        /**
+         * Override the Kubb Studio base URL.
+         * @default 'https://studio.kubb.dev'
+         */
+        studioUrl?: typeof DEFAULT_STUDIO_URL | (string & {})
+      }
   /**
    * Hooks triggered when a specific action occurs in Kubb.
    */
@@ -315,6 +404,17 @@ 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
 /**
  * Specify the export location for the files and define the behavior of the output

package/src/utils/FunctionParams.ts

@@ -1,4 +1,5 @@
 import { camelCase } from '@internals/utils'
+// TODO replace with @internals/utils
 import { sortBy } from 'remeda'
 
 type FunctionParamsASTWithoutType = {