kubb 5.0.0-beta.3 → 5.0.0-beta.31

package/README.md

@@ -1,4 +1,5 @@
 <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">
   </a>
@@ -11,7 +12,7 @@
 
 ### The meta framework for code generation
 
-**Stop writing glue code. Define your API once and Kubb generates types, clients, hooks, validators, mocks and more.**
+Point Kubb at an OpenAPI spec and it generates types, clients, hooks, validators, mocks, and more.
 
 <h4>
 <a href="https://kubb.dev" target="_blank">Documentation</a>
@@ -27,27 +28,22 @@
 ## Installation
 
 ```bash
-npm install kubb
+bun add kubb
 # or
 pnpm add kubb
+# or
+npm install kubb
 ```
 
-## Quick Start
+## Quick start
 
-Get started with Kubb in seconds:
+Run the setup wizard to create a `kubb.config.ts`:
 
 ```bash
 npx kubb init
 ```
 
-The interactive setup will:
-
-- Create a `package.json` (if needed)
-- Guide you through plugin selection
-- Install packages automatically
-- Generate `kubb.config.ts`
-
-Then generate your code:
+The wizard creates a `package.json` if needed, guides you through plugin selection, installs packages, and writes `kubb.config.ts`. Then generate your code:
 
 ```bash
 npx kubb generate
@@ -58,12 +54,12 @@ See the [documentation](https://kubb.dev) for detailed usage and advanced featur
 ## Features
 
 - Works with Node.js 22+ and TypeScript 6.
-- Convert Swagger 2.0, OpenAPI 3.0, and OpenAPI 3.1 to TypeScript types, API clients, and more via the [plugin ecosystem](https://github.com/kubb-labs/kubb-plugins).
-- Extensible plugin and middleware system for customizing and composing code generation.
-- CLI support with interactive setup, progress bar, and detailed logs.
+- 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 the `@kubb/middleware-barrel` middleware.
+- Barrel file generation via `@kubb/middleware-barrel`.
 
 ## Supporting Kubb
 

package/dist/index.cjs

@@ -3,6 +3,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let _kubb_adapter_oas = require("@kubb/adapter-oas");
 let _kubb_middleware_barrel = require("@kubb/middleware-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,15 +19,16 @@ 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, middleware, `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'`
+* - `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)()];
@@ -37,8 +39,13 @@ function applyDefaults(config) {
 	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],
+		parsers: config.parsers?.length ? config.parsers : [
+			_kubb_parser_ts.parserTs,
+			_kubb_parser_ts.parserTsx,
+			_kubb_parser_md.parserMd
+		],
 		middleware,
 		output
 	};
@@ -48,21 +55,41 @@ function normalizeConfig(config) {
 	return applyDefaults(config);
 }
 /**
-* Helper for defining a Kubb configuration with built-in defaults.
+* Defines a Kubb build configuration and applies sensible defaults so the
+* minimal config stays small.
 *
-* 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]`.
+* - `middleware` → `[middlewareBarrel()]`.
+* - `output.barrel` → `{ type: 'named' }` only when `middlewareBarrel` is
+*   in the middleware 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;AAC7E,QAAO,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;AACnC,KAAI,uBAAuB,OAAO,WAAW,KAAA,EAC3C,QAAO,SAAS,EAAE,MAAM,SAAS;AAEnC,KAAI,OAAO,WAAW,KAAA,EACpB,QAAO,SAAS;AAElB,KAAI,OAAO,SAAS,KAAA,EAClB,QAAO,OAAO;AAGhB,QAAO;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;AACvI,KAAI,MAAM,QAAQ,OAAO,CACvB,QAAO,OAAO,IAAI,cAAc;AAGlC,QAAO,cAAc,OAAO;;;;;;;;;;;;;;;;;;;;;AAsB9B,SAAgB,aAA0C,QAAyC;AACjG,KAAI,OAAO,WAAW,WACpB,SAAQ,OAAO,QAAoB;AACjC,SAAO,gBAAgB,MAAM,OAAO,IAAI,CAAC;;AAI7C,KAAI,UAAU,OAAO,CACnB,QAAO,OAAO,MAAM,aAAa,gBAAgB,SAAS,CAAC;AAG7D,QAAO,gBAAgB,OAAO"}
+{"version":3,"file":"index.cjs","names":["middlewareBarrelName","parserTs","parserTsx","parserMd"],"sources":["../../../internals/utils/src/promise.ts","../src/defineConfig.ts"],"sourcesContent":["function* chunks<T>(arr: readonly T[], size: number): Generator<T[]> {\n  for (let i = 0; i < arr.length; i += size) {\n    yield arr.slice(i, i + size)\n  }\n}\n\nexport type ForBatchesOptions = {\n  /**\n   * Maximum batch size handed to `process`.\n   * Parallel dispatch within a batch is the caller's responsibility\n   * (typically via `Promise.all(batch.map(...))`).\n   */\n  concurrency: number\n  /**\n   * Called after every batch.\n   *\n   * Use a cheap, idempotent callback (e.g. one that short-circuits when there\n   * is nothing new to do). The helper does not coalesce calls — if you need\n   * throttling, do it inside `flush` itself.\n   */\n  flush?: () => Promise<void>\n}\n\n/**\n * Slices `source` into batches of `concurrency` items and awaits `process` for each batch.\n * Accepts both plain arrays (sync) and `AsyncIterable` (streaming).\n *\n * `process` controls whether items inside a batch run in parallel; this helper only\n * controls batch size and per-batch flushing.\n *\n * @example\n * ```ts\n * // parallel dispatch inside each batch\n * await forBatches(schemas, (batch) => Promise.all(batch.map(process)), { concurrency: 8 })\n *\n * // async iterable with a flush after every batch\n * await forBatches(stream.schemas, (batch) => dispatch(batch), { concurrency: 8, flush })\n * ```\n */\nexport async function forBatches<T>(\n  source: readonly T[] | AsyncIterable<T>,\n  process: (batch: T[]) => Promise<unknown>,\n  options: ForBatchesOptions,\n): Promise<void> {\n  const { concurrency, flush } = options\n\n  if (Array.isArray(source)) {\n    for (const batch of chunks(source, concurrency)) {\n      await process(batch)\n      if (flush) await flush()\n    }\n    return\n  }\n\n  const batch: T[] = []\n  for await (const item of source) {\n    batch.push(item)\n    if (batch.length >= concurrency) {\n      await process(batch.splice(0))\n\n      if (flush) await flush()\n    }\n  }\n  if (batch.length > 0) {\n    await process(batch.splice(0))\n\n    if (flush) await flush()\n  }\n}\n\n/**\n * Runs `work`, passing `flush` as its periodic-flush callback, then calls\n * `flush` once more to drain any items that did not cross a flush boundary.\n *\n * @example\n * ```ts\n * await withDrain(\n *   (flush) => processItems(items, { flush }),\n *   () => writeRemainingFiles(),\n * )\n * ```\n */\nexport async function withDrain(work: (flush: () => Promise<void>) => Promise<void>, flush: () => Promise<void>): Promise<void> {\n  await work(flush)\n  await flush()\n}\n\n/** 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\n/**\n * Returns a wrapper that caches the result of the first invocation and replays\n * it for every subsequent call, ignoring later arguments.\n *\n * Works for sync and async factories — for async, the cached value is the\n * promise itself, so concurrent callers share one in-flight execution and\n * cannot race each other.\n *\n * @example\n * ```ts\n * const loadDocument = once(async (path: string) => parse(await readFile(path)))\n * const a = loadDocument('./a.yaml') // parses\n * const b = loadDocument('./b.yaml') // returns the cached promise from the first call\n * ```\n */\nexport function once<TArgs extends unknown[], TReturn>(factory: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn {\n  let cache: { value: TReturn } | undefined\n  return (...args: TArgs): TReturn => {\n    if (!cache) cache = { value: factory(...args) }\n    return cache.value\n  }\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 * 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: readonly 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 type { CLIOptions, UserConfig } from '@kubb/core'\nimport { middlewareBarrel, middlewareBarrelName } from '@kubb/middleware-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, middleware, `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]`\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 `false`\n * - `output.lint` defaults to `false`\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    root: config.root || process.cwd(),\n    adapter: config.adapter ?? adapterOas(),\n    parsers: config.parsers?.length ? config.parsers : [parserTs, parserTsx, parserMd],\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 * Defines a Kubb build configuration and applies sensible defaults so the\n * minimal config stays small.\n *\n * Defaults applied when omitted:\n * - `adapter` → `adapterOas()` (OpenAPI 2.0/3.0/3.1).\n * - `parsers` → `[parserTs, parserTsx]`.\n * - `middleware` → `[middlewareBarrel()]`.\n * - `output.barrel` → `{ type: 'named' }` only when `middlewareBarrel` is\n *   in the middleware 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":";;;;;;;;;;;;;;;AA0GA,SAAgB,UAAa,QAAkD;CAC7E,OAAO,WAAW,QAAQ,WAAW,KAAA,KAAa,OAAQ,OAAmC,YAAY;;;;;;;;;;;;;;;;AC9E3G,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,MAAM,OAAO,QAAQ,QAAQ,KAAK;EAClC,SAAS,OAAO,YAAA,GAAA,kBAAA,aAAuB;EACvC,SAAS,OAAO,SAAS,SAAS,OAAO,UAAU;GAACC,gBAAAA;GAAUC,gBAAAA;GAAWC,gBAAAA;GAAS;EAClF;EACA;EACD;;AAGH,SAAS,gBAAwB,QAAwG;CACvI,IAAI,MAAM,QAAQ,OAAO,EACvB,OAAO,OAAO,IAAI,cAAc;CAGlC,OAAO,cAAc,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0C9B,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"}

package/dist/index.d.ts

@@ -20,21 +20,41 @@ 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 applies sensible defaults so the
+ * minimal config stays small.
  *
- * 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]`.
+ * - `middleware` → `[middlewareBarrel()]`.
+ * - `output.barrel` → `{ type: 'named' }` only when `middlewareBarrel` is
+ *   in the middleware 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

@@ -2,6 +2,7 @@ import "./chunk--u3MIqq1.js";
 import { adapterOas } from "@kubb/adapter-oas";
 import { middlewareBarrel, middlewareBarrelName } from "@kubb/middleware-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,15 +18,16 @@ 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, middleware, `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'`
+* - `output.format` defaults to `false`
+* - `output.lint` defaults to `false`
 */
 function applyDefaults(config) {
 	const middleware = config.middleware?.length ? config.middleware : [middlewareBarrel()];
@@ -36,8 +38,13 @@ function applyDefaults(config) {
 	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],
+		parsers: config.parsers?.length ? config.parsers : [
+			parserTs,
+			parserTsx,
+			parserMd
+		],
 		middleware,
 		output
 	};
@@ -47,21 +54,41 @@ function normalizeConfig(config) {
 	return applyDefaults(config);
 }
 /**
-* Helper for defining a Kubb configuration with built-in defaults.
+* Defines a Kubb build configuration and applies sensible defaults so the
+* minimal config stays small.
 *
-* 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]`.
+* - `middleware` → `[middlewareBarrel()]`.
+* - `output.barrel` → `{ type: 'named' }` only when `middlewareBarrel` is
+*   in the middleware 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;AAC7E,QAAO,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;AACnC,KAAI,uBAAuB,OAAO,WAAW,KAAA,EAC3C,QAAO,SAAS,EAAE,MAAM,SAAS;AAEnC,KAAI,OAAO,WAAW,KAAA,EACpB,QAAO,SAAS;AAElB,KAAI,OAAO,SAAS,KAAA,EAClB,QAAO,OAAO;AAGhB,QAAO;EACL,GAAG;EACH,SAAS,OAAO,WAAW,YAAY;EACvC,SAAS,OAAO,SAAS,SAAS,OAAO,UAAU,CAAC,UAAU,UAAU;EACxE;EACA;EACD;;AAGH,SAAS,gBAAwB,QAAwG;AACvI,KAAI,MAAM,QAAQ,OAAO,CACvB,QAAO,OAAO,IAAI,cAAc;AAGlC,QAAO,cAAc,OAAO;;;;;;;;;;;;;;;;;;;;;AAsB9B,SAAgB,aAA0C,QAAyC;AACjG,KAAI,OAAO,WAAW,WACpB,SAAQ,OAAO,QAAoB;AACjC,SAAO,gBAAgB,MAAM,OAAO,IAAI,CAAC;;AAI7C,KAAI,UAAU,OAAO,CACnB,QAAO,OAAO,MAAM,aAAa,gBAAgB,SAAS,CAAC;AAG7D,QAAO,gBAAgB,OAAO"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../internals/utils/src/promise.ts","../src/defineConfig.ts"],"sourcesContent":["function* chunks<T>(arr: readonly T[], size: number): Generator<T[]> {\n  for (let i = 0; i < arr.length; i += size) {\n    yield arr.slice(i, i + size)\n  }\n}\n\nexport type ForBatchesOptions = {\n  /**\n   * Maximum batch size handed to `process`.\n   * Parallel dispatch within a batch is the caller's responsibility\n   * (typically via `Promise.all(batch.map(...))`).\n   */\n  concurrency: number\n  /**\n   * Called after every batch.\n   *\n   * Use a cheap, idempotent callback (e.g. one that short-circuits when there\n   * is nothing new to do). The helper does not coalesce calls — if you need\n   * throttling, do it inside `flush` itself.\n   */\n  flush?: () => Promise<void>\n}\n\n/**\n * Slices `source` into batches of `concurrency` items and awaits `process` for each batch.\n * Accepts both plain arrays (sync) and `AsyncIterable` (streaming).\n *\n * `process` controls whether items inside a batch run in parallel; this helper only\n * controls batch size and per-batch flushing.\n *\n * @example\n * ```ts\n * // parallel dispatch inside each batch\n * await forBatches(schemas, (batch) => Promise.all(batch.map(process)), { concurrency: 8 })\n *\n * // async iterable with a flush after every batch\n * await forBatches(stream.schemas, (batch) => dispatch(batch), { concurrency: 8, flush })\n * ```\n */\nexport async function forBatches<T>(\n  source: readonly T[] | AsyncIterable<T>,\n  process: (batch: T[]) => Promise<unknown>,\n  options: ForBatchesOptions,\n): Promise<void> {\n  const { concurrency, flush } = options\n\n  if (Array.isArray(source)) {\n    for (const batch of chunks(source, concurrency)) {\n      await process(batch)\n      if (flush) await flush()\n    }\n    return\n  }\n\n  const batch: T[] = []\n  for await (const item of source) {\n    batch.push(item)\n    if (batch.length >= concurrency) {\n      await process(batch.splice(0))\n\n      if (flush) await flush()\n    }\n  }\n  if (batch.length > 0) {\n    await process(batch.splice(0))\n\n    if (flush) await flush()\n  }\n}\n\n/**\n * Runs `work`, passing `flush` as its periodic-flush callback, then calls\n * `flush` once more to drain any items that did not cross a flush boundary.\n *\n * @example\n * ```ts\n * await withDrain(\n *   (flush) => processItems(items, { flush }),\n *   () => writeRemainingFiles(),\n * )\n * ```\n */\nexport async function withDrain(work: (flush: () => Promise<void>) => Promise<void>, flush: () => Promise<void>): Promise<void> {\n  await work(flush)\n  await flush()\n}\n\n/** 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\n/**\n * Returns a wrapper that caches the result of the first invocation and replays\n * it for every subsequent call, ignoring later arguments.\n *\n * Works for sync and async factories — for async, the cached value is the\n * promise itself, so concurrent callers share one in-flight execution and\n * cannot race each other.\n *\n * @example\n * ```ts\n * const loadDocument = once(async (path: string) => parse(await readFile(path)))\n * const a = loadDocument('./a.yaml') // parses\n * const b = loadDocument('./b.yaml') // returns the cached promise from the first call\n * ```\n */\nexport function once<TArgs extends unknown[], TReturn>(factory: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn {\n  let cache: { value: TReturn } | undefined\n  return (...args: TArgs): TReturn => {\n    if (!cache) cache = { value: factory(...args) }\n    return cache.value\n  }\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 * 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: readonly 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 type { CLIOptions, UserConfig } from '@kubb/core'\nimport { middlewareBarrel, middlewareBarrelName } from '@kubb/middleware-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, middleware, `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]`\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 `false`\n * - `output.lint` defaults to `false`\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    root: config.root || process.cwd(),\n    adapter: config.adapter ?? adapterOas(),\n    parsers: config.parsers?.length ? config.parsers : [parserTs, parserTsx, parserMd],\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 * Defines a Kubb build configuration and applies sensible defaults so the\n * minimal config stays small.\n *\n * Defaults applied when omitted:\n * - `adapter` → `adapterOas()` (OpenAPI 2.0/3.0/3.1).\n * - `parsers` → `[parserTs, parserTsx]`.\n * - `middleware` → `[middlewareBarrel()]`.\n * - `output.barrel` → `{ type: 'named' }` only when `middlewareBarrel` is\n *   in the middleware 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":";;;;;;;;;;;;;;AA0GA,SAAgB,UAAa,QAAkD;CAC7E,OAAO,WAAW,QAAQ,WAAW,KAAA,KAAa,OAAQ,OAAmC,YAAY;;;;;;;;;;;;;;;;AC9E3G,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,MAAM,OAAO,QAAQ,QAAQ,KAAK;EAClC,SAAS,OAAO,WAAW,YAAY;EACvC,SAAS,OAAO,SAAS,SAAS,OAAO,UAAU;GAAC;GAAU;GAAW;GAAS;EAClF;EACA;EACD;;AAGH,SAAS,gBAAwB,QAAwG;CACvI,IAAI,MAAM,QAAQ,OAAO,EACvB,OAAO,OAAO,IAAI,cAAc;CAGlC,OAAO,cAAc,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0C9B,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"}

package/package.json

@@ -1,24 +1,21 @@
 {
   "name": "kubb",
-  "version": "5.0.0-beta.3",
-  "description": "Transform OpenAPI specifications into TypeScript, React-Query, Zod, Faker.js, MSW and more with a plugin-based code generation tool.",
+  "version": "5.0.0-beta.31",
+  "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.",
   "keywords": [
     "api-client",
-    "cli",
     "code-generator",
     "codegen",
     "faker",
     "kubb",
+    "meta-framework",
     "msw",
-    "oas",
     "openapi",
     "plugin-system",
-    "plugins",
     "react-query",
     "sdk-generator",
     "swagger",
     "tanstack-query",
-    "type-safe",
     "typescript",
     "zod"
   ],
@@ -57,27 +54,25 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/adapter-oas": "5.0.0-beta.3",
-    "@kubb/cli": "5.0.0-beta.3",
-    "@kubb/core": "5.0.0-beta.3",
-    "@kubb/middleware-barrel": "5.0.0-beta.3",
-    "@kubb/parser-ts": "5.0.0-beta.3",
-    "@kubb/renderer-jsx": "5.0.0-beta.3"
+    "@kubb/adapter-oas": "5.0.0-beta.31",
+    "@kubb/cli": "5.0.0-beta.31",
+    "@kubb/core": "5.0.0-beta.31",
+    "@kubb/mcp": "5.0.0-beta.31",
+    "@kubb/middleware-barrel": "5.0.0-beta.31",
+    "@kubb/parser-md": "5.0.0-beta.31",
+    "@kubb/parser-ts": "5.0.0-beta.31",
+    "@kubb/renderer-jsx": "5.0.0-beta.31"
   },
   "devDependencies": {
     "typescript": "^6.0.3",
     "@internals/utils": "0.0.0"
   },
   "peerDependencies": {
-    "@kubb/agent": "5.0.0-beta.3",
-    "@kubb/mcp": "5.0.0-beta.3"
+    "@kubb/agent": "5.0.0-beta.31"
   },
   "peerDependenciesMeta": {
     "@kubb/agent": {
       "optional": true
-    },
-    "@kubb/mcp": {
-      "optional": true
     }
   },
   "size-limit": [

package/src/defineConfig.ts

@@ -3,6 +3,7 @@ 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'
+import { parserMd } from '@kubb/parser-md'
 
 type AnyConfigResult = UserConfig<any> | Array<UserConfig<any>>
 type ConfigInput = AnyConfigResult | Promise<AnyConfigResult> | ((cli: CLIOptions) => PossiblePromise<AnyConfigResult>)
@@ -15,15 +16,16 @@ type DefinedConfig<TConfig extends ConfigInput> = TConfig extends (cli: CLIOptio
     : NormalizeConfig<TConfig>
 
 /**
- * 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, middleware, `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'`
+ * - `output.format` defaults to `false`
+ * - `output.lint` defaults to `false`
  */
 function applyDefaults<TInput>(config: UserConfig<TInput>): UserConfig<TInput> {
   const middleware = config.middleware?.length ? config.middleware : [middlewareBarrel()]
@@ -42,8 +44,9 @@ function applyDefaults<TInput>(config: UserConfig<TInput>): UserConfig<TInput> {
 
   return {
     ...config,
+    root: config.root || process.cwd(),
     adapter: config.adapter ?? adapterOas(),
-    parsers: config.parsers?.length ? config.parsers : [parserTs, parserTsx],
+    parsers: config.parsers?.length ? config.parsers : [parserTs, parserTsx, parserMd],
     middleware,
     output,
   }
@@ -58,21 +61,41 @@ function normalizeConfig<TInput>(config: UserConfig<TInput> | Array<UserConfig<T
 }
 
 /**
- * Helper for defining a Kubb configuration with built-in defaults.
+ * Defines a Kubb build configuration and applies sensible defaults so the
+ * minimal config stays small.
  *
- * 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]`.
+ * - `middleware` → `[middlewareBarrel()]`.
+ * - `output.barrel` → `{ type: 'named' }` only when `middlewareBarrel` is
+ *   in the middleware 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: [],
  * }))
  * ```
  */