@kubb/core 5.0.0-beta.15 → 5.0.0-beta.16

package/dist/mocks.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_PluginDriver = require("./PluginDriver-C1OsqGBJ.cjs");
+const require_PluginDriver = require("./PluginDriver-C5hyNJfM.cjs");
 let node_path = require("node:path");
 let _kubb_ast = require("@kubb/ast");
 //#region src/mocks.ts

package/dist/mocks.d.ts

@@ -1,5 +1,5 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import { H as NormalizedPlugin, K as PluginFactoryOptions, P as PluginDriver, j as Generator, r as Config, vt as Adapter, yt as AdapterFactoryOptions } from "./createKubb-uVWTlN_w.js";
+import { H as NormalizedPlugin, K as PluginFactoryOptions, P as PluginDriver, bt as AdapterFactoryOptions, j as Generator, r as Config, yt as Adapter } from "./createKubb-BncBLGm_.js";
 import { InputNode, OperationNode, SchemaNode, Visitor } from "@kubb/ast";
 
 //#region src/mocks.d.ts

package/dist/mocks.js

@@ -1,5 +1,5 @@
 import "./chunk--u3MIqq1.js";
-import { n as applyHookResult, r as FileManager, t as PluginDriver } from "./PluginDriver-CGypdXHg.js";
+import { n as applyHookResult, r as FileManager, t as PluginDriver } from "./PluginDriver-CT33kVoQ.js";
 import { resolve } from "node:path";
 import { transform } from "@kubb/ast";
 //#region src/mocks.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/core",
-  "version": "5.0.0-beta.15",
+  "version": "5.0.0-beta.16",
   "description": "Core engine for Kubb's plugin-based code generation system. Provides the plugin driver, file manager, defineConfig, and build orchestration used by every Kubb plugin.",
   "keywords": [
     "code-generator",
@@ -58,15 +58,14 @@
   "dependencies": {
     "fflate": "^0.8.2",
     "tinyexec": "^1.1.2",
-    "@kubb/ast": "5.0.0-beta.15"
+    "@kubb/ast": "5.0.0-beta.16"
   },
   "devDependencies": {
-    "p-limit": "^7.3.0",
     "@internals/utils": "0.0.0",
-    "@kubb/renderer-jsx": "5.0.0-beta.15"
+    "@kubb/renderer-jsx": "5.0.0-beta.16"
   },
   "peerDependencies": {
-    "@kubb/renderer-jsx": "5.0.0-beta.15"
+    "@kubb/renderer-jsx": "5.0.0-beta.16"
   },
   "size-limit": [
     {
@@ -78,10 +77,6 @@
   "engines": {
     "node": ">=22"
   },
-  "inlinedDependencies": {
-    "p-limit": "7.3.0",
-    "yocto-queue": "1.2.2"
-  },
   "scripts": {
     "build": "tsdown && size-limit",
     "clean": "npx rimraf ./dist",

package/src/FileProcessor.ts

@@ -1,8 +1,6 @@
 import type { CodeNode, FileNode } from '@kubb/ast'
 import { extractStringsFromNodes } from '@kubb/ast'
 import { AsyncEventEmitter } from '@internals/utils'
-import pLimit from 'p-limit'
-import { PARALLEL_CONCURRENCY_LIMIT } from './constants.ts'
 import type { Parser } from './defineParser.ts'
 
 type ParseOptions = {
@@ -10,19 +8,20 @@ type ParseOptions = {
   extension?: Record<FileNode['extname'], FileNode['extname'] | ''>
 }
 
-type RunOptions = ParseOptions & {
-  /**
-   * @default 'sequential'
-   */
-  mode?: 'sequential' | 'parallel'
-}
-
 export type FileProcessorEvents = {
   start: [files: Array<FileNode>]
   update: [params: { file: FileNode; source?: string; processed: number; total: number; percentage: number }]
   end: [files: Array<FileNode>]
 }
 
+export type ParsedFile = {
+  file: FileNode
+  source: string
+  processed: number
+  total: number
+  percentage: number
+}
+
 function joinSources(file: FileNode): string {
   return file.sources
     .map((item) => extractStringsFromNodes(item.nodes as Array<CodeNode>))
@@ -38,7 +37,6 @@ function joinSources(file: FileNode): string {
  */
 export class FileProcessor {
   readonly events = new AsyncEventEmitter<FileProcessorEvents>()
-  readonly #limit = pLimit(PARALLEL_CONCURRENCY_LIMIT)
 
   async parse(file: FileNode, { parsers, extension }: ParseOptions = {}): Promise<string> {
     const parseExtName = extension?.[file.extname] || undefined
@@ -56,32 +54,29 @@ export class FileProcessor {
     return parser.parse(file, { extname: parseExtName })
   }
 
-  async run(files: Array<FileNode>, { parsers, mode = 'sequential', extension }: RunOptions = {}): Promise<Array<FileNode>> {
-    await this.events.emit('start', files)
-
+  /**
+   * Streams parsed files one at a time as each is processed.
+   *
+   * Unlike `run()`, files are yielded immediately after parsing rather than batched.
+   * Storage writes can begin as soon as the first file is ready, keeping peak
+   * memory proportional to one file at a time instead of the full batch.
+   */
+  async *stream(files: ReadonlyArray<FileNode>, options: ParseOptions = {}): AsyncGenerator<ParsedFile> {
     const total = files.length
     let processed = 0
 
-    const processOne = async (file: FileNode) => {
-      const source = await this.parse(file, { extension, parsers })
-      const currentProcessed = ++processed
-      const percentage = (currentProcessed / total) * 100
-
-      await this.events.emit('update', {
-        file,
-        source,
-        processed: currentProcessed,
-        percentage,
-        total,
-      })
+    for (const file of files) {
+      const source = await this.parse(file, options)
+      processed++
+      yield { file, source, processed, total, percentage: (processed / total) * 100 }
     }
+  }
+
+  async run(files: Array<FileNode>, options: ParseOptions = {}): Promise<Array<FileNode>> {
+    await this.events.emit('start', files)
 
-    if (mode === 'sequential') {
-      for (const file of files) {
-        await processOne(file)
-      }
-    } else {
-      await Promise.all(files.map((file) => this.#limit(() => processOne(file))))
+    for await (const { file, source, processed, total, percentage } of this.stream(files, options)) {
+      await this.events.emit('update', { file, source, processed, percentage, total })
     }
 
     await this.events.emit('end', files)

package/src/PluginDriver.ts

@@ -1,6 +1,6 @@
 import { resolve } from 'node:path'
 import type { AsyncEventEmitter } from '@internals/utils'
-import type { FileNode, InputNode, OperationNode, SchemaNode } from '@kubb/ast'
+import type { FileNode, InputNode, InputStreamNode, OperationNode, SchemaNode } from '@kubb/ast'
 import { createFile } from '@kubb/ast'
 import { DEFAULT_STUDIO_URL } from './constants.ts'
 import type { Generator } from './defineGenerator.ts'
@@ -55,6 +55,12 @@ export class PluginDriver {
    * the build pipeline after the adapter's `parse()` resolves.
    */
   inputNode: InputNode | undefined = undefined
+  /**
+   * Set when the adapter returns a streaming `InputStreamNode` (large specs).
+   * Mutually exclusive with `inputNode` — exactly one is set after adapter setup.
+   */
+  inputStreamNode: InputStreamNode | undefined = undefined
+
   adapter: Adapter | undefined = undefined
   #studioIsOpen = false
 
@@ -246,7 +252,7 @@ export class PluginDriver {
     }
 
     if (gen.operations) {
-      const operationsHandler = async (nodes: Array<OperationNode>, ctx: GeneratorContext) => {
+      const operationsHandler = async (nodes: AsyncIterable<OperationNode> | Array<OperationNode>, ctx: GeneratorContext) => {
         if (ctx.plugin.name !== pluginName) return
         const result = await gen.operations!(nodes, ctx)
         await applyHookResult(result, this, resolveRenderer())
@@ -293,6 +299,7 @@ export class PluginDriver {
     // any FileNodes the caller needs to inspect.
     this.fileManager.dispose()
     this.inputNode = undefined
+    this.inputStreamNode = undefined
   }
 
   #trackHookListener(event: keyof KubbHooks, handler: (...args: never[]) => void | Promise<void>): void {
@@ -368,8 +375,8 @@ export class PluginDriver {
       upsertFile: async (...files: Array<FileNode>) => {
         driver.fileManager.upsert(...files)
       },
-      get inputNode(): InputNode | undefined {
-        return driver.inputNode
+      get inputNode(): InputNode {
+        return driver.inputNode ?? { kind: 'Input' as const, schemas: [], operations: [], meta: driver.inputStreamNode?.meta }
       },
       get adapter(): Adapter | undefined {
         return driver.adapter

package/src/constants.ts

@@ -5,15 +5,6 @@ import type { FileNode } from '@kubb/ast'
  */
 export const DEFAULT_STUDIO_URL = 'https://kubb.studio' as const
 
-/**
- * Maximum number of files processed in parallel by FileProcessor.
- *
- * Capped at 16 to bound the number of CodeNode trees that are alive simultaneously
- * during rendering; I/O latency is the real bottleneck so higher values offer no
- * meaningful throughput improvement.
- */
-export const PARALLEL_CONCURRENCY_LIMIT = 16
-
 /**
  * Default banner style written at the top of every generated file.
  */
@@ -24,6 +15,16 @@ export const DEFAULT_BANNER = 'simple' as const
  */
 export const DEFAULT_EXTENSION: Record<FileNode['extname'], FileNode['extname'] | ''> = { '.ts': '.ts' }
 
+/**
+ * Schema count above which the adapter's `stream()` path is used instead of `parse()`.
+ */
+export const STREAM_SCHEMA_THRESHOLD = 100
+
+/**
+ * In streaming mode, flush generated files to disk every N schemas to bound in-memory file buffers.
+ */
+export const STREAM_FLUSH_EVERY = 50
+
 /**
  * Numeric log-level thresholds used internally to compare verbosity.
  *

package/src/createAdapter.ts

@@ -1,5 +1,5 @@
 import type { PossiblePromise } from '@internals/utils'
-import type { ImportNode, InputNode, SchemaNode } from '@kubb/ast'
+import type { ImportNode, InputNode, InputStreamNode, SchemaNode } from '@kubb/ast'
 
 /**
  * Source data passed to an adapter's `parse` function.
@@ -73,6 +73,22 @@ export type Adapter<TOptions extends AdapterFactoryOptions = AdapterFactoryOptio
    * Validate the document at the given path or URL.
    */
   validate: (input: string, options?: { throwOnError?: boolean }) => Promise<void>
+  /**
+   * Lightweight pre-flight count of schemas and operations without parsing AST nodes.
+   * The adapter should cache the loaded document so subsequent `parse()` or `stream()` calls
+   * do not reload it.
+   *
+   * Used by the core to decide whether to use `parse()` or `stream()`.
+   */
+  count?: (source: AdapterSource) => Promise<{ schemas: number; operations: number }>
+  /**
+   * Memory-efficient streaming variant of `parse()`.
+   *
+   * Returns an `InputStreamNode` whose `schemas` and `operations` are `AsyncIterable`.
+   * Each `for await` loop creates a fresh parse pass over the cached in-memory document —
+   * no pre-built arrays are held in memory.
+   */
+  stream?: (source: AdapterSource) => Promise<InputStreamNode>
 }
 
 type AdapterBuilder<T extends AdapterFactoryOptions> = (options: T['options']) => Adapter<T>