@kubb/renderer-jsx 5.0.0-beta.2 → 5.0.0-beta.20

package/dist/index.js

@@ -4,14 +4,17 @@ import { Fragment, jsx } from "./jsx-runtime.js";
 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)
 *
@@ -343,7 +346,7 @@ function Jsx({ children }) {
 Jsx.displayName = "Jsx";
 //#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";
@@ -481,7 +484,7 @@ const nodeNames = new Set([
 const createNode = (nodeName) => {
 	return {
 		nodeName,
-		attributes: /* @__PURE__ */ new Map(),
+		attributes: Object.create(null),
 		childNodes: [],
 		parentNode: void 0
 	};
@@ -529,26 +532,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
 	};
-	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
@@ -17817,7 +17816,7 @@ const Renderer = (0, import_react_reconciler.default)({
 		return false;
 	},
 	supportsMutation: true,
-	isPrimaryRenderer: true,
+	isPrimaryRenderer: false,
 	supportsPersistence: false,
 	supportsHydration: false,
 	scheduleTimeout: setTimeout,
@@ -17883,20 +17882,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 +17909,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 +18076,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 +18089,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 +18102,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,43 +18147,260 @@ 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 for generators that produce JSX output.
 *
-* 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.
+* Pass as the `renderer` property of `defineGenerator`. Core drives rendering
+* without a hard dependency on `@kubb/renderer-jsx`.
 *
-* @example Basic usage
+* @example
 * ```ts
-* import { createRenderer, File } from '@kubb/renderer-jsx'
+* 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>({
+*   renderer: jsxRenderer,
+*   schema(node, options) {
+*     return <File baseName="output.ts" path="src/output.ts">...</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;
@@ -18191,30 +18409,49 @@ function createRenderer(options = {}) {
 			runtime.unmount(error);
 		}
 	};
-}
+};
 /**
-* A renderer factory for generators that produce JSX output.
+* Lightweight renderer factory with no React fiber, scheduler, or work loop.
 *
-* 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`.
+* Walks the JSX element tree in a single recursive pass. All components must be
+* pure functions; hooks and class components are not supported. Drop-in
+* replacement for {@link jsxRenderer} at approximately 2–4× the speed.
 *
-* @example
+* @example Drop-in replacement
 * ```ts
-* import { jsxRenderer } from '@kubb/renderer-jsx'
-* import { defineGenerator } from '@kubb/core'
+* import { jsxRendererSync } from '@kubb/renderer-jsx'
 *
 * export const myGenerator = defineGenerator<PluginTs>({
-*   name: 'my-generator',
-*   renderer: jsxRenderer,
+*   renderer: jsxRendererSync,
 *   schema(node, options) {
 *     return <File baseName="output.ts" path="src/output.ts">...</File>
 *   },
 * })
 * ```
+*
+* @example Stream files as they are produced
+* ```ts
+* for await (const file of jsxRendererSync().stream(element)) {
+*   await writeFile(file)
+* }
+* ```
 */
-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);
+		},
+		unmount(_error) {}
+	};
+};
 //#endregion
-export { Const, File, Function$1 as Function, Jsx, Root, Type, createContext, createRenderer, inject, jsxRenderer, provide, unprovide };
+export { Const, File, Function$1 as Function, Jsx, Root, Type, createContext, inject, jsxRenderer, jsxRendererSync, provide, unprovide };
 
 //# sourceMappingURL=index.js.map