@kubb/renderer-jsx 5.0.0-beta.4 → 5.0.0-beta.40

package/dist/index.js

@@ -1,17 +1,21 @@
-import { n as __name, r as __toESM, t as __commonJSMin } from "./chunk-Bb7HlUDG.js";
-import { n as require_react } from "./jsx-runtime-Cvu_ZYgL.js";
+import { n as __name, r as __toESM, t as __commonJSMin } from "./chunk-DoukXa0m.js";
+import { n as require_react } from "./jsx-runtime-CQ6-_gue.js";
 import { Fragment, jsx } from "./jsx-runtime.js";
+import { stringify } from "yaml";
 import { createArrowFunction, createBreak, createConst, createExport, createFunction, createImport, createJsx, createSource, createText, createType } from "@kubb/ast";
 //#region ../../internals/utils/src/context.ts
 /**
-* Context stack for tracking the current context values
+* Context stack for tracking the current context values.
+*
+* WeakMap keyed by symbol so entries are GC-eligible once no external code
+* holds a reference to the context key — important for long-running agent
+* builds where plugins create and discard context keys across repeated runs.
 *
-* Note: This uses a global Map for simplicity in code generation scenarios.
 * For concurrent runtime execution, consider using AsyncLocalStorage or
 * instance-based context management.
 */
-const contextStack = /* @__PURE__ */ new Map();
-const contextDefaults = /* @__PURE__ */ new Map();
+const contextStack = /* @__PURE__ */ new WeakMap();
+const contextDefaults = /* @__PURE__ */ new WeakMap();
 /**
 * Provides a value to descendant components (Vue 3 style)
 *
@@ -106,6 +110,64 @@ function onProcessExit(callback) {
 	return unsubscribe;
 }
 //#endregion
+//#region src/components/Callout.tsx
+const CALLOUT_LABEL = {
+	tip: "TIP",
+	note: "NOTE",
+	important: "IMPORTANT",
+	warning: "WARNING",
+	caution: "CAUTION"
+};
+/**
+* Renders a GitHub-style alert callout, portable across GitHub, GitLab,
+* VitePress, Obsidian, and MDX.
+*
+* Emits a `<File.Source>` block containing `> [!TYPE] Title` followed by the
+* body with every line prefixed by `> `.
+*
+* @example
+* ```tsx
+* <Callout type="tip">Run `kubb start --watch` to keep the generator hot.</Callout>
+* // > [!TIP]
+* // > Run `kubb start --watch` to keep the generator hot.
+*
+* <Callout type="warning" title="Heads up">Breaking change in v6.</Callout>
+* // > [!WARNING] Heads up
+* // > Breaking change in v6.
+* ```
+*/
+function Callout({ type, title, children }) {
+	const label = CALLOUT_LABEL[type];
+	return /* @__PURE__ */ jsx("kubb-source", {
+		name: "callout",
+		children: `${title ? `> [!${label}] ${title}` : `> [!${label}]`}\n${children.trimEnd().split("\n").map((line) => line.length > 0 ? `> ${line}` : ">").join("\n")}`
+	});
+}
+Callout.displayName = "Callout";
+//#endregion
+//#region src/components/CodeBlock.tsx
+/**
+* Renders a fenced markdown code block.
+*
+* Emits a `<File.Source>` block containing the children wrapped in
+* triple-backtick fences with an optional language tag.
+*
+* @example
+* ```tsx
+* <CodeBlock lang="typescript">{'const pet = { id: 1 }'}</CodeBlock>
+* // ```typescript
+* // const pet = { id: 1 }
+* // ```
+* ```
+*/
+function CodeBlock({ lang, children }) {
+	return /* @__PURE__ */ jsx("kubb-source", {
+		name: "codeBlock",
+		children: `\`\`\`${lang ?? ""}\n${children}\n\`\`\``
+	});
+}
+CodeBlock.displayName = "CodeBlock";
+//#endregion
 //#region src/components/Const.tsx
 /**
 * Generates a TypeScript constant declaration.
@@ -260,6 +322,33 @@ File.Export = FileExport;
 File.Import = FileImport;
 File.Source = FileSource;
 //#endregion
+//#region src/components/Frontmatter.tsx
+/**
+* Emits a YAML frontmatter envelope at the top of a generated markdown file.
+*
+* Renders a `<File.Source>` block containing `---\n<yaml>\n---`. Place it as
+* the first child of `<File>` so it appears at the top of the output. Pair with
+* `parserMd` to write `.md` files that downstream tooling (VitePress, MDX,
+* static-site generators) treats as frontmatter.
+*
+* @example Page frontmatter at the top of a generated markdown file
+* ```tsx
+* <File baseName="pets.md" path="src/pets.md">
+*   <Frontmatter data={{ title: 'Pets', layout: 'doc' }} />
+*   <File.Source>
+*     {'# Pets\n\nList of pets.'}
+*   </File.Source>
+* </File>
+* ```
+*/
+function Frontmatter({ data }) {
+	return /* @__PURE__ */ jsx("kubb-source", {
+		name: "frontmatter",
+		children: `---\n${stringify(data).trimEnd()}\n---`
+	});
+}
+Frontmatter.displayName = "Frontmatter";
+//#endregion
 //#region src/components/Function.tsx
 /**
 * Generates a TypeScript function declaration.
@@ -321,13 +410,34 @@ function ArrowFunction({ children, ...props }) {
 ArrowFunction.displayName = "ArrowFunction";
 Function$1.Arrow = ArrowFunction;
 //#endregion
+//#region src/components/Heading.tsx
+/**
+* Renders an ATX-style markdown heading.
+*
+* Emits a `<File.Source>` block containing `${'#'.repeat(level)} ${children}`.
+* Use inside a `<File>` rendered by `parserMd`.
+*
+* @example
+* ```tsx
+* <Heading level={2}>Installation</Heading>
+* // ## Installation
+* ```
+*/
+function Heading({ level, children }) {
+	return /* @__PURE__ */ jsx("kubb-source", {
+		name: "heading",
+		children: `${"#".repeat(level)} ${children}`
+	});
+}
+Heading.displayName = "Heading";
+//#endregion
 //#region src/components/Jsx.tsx
 /**
 * Embeds a raw JSX string verbatim in the generated source code.
 *
 * Use this component when you need to include JSX markup (including fragments
 * `<>…</>`) in the body of a generated function or component. The `children`
-* prop must be a plain string — expression attributes that reference runtime
+* prop must be a plain string, expression attributes that reference runtime
 * values should be written as template literals.
 *
 * @example
@@ -342,8 +452,55 @@ function Jsx({ children }) {
 }
 Jsx.displayName = "Jsx";
 //#endregion
+//#region src/components/List.tsx
+/**
+* Renders a markdown list.
+*
+* Emits a `<File.Source>` block containing one entry per line, prefixed with
+* `1.` / `2.` … when `ordered`, or `-` otherwise.
+*
+* @example
+* ```tsx
+* <List items={['Add the parser', 'Render the page']} />
+* // - Add the parser
+* // - Render the page
+*
+* <List ordered items={['First', 'Second']} />
+* // 1. First
+* // 2. Second
+* ```
+*/
+function List({ ordered, items }) {
+	return /* @__PURE__ */ jsx("kubb-source", {
+		name: "list",
+		children: items.map((item, index) => `${ordered ? `${index + 1}.` : "-"} ${item}`).join("\n")
+	});
+}
+List.displayName = "List";
+//#endregion
+//#region src/components/Paragraph.tsx
+/**
+* Renders a markdown paragraph.
+*
+* Emits a `<File.Source>` block containing the text as-is. Paragraphs are
+* separated from surrounding blocks by blank lines via the parser's source
+* joining.
+*
+* @example
+* ```tsx
+* <Paragraph>{'A pet object with `id` and `name` fields.'}</Paragraph>
+* ```
+*/
+function Paragraph({ children }) {
+	return /* @__PURE__ */ jsx("kubb-source", {
+		name: "paragraph",
+		children
+	});
+}
+Paragraph.displayName = "Paragraph";
+//#endregion
 //#region src/components/Root.tsx
-var import_react = require_react();
+var import_react = /* @__PURE__ */ __toESM(require_react());
 var ErrorBoundary = class extends import_react.Component {
 	state = { hasError: false };
 	static displayName = "ErrorBoundary";
@@ -378,7 +535,7 @@ Root.displayName = "Root";
 /**
 * Generates a TypeScript type alias declaration.
 *
-* Throws if `name` does not start with an uppercase letter — TypeScript type aliases
+* Throws if `name` does not start with an uppercase letter. TypeScript type aliases
 * should follow PascalCase naming conventions.
 *
 * @example Simple exported type alias
@@ -408,7 +565,7 @@ function Type({ children, ...props }) {
 }
 Type.displayName = "Type";
 //#endregion
-//#region ../../node_modules/.pnpm/react-reconciler@0.33.0_react@19.2.5/node_modules/react-reconciler/cjs/react-reconciler-constants.production.js
+//#region ../../node_modules/.pnpm/react-reconciler@0.33.0_react@19.2.6/node_modules/react-reconciler/cjs/react-reconciler-constants.production.js
 /**
 * @license React
 * react-reconciler-constants.production.js
@@ -428,7 +585,7 @@ var require_react_reconciler_constants_production = /* @__PURE__ */ __commonJSMi
 	exports.NoEventPriority = 0;
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/react-reconciler@0.33.0_react@19.2.5/node_modules/react-reconciler/cjs/react-reconciler-constants.development.js
+//#region ../../node_modules/.pnpm/react-reconciler@0.33.0_react@19.2.6/node_modules/react-reconciler/cjs/react-reconciler-constants.development.js
 /**
 * @license React
 * react-reconciler-constants.development.js
@@ -481,9 +638,9 @@ const nodeNames = new Set([
 const createNode = (nodeName) => {
 	return {
 		nodeName,
-		attributes: /* @__PURE__ */ new Map(),
+		attributes: Object.create(null),
 		childNodes: [],
-		parentNode: void 0
+		parentNode: null
 	};
 };
 /**
@@ -521,7 +678,7 @@ const insertBeforeNode = (node, newChildNode, beforeChildNode) => {
 * Does nothing if `removeNode` is not a direct child of `node`.
 */
 const removeChildNode = (node, removeNode) => {
-	removeNode.parentNode = void 0;
+	removeNode.parentNode = null;
 	const index = node.childNodes.indexOf(removeNode);
 	if (index >= 0) node.childNodes.splice(index, 1);
 };
@@ -529,26 +686,22 @@ const removeChildNode = (node, removeNode) => {
 * Set an attribute on `node`, storing it in the node's `attributes` map.
 */
 const setAttribute = (node, key, value) => {
-	node.attributes.set(key, value);
+	node.attributes[key] = value;
 };
 /**
 * Create a new {@link TextNode} with the given text value.
 */
 const createTextNode = (text) => {
-	const node = {
+	return {
 		nodeName: TEXT_NODE_NAME,
 		nodeValue: text,
-		parentNode: void 0
+		parentNode: null
 	};
-	setTextNodeValue(node, text);
-	return node;
 };
 /**
 * Update the `nodeValue` of an existing {@link TextNode}.
-* Non-string values are coerced to strings via `String(text)`.
 */
 const setTextNodeValue = (node, text) => {
-	if (typeof text !== "string") text = String(text);
 	node.nodeValue = text;
 };
 //#endregion
@@ -1085,7 +1238,7 @@ var require_scheduler = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	else module.exports = require_scheduler_development();
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/react-reconciler@0.33.0_react@19.2.5/node_modules/react-reconciler/cjs/react-reconciler.production.js
+//#region ../../node_modules/.pnpm/react-reconciler@0.33.0_react@19.2.6/node_modules/react-reconciler/cjs/react-reconciler.production.js
 /**
 * @license React
 * react-reconciler.production.js
@@ -7654,7 +7807,7 @@ var require_react_reconciler_production = /* @__PURE__ */ __commonJSMin(((export
 	Object.defineProperty(module.exports, "__esModule", { value: !0 });
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/react-reconciler@0.33.0_react@19.2.5/node_modules/react-reconciler/cjs/react-reconciler.development.js
+//#region ../../node_modules/.pnpm/react-reconciler@0.33.0_react@19.2.6/node_modules/react-reconciler/cjs/react-reconciler.development.js
 /**
 * @license React
 * react-reconciler.development.js
@@ -17817,7 +17970,7 @@ const Renderer = (0, import_react_reconciler.default)({
 		return false;
 	},
 	supportsMutation: true,
-	isPrimaryRenderer: true,
+	isPrimaryRenderer: false,
 	supportsPersistence: false,
 	supportsHydration: false,
 	scheduleTimeout: setTimeout,
@@ -17883,20 +18036,24 @@ const Renderer = (0, import_react_reconciler.default)({
 });
 //#endregion
 //#region src/utils.ts
+function toBool$1(val) {
+	return val ?? false;
+}
+__name(toBool$1, "toBool");
 /**
 * Collect the text and nested AST-node children of a single kubb-* element.
 *
-* `#text` children become raw {@link TextNode}s; nested `kubb-function`, `kubb-const`,
+* `#text` children become raw text nodes. Nested `kubb-function`, `kubb-const`,
 * `kubb-type`, and similar elements are converted into their respective {@link CodeNode}s.
-* Any unrecognized DOM elements are silently skipped.
+* Any unrecognized element names are silently skipped.
 */
-function collectChildNodes(element) {
+function collectCodeNodes$1(element) {
 	const result = [];
 	for (const child of element.childNodes) {
 		if (!child) continue;
 		if (child.nodeName === "#text") {
 			const text = child.nodeValue;
-			if (text && text.trim().length > 0) result.push(createText(text));
+			if (text && text.trim()) result.push(createText(text));
 			continue;
 		}
 		if (child.nodeName === "br") {
@@ -17906,164 +18063,162 @@ function collectChildNodes(element) {
 		if (child.nodeName === "kubb-function") {
 			const attrs = child.attributes;
 			result.push(createFunction({
-				name: attrs.get("name"),
-				params: attrs.get("params"),
-				export: attrs.get("export"),
-				default: attrs.get("default"),
-				async: attrs.get("async"),
-				generics: attrs.get("generics"),
-				returnType: attrs.get("returnType"),
-				JSDoc: attrs.get("JSDoc"),
-				nodes: collectChildNodes(child)
+				name: attrs["name"],
+				params: attrs["params"],
+				export: attrs["export"],
+				default: attrs["default"],
+				async: attrs["async"],
+				generics: attrs["generics"],
+				returnType: attrs["returnType"],
+				JSDoc: attrs["JSDoc"],
+				nodes: collectCodeNodes$1(child)
 			}));
-		} else if (child.nodeName === "kubb-arrow-function") {
+			continue;
+		}
+		if (child.nodeName === "kubb-arrow-function") {
 			const attrs = child.attributes;
 			result.push(createArrowFunction({
-				name: attrs.get("name"),
-				params: attrs.get("params"),
-				export: attrs.get("export"),
-				default: attrs.get("default"),
-				async: attrs.get("async"),
-				generics: attrs.get("generics"),
-				returnType: attrs.get("returnType"),
-				singleLine: attrs.get("singleLine"),
-				JSDoc: attrs.get("JSDoc"),
-				nodes: collectChildNodes(child)
+				name: attrs["name"],
+				params: attrs["params"],
+				export: attrs["export"],
+				default: attrs["default"],
+				async: attrs["async"],
+				generics: attrs["generics"],
+				returnType: attrs["returnType"],
+				singleLine: attrs["singleLine"],
+				JSDoc: attrs["JSDoc"],
+				nodes: collectCodeNodes$1(child)
 			}));
-		} else if (child.nodeName === "kubb-const") {
+			continue;
+		}
+		if (child.nodeName === "kubb-const") {
 			const attrs = child.attributes;
 			result.push(createConst({
-				name: attrs.get("name"),
-				type: attrs.get("type"),
-				export: attrs.get("export"),
-				asConst: attrs.get("asConst"),
-				JSDoc: attrs.get("JSDoc"),
-				nodes: collectChildNodes(child)
+				name: attrs["name"],
+				type: attrs["type"],
+				export: attrs["export"],
+				asConst: attrs["asConst"],
+				JSDoc: attrs["JSDoc"],
+				nodes: collectCodeNodes$1(child)
 			}));
-		} else if (child.nodeName === "kubb-type") {
+			continue;
+		}
+		if (child.nodeName === "kubb-type") {
 			const attrs = child.attributes;
 			result.push(createType({
-				name: attrs.get("name"),
-				export: attrs.get("export"),
-				JSDoc: attrs.get("JSDoc"),
-				nodes: collectChildNodes(child)
+				name: attrs["name"],
+				export: attrs["export"],
+				JSDoc: attrs["JSDoc"],
+				nodes: collectCodeNodes$1(child)
 			}));
-		} else if (child.nodeName === "kubb-jsx") {
+			continue;
+		}
+		if (child.nodeName === "kubb-jsx") {
 			const textChild = child.childNodes[0];
 			const value = textChild?.nodeName === "#text" ? textChild.nodeValue : "";
 			if (value) result.push(createJsx(value));
+			continue;
 		}
 	}
 	return result;
 }
+__name(collectCodeNodes$1, "collectCodeNodes");
 /**
-* Traverse `node` and collect all `<kubb-source>` elements into a `Set<SourceNode>`.
+* Yields every {@link SourceNode}, {@link ExportNode}, and {@link ImportNode}
+* within a `<kubb-file>` subtree in a single tree walk.
 *
-* Elements whose `nodeName` is in `ignores` are skipped entirely (including their subtrees).
-* This is used to collect source blocks from a file node while excluding import/export subtrees.
-*
-* @example Collect sources while ignoring export and import elements
-* ```ts
-* const sources = squashSourceNodes(fileElement, ['kubb-export', 'kubb-import'])
-* ```
+* Import and export elements are leaf nodes. Once yielded, the walker does not
+* recurse into them, which also prevents source collection from descending into
+* their subtrees. Dispatch on `.kind` (`'Source'`, `'Export'`, `'Import'`) to
+* separate the results.
 */
-function squashSourceNodes(node, ignores) {
-	const ignoreSet = new Set(ignores);
-	const sources = /* @__PURE__ */ new Set();
-	const walk = (current) => {
-		for (const child of current.childNodes) {
-			if (!child) continue;
-			if (child.nodeName !== "#text" && ignoreSet.has(child.nodeName)) continue;
-			if (child.nodeName === "kubb-source") {
-				const source = createSource({
-					name: child.attributes.get("name")?.toString(),
-					isTypeOnly: child.attributes.get("isTypeOnly") ?? false,
-					isExportable: child.attributes.get("isExportable") ?? false,
-					isIndexable: child.attributes.get("isIndexable") ?? false,
-					nodes: collectChildNodes(child)
-				});
-				sources.add(source);
-				continue;
-			}
-			if (child.nodeName !== "#text" && nodeNames.has(child.nodeName)) walk(child);
+function* collectFileEntries(node) {
+	for (const child of node.childNodes) {
+		if (!child || child.nodeName === "#text") continue;
+		if (child.nodeName === "kubb-source") {
+			yield createSource({
+				name: child.attributes["name"]?.toString(),
+				isTypeOnly: toBool$1(child.attributes["isTypeOnly"]),
+				isExportable: toBool$1(child.attributes["isExportable"]),
+				isIndexable: toBool$1(child.attributes["isIndexable"]),
+				nodes: collectCodeNodes$1(child)
+			});
+			continue;
 		}
-	};
-	walk(node);
-	return sources;
+		if (child.nodeName === "kubb-export") {
+			yield createExport({
+				name: child.attributes["name"],
+				path: child.attributes["path"],
+				isTypeOnly: toBool$1(child.attributes["isTypeOnly"]),
+				asAlias: toBool$1(child.attributes["asAlias"])
+			});
+			continue;
+		}
+		if (child.nodeName === "kubb-import") {
+			yield createImport({
+				name: child.attributes["name"],
+				path: child.attributes["path"],
+				root: child.attributes["root"],
+				isTypeOnly: toBool$1(child.attributes["isTypeOnly"]),
+				isNameSpace: toBool$1(child.attributes["isNameSpace"])
+			});
+			continue;
+		}
+		if (nodeNames.has(child.nodeName)) yield* collectFileEntries(child);
+	}
 }
 /**
-* Traverse `node` and collect all `<kubb-export>` elements into a `Set<ExportNode>`.
+* Runs a single {@link collectFileEntries} pass over a `<kubb-file>` DOM element
+* and assembles the result into a {@link FileNode}, bucketing each yielded
+* node by its `.kind`.
 */
-function squashExportNodes(node) {
-	const exports = /* @__PURE__ */ new Set();
-	const walk = (current) => {
-		for (const child of current.childNodes) {
-			if (!child) continue;
-			if (child.nodeName !== "#text" && nodeNames.has(child.nodeName)) walk(child);
-			if (child.nodeName === "kubb-export") exports.add(createExport({
-				name: child.attributes.get("name"),
-				path: child.attributes.get("path"),
-				isTypeOnly: child.attributes.get("isTypeOnly") ?? false,
-				asAlias: child.attributes.get("asAlias") ?? false
-			}));
+function createFileNode(child) {
+	const sources = [];
+	const exports = [];
+	const imports = [];
+	for (const node of collectFileEntries(child)) {
+		if (node.kind === "Source") {
+			sources.push(node);
+			continue;
+		}
+		if (node.kind === "Export") {
+			exports.push(node);
+			continue;
 		}
+		imports.push(node);
+	}
+	return {
+		baseName: child.attributes["baseName"],
+		path: child.attributes["path"],
+		meta: child.attributes["meta"] || {},
+		footer: child.attributes["footer"],
+		banner: child.attributes["banner"],
+		sources,
+		exports,
+		imports
 	};
-	walk(node);
-	return exports;
 }
 /**
-* Traverse `node` and collect all `<kubb-import>` elements into a `Set<ImportNode>`.
+* Yields each {@link FileNode} as it is encountered during the tree walk,
+* without collecting into an intermediate array. Callers can begin processing
+* each file before the rest of the tree is traversed.
 */
-function squashImportNodes(node) {
-	const imports = /* @__PURE__ */ new Set();
-	const walk = (current) => {
-		for (const child of current.childNodes) {
-			if (!child) continue;
-			if (child.nodeName !== "#text" && nodeNames.has(child.nodeName)) walk(child);
-			if (child.nodeName === "kubb-import") imports.add(createImport({
-				name: child.attributes.get("name"),
-				path: child.attributes.get("path"),
-				root: child.attributes.get("root"),
-				isTypeOnly: child.attributes.get("isTypeOnly") ?? false,
-				isNameSpace: child.attributes.get("isNameSpace") ?? false
-			}));
-		}
-	};
-	walk(node);
-	return imports;
+function* streamFiles(node) {
+	for (const child of node.childNodes) {
+		if (!child) continue;
+		if (child.nodeName !== "#text" && child.nodeName !== "kubb-file" && nodeNames.has(child.nodeName)) yield* streamFiles(child);
+		if (child.nodeName === "kubb-file" && child.attributes["baseName"] !== void 0 && child.attributes["path"] !== void 0) yield createFileNode(child);
+	}
 }
 /**
 * Walk the virtual DOM tree rooted at `node` and convert every `<kubb-file>` element
 * into a {@link FileNode}, collecting its source blocks, imports, and exports.
 *
-* Returns the list of file nodes in document order. Nested files are supported —
+* Returns the list of file nodes in document order. Nested files are supported;
 * the walker descends into non-file elements and recurses through them.
 */
-function processFiles(node) {
-	const collected = [];
-	function walk(current) {
-		for (const child of current.childNodes) {
-			if (!child) continue;
-			if (child.nodeName !== "#text" && child.nodeName !== "kubb-file" && nodeNames.has(child.nodeName)) walk(child);
-			if (child.nodeName === "kubb-file") {
-				if (child.attributes.has("baseName") && child.attributes.has("path")) {
-					const sources = squashSourceNodes(child, ["kubb-export", "kubb-import"]);
-					collected.push({
-						baseName: child.attributes.get("baseName"),
-						path: child.attributes.get("path"),
-						meta: child.attributes.get("meta") || {},
-						footer: child.attributes.get("footer"),
-						banner: child.attributes.get("banner"),
-						sources: [...sources],
-						exports: [...squashExportNodes(child)],
-						imports: [...squashImportNodes(child)]
-					});
-				}
-			}
-		}
-	}
-	walk(node);
-	return collected;
+function collectFiles(node) {
+	return [...streamFiles(node)];
 }
 //#endregion
 //#region src/Runtime.tsx
@@ -18075,7 +18230,7 @@ var Runtime = class {
 	nodes = [];
 	#container;
 	#rootNode;
-	constructor(options) {
+	constructor(options = {}) {
 		this.#options = options;
 		this.#rootNode = createNode("kubb-root");
 		this.#rootNode.onRender = this.onRender;
@@ -18088,7 +18243,7 @@ var Runtime = class {
 			console.log(data);
 		};
 		const logRecoverableError = typeof reportError === "function" ? reportError : console.error;
-		const rootTag = import_constants.ConcurrentRoot;
+		const rootTag = import_constants.LegacyRoot;
 		this.#container = Renderer.createContainer(this.#rootNode, rootTag, null, false, false, "id", logRecoverableError, logRecoverableError, logRecoverableError, null);
 		this.unsubscribeExit = onProcessExit((code) => {
 			this.unmount(code);
@@ -18101,7 +18256,7 @@ var Runtime = class {
 	onRender = () => {
 		const task = this.#renderPromise.catch(() => {}).then(() => {
 			if (this.#isUnmounted) return;
-			const files = processFiles(this.#rootNode);
+			const files = collectFiles(this.#rootNode);
 			this.nodes.push(...files);
 			if (!this.#options?.debug) return;
 		});
@@ -18146,75 +18301,342 @@ var Runtime = class {
 		}
 		this.resolveExitPromise();
 	}
-	async waitUntilExit() {
-		if (!this.exitPromise) this.exitPromise = new Promise((resolve, reject) => {
-			this.resolveExitPromise = resolve;
-			this.rejectExitPromise = reject;
-		});
-		return this.exitPromise;
+};
+//#endregion
+//#region src/SyncRuntime.tsx
+/**
+* Walks `element`, resolving arrays, Fragments, and function components
+* transparently, then calls `onText` for primitive values and `onHost` for
+* every host element encountered. Pure function components are called
+* synchronously. Hooks and class components are not supported.
+*/
+function walkElement(element, onText, onHost) {
+	if (element == null || typeof element === "boolean") return;
+	if (typeof element === "string" || typeof element === "number" || typeof element === "bigint") {
+		onText(String(element));
+		return;
+	}
+	if (Array.isArray(element)) {
+		for (const child of element) walkElement(child, onText, onHost);
+		return;
+	}
+	if (typeof element === "object" && "$$typeof" in element) {
+		const el = element;
+		const { type } = el;
+		const props = el.props;
+		if (type === import_react.Fragment) {
+			walkElement(props["children"], onText, onHost);
+			return;
+		}
+		if (typeof type === "function") {
+			walkElement(type(props), onText, onHost);
+			return;
+		}
+		if (typeof type === "string") onHost(type, props);
+	}
+}
+function toBool(val) {
+	return val ?? false;
+}
+function collectCodeNodes(props) {
+	const nodes = [];
+	collectCode(props["children"], nodes);
+	return nodes;
+}
+function collectCode(element, nodes) {
+	walkElement(element, (text) => {
+		if (text.trim()) nodes.push(createText(text));
+	}, (type, props) => resolveCodeNode(type, props, nodes));
+}
+function resolveCodeNode(type, props, nodes) {
+	if (type === "br") {
+		nodes.push(createBreak());
+		return;
+	}
+	if (type === "kubb-jsx") {
+		let value = "";
+		walkElement(props["children"], (t) => {
+			value += t;
+		}, () => {});
+		if (value) nodes.push(createJsx(value));
+		return;
+	}
+	if (type === "kubb-function") {
+		nodes.push(createFunction({
+			name: props["name"],
+			params: props["params"],
+			export: props["export"],
+			default: props["default"],
+			async: props["async"],
+			generics: props["generics"],
+			returnType: props["returnType"],
+			JSDoc: props["JSDoc"],
+			nodes: collectCodeNodes(props)
+		}));
+		return;
+	}
+	if (type === "kubb-arrow-function") {
+		nodes.push(createArrowFunction({
+			name: props["name"],
+			params: props["params"],
+			export: props["export"],
+			default: props["default"],
+			async: props["async"],
+			generics: props["generics"],
+			returnType: props["returnType"],
+			singleLine: props["singleLine"],
+			JSDoc: props["JSDoc"],
+			nodes: collectCodeNodes(props)
+		}));
+		return;
+	}
+	if (type === "kubb-const") {
+		nodes.push(createConst({
+			name: props["name"],
+			type: props["type"],
+			export: props["export"],
+			asConst: props["asConst"],
+			JSDoc: props["JSDoc"],
+			nodes: collectCodeNodes(props)
+		}));
+		return;
+	}
+	if (type === "kubb-type") {
+		nodes.push(createType({
+			name: props["name"],
+			export: props["export"],
+			JSDoc: props["JSDoc"],
+			nodes: collectCodeNodes(props)
+		}));
+		return;
+	}
+}
+function collectFileChildren(element) {
+	const sources = [];
+	const exports = [];
+	const imports = [];
+	walkElement(element, (text) => {
+		if (text.trim()) throw new Error(`[react] '${text}' should be part of <File.Source> component when using the <File/> component`);
+	}, (type, props) => {
+		if (type === "kubb-source") {
+			sources.push(createSource({
+				name: props["name"]?.toString(),
+				isTypeOnly: toBool(props["isTypeOnly"]),
+				isExportable: toBool(props["isExportable"]),
+				isIndexable: toBool(props["isIndexable"]),
+				nodes: collectCodeNodes(props)
+			}));
+			return;
+		}
+		if (type === "kubb-export") {
+			exports.push(createExport({
+				name: props["name"],
+				path: props["path"],
+				isTypeOnly: toBool(props["isTypeOnly"]),
+				asAlias: toBool(props["asAlias"])
+			}));
+			return;
+		}
+		if (type === "kubb-import") {
+			imports.push(createImport({
+				name: props["name"],
+				path: props["path"],
+				root: props["root"],
+				isTypeOnly: toBool(props["isTypeOnly"]),
+				isNameSpace: toBool(props["isNameSpace"])
+			}));
+			return;
+		}
+		const nested = collectFileChildren(props["children"]);
+		sources.push(...nested.sources);
+		exports.push(...nested.exports);
+		imports.push(...nested.imports);
+	});
+	return {
+		sources,
+		exports,
+		imports
+	};
+}
+function* walkFiles(element) {
+	if (element == null || typeof element === "boolean") return;
+	if (typeof element === "string" || typeof element === "number" || typeof element === "bigint") return;
+	if (Array.isArray(element)) {
+		for (const child of element) yield* walkFiles(child);
+		return;
+	}
+	if (typeof element === "object" && "$$typeof" in element) {
+		const el = element;
+		const { type } = el;
+		const props = el.props;
+		if (type === import_react.Fragment) {
+			yield* walkFiles(props["children"]);
+			return;
+		}
+		if (typeof type === "function") {
+			yield* walkFiles(type(props));
+			return;
+		}
+		if (typeof type === "string") if (type === "kubb-file" && props["baseName"] !== void 0 && props["path"] !== void 0) {
+			const { sources, exports, imports } = collectFileChildren(props["children"]);
+			yield {
+				baseName: props["baseName"],
+				path: props["path"],
+				meta: props["meta"] || {},
+				footer: props["footer"],
+				banner: props["banner"],
+				sources,
+				exports,
+				imports
+			};
+		} else yield* walkFiles(props["children"]);
+	}
+}
+/**
+* Synchronous JSX renderer that walks the element tree in a single pass,
+* producing {@link FileNode} objects directly without an intermediate virtual
+* DOM. No React fiber, scheduler, or work loop is involved.
+*
+* All components must be pure functions. Hooks and class components are not
+* supported. Produces identical output to the React-backed {@link Runtime} at
+* approximately 2, 4× the speed and a fraction of the allocations.
+*/
+var SyncRuntime = class {
+	/**
+	* Accumulated {@link FileNode} results from every {@link render} call.
+	*/
+	nodes = [];
+	/**
+	* Walks `element` synchronously, converts every `<kubb-file>` subtree into
+	* a {@link FileNode} with no intermediate virtual DOM, and appends the results
+	* to {@link nodes}.
+	*/
+	render(element) {
+		for (const file of walkFiles(element)) this.nodes.push(file);
+	}
+	/**
+	* Walks `element` synchronously and yields each {@link FileNode} as it is
+	* produced, without buffering into an intermediate array first. Callers can
+	* begin processing each file before the rest of the element tree is traversed.
+	*
+	* @example
+	* ```ts
+	* for (const file of runtime.stream(element)) {
+	*   await writeFile(file)
+	* }
+	* ```
+	*/
+	*stream(element) {
+		yield* walkFiles(element);
 	}
 };
 //#endregion
 //#region src/createRenderer.tsx
 /**
-* Create a Kubb JSX renderer.
+* Renderer factory that turns the JSX produced by a generator into
+* `FileNode`s using React's reconciler under the hood. Pass as the `renderer`
+* property on `defineGenerator`. Kubb core stays generic, with no hard
+* dependency on `@kubb/renderer-jsx`.
 *
-* The renderer converts a React JSX element tree — built from the components in this
-* package — into an array of {@link FileNode} entries representing the generated files.
+* Use this when generators rely on React features (hooks, suspense, context).
+* For pure-function components, see {@link jsxRendererSync} for ~2-4× faster
+* rendering.
 *
-* @example Basic usage
-* ```ts
-* import { createRenderer, File } from '@kubb/renderer-jsx'
+* @example Wire up a JSX generator
+* ```tsx
+* import { defineGenerator } from '@kubb/core'
+* import { jsxRenderer } from '@kubb/renderer-jsx'
 *
-* const renderer = createRenderer()
-* await renderer.render(
-*   <File baseName="pet.ts" path="src/models/pet.ts">
-*     <File.Source name="Pet" isExportable isIndexable>
-*       {`export type Pet = { id: number; name: string }`}
-*     </File.Source>
-*   </File>
-* )
-* console.log(renderer.files) // [FileNode]
-* renderer.unmount()
+* export const myGenerator = defineGenerator<PluginTs>({
+*   name: 'types',
+*   renderer: jsxRenderer,
+*   schema(node, ctx) {
+*     return (
+*       <File baseName="output.ts" path={`${ctx.root}/output.ts`}>
+*         <Type node={node} resolver={ctx.resolver} />
+*       </File>
+*     )
+*   },
+* })
 * ```
 */
-function createRenderer(options = {}) {
-	const runtime = new Runtime(options);
+const jsxRenderer = () => {
+	const runtime = new Runtime();
 	return {
-		async render(Element) {
-			await runtime.render(Element);
+		async render(element) {
+			await runtime.render(element);
 		},
 		get files() {
 			return runtime.nodes;
 		},
+		dispose() {
+			runtime.unmount();
+		},
 		unmount(error) {
 			runtime.unmount(error);
+		},
+		[Symbol.dispose]() {
+			this.dispose();
 		}
 	};
-}
+};
 /**
-* A renderer factory for generators that produce JSX output.
+* Lightweight renderer that walks the JSX tree in a single recursive pass,  * no React reconciler, no scheduler. Drop-in replacement for
+* {@link jsxRenderer} at roughly 2, 4× the throughput.
 *
-* Pass this as the `renderer` property of a `defineGenerator` call so that
-* core can render the JSX element tree returned by your generator methods
-* without a hard dependency on `@kubb/renderer-jsx`.
+* Constraints: every component must be a pure function. Hooks, suspense, and
+* class components are not supported.
 *
-* @example
-* ```ts
-* import { jsxRenderer } from '@kubb/renderer-jsx'
+* Use this for generators that produce large amounts of output and do not need
+* React's runtime features. It also exposes `stream()` for incremental file
+* emission.
+*
+* @example Drop-in faster renderer
+* ```tsx
 * import { defineGenerator } from '@kubb/core'
+* import { jsxRendererSync } from '@kubb/renderer-jsx'
 *
 * export const myGenerator = defineGenerator<PluginTs>({
-*   name: 'my-generator',
-*   renderer: jsxRenderer,
-*   schema(node, options) {
-*     return <File baseName="output.ts" path="src/output.ts">...</File>
+*   name: 'types',
+*   renderer: jsxRendererSync,
+*   schema(node, ctx) {
+*     return (
+*       <File baseName="output.ts" path={`${ctx.root}/output.ts`}>
+*         <Type node={node} resolver={ctx.resolver} />
+*       </File>
+*     )
 *   },
 * })
 * ```
+*
+* @example Stream files as they are produced
+* ```tsx
+* const renderer = jsxRendererSync()
+* for (const file of renderer.stream(element)) {
+*   await writeFile(file.path, file.sources[0])
+* }
+* ```
 */
-const jsxRenderer = () => createRenderer();
+const jsxRendererSync = () => {
+	const runtime = new SyncRuntime();
+	return {
+		async render(element) {
+			runtime.render(element);
+		},
+		get files() {
+			return runtime.nodes;
+		},
+		stream(element) {
+			return runtime.stream(element);
+		},
+		dispose() {},
+		unmount(_error) {},
+		[Symbol.dispose]() {
+			this.dispose();
+		}
+	};
+};
 //#endregion
-export { Const, File, Function$1 as Function, Jsx, Root, Type, createContext, createRenderer, inject, jsxRenderer, provide, unprovide };
+export { Callout, CodeBlock, Const, File, Frontmatter, Function$1 as Function, Heading, Jsx, List, Paragraph, Root, Type, createContext, inject, jsxRenderer, jsxRendererSync, provide, unprovide };
 
 //# sourceMappingURL=index.js.map