kubb 5.0.0-beta.7 → 5.0.0-beta.70

package/LICENSE

@@ -1,14 +1,21 @@
-Copyright (c) 2026 Stijn Van Hulle
-
-This repository contains software under two licenses:
+MIT License
 
-1. Most of the code in this repository is licensed under the
-   MIT License — see licenses/LICENSE-MIT for the full license text.
+Copyright (c) 2026 Stijn Van Hulle
 
-2. The following components are licensed under the
-   GNU Affero General Public License v3.0 or later (AGPL-3.0-or-later)
-   — see licenses/LICENSE-AGPL-3.0 for the full license text:
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-   - packages/agent (published as @kubb/agent)
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-Each package's own LICENSE file or package.json specifies its applicable license.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,18 +1,14 @@
 <div align="center">
-  <h1>kubb</h1>
   <a href="https://kubb.dev" target="_blank" rel="noopener noreferrer">
-    <img width="180" src="https://raw.githubusercontent.com/kubb-labs/kubb/main/assets/logo.png" alt="Kubb logo">
+    <img src="https://kubb.dev/og.png" alt="Kubb banner">
   </a>
 
 [![npm version][npm-version-src]][npm-version-href]
 [![npm downloads][npm-downloads-src]][npm-downloads-href]
-[![Coverage][coverage-src]][coverage-href]
+[![Stars][stars-src]][stars-href]
 [![License][license-src]][license-href]
-[![Sponsors][sponsors-src]][sponsors-href]
-
-### The meta framework for code generation
-
-Point Kubb at an OpenAPI spec and it generates types, clients, hooks, validators, mocks, and more.
+[![Coverage][coverage-src]][coverage-href]
+[![Node][node-src]][node-href]
 
 <h4>
 <a href="https://kubb.dev" target="_blank">Documentation</a>
@@ -25,6 +21,12 @@ Point Kubb at an OpenAPI spec and it generates types, clients, hooks, validators
 
 <br />
 
+# Kubb
+
+### The meta framework for code generation
+
+Point Kubb at a schema and it generates types, clients, hooks, validators, mocks, and more.
+
 ## Installation
 
 ```bash
@@ -53,19 +55,22 @@ See the [documentation](https://kubb.dev) for detailed usage and advanced featur
 
 ## Features
 
-- Works with Node.js 22+ and TypeScript 6.
-- Converts Swagger 2.0, OpenAPI 3.0, and OpenAPI 3.1 into TypeScript types, API clients, and more via the [plugin ecosystem](https://github.com/kubb-labs/kubb-plugins).
-- Extensible plugin and middleware system that you can compose for custom code generation pipelines.
-- CLI with interactive setup, progress bar, and detailed logs.
-- Model Context Protocol (MCP) server for AI assistants like [Claude](https://claude.ai), [Cursor](https://cursor.sh), and other MCP-compatible tools.
-- JSX-based renderer (`@kubb/renderer-jsx`) for building custom plugin output.
-- Barrel file generation via `@kubb/middleware-barrel`.
+- Generate from a schema: Kubb produces TypeScript types, type-safe API clients, [TanStack Query](https://github.com/TanStack/query) hooks for React and Vue, [SWR](https://github.com/vercel/swr) hooks, [Zod](https://github.com/colinhacks/zod) validators, [Faker](https://github.com/faker-js/faker) mocks, and [MSW](https://github.com/mswjs/msw) handlers.
+- Plug in input formats through adapters like [`@kubb/adapter-oas`](https://npmx.dev/package/@kubb/adapter-oas), with TypeScript-first output that runs on Node.js and Bun.
+- Pick what you generate from the [plugin ecosystem](https://github.com/kubb-labs/plugins): `plugin-ts`, `plugin-client`, `plugin-react-query`, `plugin-vue-query`, `plugin-swr`, `plugin-zod`, `plugin-faker`, `plugin-msw`, `plugin-cypress`, `plugin-redoc`, and `plugin-mcp`. Enable only the ones a project needs.
+- Choose your HTTP client: use the axios or fetch presets, or point at a custom client module so generated requests run through your own wrapper.
+- Control the generated tree: group files by tag, emit barrel exports, and include or exclude operations to keep the output focused.
+- Build your own output with custom plugins, adapters, and the JSX-based renderer (`@kubb/renderer-jsx`) for full control over what lands on disk.
+- Hook into your bundler with `unplugin-kubb`, which runs generation inside [Vite](https://github.com/vitejs/vite), [Nuxt](https://github.com/nuxt/nuxt), [Astro](https://github.com/withastro/astro), [webpack](https://github.com/webpack/webpack), and other build tools.
+- Drive generation from AI tools through the built-in Model Context Protocol (MCP) server, which works with [Claude](https://claude.ai), [Cursor](https://cursor.sh), and other MCP-compatible assistants.
+- Generate from inside [Claude Code](https://kubb.dev/docs/5.x/ai/claude) with the Kubb plugin, which adds slash commands, a config skill, and an agent that run the Kubb CLI.
 
 ## Supporting Kubb
 
-Kubb is an open source project with its ongoing development made possible entirely by the support of Sponsors. If you would like to become a sponsor, please consider:
+Kubb is an open source project, and its development is funded entirely by sponsors. If you would like to become a sponsor, please consider:
 
 - [Become a Sponsor on GitHub](https://github.com/sponsors/stijnvanhulle)
+- [See sponsorship tiers and our sponsors](https://kubb.dev/sponsors)
 
 <p align="center">
   <a href="https://github.com/sponsors/stijnvanhulle">
@@ -73,6 +78,16 @@ Kubb is an open source project with its ongoing development made possible entire
   </a>
 </p>
 
+## Contributing
+
+We welcome contributions that help improve Kubb. A few ways to get involved:
+
+- Found a bug? File it in the [issue tracker](https://github.com/kubb-labs/kubb/issues).
+- Have an idea to improve Kubb? [Open an issue](https://github.com/kubb-labs/kubb/issues/new) to share it.
+- Need help? Ask the community on [Discord](https://discord.gg/4dQjA6vrWX).
+
+See [CONTRIBUTING.md](https://github.com/kubb-labs/kubb/blob/main/CONTRIBUTING.md) for the project structure, local setup, and commands.
+
 ## Contributors [![Contributors][contributors-src]][contributors-href]
 
 <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
@@ -160,15 +175,11 @@ Kubb is an open source project with its ongoing development made possible entire
 
 ## License
 
-Most of this repository is licensed under the [MIT License](./licenses/LICENSE-MIT), Copyright © 2025 [Stijn Van Hulle](https://stijnvanhulle.be). Some components are licensed
-under AGPL-3.0-or-later.
-
-- **Most packages** — [MIT](./licenses/LICENSE-MIT)
-- **`@kubb/agent`** — [AGPL-3.0-or-later](./licenses/LICENSE-AGPL-3.0)
+This repository is licensed under the [MIT License](./licenses/LICENSE-MIT), Copyright © 2025 [Stijn Van Hulle](https://stijnvanhulle.be).
 
 See [LICENSE](./LICENSE) for details.
 
-## Star History
+## Star history
 
 <a href="https://star-history.com/#kubb-labs/kubb&Date">
   <picture>
@@ -180,19 +191,17 @@ See [LICENSE](./LICENSE) for details.
 
 <!-- Badges -->
 
-[npm-version-src]: https://img.shields.io/npm/v/@kubb/core?flat&colorA=18181B&colorB=f58517
-[npm-version-href]: https://npmx.dev/package/@kubb/core
-[npm-downloads-src]: https://img.shields.io/npm/dm/@kubb/core?flat&colorA=18181B&colorB=f58517
-[npm-downloads-href]: https://npmjs.com/package/@kubb/core
-[license-src]: https://img.shields.io/npm/l/%40kubb%2Fcore?flat&colorA=18181B&colorB=f58517
-[license-href]: https://github.com/kubb-labs/kubb/blob/main/licenses/LICENSE-MIT
-[build-src]: https://img.shields.io/github/actions/workflow/status/kubb-labs/kubb/ci.yaml?style=flat&colorA=18181B&colorB=f58517
-[build-href]: https://www.npmjs.com/package/@kubb/core
-[minified-src]: https://img.shields.io/bundlephobia/min/@kubb/core?style=flat&colorA=18181B&colorB=f58517
-[minified-href]: https://www.npmjs.com/package/@kubb/core
-[coverage-src]: https://img.shields.io/codecov/c/github/kubb-labs/kubb?style=flat&colorA=18181B&colorB=f58517
-[coverage-href]: https://www.npmjs.com/package/@kubb/core
-[contributors-src]: https://img.shields.io/github/contributors/kubb-labs/kubb?style=flat&colorA=18181B&colorB=f58517&label=%20
+[npm-version-src]: https://shieldcn.dev/npm/v/@kubb/core.svg?variant=secondary&size=xs&theme=zinc&mode=dark
+[npm-version-href]: https://npmx.dev/package/kubb
+[npm-downloads-src]: https://shieldcn.dev/npm/dm/@kubb/core.svg?variant=secondary&size=xs&theme=zinc&mode=dark
+[npm-downloads-href]: https://npmx.dev/package/kubb
+[stars-src]: https://shieldcn.dev/github/stars/kubb-labs/kubb.svg?variant=secondary&size=xs&theme=zinc&mode=dark
+[stars-href]: https://github.com/kubb-labs/kubb
+[license-src]: https://shieldcn.dev/npm/license/kubb.svg?variant=secondary&size=xs&theme=zinc
+[license-href]: https://github.com/kubb-labs/kubb/blob/main/LICENSE
+[node-src]: https://shieldcn.dev/npm/node/kubb.svg?variant=secondary&size=xs&theme=zinc&mode=dark
+[node-href]: https://npmx.dev/package/kubb
+[contributors-src]: https://shieldcn.dev/github/contributors/kubb-labs/kubb.svg?variant=secondary&size=xs&theme=zinc&mode=dark
 [contributors-href]: #contributors-
-[sponsors-src]: https://img.shields.io/github/sponsors/stijnvanhulle?style=flat&colorA=18181B&colorB=f58517
-[sponsors-href]: https://github.com/sponsors/stijnvanhulle/
+[coverage-src]: https://shieldcn.dev/codecov/github/kubb-labs/kubb.svg?variant=secondary&size=xs&theme=zinc&mode=dark
+[coverage-href]: https://app.codecov.io/gh/kubb-labs/kubb

package/bin/kubb.js

@@ -1,4 +1,12 @@
 #!/usr/bin/env node
-import('@kubb/cli').then(({ run }) => {
-  run(process.argv)
-})
+
+process.setSourceMapsEnabled?.(true)
+process.title = 'Kubb'
+
+try {
+  const { run } = await import('@kubb/cli')
+  await run(process.argv)
+} catch (err) {
+  console.error(err)
+  process.exit(1)
+}

package/dist/index.cjs

@@ -1,8 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#endregion
 let _kubb_adapter_oas = require("@kubb/adapter-oas");
-let _kubb_middleware_barrel = require("@kubb/middleware-barrel");
+let _kubb_core = require("@kubb/core");
+let _kubb_plugin_barrel = require("@kubb/plugin-barrel");
 let _kubb_parser_ts = require("@kubb/parser-ts");
+let _kubb_parser_md = require("@kubb/parser-md");
 //#region ../../internals/utils/src/promise.ts
 /** Returns `true` when `result` is a thenable `Promise`.
 *
@@ -18,28 +20,40 @@ function isPromise(result) {
 //#endregion
 //#region src/defineConfig.ts
 /**
-* Applies default adapter, parsers, middleware, `output.barrel`, `output.format`, and `output.lint` to a single user config when not set.
+* Applies default `root`, adapter, parsers, plugins, `output.barrel`, `output.format`, and `output.lint` to a single user config when not set.
 *
+* - `root` defaults to `process.cwd()`
 * - `adapter` defaults to `adapterOas()`
-* - `parsers` defaults to `[parserTs, parserTsx]`
-* - `middleware` defaults to `[middlewareBarrel()]`
-* - `output.barrel` defaults to `{ type: 'named' }` **only when `middlewareBarrel` is part of `middleware`**.
-*   When the user provides a custom middleware list without `middlewareBarrel`, `barrel` is left untouched.
-* - `output.format` defaults to `'auto'`
-* - `output.lint` defaults to `'auto'`
+* - `parsers` defaults to `[parserTs, parserTsx, parserMd]`
+* - `reporters` defaults to `[cliReporter, jsonReporter, fileReporter]`
+* - `plugins` gets `pluginBarrel()` appended when none is already present
+* - `output.barrel` defaults to `{ type: 'named' }` only when `pluginBarrel` is part of `plugins`.
+*   When the user provides a plugins list without `pluginBarrel`, `barrel` is left untouched.
+* - `output.format` defaults to `false`
+* - `output.lint` defaults to `false`
 */
 function applyDefaults(config) {
-	const middleware = config.middleware?.length ? config.middleware : [(0, _kubb_middleware_barrel.middlewareBarrel)()];
-	const hasBarrelMiddleware = middleware.some((m) => m.name === _kubb_middleware_barrel.middlewareBarrelName);
+	const plugins = config.plugins?.some((p) => p.name === _kubb_plugin_barrel.pluginBarrelName) ? config.plugins ?? [] : [...config.plugins ?? [], (0, _kubb_plugin_barrel.pluginBarrel)()];
+	const hasBarrelPlugin = plugins.some((p) => p.name === _kubb_plugin_barrel.pluginBarrelName);
 	const output = { ...config.output };
-	if (hasBarrelMiddleware && output.barrel === void 0) output.barrel = { type: "named" };
+	if (hasBarrelPlugin && output.barrel === void 0) output.barrel = { type: "named" };
 	if (output.format === void 0) output.format = false;
 	if (output.lint === void 0) output.lint = false;
 	return {
 		...config,
+		root: config.root || process.cwd(),
 		adapter: config.adapter ?? (0, _kubb_adapter_oas.adapterOas)(),
-		parsers: config.parsers?.length ? config.parsers : [_kubb_parser_ts.parserTs, _kubb_parser_ts.parserTsx],
-		middleware,
+		parsers: config.parsers?.length ? config.parsers : [
+			_kubb_parser_ts.parserTs,
+			_kubb_parser_ts.parserTsx,
+			_kubb_parser_md.parserMd
+		],
+		reporters: config.reporters?.length ? config.reporters : [
+			_kubb_core.cliReporter,
+			_kubb_core.jsonReporter,
+			_kubb_core.fileReporter
+		],
+		plugins,
 		output
 	};
 }
@@ -48,21 +62,41 @@ function normalizeConfig(config) {
 	return applyDefaults(config);
 }
 /**
-* Helper for defining a Kubb configuration with built-in defaults.
+* Defines a Kubb build configuration and fills in defaults for any omitted fields.
 *
-* When no `adapter` is provided, `adapterOas()` is used automatically.
-* When no `parsers` are provided, `[parserTs, parserTsx]` is used automatically.
+* Defaults applied when omitted:
+* - `adapter` → `adapterOas()` (OpenAPI 2.0/3.0/3.1).
+* - `parsers` → `[parserTs, parserTsx, parserMd]`.
+* - `reporters` → `[cliReporter, jsonReporter, fileReporter]`.
+* - `plugins` → `pluginBarrel()` is appended when not already present.
+* - `output.barrel` → `{ type: 'named' }` only when `pluginBarrel` is
+*   in the plugins list.
+* - `output.format` and `output.lint` → `false`.
 *
-* Accepts either:
-* - A config object or array of configs
-* - A function returning the config(s), optionally async,
-*   receiving the CLI options as argument
+* Accepts a config object, an array of configs, a Promise resolving to one,
+* or a function that receives the parsed CLI options and returns any of the
+* above. The return type is preserved so async/array variants stay typed.
 *
 * @example
 * ```ts
-* export default defineConfig(({ logLevel }) => ({
-*   root: 'src',
-*   plugins: [myPlugin()],
+* import { defineConfig } from 'kubb'
+* import { pluginTs } from '@kubb/plugin-ts'
+*
+* export default defineConfig({
+*   input: { path: './petStore.yaml' },
+*   output: { path: './src/gen' },
+*   plugins: [pluginTs()],
+* })
+* ```
+*
+* @example Function form with CLI options
+* ```ts
+* import { defineConfig } from 'kubb'
+*
+* export default defineConfig(({ input }) => ({
+*   input: { path: input ?? './petStore.yaml' },
+*   output: { path: './src/gen' },
+*   plugins: [],
 * }))
 * ```
 */

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["middlewareBarrelName","parserTs","parserTsx"],"sources":["../../../internals/utils/src/promise.ts","../src/defineConfig.ts"],"sourcesContent":["/** A value that may already be resolved or still pending.\n *\n * @example\n * ```ts\n * function load(id: string): PossiblePromise<string> {\n *   return cache.get(id) ?? fetchRemote(id)\n * }\n * ```\n */\nexport type PossiblePromise<T> = Promise<T> | T\n\n/** Returns `true` when `result` is a thenable `Promise`.\n *\n * @example\n * ```ts\n * isPromise(Promise.resolve(1)) // true\n * isPromise(42)                 // false\n * ```\n */\nexport function isPromise<T>(result: PossiblePromise<T>): result is Promise<T> {\n  return result !== null && result !== undefined && typeof (result as Record<string, unknown>)['then'] === 'function'\n}\n\n/** Returns `true` when `result` is a fulfilled `Promise.allSettled` result.\n *\n * @example\n * ```ts\n * const results = await Promise.allSettled([p1, p2])\n * results.filter(isPromiseFulfilledResult).map((r) => r.value)\n * ```\n */\nexport function isPromiseFulfilledResult<T = unknown>(result: PromiseSettledResult<unknown>): result is PromiseFulfilledResult<T> {\n  return result.status === 'fulfilled'\n}\n\n/** Returns `true` when `result` is a rejected `Promise.allSettled` result with a typed `reason`.\n *\n * @example\n * ```ts\n * const results = await Promise.allSettled([p1, p2])\n * results.filter(isPromiseRejectedResult<Error>).map((r) => r.reason.message)\n * ```\n */\nexport function isPromiseRejectedResult<T>(result: PromiseSettledResult<unknown>): result is Omit<PromiseRejectedResult, 'reason'> & { reason: T } {\n  return result.status === 'rejected'\n}\n","import { isPromise, type PossiblePromise } from '@internals/utils'\nimport { adapterOas } from '@kubb/adapter-oas'\nimport type { CLIOptions, UserConfig } from '@kubb/core'\nimport { middlewareBarrel, middlewareBarrelName } from '@kubb/middleware-barrel'\nimport { parserTs, parserTsx } from '@kubb/parser-ts'\n\ntype AnyConfigResult = UserConfig<any> | Array<UserConfig<any>>\ntype ConfigInput = AnyConfigResult | Promise<AnyConfigResult> | ((cli: CLIOptions) => PossiblePromise<AnyConfigResult>)\ntype NormalizeConfig<TConfig> =\n  TConfig extends Array<UserConfig<infer TInput>> ? Array<UserConfig<TInput>> : TConfig extends UserConfig<infer TInput> ? UserConfig<TInput> : never\ntype DefinedConfig<TConfig extends ConfigInput> = TConfig extends (cli: CLIOptions) => PossiblePromise<infer TResult>\n  ? (cli: CLIOptions) => Promise<NormalizeConfig<TResult>>\n  : TConfig extends Promise<infer TResult>\n    ? Promise<NormalizeConfig<TResult>>\n    : NormalizeConfig<TConfig>\n\n/**\n * Applies default adapter, parsers, middleware, `output.barrel`, `output.format`, and `output.lint` to a single user config when not set.\n *\n * - `adapter` defaults to `adapterOas()`\n * - `parsers` defaults to `[parserTs, parserTsx]`\n * - `middleware` defaults to `[middlewareBarrel()]`\n * - `output.barrel` defaults to `{ type: 'named' }` **only when `middlewareBarrel` is part of `middleware`**.\n *   When the user provides a custom middleware list without `middlewareBarrel`, `barrel` is left untouched.\n * - `output.format` defaults to `'auto'`\n * - `output.lint` defaults to `'auto'`\n */\nfunction applyDefaults<TInput>(config: UserConfig<TInput>): UserConfig<TInput> {\n  const middleware = config.middleware?.length ? config.middleware : [middlewareBarrel()]\n  const hasBarrelMiddleware = middleware.some((m) => m.name === middlewareBarrelName)\n\n  const output = { ...config.output }\n  if (hasBarrelMiddleware && output.barrel === undefined) {\n    output.barrel = { type: 'named' }\n  }\n  if (output.format === undefined) {\n    output.format = false\n  }\n  if (output.lint === undefined) {\n    output.lint = false\n  }\n\n  return {\n    ...config,\n    adapter: config.adapter ?? adapterOas(),\n    parsers: config.parsers?.length ? config.parsers : [parserTs, parserTsx],\n    middleware,\n    output,\n  }\n}\n\nfunction normalizeConfig<TInput>(config: UserConfig<TInput> | Array<UserConfig<TInput>>): UserConfig<TInput> | Array<UserConfig<TInput>> {\n  if (Array.isArray(config)) {\n    return config.map(applyDefaults)\n  }\n\n  return applyDefaults(config)\n}\n\n/**\n * Helper for defining a Kubb configuration with built-in defaults.\n *\n * When no `adapter` is provided, `adapterOas()` is used automatically.\n * When no `parsers` are provided, `[parserTs, parserTsx]` is used automatically.\n *\n * Accepts either:\n * - A config object or array of configs\n * - A function returning the config(s), optionally async,\n *   receiving the CLI options as argument\n *\n * @example\n * ```ts\n * export default defineConfig(({ logLevel }) => ({\n *   root: 'src',\n *   plugins: [myPlugin()],\n * }))\n * ```\n */\nexport function defineConfig<TConfig extends ConfigInput>(config: TConfig): DefinedConfig<TConfig> {\n  if (typeof config === 'function') {\n    return (async (cli: CLIOptions) => {\n      return normalizeConfig(await config(cli))\n    }) as DefinedConfig<TConfig>\n  }\n\n  if (isPromise(config)) {\n    return config.then((resolved) => normalizeConfig(resolved)) as DefinedConfig<TConfig>\n  }\n\n  return normalizeConfig(config) as DefinedConfig<TConfig>\n}\n"],"mappings":";;;;;;;;;;;;;;AAmBA,SAAgB,UAAa,QAAkD;CAC7E,OAAO,WAAW,QAAQ,WAAW,KAAA,KAAa,OAAQ,OAAmC,YAAY;;;;;;;;;;;;;;;ACO3G,SAAS,cAAsB,QAAgD;CAC7E,MAAM,aAAa,OAAO,YAAY,SAAS,OAAO,aAAa,EAAA,GAAA,wBAAA,mBAAmB,CAAC;CACvF,MAAM,sBAAsB,WAAW,MAAM,MAAM,EAAE,SAASA,wBAAAA,qBAAqB;CAEnF,MAAM,SAAS,EAAE,GAAG,OAAO,QAAQ;CACnC,IAAI,uBAAuB,OAAO,WAAW,KAAA,GAC3C,OAAO,SAAS,EAAE,MAAM,SAAS;CAEnC,IAAI,OAAO,WAAW,KAAA,GACpB,OAAO,SAAS;CAElB,IAAI,OAAO,SAAS,KAAA,GAClB,OAAO,OAAO;CAGhB,OAAO;EACL,GAAG;EACH,SAAS,OAAO,YAAA,GAAA,kBAAA,aAAuB;EACvC,SAAS,OAAO,SAAS,SAAS,OAAO,UAAU,CAACC,gBAAAA,UAAUC,gBAAAA,UAAU;EACxE;EACA;EACD;;AAGH,SAAS,gBAAwB,QAAwG;CACvI,IAAI,MAAM,QAAQ,OAAO,EACvB,OAAO,OAAO,IAAI,cAAc;CAGlC,OAAO,cAAc,OAAO;;;;;;;;;;;;;;;;;;;;;AAsB9B,SAAgB,aAA0C,QAAyC;CACjG,IAAI,OAAO,WAAW,YACpB,QAAQ,OAAO,QAAoB;EACjC,OAAO,gBAAgB,MAAM,OAAO,IAAI,CAAC;;CAI7C,IAAI,UAAU,OAAO,EACnB,OAAO,OAAO,MAAM,aAAa,gBAAgB,SAAS,CAAC;CAG7D,OAAO,gBAAgB,OAAO"}
+{"version":3,"file":"index.cjs","names":["pluginBarrelName","parserTs","parserTsx","parserMd","cliReporter","jsonReporter","fileReporter"],"sources":["../../../internals/utils/src/promise.ts","../src/defineConfig.ts"],"sourcesContent":["/** A value that may already be resolved or still pending.\n *\n * @example\n * ```ts\n * function load(id: string): PossiblePromise<string> {\n *   return cache.get(id) ?? fetchRemote(id)\n * }\n * ```\n */\nexport type PossiblePromise<T> = Promise<T> | T\n\n/** Returns `true` when `result` is a thenable `Promise`.\n *\n * @example\n * ```ts\n * isPromise(Promise.resolve(1)) // true\n * isPromise(42)                 // false\n * ```\n */\nexport function isPromise<T>(result: PossiblePromise<T>): result is Promise<T> {\n  return result !== null && result !== undefined && typeof (result as Record<string, unknown>)['then'] === 'function'\n}\n\ntype Store<TKey, TValue> = {\n  has(key: TKey): boolean\n  get(key: TKey): TValue | undefined\n  set(key: TKey, value: TValue): unknown\n}\n\n/**\n * Wraps `factory` with a keyed cache backed by the provided store.\n *\n * Pass a `WeakMap` for object keys (results are GC-eligible when the key is\n * collected) or a `Map` for primitive keys. For multi-argument functions,\n * nest two `memoize` calls — the outer keyed by the first argument, the\n * inner (created once per outer miss) keyed by the second.\n *\n * Because the cache is owned by the caller, it can be shared, inspected, or\n * cleared independently of the memoized function.\n *\n * @example Single WeakMap key\n * ```ts\n * const cache = new WeakMap<SchemaNode, Set<string>>()\n * const getRefs = memoize(cache, (node) => collectRefs(node))\n * ```\n *\n * @example Single Map key (primitive)\n * ```ts\n * const cache = new Map<string, Resolver>()\n * const getResolver = memoize(cache, (name) => buildResolver(name))\n * ```\n *\n * @example Two-level (object + primitive)\n * ```ts\n * const outer = new WeakMap<Params[], Map<string, Params[]>>()\n * const fn = memoize(outer, (params) => memoize(new Map(), (key) => transform(params, key)))\n * fn(params)('camelcase')\n * ```\n */\nexport function memoize<TKey, TValue>(store: Store<TKey, TValue>, factory: (key: TKey) => TValue): (key: TKey) => TValue {\n  return (key: TKey): TValue => {\n    if (store.has(key)) return store.get(key)!\n    const value = factory(key)\n    store.set(key, value)\n    return value\n  }\n}\n\n/**\n * Container that switches between an eager `Array<T>` and a lazy `AsyncIterable<T>`.\n *\n * `Array<T>` by default. With `Stream` set to `true` it becomes `AsyncIterable<T>`, so large\n * collections can be produced lazily without holding every item in memory. Pairs with\n * {@link arrayToAsyncIterable}, which lifts a plain array into the streaming form.\n *\n * @example\n * ```ts\n * type Eager = Streamable<number> // Array<number>\n * type Lazy = Streamable<number, true> // AsyncIterable<number>\n * ```\n */\nexport type Streamable<T, Stream extends boolean = false> = Stream extends true ? AsyncIterable<T> : Array<T>\n\n/**\n * Wraps a plain array in a reusable `AsyncIterable`.\n * Each `[Symbol.asyncIterator]()` call returns a fresh generator so the\n * iterable can be consumed multiple times (e.g. once per plugin pre-scan).\n *\n * @example\n * ```ts\n * const stream = arrayToAsyncIterable([1, 2, 3])\n * for await (const n of stream) console.log(n) // 1, 2, 3\n * ```\n */\nexport function arrayToAsyncIterable<T>(arr: ReadonlyArray<T>): AsyncIterable<T> {\n  return {\n    [Symbol.asyncIterator]() {\n      return (async function* () {\n        yield* arr\n      })()\n    },\n  }\n}\n","import { isPromise, type PossiblePromise } from '@internals/utils'\nimport { adapterOas } from '@kubb/adapter-oas'\nimport { cliReporter, type CLIOptions, fileReporter, jsonReporter, type UserConfig } from '@kubb/core'\nimport { pluginBarrel, pluginBarrelName } from '@kubb/plugin-barrel'\nimport { parserTs, parserTsx } from '@kubb/parser-ts'\nimport { parserMd } from '@kubb/parser-md'\n\ntype AnyConfigResult = UserConfig<any> | Array<UserConfig<any>>\ntype ConfigInput = AnyConfigResult | Promise<AnyConfigResult> | ((cli: CLIOptions) => PossiblePromise<AnyConfigResult>)\ntype NormalizeConfig<TConfig> =\n  TConfig extends Array<UserConfig<infer TInput>> ? Array<UserConfig<TInput>> : TConfig extends UserConfig<infer TInput> ? UserConfig<TInput> : never\ntype DefinedConfig<TConfig extends ConfigInput> = TConfig extends (cli: CLIOptions) => PossiblePromise<infer TResult>\n  ? (cli: CLIOptions) => Promise<NormalizeConfig<TResult>>\n  : TConfig extends Promise<infer TResult>\n    ? Promise<NormalizeConfig<TResult>>\n    : NormalizeConfig<TConfig>\n\n/**\n * Applies default `root`, adapter, parsers, plugins, `output.barrel`, `output.format`, and `output.lint` to a single user config when not set.\n *\n * - `root` defaults to `process.cwd()`\n * - `adapter` defaults to `adapterOas()`\n * - `parsers` defaults to `[parserTs, parserTsx, parserMd]`\n * - `reporters` defaults to `[cliReporter, jsonReporter, fileReporter]`\n * - `plugins` gets `pluginBarrel()` appended when none is already present\n * - `output.barrel` defaults to `{ type: 'named' }` only when `pluginBarrel` is part of `plugins`.\n *   When the user provides a plugins list without `pluginBarrel`, `barrel` is left untouched.\n * - `output.format` defaults to `false`\n * - `output.lint` defaults to `false`\n */\nfunction applyDefaults<TInput>(config: UserConfig<TInput>): UserConfig<TInput> {\n  const alreadyHasBarrel = config.plugins?.some((p) => p.name === pluginBarrelName)\n  const plugins = alreadyHasBarrel ? (config.plugins ?? []) : [...(config.plugins ?? []), pluginBarrel()]\n  const hasBarrelPlugin = plugins.some((p) => p.name === pluginBarrelName)\n\n  const output = { ...config.output }\n  if (hasBarrelPlugin && output.barrel === undefined) {\n    output.barrel = { type: 'named' }\n  }\n  if (output.format === undefined) {\n    output.format = false\n  }\n  if (output.lint === undefined) {\n    output.lint = false\n  }\n\n  return {\n    ...config,\n    root: config.root || process.cwd(),\n    adapter: config.adapter ?? adapterOas(),\n    parsers: config.parsers?.length ? config.parsers : [parserTs, parserTsx, parserMd],\n    reporters: config.reporters?.length ? config.reporters : [cliReporter, jsonReporter, fileReporter],\n    plugins,\n    output,\n  }\n}\n\nfunction normalizeConfig<TInput>(config: UserConfig<TInput> | Array<UserConfig<TInput>>): UserConfig<TInput> | Array<UserConfig<TInput>> {\n  if (Array.isArray(config)) {\n    return config.map(applyDefaults)\n  }\n\n  return applyDefaults(config)\n}\n\n/**\n * Defines a Kubb build configuration and fills in defaults for any omitted fields.\n *\n * Defaults applied when omitted:\n * - `adapter` → `adapterOas()` (OpenAPI 2.0/3.0/3.1).\n * - `parsers` → `[parserTs, parserTsx, parserMd]`.\n * - `reporters` → `[cliReporter, jsonReporter, fileReporter]`.\n * - `plugins` → `pluginBarrel()` is appended when not already present.\n * - `output.barrel` → `{ type: 'named' }` only when `pluginBarrel` is\n *   in the plugins list.\n * - `output.format` and `output.lint` → `false`.\n *\n * Accepts a config object, an array of configs, a Promise resolving to one,\n * or a function that receives the parsed CLI options and returns any of the\n * above. The return type is preserved so async/array variants stay typed.\n *\n * @example\n * ```ts\n * import { defineConfig } from 'kubb'\n * import { pluginTs } from '@kubb/plugin-ts'\n *\n * export default defineConfig({\n *   input: { path: './petStore.yaml' },\n *   output: { path: './src/gen' },\n *   plugins: [pluginTs()],\n * })\n * ```\n *\n * @example Function form with CLI options\n * ```ts\n * import { defineConfig } from 'kubb'\n *\n * export default defineConfig(({ input }) => ({\n *   input: { path: input ?? './petStore.yaml' },\n *   output: { path: './src/gen' },\n *   plugins: [],\n * }))\n * ```\n */\nexport function defineConfig<TConfig extends ConfigInput>(config: TConfig): DefinedConfig<TConfig> {\n  if (typeof config === 'function') {\n    return (async (cli: CLIOptions) => {\n      return normalizeConfig(await config(cli))\n    }) as DefinedConfig<TConfig>\n  }\n\n  if (isPromise(config)) {\n    return config.then((resolved) => normalizeConfig(resolved)) as DefinedConfig<TConfig>\n  }\n\n  return normalizeConfig(config) as DefinedConfig<TConfig>\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAmBA,SAAgB,UAAa,QAAkD;CAC7E,OAAO,WAAW,QAAQ,WAAW,KAAA,KAAa,OAAQ,OAAmC,YAAY;AAC3G;;;;;;;;;;;;;;;;ACSA,SAAS,cAAsB,QAAgD;CAE7E,MAAM,UADmB,OAAO,SAAS,MAAM,MAAM,EAAE,SAASA,oBAAAA,gBAAgB,IAC5C,OAAO,WAAW,CAAC,IAAK,CAAC,GAAI,OAAO,WAAW,CAAC,IAAA,GAAA,oBAAA,aAAA,CAAiB,CAAC;CACtG,MAAM,kBAAkB,QAAQ,MAAM,MAAM,EAAE,SAASA,oBAAAA,gBAAgB;CAEvE,MAAM,SAAS,EAAE,GAAG,OAAO,OAAO;CAClC,IAAI,mBAAmB,OAAO,WAAW,KAAA,GACvC,OAAO,SAAS,EAAE,MAAM,QAAQ;CAElC,IAAI,OAAO,WAAW,KAAA,GACpB,OAAO,SAAS;CAElB,IAAI,OAAO,SAAS,KAAA,GAClB,OAAO,OAAO;CAGhB,OAAO;EACL,GAAG;EACH,MAAM,OAAO,QAAQ,QAAQ,IAAI;EACjC,SAAS,OAAO,YAAA,GAAA,kBAAA,WAAA,CAAsB;EACtC,SAAS,OAAO,SAAS,SAAS,OAAO,UAAU;GAACC,gBAAAA;GAAUC,gBAAAA;GAAWC,gBAAAA;EAAQ;EACjF,WAAW,OAAO,WAAW,SAAS,OAAO,YAAY;GAACC,WAAAA;GAAaC,WAAAA;GAAcC,WAAAA;EAAY;EACjG;EACA;CACF;AACF;AAEA,SAAS,gBAAwB,QAAwG;CACvI,IAAI,MAAM,QAAQ,MAAM,GACtB,OAAO,OAAO,IAAI,aAAa;CAGjC,OAAO,cAAc,MAAM;AAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,aAA0C,QAAyC;CACjG,IAAI,OAAO,WAAW,YACpB,QAAQ,OAAO,QAAoB;EACjC,OAAO,gBAAgB,MAAM,OAAO,GAAG,CAAC;CAC1C;CAGF,IAAI,UAAU,MAAM,GAClB,OAAO,OAAO,MAAM,aAAa,gBAAgB,QAAQ,CAAC;CAG5D,OAAO,gBAAgB,MAAM;AAC/B"}

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
+import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
 import { CLIOptions, UserConfig } from "@kubb/core";
+import { BarrelType } from "@kubb/plugin-barrel";
 
 //#region ../../internals/utils/src/promise.d.ts
 /** A value that may already be resolved or still pending.
@@ -19,25 +20,45 @@ type ConfigInput = AnyConfigResult | Promise<AnyConfigResult> | ((cli: CLIOption
 type NormalizeConfig<TConfig> = TConfig extends Array<UserConfig<infer TInput>> ? Array<UserConfig<TInput>> : TConfig extends UserConfig<infer TInput> ? UserConfig<TInput> : never;
 type DefinedConfig<TConfig extends ConfigInput> = TConfig extends ((cli: CLIOptions) => PossiblePromise<infer TResult>) ? (cli: CLIOptions) => Promise<NormalizeConfig<TResult>> : TConfig extends Promise<infer TResult> ? Promise<NormalizeConfig<TResult>> : NormalizeConfig<TConfig>;
 /**
- * Helper for defining a Kubb configuration with built-in defaults.
+ * Defines a Kubb build configuration and fills in defaults for any omitted fields.
  *
- * When no `adapter` is provided, `adapterOas()` is used automatically.
- * When no `parsers` are provided, `[parserTs, parserTsx]` is used automatically.
+ * Defaults applied when omitted:
+ * - `adapter` → `adapterOas()` (OpenAPI 2.0/3.0/3.1).
+ * - `parsers` → `[parserTs, parserTsx, parserMd]`.
+ * - `reporters` → `[cliReporter, jsonReporter, fileReporter]`.
+ * - `plugins` → `pluginBarrel()` is appended when not already present.
+ * - `output.barrel` → `{ type: 'named' }` only when `pluginBarrel` is
+ *   in the plugins list.
+ * - `output.format` and `output.lint` → `false`.
  *
- * Accepts either:
- * - A config object or array of configs
- * - A function returning the config(s), optionally async,
- *   receiving the CLI options as argument
+ * Accepts a config object, an array of configs, a Promise resolving to one,
+ * or a function that receives the parsed CLI options and returns any of the
+ * above. The return type is preserved so async/array variants stay typed.
  *
  * @example
  * ```ts
- * export default defineConfig(({ logLevel }) => ({
- *   root: 'src',
- *   plugins: [myPlugin()],
+ * import { defineConfig } from 'kubb'
+ * import { pluginTs } from '@kubb/plugin-ts'
+ *
+ * export default defineConfig({
+ *   input: { path: './petStore.yaml' },
+ *   output: { path: './src/gen' },
+ *   plugins: [pluginTs()],
+ * })
+ * ```
+ *
+ * @example Function form with CLI options
+ * ```ts
+ * import { defineConfig } from 'kubb'
+ *
+ * export default defineConfig(({ input }) => ({
+ *   input: { path: input ?? './petStore.yaml' },
+ *   output: { path: './src/gen' },
+ *   plugins: [],
  * }))
  * ```
  */
 declare function defineConfig<TConfig extends ConfigInput>(config: TConfig): DefinedConfig<TConfig>;
 //#endregion
-export { defineConfig };
+export { type BarrelType, defineConfig };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,7 +1,9 @@
-import "./chunk--u3MIqq1.js";
+import "./rolldown-runtime-C0LytTxp.js";
 import { adapterOas } from "@kubb/adapter-oas";
-import { middlewareBarrel, middlewareBarrelName } from "@kubb/middleware-barrel";
+import { cliReporter, fileReporter, jsonReporter } from "@kubb/core";
+import { pluginBarrel, pluginBarrelName } from "@kubb/plugin-barrel";
 import { parserTs, parserTsx } from "@kubb/parser-ts";
+import { parserMd } from "@kubb/parser-md";
 //#region ../../internals/utils/src/promise.ts
 /** Returns `true` when `result` is a thenable `Promise`.
 *
@@ -17,28 +19,40 @@ function isPromise(result) {
 //#endregion
 //#region src/defineConfig.ts
 /**
-* Applies default adapter, parsers, middleware, `output.barrel`, `output.format`, and `output.lint` to a single user config when not set.
+* Applies default `root`, adapter, parsers, plugins, `output.barrel`, `output.format`, and `output.lint` to a single user config when not set.
 *
+* - `root` defaults to `process.cwd()`
 * - `adapter` defaults to `adapterOas()`
-* - `parsers` defaults to `[parserTs, parserTsx]`
-* - `middleware` defaults to `[middlewareBarrel()]`
-* - `output.barrel` defaults to `{ type: 'named' }` **only when `middlewareBarrel` is part of `middleware`**.
-*   When the user provides a custom middleware list without `middlewareBarrel`, `barrel` is left untouched.
-* - `output.format` defaults to `'auto'`
-* - `output.lint` defaults to `'auto'`
+* - `parsers` defaults to `[parserTs, parserTsx, parserMd]`
+* - `reporters` defaults to `[cliReporter, jsonReporter, fileReporter]`
+* - `plugins` gets `pluginBarrel()` appended when none is already present
+* - `output.barrel` defaults to `{ type: 'named' }` only when `pluginBarrel` is part of `plugins`.
+*   When the user provides a plugins list without `pluginBarrel`, `barrel` is left untouched.
+* - `output.format` defaults to `false`
+* - `output.lint` defaults to `false`
 */
 function applyDefaults(config) {
-	const middleware = config.middleware?.length ? config.middleware : [middlewareBarrel()];
-	const hasBarrelMiddleware = middleware.some((m) => m.name === middlewareBarrelName);
+	const plugins = config.plugins?.some((p) => p.name === pluginBarrelName) ? config.plugins ?? [] : [...config.plugins ?? [], pluginBarrel()];
+	const hasBarrelPlugin = plugins.some((p) => p.name === pluginBarrelName);
 	const output = { ...config.output };
-	if (hasBarrelMiddleware && output.barrel === void 0) output.barrel = { type: "named" };
+	if (hasBarrelPlugin && output.barrel === void 0) output.barrel = { type: "named" };
 	if (output.format === void 0) output.format = false;
 	if (output.lint === void 0) output.lint = false;
 	return {
 		...config,
+		root: config.root || process.cwd(),
 		adapter: config.adapter ?? adapterOas(),
-		parsers: config.parsers?.length ? config.parsers : [parserTs, parserTsx],
-		middleware,
+		parsers: config.parsers?.length ? config.parsers : [
+			parserTs,
+			parserTsx,
+			parserMd
+		],
+		reporters: config.reporters?.length ? config.reporters : [
+			cliReporter,
+			jsonReporter,
+			fileReporter
+		],
+		plugins,
 		output
 	};
 }
@@ -47,21 +61,41 @@ function normalizeConfig(config) {
 	return applyDefaults(config);
 }
 /**
-* Helper for defining a Kubb configuration with built-in defaults.
+* Defines a Kubb build configuration and fills in defaults for any omitted fields.
 *
-* When no `adapter` is provided, `adapterOas()` is used automatically.
-* When no `parsers` are provided, `[parserTs, parserTsx]` is used automatically.
+* Defaults applied when omitted:
+* - `adapter` → `adapterOas()` (OpenAPI 2.0/3.0/3.1).
+* - `parsers` → `[parserTs, parserTsx, parserMd]`.
+* - `reporters` → `[cliReporter, jsonReporter, fileReporter]`.
+* - `plugins` → `pluginBarrel()` is appended when not already present.
+* - `output.barrel` → `{ type: 'named' }` only when `pluginBarrel` is
+*   in the plugins list.
+* - `output.format` and `output.lint` → `false`.
 *
-* Accepts either:
-* - A config object or array of configs
-* - A function returning the config(s), optionally async,
-*   receiving the CLI options as argument
+* Accepts a config object, an array of configs, a Promise resolving to one,
+* or a function that receives the parsed CLI options and returns any of the
+* above. The return type is preserved so async/array variants stay typed.
 *
 * @example
 * ```ts
-* export default defineConfig(({ logLevel }) => ({
-*   root: 'src',
-*   plugins: [myPlugin()],
+* import { defineConfig } from 'kubb'
+* import { pluginTs } from '@kubb/plugin-ts'
+*
+* export default defineConfig({
+*   input: { path: './petStore.yaml' },
+*   output: { path: './src/gen' },
+*   plugins: [pluginTs()],
+* })
+* ```
+*
+* @example Function form with CLI options
+* ```ts
+* import { defineConfig } from 'kubb'
+*
+* export default defineConfig(({ input }) => ({
+*   input: { path: input ?? './petStore.yaml' },
+*   output: { path: './src/gen' },
+*   plugins: [],
 * }))
 * ```
 */

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../internals/utils/src/promise.ts","../src/defineConfig.ts"],"sourcesContent":["/** A value that may already be resolved or still pending.\n *\n * @example\n * ```ts\n * function load(id: string): PossiblePromise<string> {\n *   return cache.get(id) ?? fetchRemote(id)\n * }\n * ```\n */\nexport type PossiblePromise<T> = Promise<T> | T\n\n/** Returns `true` when `result` is a thenable `Promise`.\n *\n * @example\n * ```ts\n * isPromise(Promise.resolve(1)) // true\n * isPromise(42)                 // false\n * ```\n */\nexport function isPromise<T>(result: PossiblePromise<T>): result is Promise<T> {\n  return result !== null && result !== undefined && typeof (result as Record<string, unknown>)['then'] === 'function'\n}\n\n/** Returns `true` when `result` is a fulfilled `Promise.allSettled` result.\n *\n * @example\n * ```ts\n * const results = await Promise.allSettled([p1, p2])\n * results.filter(isPromiseFulfilledResult).map((r) => r.value)\n * ```\n */\nexport function isPromiseFulfilledResult<T = unknown>(result: PromiseSettledResult<unknown>): result is PromiseFulfilledResult<T> {\n  return result.status === 'fulfilled'\n}\n\n/** Returns `true` when `result` is a rejected `Promise.allSettled` result with a typed `reason`.\n *\n * @example\n * ```ts\n * const results = await Promise.allSettled([p1, p2])\n * results.filter(isPromiseRejectedResult<Error>).map((r) => r.reason.message)\n * ```\n */\nexport function isPromiseRejectedResult<T>(result: PromiseSettledResult<unknown>): result is Omit<PromiseRejectedResult, 'reason'> & { reason: T } {\n  return result.status === 'rejected'\n}\n","import { isPromise, type PossiblePromise } from '@internals/utils'\nimport { adapterOas } from '@kubb/adapter-oas'\nimport type { CLIOptions, UserConfig } from '@kubb/core'\nimport { middlewareBarrel, middlewareBarrelName } from '@kubb/middleware-barrel'\nimport { parserTs, parserTsx } from '@kubb/parser-ts'\n\ntype AnyConfigResult = UserConfig<any> | Array<UserConfig<any>>\ntype ConfigInput = AnyConfigResult | Promise<AnyConfigResult> | ((cli: CLIOptions) => PossiblePromise<AnyConfigResult>)\ntype NormalizeConfig<TConfig> =\n  TConfig extends Array<UserConfig<infer TInput>> ? Array<UserConfig<TInput>> : TConfig extends UserConfig<infer TInput> ? UserConfig<TInput> : never\ntype DefinedConfig<TConfig extends ConfigInput> = TConfig extends (cli: CLIOptions) => PossiblePromise<infer TResult>\n  ? (cli: CLIOptions) => Promise<NormalizeConfig<TResult>>\n  : TConfig extends Promise<infer TResult>\n    ? Promise<NormalizeConfig<TResult>>\n    : NormalizeConfig<TConfig>\n\n/**\n * Applies default adapter, parsers, middleware, `output.barrel`, `output.format`, and `output.lint` to a single user config when not set.\n *\n * - `adapter` defaults to `adapterOas()`\n * - `parsers` defaults to `[parserTs, parserTsx]`\n * - `middleware` defaults to `[middlewareBarrel()]`\n * - `output.barrel` defaults to `{ type: 'named' }` **only when `middlewareBarrel` is part of `middleware`**.\n *   When the user provides a custom middleware list without `middlewareBarrel`, `barrel` is left untouched.\n * - `output.format` defaults to `'auto'`\n * - `output.lint` defaults to `'auto'`\n */\nfunction applyDefaults<TInput>(config: UserConfig<TInput>): UserConfig<TInput> {\n  const middleware = config.middleware?.length ? config.middleware : [middlewareBarrel()]\n  const hasBarrelMiddleware = middleware.some((m) => m.name === middlewareBarrelName)\n\n  const output = { ...config.output }\n  if (hasBarrelMiddleware && output.barrel === undefined) {\n    output.barrel = { type: 'named' }\n  }\n  if (output.format === undefined) {\n    output.format = false\n  }\n  if (output.lint === undefined) {\n    output.lint = false\n  }\n\n  return {\n    ...config,\n    adapter: config.adapter ?? adapterOas(),\n    parsers: config.parsers?.length ? config.parsers : [parserTs, parserTsx],\n    middleware,\n    output,\n  }\n}\n\nfunction normalizeConfig<TInput>(config: UserConfig<TInput> | Array<UserConfig<TInput>>): UserConfig<TInput> | Array<UserConfig<TInput>> {\n  if (Array.isArray(config)) {\n    return config.map(applyDefaults)\n  }\n\n  return applyDefaults(config)\n}\n\n/**\n * Helper for defining a Kubb configuration with built-in defaults.\n *\n * When no `adapter` is provided, `adapterOas()` is used automatically.\n * When no `parsers` are provided, `[parserTs, parserTsx]` is used automatically.\n *\n * Accepts either:\n * - A config object or array of configs\n * - A function returning the config(s), optionally async,\n *   receiving the CLI options as argument\n *\n * @example\n * ```ts\n * export default defineConfig(({ logLevel }) => ({\n *   root: 'src',\n *   plugins: [myPlugin()],\n * }))\n * ```\n */\nexport function defineConfig<TConfig extends ConfigInput>(config: TConfig): DefinedConfig<TConfig> {\n  if (typeof config === 'function') {\n    return (async (cli: CLIOptions) => {\n      return normalizeConfig(await config(cli))\n    }) as DefinedConfig<TConfig>\n  }\n\n  if (isPromise(config)) {\n    return config.then((resolved) => normalizeConfig(resolved)) as DefinedConfig<TConfig>\n  }\n\n  return normalizeConfig(config) as DefinedConfig<TConfig>\n}\n"],"mappings":";;;;;;;;;;;;;AAmBA,SAAgB,UAAa,QAAkD;CAC7E,OAAO,WAAW,QAAQ,WAAW,KAAA,KAAa,OAAQ,OAAmC,YAAY;;;;;;;;;;;;;;;ACO3G,SAAS,cAAsB,QAAgD;CAC7E,MAAM,aAAa,OAAO,YAAY,SAAS,OAAO,aAAa,CAAC,kBAAkB,CAAC;CACvF,MAAM,sBAAsB,WAAW,MAAM,MAAM,EAAE,SAAS,qBAAqB;CAEnF,MAAM,SAAS,EAAE,GAAG,OAAO,QAAQ;CACnC,IAAI,uBAAuB,OAAO,WAAW,KAAA,GAC3C,OAAO,SAAS,EAAE,MAAM,SAAS;CAEnC,IAAI,OAAO,WAAW,KAAA,GACpB,OAAO,SAAS;CAElB,IAAI,OAAO,SAAS,KAAA,GAClB,OAAO,OAAO;CAGhB,OAAO;EACL,GAAG;EACH,SAAS,OAAO,WAAW,YAAY;EACvC,SAAS,OAAO,SAAS,SAAS,OAAO,UAAU,CAAC,UAAU,UAAU;EACxE;EACA;EACD;;AAGH,SAAS,gBAAwB,QAAwG;CACvI,IAAI,MAAM,QAAQ,OAAO,EACvB,OAAO,OAAO,IAAI,cAAc;CAGlC,OAAO,cAAc,OAAO;;;;;;;;;;;;;;;;;;;;;AAsB9B,SAAgB,aAA0C,QAAyC;CACjG,IAAI,OAAO,WAAW,YACpB,QAAQ,OAAO,QAAoB;EACjC,OAAO,gBAAgB,MAAM,OAAO,IAAI,CAAC;;CAI7C,IAAI,UAAU,OAAO,EACnB,OAAO,OAAO,MAAM,aAAa,gBAAgB,SAAS,CAAC;CAG7D,OAAO,gBAAgB,OAAO"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../internals/utils/src/promise.ts","../src/defineConfig.ts"],"sourcesContent":["/** A value that may already be resolved or still pending.\n *\n * @example\n * ```ts\n * function load(id: string): PossiblePromise<string> {\n *   return cache.get(id) ?? fetchRemote(id)\n * }\n * ```\n */\nexport type PossiblePromise<T> = Promise<T> | T\n\n/** Returns `true` when `result` is a thenable `Promise`.\n *\n * @example\n * ```ts\n * isPromise(Promise.resolve(1)) // true\n * isPromise(42)                 // false\n * ```\n */\nexport function isPromise<T>(result: PossiblePromise<T>): result is Promise<T> {\n  return result !== null && result !== undefined && typeof (result as Record<string, unknown>)['then'] === 'function'\n}\n\ntype Store<TKey, TValue> = {\n  has(key: TKey): boolean\n  get(key: TKey): TValue | undefined\n  set(key: TKey, value: TValue): unknown\n}\n\n/**\n * Wraps `factory` with a keyed cache backed by the provided store.\n *\n * Pass a `WeakMap` for object keys (results are GC-eligible when the key is\n * collected) or a `Map` for primitive keys. For multi-argument functions,\n * nest two `memoize` calls — the outer keyed by the first argument, the\n * inner (created once per outer miss) keyed by the second.\n *\n * Because the cache is owned by the caller, it can be shared, inspected, or\n * cleared independently of the memoized function.\n *\n * @example Single WeakMap key\n * ```ts\n * const cache = new WeakMap<SchemaNode, Set<string>>()\n * const getRefs = memoize(cache, (node) => collectRefs(node))\n * ```\n *\n * @example Single Map key (primitive)\n * ```ts\n * const cache = new Map<string, Resolver>()\n * const getResolver = memoize(cache, (name) => buildResolver(name))\n * ```\n *\n * @example Two-level (object + primitive)\n * ```ts\n * const outer = new WeakMap<Params[], Map<string, Params[]>>()\n * const fn = memoize(outer, (params) => memoize(new Map(), (key) => transform(params, key)))\n * fn(params)('camelcase')\n * ```\n */\nexport function memoize<TKey, TValue>(store: Store<TKey, TValue>, factory: (key: TKey) => TValue): (key: TKey) => TValue {\n  return (key: TKey): TValue => {\n    if (store.has(key)) return store.get(key)!\n    const value = factory(key)\n    store.set(key, value)\n    return value\n  }\n}\n\n/**\n * Container that switches between an eager `Array<T>` and a lazy `AsyncIterable<T>`.\n *\n * `Array<T>` by default. With `Stream` set to `true` it becomes `AsyncIterable<T>`, so large\n * collections can be produced lazily without holding every item in memory. Pairs with\n * {@link arrayToAsyncIterable}, which lifts a plain array into the streaming form.\n *\n * @example\n * ```ts\n * type Eager = Streamable<number> // Array<number>\n * type Lazy = Streamable<number, true> // AsyncIterable<number>\n * ```\n */\nexport type Streamable<T, Stream extends boolean = false> = Stream extends true ? AsyncIterable<T> : Array<T>\n\n/**\n * Wraps a plain array in a reusable `AsyncIterable`.\n * Each `[Symbol.asyncIterator]()` call returns a fresh generator so the\n * iterable can be consumed multiple times (e.g. once per plugin pre-scan).\n *\n * @example\n * ```ts\n * const stream = arrayToAsyncIterable([1, 2, 3])\n * for await (const n of stream) console.log(n) // 1, 2, 3\n * ```\n */\nexport function arrayToAsyncIterable<T>(arr: ReadonlyArray<T>): AsyncIterable<T> {\n  return {\n    [Symbol.asyncIterator]() {\n      return (async function* () {\n        yield* arr\n      })()\n    },\n  }\n}\n","import { isPromise, type PossiblePromise } from '@internals/utils'\nimport { adapterOas } from '@kubb/adapter-oas'\nimport { cliReporter, type CLIOptions, fileReporter, jsonReporter, type UserConfig } from '@kubb/core'\nimport { pluginBarrel, pluginBarrelName } from '@kubb/plugin-barrel'\nimport { parserTs, parserTsx } from '@kubb/parser-ts'\nimport { parserMd } from '@kubb/parser-md'\n\ntype AnyConfigResult = UserConfig<any> | Array<UserConfig<any>>\ntype ConfigInput = AnyConfigResult | Promise<AnyConfigResult> | ((cli: CLIOptions) => PossiblePromise<AnyConfigResult>)\ntype NormalizeConfig<TConfig> =\n  TConfig extends Array<UserConfig<infer TInput>> ? Array<UserConfig<TInput>> : TConfig extends UserConfig<infer TInput> ? UserConfig<TInput> : never\ntype DefinedConfig<TConfig extends ConfigInput> = TConfig extends (cli: CLIOptions) => PossiblePromise<infer TResult>\n  ? (cli: CLIOptions) => Promise<NormalizeConfig<TResult>>\n  : TConfig extends Promise<infer TResult>\n    ? Promise<NormalizeConfig<TResult>>\n    : NormalizeConfig<TConfig>\n\n/**\n * Applies default `root`, adapter, parsers, plugins, `output.barrel`, `output.format`, and `output.lint` to a single user config when not set.\n *\n * - `root` defaults to `process.cwd()`\n * - `adapter` defaults to `adapterOas()`\n * - `parsers` defaults to `[parserTs, parserTsx, parserMd]`\n * - `reporters` defaults to `[cliReporter, jsonReporter, fileReporter]`\n * - `plugins` gets `pluginBarrel()` appended when none is already present\n * - `output.barrel` defaults to `{ type: 'named' }` only when `pluginBarrel` is part of `plugins`.\n *   When the user provides a plugins list without `pluginBarrel`, `barrel` is left untouched.\n * - `output.format` defaults to `false`\n * - `output.lint` defaults to `false`\n */\nfunction applyDefaults<TInput>(config: UserConfig<TInput>): UserConfig<TInput> {\n  const alreadyHasBarrel = config.plugins?.some((p) => p.name === pluginBarrelName)\n  const plugins = alreadyHasBarrel ? (config.plugins ?? []) : [...(config.plugins ?? []), pluginBarrel()]\n  const hasBarrelPlugin = plugins.some((p) => p.name === pluginBarrelName)\n\n  const output = { ...config.output }\n  if (hasBarrelPlugin && output.barrel === undefined) {\n    output.barrel = { type: 'named' }\n  }\n  if (output.format === undefined) {\n    output.format = false\n  }\n  if (output.lint === undefined) {\n    output.lint = false\n  }\n\n  return {\n    ...config,\n    root: config.root || process.cwd(),\n    adapter: config.adapter ?? adapterOas(),\n    parsers: config.parsers?.length ? config.parsers : [parserTs, parserTsx, parserMd],\n    reporters: config.reporters?.length ? config.reporters : [cliReporter, jsonReporter, fileReporter],\n    plugins,\n    output,\n  }\n}\n\nfunction normalizeConfig<TInput>(config: UserConfig<TInput> | Array<UserConfig<TInput>>): UserConfig<TInput> | Array<UserConfig<TInput>> {\n  if (Array.isArray(config)) {\n    return config.map(applyDefaults)\n  }\n\n  return applyDefaults(config)\n}\n\n/**\n * Defines a Kubb build configuration and fills in defaults for any omitted fields.\n *\n * Defaults applied when omitted:\n * - `adapter` → `adapterOas()` (OpenAPI 2.0/3.0/3.1).\n * - `parsers` → `[parserTs, parserTsx, parserMd]`.\n * - `reporters` → `[cliReporter, jsonReporter, fileReporter]`.\n * - `plugins` → `pluginBarrel()` is appended when not already present.\n * - `output.barrel` → `{ type: 'named' }` only when `pluginBarrel` is\n *   in the plugins list.\n * - `output.format` and `output.lint` → `false`.\n *\n * Accepts a config object, an array of configs, a Promise resolving to one,\n * or a function that receives the parsed CLI options and returns any of the\n * above. The return type is preserved so async/array variants stay typed.\n *\n * @example\n * ```ts\n * import { defineConfig } from 'kubb'\n * import { pluginTs } from '@kubb/plugin-ts'\n *\n * export default defineConfig({\n *   input: { path: './petStore.yaml' },\n *   output: { path: './src/gen' },\n *   plugins: [pluginTs()],\n * })\n * ```\n *\n * @example Function form with CLI options\n * ```ts\n * import { defineConfig } from 'kubb'\n *\n * export default defineConfig(({ input }) => ({\n *   input: { path: input ?? './petStore.yaml' },\n *   output: { path: './src/gen' },\n *   plugins: [],\n * }))\n * ```\n */\nexport function defineConfig<TConfig extends ConfigInput>(config: TConfig): DefinedConfig<TConfig> {\n  if (typeof config === 'function') {\n    return (async (cli: CLIOptions) => {\n      return normalizeConfig(await config(cli))\n    }) as DefinedConfig<TConfig>\n  }\n\n  if (isPromise(config)) {\n    return config.then((resolved) => normalizeConfig(resolved)) as DefinedConfig<TConfig>\n  }\n\n  return normalizeConfig(config) as DefinedConfig<TConfig>\n}\n"],"mappings":";;;;;;;;;;;;;;;AAmBA,SAAgB,UAAa,QAAkD;CAC7E,OAAO,WAAW,QAAQ,WAAW,KAAA,KAAa,OAAQ,OAAmC,YAAY;AAC3G;;;;;;;;;;;;;;;;ACSA,SAAS,cAAsB,QAAgD;CAE7E,MAAM,UADmB,OAAO,SAAS,MAAM,MAAM,EAAE,SAAS,gBAAgB,IAC5C,OAAO,WAAW,CAAC,IAAK,CAAC,GAAI,OAAO,WAAW,CAAC,GAAI,aAAa,CAAC;CACtG,MAAM,kBAAkB,QAAQ,MAAM,MAAM,EAAE,SAAS,gBAAgB;CAEvE,MAAM,SAAS,EAAE,GAAG,OAAO,OAAO;CAClC,IAAI,mBAAmB,OAAO,WAAW,KAAA,GACvC,OAAO,SAAS,EAAE,MAAM,QAAQ;CAElC,IAAI,OAAO,WAAW,KAAA,GACpB,OAAO,SAAS;CAElB,IAAI,OAAO,SAAS,KAAA,GAClB,OAAO,OAAO;CAGhB,OAAO;EACL,GAAG;EACH,MAAM,OAAO,QAAQ,QAAQ,IAAI;EACjC,SAAS,OAAO,WAAW,WAAW;EACtC,SAAS,OAAO,SAAS,SAAS,OAAO,UAAU;GAAC;GAAU;GAAW;EAAQ;EACjF,WAAW,OAAO,WAAW,SAAS,OAAO,YAAY;GAAC;GAAa;GAAc;EAAY;EACjG;EACA;CACF;AACF;AAEA,SAAS,gBAAwB,QAAwG;CACvI,IAAI,MAAM,QAAQ,MAAM,GACtB,OAAO,OAAO,IAAI,aAAa;CAGjC,OAAO,cAAc,MAAM;AAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,aAA0C,QAAyC;CACjG,IAAI,OAAO,WAAW,YACpB,QAAQ,OAAO,QAAoB;EACjC,OAAO,gBAAgB,MAAM,OAAO,GAAG,CAAC;CAC1C;CAGF,IAAI,UAAU,MAAM,GAClB,OAAO,OAAO,MAAM,aAAa,gBAAgB,QAAQ,CAAC;CAG5D,OAAO,gBAAgB,MAAM;AAC/B"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kubb",
-  "version": "5.0.0-beta.7",
-  "description": "Meta-package and entry point for Kubb — a plugin-based code generation framework for OpenAPI. Includes defineConfig, all public APIs, and serves as the gateway to the entire Kubb ecosystem.",
+  "version": "5.0.0-beta.70",
+  "description": "Meta-package and entry point for Kubb, the meta framework for code generation. Bundles defineConfig and all public APIs into a single install.",
   "keywords": [
     "api-client",
     "code-generator",
@@ -10,11 +10,9 @@
     "kubb",
     "meta-framework",
     "msw",
-    "openapi",
     "plugin-system",
     "react-query",
     "sdk-generator",
-    "swagger",
     "tanstack-query",
     "typescript",
     "zod"
@@ -30,7 +28,6 @@
     "kubb": "bin/kubb.js"
   },
   "files": [
-    "src",
     "dist",
     "bin",
     "!/**/**.test.**",
@@ -54,47 +51,31 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/adapter-oas": "5.0.0-beta.7",
-    "@kubb/cli": "5.0.0-beta.7",
-    "@kubb/core": "5.0.0-beta.7",
-    "@kubb/middleware-barrel": "5.0.0-beta.7",
-    "@kubb/parser-ts": "5.0.0-beta.7",
-    "@kubb/renderer-jsx": "5.0.0-beta.7"
+    "@kubb/adapter-oas": "5.0.0-beta.70",
+    "@kubb/cli": "5.0.0-beta.70",
+    "@kubb/core": "5.0.0-beta.70",
+    "@kubb/mcp": "5.0.0-beta.70",
+    "@kubb/parser-md": "5.0.0-beta.70",
+    "@kubb/parser-ts": "5.0.0-beta.70",
+    "@kubb/plugin-barrel": "5.0.0-beta.70",
+    "@kubb/renderer-jsx": "5.0.0-beta.70"
   },
   "devDependencies": {
     "typescript": "^6.0.3",
     "@internals/utils": "0.0.0"
   },
-  "peerDependencies": {
-    "@kubb/agent": "5.0.0-beta.7",
-    "@kubb/mcp": "5.0.0-beta.7"
-  },
-  "peerDependenciesMeta": {
-    "@kubb/agent": {
-      "optional": true
-    },
-    "@kubb/mcp": {
-      "optional": true
-    }
-  },
-  "size-limit": [
-    {
-      "path": "./dist/*.js",
-      "limit": "510 KiB",
-      "gzip": true
-    }
-  ],
   "preferGlobal": true,
   "engines": {
     "node": ">=22"
   },
   "scripts": {
     "build": "tsdown",
-    "clean": "npx rimraf ./dist",
+    "clean": "node -e \"require('node:fs').rmSync('./dist', {recursive:true,force:true})\"",
     "lint": "oxlint .",
     "lint:fix": "oxlint --fix .",
     "release": "pnpm publish --no-git-check",
     "release:canary": "bash ../../.github/canary.sh && node ../../scripts/build.js canary && pnpm publish --no-git-check",
+    "release:stage": "pnpm stage publish --no-git-check",
     "start": "tsdown --watch",
     "test": "vitest --passWithNoTests",
     "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"

package/src/defineConfig.ts

@@ -1,91 +0,0 @@
-import { isPromise, type PossiblePromise } from '@internals/utils'
-import { adapterOas } from '@kubb/adapter-oas'
-import type { CLIOptions, UserConfig } from '@kubb/core'
-import { middlewareBarrel, middlewareBarrelName } from '@kubb/middleware-barrel'
-import { parserTs, parserTsx } from '@kubb/parser-ts'
-
-type AnyConfigResult = UserConfig<any> | Array<UserConfig<any>>
-type ConfigInput = AnyConfigResult | Promise<AnyConfigResult> | ((cli: CLIOptions) => PossiblePromise<AnyConfigResult>)
-type NormalizeConfig<TConfig> =
-  TConfig extends Array<UserConfig<infer TInput>> ? Array<UserConfig<TInput>> : TConfig extends UserConfig<infer TInput> ? UserConfig<TInput> : never
-type DefinedConfig<TConfig extends ConfigInput> = TConfig extends (cli: CLIOptions) => PossiblePromise<infer TResult>
-  ? (cli: CLIOptions) => Promise<NormalizeConfig<TResult>>
-  : TConfig extends Promise<infer TResult>
-    ? Promise<NormalizeConfig<TResult>>
-    : NormalizeConfig<TConfig>
-
-/**
- * Applies default adapter, parsers, middleware, `output.barrel`, `output.format`, and `output.lint` to a single user config when not set.
- *
- * - `adapter` defaults to `adapterOas()`
- * - `parsers` defaults to `[parserTs, parserTsx]`
- * - `middleware` defaults to `[middlewareBarrel()]`
- * - `output.barrel` defaults to `{ type: 'named' }` **only when `middlewareBarrel` is part of `middleware`**.
- *   When the user provides a custom middleware list without `middlewareBarrel`, `barrel` is left untouched.
- * - `output.format` defaults to `'auto'`
- * - `output.lint` defaults to `'auto'`
- */
-function applyDefaults<TInput>(config: UserConfig<TInput>): UserConfig<TInput> {
-  const middleware = config.middleware?.length ? config.middleware : [middlewareBarrel()]
-  const hasBarrelMiddleware = middleware.some((m) => m.name === middlewareBarrelName)
-
-  const output = { ...config.output }
-  if (hasBarrelMiddleware && output.barrel === undefined) {
-    output.barrel = { type: 'named' }
-  }
-  if (output.format === undefined) {
-    output.format = false
-  }
-  if (output.lint === undefined) {
-    output.lint = false
-  }
-
-  return {
-    ...config,
-    adapter: config.adapter ?? adapterOas(),
-    parsers: config.parsers?.length ? config.parsers : [parserTs, parserTsx],
-    middleware,
-    output,
-  }
-}
-
-function normalizeConfig<TInput>(config: UserConfig<TInput> | Array<UserConfig<TInput>>): UserConfig<TInput> | Array<UserConfig<TInput>> {
-  if (Array.isArray(config)) {
-    return config.map(applyDefaults)
-  }
-
-  return applyDefaults(config)
-}
-
-/**
- * Helper for defining a Kubb configuration with built-in defaults.
- *
- * When no `adapter` is provided, `adapterOas()` is used automatically.
- * When no `parsers` are provided, `[parserTs, parserTsx]` is used automatically.
- *
- * Accepts either:
- * - A config object or array of configs
- * - A function returning the config(s), optionally async,
- *   receiving the CLI options as argument
- *
- * @example
- * ```ts
- * export default defineConfig(({ logLevel }) => ({
- *   root: 'src',
- *   plugins: [myPlugin()],
- * }))
- * ```
- */
-export function defineConfig<TConfig extends ConfigInput>(config: TConfig): DefinedConfig<TConfig> {
-  if (typeof config === 'function') {
-    return (async (cli: CLIOptions) => {
-      return normalizeConfig(await config(cli))
-    }) as DefinedConfig<TConfig>
-  }
-
-  if (isPromise(config)) {
-    return config.then((resolved) => normalizeConfig(resolved)) as DefinedConfig<TConfig>
-  }
-
-  return normalizeConfig(config) as DefinedConfig<TConfig>
-}

package/src/index.ts

@@ -1 +0,0 @@
-export { defineConfig } from './defineConfig.ts'