@kubb/ast 5.0.0-beta.8 → 5.0.0-beta.81

package/dist/index.js

@@ -1,36 +1,15 @@
-import "./chunk--u3MIqq1.js";
-import { createHash } from "node:crypto";
+import { t as __exportAll } from "./rolldown-runtime-CNktS9qV.js";
+import { hash } from "node:crypto";
 import path from "node:path";
 //#region src/constants.ts
 const visitorDepths = {
 	shallow: "shallow",
 	deep: "deep"
 };
-const nodeKinds = {
-	input: "Input",
-	output: "Output",
-	operation: "Operation",
-	schema: "Schema",
-	property: "Property",
-	parameter: "Parameter",
-	response: "Response",
-	functionParameter: "FunctionParameter",
-	parameterGroup: "ParameterGroup",
-	functionParameters: "FunctionParameters",
-	type: "Type",
-	file: "File",
-	import: "Import",
-	export: "Export",
-	source: "Source",
-	text: "Text",
-	break: "Break"
-};
 /**
 * Schema type discriminators used by all AST schema nodes.
 *
-* These values serve as stable discriminators across the AST (e.g., `schema.type === schemaTypes.object`).
-* Grouped by category: primitives (`string`, `number`, `boolean`), structural types (`object`, `array`, `union`),
-* and format-specific types (`date`, `uuid`, `email`). Use `isScalarPrimitive()` to check for scalar types.
+* Each value is a stable discriminator across the AST (for example `schema.type === schemaTypes.object`).
 */
 const schemaTypes = {
 	/**
@@ -50,7 +29,7 @@ const schemaTypes = {
 	*/
 	bigint: "bigint",
 	/**
-	* Boolean value
+	* Boolean value.
 	*/
 	boolean: "boolean",
 	/**
@@ -138,68 +117,242 @@ const schemaTypes = {
 	*/
 	never: "never"
 };
+//#endregion
+//#region src/defineDialect.ts
 /**
-* Scalar primitive schema types used for union simplification and type narrowing.
+* Types a {@link Dialect} for an adapter. Adds no runtime behavior and only pins the
+* dialect's type for inference.
 *
-* Use `isScalarPrimitive()` to safely check whether a type is a scalar primitive.
+* @example
+* ```ts
+* export const oasDialect = defineDialect({
+*   name: 'oas',
+*   schema: {
+*     isNullable,
+*     isReference,
+*     isDiscriminator,
+*     isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',
+*     resolveRef,
+*   },
+* })
+* ```
 */
-const SCALAR_PRIMITIVE_TYPES = new Set([
-	"string",
-	"number",
-	"integer",
-	"bigint",
-	"boolean"
-]);
+function defineDialect(dialect) {
+	return dialect;
+}
+//#endregion
+//#region src/guards.ts
 /**
-* Type guard that returns `true` when `type` is a scalar primitive schema type.
+* Narrows a `SchemaNode` to the variant that matches `type`.
 *
-* Use this to check if a schema type can be directly assigned without wrapping (e.g., `string | number | boolean`).
+* @example
+* ```ts
+* const schema = createSchema({ type: 'string' })
+* const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | null
+* ```
 */
-function isScalarPrimitive(type) {
-	return SCALAR_PRIMITIVE_TYPES.has(type);
+function narrowSchema(node, type) {
+	return node?.type === type ? node : null;
 }
 /**
-* HTTP method identifiers used by operation nodes.
+* Narrows an `OperationNode` to an `HttpOperationNode` so `method` and `path` are present.
 *
-* Includes all standard HTTP methods (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS, TRACE).
+* @example
+* ```ts
+* if (isHttpOperationNode(node)) {
+*   console.log(node.method, node.path)
+* }
+* ```
 */
-const httpMethods = {
-	get: "GET",
-	post: "POST",
-	put: "PUT",
-	patch: "PATCH",
-	delete: "DELETE",
-	head: "HEAD",
-	options: "OPTIONS",
-	trace: "TRACE"
-};
+function isHttpOperationNode(node) {
+	return node.protocol === "http" || node.method !== void 0 && node.path !== void 0;
+}
+//#endregion
+//#region src/defineNode.ts
 /**
-* Common MIME types used in request/response content negotiation.
-*
-* Covers JSON, XML, form data, PDFs, images, audio, and video formats.
-* Use these as keys when serializing request/response bodies.
-*/
-const mediaTypes = {
-	applicationJson: "application/json",
-	applicationXml: "application/xml",
-	applicationFormUrlEncoded: "application/x-www-form-urlencoded",
-	applicationOctetStream: "application/octet-stream",
-	applicationPdf: "application/pdf",
-	applicationZip: "application/zip",
-	applicationGraphql: "application/graphql",
-	multipartFormData: "multipart/form-data",
-	textPlain: "text/plain",
-	textHtml: "text/html",
-	textCsv: "text/csv",
-	textXml: "text/xml",
-	imagePng: "image/png",
-	imageJpeg: "image/jpeg",
-	imageGif: "image/gif",
-	imageWebp: "image/webp",
-	imageSvgXml: "image/svg+xml",
-	audioMpeg: "audio/mpeg",
-	videoMp4: "video/mp4"
-};
+* Visitor callback names, one per traversable node kind, in traversal order.
+* Kept in sync with the keys of `Visitor` in `visitor.ts`.
+*/
+const visitorKeys = [
+	"input",
+	"output",
+	"operation",
+	"schema",
+	"property",
+	"parameter",
+	"response"
+];
+/**
+* Builds a type guard that matches nodes of the given `kind`.
+*/
+function isKind(kind) {
+	return (node) => node?.kind === kind;
+}
+/**
+* Defines a node once and derives its `create` builder, `is` guard, and traversal
+* metadata. `create` merges `defaults`, the `build` hook (or the raw input), and the
+* `kind`, so node construction lives in one place without scattered `as` casts.
+*
+* @example Simple node
+* ```ts
+* const importDef = defineNode<ImportNode>({ kind: 'Import' })
+* const createImport = importDef.create
+* ```
+*
+* @example Node with a build hook
+* ```ts
+* const propertyDef = defineNode<PropertyNode, UserPropertyNode>({
+*   kind: 'Property',
+*   build: (props) => ({ ...props, required: props.required ?? false }),
+*   children: ['schema'],
+*   visitorKey: 'property',
+* })
+* ```
+*/
+function defineNode(config) {
+	const { kind, defaults, build, children, visitorKey } = config;
+	function create(input) {
+		const base = build ? build(input) : input;
+		const node = {
+			kind,
+			...defaults,
+			...base
+		};
+		node.kind = kind;
+		return node;
+	}
+	return {
+		kind,
+		create,
+		is: isKind(kind),
+		children,
+		visitorKey
+	};
+}
+//#endregion
+//#region src/nodes/code.ts
+/**
+* Definition for the {@link ConstNode}.
+*/
+const constDef = defineNode({ kind: "Const" });
+/**
+* Definition for the {@link TypeNode}.
+*/
+const typeDef = defineNode({ kind: "Type" });
+/**
+* Definition for the {@link FunctionNode}.
+*/
+const functionDef = defineNode({ kind: "Function" });
+/**
+* Definition for the {@link ArrowFunctionNode}.
+*/
+const arrowFunctionDef = defineNode({ kind: "ArrowFunction" });
+/**
+* Definition for the {@link TextNode}.
+*/
+const textDef = defineNode({
+	kind: "Text",
+	build: (value) => ({ value })
+});
+/**
+* Definition for the {@link BreakNode}.
+*/
+const breakDef = defineNode({
+	kind: "Break",
+	build: () => ({})
+});
+/**
+* Definition for the {@link JsxNode}.
+*/
+const jsxDef = defineNode({
+	kind: "Jsx",
+	build: (value) => ({ value })
+});
+/**
+* Creates a `ConstNode` representing a TypeScript `const` declaration.
+*
+* @example Exported constant with type and `as const`
+* ```ts
+* createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
+* // export const pets: Pet[] = ... as const
+* ```
+*/
+const createConst = constDef.create;
+/**
+* Creates a `TypeNode` representing a TypeScript `type` alias declaration.
+*
+* @example
+* ```ts
+* createType({ name: 'Pet', export: true })
+* // export type Pet = ...
+* ```
+*/
+const createType = typeDef.create;
+/**
+* Creates a `FunctionNode` representing a TypeScript `function` declaration.
+*
+* @example
+* ```ts
+* createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
+* // export async function fetchPet(): Promise<Pet> { ... }
+* ```
+*/
+const createFunction = functionDef.create;
+/**
+* Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
+*
+* @example
+* ```ts
+* createArrowFunction({ name: 'double', export: true, params: 'n: number', singleLine: true })
+* // export const double = (n: number) => ...
+* ```
+*/
+const createArrowFunction = arrowFunctionDef.create;
+/**
+* Creates a {@link TextNode} representing a raw string fragment in the source output.
+*
+* @example
+* ```ts
+* createText('return fetch(id)')
+* // { kind: 'Text', value: 'return fetch(id)' }
+* ```
+*/
+const createText = textDef.create;
+/**
+* Creates a {@link BreakNode} representing a line break in the source output.
+*
+* @example
+* ```ts
+* createBreak()
+* // { kind: 'Break' }
+* ```
+*/
+function createBreak() {
+	return breakDef.create();
+}
+/**
+* Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
+*
+* @example
+* ```ts
+* createJsx('<>\n  <a href={href}>Open</a>\n</>')
+* // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
+* ```
+*/
+const createJsx = jsxDef.create;
+//#endregion
+//#region src/nodes/content.ts
+/**
+* Definition for the {@link ContentNode}.
+*/
+const contentDef = defineNode({
+	kind: "Content",
+	children: ["schema"]
+});
+/**
+* Creates a `ContentNode` for a single request-body or response content type.
+*/
+const createContent = contentDef.create;
 //#endregion
 //#region ../../internals/utils/src/casing.ts
 /**
@@ -212,57 +365,77 @@ const mediaTypes = {
 function toCamelOrPascal(text, pascal) {
 	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
 		if (word.length > 1 && word === word.toUpperCase()) return word;
-		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
-		return word.charAt(0).toUpperCase() + word.slice(1);
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
 	}).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 /**
-* Splits `text` on `.` and applies `transformPart` to each segment.
-* The last segment receives `isLast = true`, all earlier segments receive `false`.
-* Segments are joined with `/` to form a file path.
+* Converts `text` to PascalCase.
 *
-* Only splits on dots followed by a letter so that version numbers
-* embedded in operationIds (e.g. `v2025.0`) are kept intact.
+* @example Word boundaries
+* `pascalCase('hello-world') // 'HelloWorld'`
 *
-* Empty segments are filtered before joining. They arise when the text starts with
-* a dot followed immediately by a letter (e.g. `..Schema` splits into `['..', 'Schema']`
-* and `'..'` transforms to an empty string). Without this filter the join would produce
-* a leading `/`, which `path.resolve` would interpret as an absolute path, allowing
-* generated files to escape the configured output directory.
+* @example With a suffix
+* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
 */
-function applyToFileParts(text, transformPart) {
-	const parts = text.split(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).filter(Boolean).join("/");
+function pascalCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
+//#endregion
+//#region ../../internals/utils/src/fs.ts
 /**
-* Converts `text` to camelCase.
-* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
+* Strips the file extension from a path or file name.
+* Only removes the last `.ext` segment when the dot is not part of a directory name.
 *
 * @example
-* camelCase('hello-world')                   // 'helloWorld'
-* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+* trimExtName('petStore.ts')             // 'petStore'
+* trimExtName('/src/models/pet.ts')      // '/src/models/pet'
+* trimExtName('/project.v2/gen/pet.ts')  // '/project.v2/gen/pet'
+* trimExtName('noExtension')             // 'noExtension'
 */
-function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
-		prefix,
-		suffix
-	} : {}));
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+function trimExtName(text) {
+	const dotIndex = text.lastIndexOf(".");
+	if (dotIndex > 0 && !text.includes("/", dotIndex)) return text.slice(0, dotIndex);
+	return text;
 }
+//#endregion
+//#region ../../internals/utils/src/promise.ts
 /**
-* Converts `text` to PascalCase.
-* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
+* Wraps `factory` with a keyed cache backed by the provided store.
 *
-* @example
-* pascalCase('hello-world')                  // 'HelloWorld'
-* pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'
-*/
-function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => isLast ? pascalCase(part, {
-		prefix,
-		suffix
-	}) : camelCase(part));
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
+* Pass a `WeakMap` for object keys (results are GC-eligible when the key is
+* collected) or a `Map` for primitive keys. For multi-argument functions,
+* nest two `memoize` calls — the outer keyed by the first argument, the
+* inner (created once per outer miss) keyed by the second.
+*
+* Because the cache is owned by the caller, it can be shared, inspected, or
+* cleared independently of the memoized function.
+*
+* @example Single WeakMap key
+* ```ts
+* const cache = new WeakMap<SchemaNode, Set<string>>()
+* const getRefs = memoize(cache, (node) => collectRefs(node))
+* ```
+*
+* @example Single Map key (primitive)
+* ```ts
+* const cache = new Map<string, Resolver>()
+* const getResolver = memoize(cache, (name) => buildResolver(name))
+* ```
+*
+* @example Two-level (object + primitive)
+* ```ts
+* const outer = new WeakMap<Params[], Map<string, Params[]>>()
+* const fn = memoize(outer, (params) => memoize(new Map(), (key) => transform(params, key)))
+* fn(params)('camelcase')
+* ```
+*/
+function memoize(store, factory) {
+	return (key) => {
+		if (store.has(key)) return store.get(key);
+		const value = factory(key);
+		store.set(key, value);
+		return value;
+	};
 }
 //#endregion
 //#region ../../internals/utils/src/reserved.ts
@@ -270,7 +443,7 @@ function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
 * JavaScript and Java reserved words.
 * @link https://github.com/jonschlinkert/reserved/blob/master/index.js
 */
-const reservedWords = new Set([
+const reservedWords = /* @__PURE__ */ new Set([
 	"abstract",
 	"arguments",
 	"boolean",
@@ -365,740 +538,126 @@ const reservedWords = new Set([
 */
 function isValidVarName(name) {
 	if (!name || reservedWords.has(name)) return false;
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+	return isIdentifier(name);
 }
-//#endregion
-//#region ../../internals/utils/src/string.ts
 /**
-* Strips the file extension from a path or file name.
-* Only removes the last `.ext` segment when the dot is not part of a directory name.
+* Returns `true` when `name` is syntactically a valid identifier, ignoring reserved words.
+*
+* Reserved words and globals (`class`, `name`, `Date`, …) are valid as bare object-literal keys
+* even though they are not valid variable names, so use this (not {@link isValidVarName}) when
+* deciding whether an object key needs quoting.
 *
 * @example
-* trimExtName('petStore.ts')             // 'petStore'
-* trimExtName('/src/models/pet.ts')      // '/src/models/pet'
-* trimExtName('/project.v2/gen/pet.ts')  // '/project.v2/gen/pet'
-* trimExtName('noExtension')             // 'noExtension'
+* ```ts
+* isIdentifier('name')   // true
+* isIdentifier('x-total')// false
+* ```
 */
-function trimExtName(text) {
-	const dotIndex = text.lastIndexOf(".");
-	if (dotIndex > 0 && !text.includes("/", dotIndex)) return text.slice(0, dotIndex);
-	return text;
+function isIdentifier(name) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
 //#endregion
-//#region src/guards.ts
+//#region ../../internals/utils/src/string.ts
 /**
-* Narrows a `SchemaNode` to the variant that matches `type`.
+* Wraps a value in single quotes for emitting a single-quoted JavaScript string literal, escaping
+* any backslash or single quote in the content.
 *
 * @example
 * ```ts
-* const schema = createSchema({ type: 'string' })
-* const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | undefined
+* singleQuote('foo')      // "'foo'"
+* singleQuote("o'clock")  // "'o\\'clock'"
 * ```
 */
-function narrowSchema(node, type) {
-	return node?.type === type ? node : void 0;
-}
-function isKind(kind) {
-	return (node) => node.kind === kind;
+function singleQuote(value) {
+	if (value === void 0 || value === null) return "''";
+	return `'${String(value).replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
 }
+//#endregion
+//#region src/utils/extractStringsFromNodes.ts
 /**
-* Returns `true` when the input is an `InputNode`.
+* Extracts all string content from a `CodeNode` tree recursively.
 *
-* @example
-* ```ts
-* if (isInputNode(node)) {
-*   console.log(node.schemas.length)
-* }
-* ```
+* Collects text node values, identifier references in string fields (`params`, `generics`, `returnType`, `type`),
+* and nested node content. Used to build the full source string for import filtering.
 */
-const isInputNode = isKind("Input");
+function extractStringsFromNodes(nodes) {
+	if (!nodes?.length) return "";
+	const collected = [];
+	for (const node of nodes) {
+		if (typeof node === "string") {
+			if (node) collected.push(node);
+			continue;
+		}
+		if (node.kind === "Text") {
+			if (node.value) collected.push(node.value);
+			continue;
+		}
+		if (node.kind === "Break") continue;
+		if (node.kind === "Jsx") {
+			if (node.value) collected.push(node.value);
+			continue;
+		}
+		const parts = [];
+		if ("params" in node && node.params) parts.push(node.params);
+		if ("generics" in node && node.generics) parts.push(Array.isArray(node.generics) ? node.generics.join(", ") : node.generics);
+		if ("returnType" in node && node.returnType) parts.push(node.returnType);
+		if ("type" in node && typeof node.type === "string") parts.push(node.type);
+		const nested = extractStringsFromNodes(node.nodes);
+		if (nested) parts.push(nested);
+		if (parts.length) collected.push(parts.join("\n"));
+	}
+	return collected.join("\n");
+}
+//#endregion
+//#region src/utils/fileMerge.ts
+function sourceKey(source) {
+	return `${source.name ?? extractStringsFromNodes(source.nodes)}:${source.isExportable ?? false}:${source.isTypeOnly ?? false}`;
+}
+function pathTypeKey(path, isTypeOnly) {
+	return `${path}:${isTypeOnly ?? false}`;
+}
+function exportKey(path, name, isTypeOnly, asAlias) {
+	return `${path}:${name ?? ""}:${isTypeOnly ?? false}:${asAlias ?? ""}`;
+}
+function importKey(path, name, isTypeOnly) {
+	return `${path}:${name ?? ""}:${isTypeOnly ?? false}`;
+}
 /**
-* Returns `true` when the input is an `OutputNode`.
-*
-* @example
-* ```ts
-* if (isOutputNode(node)) {
-*   console.log(node.files.length)
-* }
-* ```
+* Computes a multi-level sort key for exports and imports:
+* non-array names first (wildcards/namespace aliases). Type-only before value. Alphabetical path. Unnamed before named.
 */
-const isOutputNode = isKind("Output");
+function sortKey(node) {
+	const isArray = Array.isArray(node.name) ? "1" : "0";
+	const typeOnly = node.isTypeOnly ? "0" : "1";
+	const hasName = node.name != null ? "1" : "0";
+	const name = Array.isArray(node.name) ? node.name.toSorted().join("\0") : node.name ?? "";
+	return `${isArray}:${typeOnly}:${node.path}:${hasName}:${name}`;
+}
 /**
-* Returns `true` when the input is an `OperationNode`.
-*
-* @example
-* ```ts
-* if (isOperationNode(node)) {
-*   console.log(node.operationId)
-* }
-* ```
+* Deduplicates `SourceNode` objects by `name + isExportable + isTypeOnly`, keeping the first of each
+* key. Unnamed sources fall back to their extracted node strings as the name part of the key. Returns
+* the deduplicated array in original order.
 */
-const isOperationNode = isKind("Operation");
+function combineSources(sources) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		const key = sourceKey(source);
+		if (!seen.has(key)) seen.set(key, source);
+	}
+	return [...seen.values()];
+}
 /**
-* Returns `true` when the input is a `SchemaNode`.
+* Merges `incoming` names into `existing`, preserving order and dropping duplicates.
 *
-* @example
-* ```ts
-* if (isSchemaNode(node)) {
-*   console.log(node.type)
-* }
-* ```
+* Shared by `combineExports` and `combineImports` for the same-path name-merge case.
 */
-const isSchemaNode = isKind("Schema");
-//#endregion
-//#region src/refs.ts
+function mergeNameArrays(existing, incoming) {
+	const merged = new Set(existing);
+	for (const name of incoming) merged.add(name);
+	return [...merged];
+}
 /**
-* Returns the last path segment of a reference string.
-*
-* Example: `#/components/schemas/Pet` becomes `Pet`.
-*
-* @example
-* ```ts
-* extractRefName('#/components/schemas/Pet') // 'Pet'
-* ```
-*/
-function extractRefName(ref) {
-	return ref.split("/").at(-1) ?? ref;
-}
-//#endregion
-//#region src/visitor.ts
-/**
-* Creates a small async concurrency limiter.
-*
-* At most `concurrency` tasks are in flight at once. Extra tasks are queued.
-*
-* @example
-* ```ts
-* const limit = createLimit(2)
-* for (const task of [taskA, taskB, taskC]) {
-*   await limit(() => task())
-* }
-* // only 2 tasks run at the same time
-* ```
-*/
-function createLimit(concurrency) {
-	let active = 0;
-	const queue = [];
-	function next() {
-		if (active < concurrency && queue.length > 0) {
-			active++;
-			queue.shift()();
-		}
-	}
-	return function limit(fn) {
-		return new Promise((resolve, reject) => {
-			queue.push(() => {
-				Promise.resolve(fn()).then(resolve, reject).finally(() => {
-					active--;
-					next();
-				});
-			});
-			next();
-		});
-	};
-}
-/**
-* Returns the immediate traversable children of `node`.
-*
-* For `Schema` nodes, children (`properties`, `items`, `members`, and non-boolean
-* `additionalProperties`) are only included
-* when `recurse` is `true`; shallow mode skips them.
-*
-* @example
-* ```ts
-* const children = getChildren(operationNode, true)
-* // returns parameters, requestBody schema (if present), and responses
-* ```
-*/
-function getChildren(node, recurse) {
-	switch (node.kind) {
-		case "Input": return [...node.schemas, ...node.operations];
-		case "Output": return [];
-		case "Operation": return [
-			...node.parameters,
-			...node.requestBody?.content?.flatMap((c) => c.schema ? [c.schema] : []) ?? [],
-			...node.responses
-		];
-		case "Schema": {
-			const children = [];
-			if (!recurse) return [];
-			if ("properties" in node && node.properties.length > 0) children.push(...node.properties);
-			if ("items" in node && node.items) children.push(...node.items);
-			if ("members" in node && node.members) children.push(...node.members);
-			if ("additionalProperties" in node && node.additionalProperties && node.additionalProperties !== true) children.push(node.additionalProperties);
-			return children;
-		}
-		case "Property": return [node.schema];
-		case "Parameter": return [node.schema];
-		case "Response": return node.schema ? [node.schema] : [];
-		case "FunctionParameter":
-		case "ParameterGroup":
-		case "FunctionParameters":
-		case "Type": return [];
-		default: return [];
-	}
-}
-/**
-* Depth-first traversal for side effects. Visitor return values are ignored.
-* Sibling nodes at each level are visited concurrently up to `options.concurrency`
-* (default: `WALK_CONCURRENCY`).
-*
-* @example
-* ```ts
-* await walk(root, {
-*   operation(node) {
-*     console.log(node.operationId)
-*   },
-* })
-* ```
-*
-* @example
-* ```ts
-* // Visit only the current node
-* await walk(root, { depth: 'shallow', root: () => {} })
-* ```
-*/
-async function walk(node, options) {
-	return _walk(node, options, (options.depth ?? visitorDepths.deep) === visitorDepths.deep, createLimit(options.concurrency ?? 30), void 0);
-}
-async function _walk(node, visitor, recurse, limit, parent) {
-	switch (node.kind) {
-		case "Input":
-			await limit(() => visitor.input?.(node, { parent }));
-			break;
-		case "Output":
-			await limit(() => visitor.output?.(node, { parent }));
-			break;
-		case "Operation":
-			await limit(() => visitor.operation?.(node, { parent }));
-			break;
-		case "Schema":
-			await limit(() => visitor.schema?.(node, { parent }));
-			break;
-		case "Property":
-			await limit(() => visitor.property?.(node, { parent }));
-			break;
-		case "Parameter":
-			await limit(() => visitor.parameter?.(node, { parent }));
-			break;
-		case "Response":
-			await limit(() => visitor.response?.(node, { parent }));
-			break;
-		case "FunctionParameter":
-		case "ParameterGroup":
-		case "FunctionParameters": break;
-	}
-	const children = getChildren(node, recurse);
-	for (const child of children) await _walk(child, visitor, recurse, limit, node);
-}
-function transform(node, options) {
-	const { depth, parent, ...visitor } = options;
-	const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep;
-	switch (node.kind) {
-		case "Input": {
-			let input = node;
-			const replaced = visitor.input?.(input, { parent });
-			if (replaced) input = replaced;
-			return {
-				...input,
-				schemas: input.schemas.map((s) => transform(s, {
-					...options,
-					parent: input
-				})),
-				operations: input.operations.map((op) => transform(op, {
-					...options,
-					parent: input
-				}))
-			};
-		}
-		case "Output": {
-			let output = node;
-			const replaced = visitor.output?.(output, { parent });
-			if (replaced) output = replaced;
-			return output;
-		}
-		case "Operation": {
-			let op = node;
-			const replaced = visitor.operation?.(op, { parent });
-			if (replaced) op = replaced;
-			return {
-				...op,
-				parameters: op.parameters.map((p) => transform(p, {
-					...options,
-					parent: op
-				})),
-				requestBody: op.requestBody ? {
-					...op.requestBody,
-					content: op.requestBody.content?.map((c) => ({
-						...c,
-						schema: c.schema ? transform(c.schema, {
-							...options,
-							parent: op
-						}) : void 0
-					}))
-				} : void 0,
-				responses: op.responses.map((r) => transform(r, {
-					...options,
-					parent: op
-				}))
-			};
-		}
-		case "Schema": {
-			let schema = node;
-			const replaced = visitor.schema?.(schema, { parent });
-			if (replaced) schema = replaced;
-			const childOptions = {
-				...options,
-				parent: schema
-			};
-			return {
-				...schema,
-				..."properties" in schema && recurse ? { properties: schema.properties.map((p) => transform(p, childOptions)) } : {},
-				..."items" in schema && recurse ? { items: schema.items?.map((i) => transform(i, childOptions)) } : {},
-				..."members" in schema && recurse ? { members: schema.members?.map((m) => transform(m, childOptions)) } : {},
-				..."additionalProperties" in schema && recurse && schema.additionalProperties && schema.additionalProperties !== true ? { additionalProperties: transform(schema.additionalProperties, childOptions) } : {}
-			};
-		}
-		case "Property": {
-			let prop = node;
-			const replaced = visitor.property?.(prop, { parent });
-			if (replaced) prop = replaced;
-			return createProperty({
-				...prop,
-				schema: transform(prop.schema, {
-					...options,
-					parent: prop
-				})
-			});
-		}
-		case "Parameter": {
-			let param = node;
-			const replaced = visitor.parameter?.(param, { parent });
-			if (replaced) param = replaced;
-			return createParameter({
-				...param,
-				schema: transform(param.schema, {
-					...options,
-					parent: param
-				})
-			});
-		}
-		case "Response": {
-			let response = node;
-			const replaced = visitor.response?.(response, { parent });
-			if (replaced) response = replaced;
-			return {
-				...response,
-				schema: transform(response.schema, {
-					...options,
-					parent: response
-				})
-			};
-		}
-		case "FunctionParameter":
-		case "ParameterGroup":
-		case "FunctionParameters":
-		case "Type": return node;
-		default: return node;
-	}
-}
-/**
-* Runs a depth-first synchronous collection pass.
-*
-* Non-`undefined` values returned by visitor callbacks are appended to the result.
-*
-* @example
-* ```ts
-* const ids = collect(root, {
-*   operation(node) {
-*     return node.operationId
-*   },
-* })
-* ```
-*
-* @example
-* ```ts
-* // Collect from only the current node
-* const values = collect(root, { depth: 'shallow', root: () => 'root' })
-* ```
-*/
-function collect(node, options) {
-	const { depth, parent, ...visitor } = options;
-	const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep;
-	const results = [];
-	let v;
-	switch (node.kind) {
-		case "Input":
-			v = visitor.input?.(node, { parent });
-			break;
-		case "Output":
-			v = visitor.output?.(node, { parent });
-			break;
-		case "Operation":
-			v = visitor.operation?.(node, { parent });
-			break;
-		case "Schema":
-			v = visitor.schema?.(node, { parent });
-			break;
-		case "Property":
-			v = visitor.property?.(node, { parent });
-			break;
-		case "Parameter":
-			v = visitor.parameter?.(node, { parent });
-			break;
-		case "Response":
-			v = visitor.response?.(node, { parent });
-			break;
-		case "FunctionParameter":
-		case "ParameterGroup":
-		case "FunctionParameters": break;
-	}
-	if (v !== void 0) results.push(v);
-	for (const child of getChildren(node, recurse)) for (const item of collect(child, {
-		...options,
-		parent: node
-	})) results.push(item);
-	return results;
-}
-//#endregion
-//#region src/utils.ts
-const plainStringTypes = new Set([
-	"string",
-	"uuid",
-	"email",
-	"url",
-	"datetime"
-]);
-/**
-* Merges a ref node with its resolved schema, giving usage-site fields precedence.
-*
-* Usage-site fields (`description`, `readOnly`, `nullable`, `deprecated`) on the ref node
-* override the same fields in the resolved `node.schema`. Non-ref nodes are returned unchanged.
-*
-* @example
-* ```ts
-* // Ref with description override
-* const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A cute pet' })
-* const merged = syncSchemaRef(ref)  // merges with resolved Pet schema
-* ```
-*/
-function syncSchemaRef(node) {
-	const ref = narrowSchema(node, "ref");
-	if (!ref) return node;
-	if (!ref.schema) return node;
-	const { kind: _kind, type: _type, name: _name, ref: _ref, schema: _schema, ...overrides } = ref;
-	const definedOverrides = Object.fromEntries(Object.entries(overrides).filter(([, v]) => v !== void 0));
-	return createSchema({
-		...ref.schema,
-		...definedOverrides
-	});
-}
-/**
-* Type guard that returns `true` when a schema emits as a plain `string` type.
-*
-* Covers `string`, `uuid`, `email`, `url`, and `datetime` types. For `date` and `time`
-* types, returns `true` only when `representation` is `'string'` rather than `'date'`.
-*/
-function isStringType(node) {
-	if (plainStringTypes.has(node.type)) return true;
-	const temporal = narrowSchema(node, "date") ?? narrowSchema(node, "time");
-	if (temporal) return temporal.representation !== "date";
-	return false;
-}
-/**
-* Applies casing rules to parameter names and returns a new parameter array.
-*
-* Use this before passing parameters to schema builders so output property keys match
-* the desired casing while preserving `OperationNode.parameters` for other consumers.
-* The input array is not mutated. When `casing` is not set, the original array is returned unchanged.
-*/
-function caseParams(params, casing) {
-	if (!casing) return params;
-	return params.map((param) => {
-		const transformed = casing === "camelcase" || !isValidVarName(param.name) ? camelCase(param.name) : param.name;
-		return {
-			...param,
-			name: transformed
-		};
-	});
-}
-/**
-* Creates a single-property object schema used as a discriminator literal.
-*
-* @example
-* ```ts
-* createDiscriminantNode({ propertyName: 'type', value: 'dog' })
-* // -> { type: 'object', properties: [{ name: 'type', required: true, schema: enum('dog') }] }
-* ```
-*/
-function createDiscriminantNode({ propertyName, value }) {
-	return createSchema({
-		type: "object",
-		primitive: "object",
-		properties: [createProperty({
-			name: propertyName,
-			schema: createSchema({
-				type: "enum",
-				primitive: "string",
-				enumValues: [value]
-			}),
-			required: true
-		})]
-	});
-}
-function resolveParamsType({ node, param, resolver }) {
-	if (!resolver) return createParamsType({
-		variant: "reference",
-		name: param.schema.primitive ?? "unknown"
-	});
-	const individualName = resolver.resolveParamName(node, param);
-	const groupLocation = param.in === "path" || param.in === "query" || param.in === "header" ? param.in : void 0;
-	const groupResolvers = {
-		path: resolver.resolvePathParamsName,
-		query: resolver.resolveQueryParamsName,
-		header: resolver.resolveHeaderParamsName
-	};
-	const groupName = groupLocation ? groupResolvers[groupLocation].call(resolver, node, param) : void 0;
-	if (groupName && groupName !== individualName) return createParamsType({
-		variant: "member",
-		base: groupName,
-		key: param.name
-	});
-	return createParamsType({
-		variant: "reference",
-		name: individualName
-	});
-}
-/**
-* Converts an `OperationNode` into function parameters for code generation.
-*
-* Centralizes parameter grouping logic for all plugins. Provide a `resolver` for type name resolution
-* and `extraParams` for plugin-specific trailing parameters (e.g., `options` objects).
-* Supports three grouping modes: `object` (single destructured param), `inline` (separate params),
-* and `inlineSpread` (rest parameter). Use `CreateOperationParamsOptions` to fine-tune output.
-*/
-function createOperationParams(node, options) {
-	const { paramsType, pathParamsType, paramsCasing, resolver, pathParamsDefault, extraParams = [], paramNames, typeWrapper } = options;
-	const dataName = paramNames?.data ?? "data";
-	const paramsName = paramNames?.params ?? "params";
-	const headersName = paramNames?.headers ?? "headers";
-	const pathName = paramNames?.path ?? "pathParams";
-	const wrapType = (type) => createParamsType({
-		variant: "reference",
-		name: typeWrapper ? typeWrapper(type) : type
-	});
-	const wrapTypeNode = (type) => type.kind === "ParamsType" && type.variant === "reference" ? wrapType(type.name) : type;
-	const casedParams = caseParams(node.parameters, paramsCasing);
-	const pathParams = casedParams.filter((p) => p.in === "path");
-	const queryParams = casedParams.filter((p) => p.in === "query");
-	const headerParams = casedParams.filter((p) => p.in === "header");
-	const bodyType = node.requestBody?.content?.[0]?.schema ? wrapType(resolver?.resolveDataName(node) ?? "unknown") : void 0;
-	const bodyRequired = node.requestBody?.required ?? false;
-	const queryGroupType = resolver ? resolveGroupType({
-		node,
-		params: queryParams,
-		groupMethod: resolver.resolveQueryParamsName,
-		resolver
-	}) : void 0;
-	const headerGroupType = resolver ? resolveGroupType({
-		node,
-		params: headerParams,
-		groupMethod: resolver.resolveHeaderParamsName,
-		resolver
-	}) : void 0;
-	const params = [];
-	if (paramsType === "object") {
-		const children = [
-			...pathParams.map((p) => {
-				const type = resolveParamsType({
-					node,
-					param: p,
-					resolver
-				});
-				return createFunctionParameter({
-					name: p.name,
-					type: wrapTypeNode(type),
-					optional: !p.required
-				});
-			}),
-			...bodyType ? [createFunctionParameter({
-				name: dataName,
-				type: bodyType,
-				optional: !bodyRequired
-			})] : [],
-			...buildGroupParam({
-				name: paramsName,
-				node,
-				params: queryParams,
-				groupType: queryGroupType,
-				resolver,
-				wrapType
-			}),
-			...buildGroupParam({
-				name: headersName,
-				node,
-				params: headerParams,
-				groupType: headerGroupType,
-				resolver,
-				wrapType
-			})
-		];
-		if (children.length) params.push(createParameterGroup({
-			properties: children,
-			default: children.every((c) => c.optional) ? "{}" : void 0
-		}));
-	} else {
-		if (pathParams.length) if (pathParamsType === "inlineSpread") {
-			const spreadType = resolver?.resolvePathParamsName(node, pathParams[0]) ?? void 0;
-			params.push(createFunctionParameter({
-				name: pathName,
-				type: spreadType ? wrapType(spreadType) : void 0,
-				rest: true
-			}));
-		} else {
-			const pathChildren = pathParams.map((p) => {
-				const type = resolveParamsType({
-					node,
-					param: p,
-					resolver
-				});
-				return createFunctionParameter({
-					name: p.name,
-					type: wrapTypeNode(type),
-					optional: !p.required
-				});
-			});
-			params.push(createParameterGroup({
-				properties: pathChildren,
-				inline: pathParamsType === "inline",
-				default: pathParamsDefault ?? (pathChildren.every((c) => c.optional) ? "{}" : void 0)
-			}));
-		}
-		if (bodyType) params.push(createFunctionParameter({
-			name: dataName,
-			type: bodyType,
-			optional: !bodyRequired
-		}));
-		params.push(...buildGroupParam({
-			name: paramsName,
-			node,
-			params: queryParams,
-			groupType: queryGroupType,
-			resolver,
-			wrapType
-		}));
-		params.push(...buildGroupParam({
-			name: headersName,
-			node,
-			params: headerParams,
-			groupType: headerGroupType,
-			resolver,
-			wrapType
-		}));
-	}
-	params.push(...extraParams);
-	return createFunctionParameters({ params });
-}
-/**
-* Builds a single {@link FunctionParameterNode} for a query or header group.
-* Returns an empty array when there are no params to emit.
-*
-* If a pre-resolved `groupType` is provided it emits `name: GroupType`.
-* Otherwise, it builds an inline struct from the individual params.
-*/
-function buildGroupParam({ name, node, params, groupType, resolver, wrapType }) {
-	if (groupType) return [createFunctionParameter({
-		name,
-		type: groupType.type.kind === "ParamsType" && groupType.type.variant === "reference" ? wrapType(groupType.type.name) : groupType.type,
-		optional: groupType.optional
-	})];
-	if (params.length) return [createFunctionParameter({
-		name,
-		type: toStructType({
-			node,
-			params,
-			resolver
-		}),
-		optional: params.every((p) => !p.required)
-	})];
-	return [];
-}
-/**
-* Derives a {@link ParamGroupType} from the resolver's group method.
-* Returns `undefined` when the group name equals the individual param name (no real group).
-*/
-function resolveGroupType({ node, params, groupMethod, resolver }) {
-	if (!params.length) return;
-	const firstParam = params[0];
-	const groupName = groupMethod.call(resolver, node, firstParam);
-	if (groupName === resolver.resolveParamName(node, firstParam)) return;
-	const allOptional = params.every((p) => !p.required);
-	return {
-		type: createParamsType({
-			variant: "reference",
-			name: groupName
-		}),
-		optional: allOptional
-	};
-}
-/**
-* Builds a {@link TypeNode} with `variant: 'struct'` for an inline anonymous type grouping named fields.
-*
-* Used when query or header parameters have no dedicated group type name.
-* Each language printer renders this appropriately (TypeScript: `{ petId: string; name?: string }`).
-*/
-function toStructType({ node, params, resolver }) {
-	return createParamsType({
-		variant: "struct",
-		properties: params.map((p) => ({
-			name: p.name,
-			optional: !p.required,
-			type: resolveParamsType({
-				node,
-				param: p,
-				resolver
-			})
-		}))
-	});
-}
-function sourceKey(source) {
-	return `${source.name ?? extractStringsFromNodes(source.nodes)}:${source.isExportable ?? false}:${source.isTypeOnly ?? false}`;
-}
-function pathTypeKey(path, isTypeOnly) {
-	return `${path}:${isTypeOnly ?? false}`;
-}
-function exportKey(path, name, isTypeOnly, asAlias) {
-	return `${path}:${name ?? ""}:${isTypeOnly ?? false}:${asAlias ?? ""}`;
-}
-function importKey(path, name, isTypeOnly) {
-	return `${path}:${name ?? ""}:${isTypeOnly ?? false}`;
-}
-/**
-* Computes a multi-level sort key for exports and imports:
-* non-array names first (wildcards/namespace aliases); type-only before value; alphabetical path; unnamed before named.
-*/
-function sortKey(node) {
-	const isArray = Array.isArray(node.name) ? "1" : "0";
-	const typeOnly = node.isTypeOnly ? "0" : "1";
-	const hasName = node.name != null ? "1" : "0";
-	const name = Array.isArray(node.name) ? [...node.name].sort().join("\0") : node.name ?? "";
-	return `${isArray}:${typeOnly}:${node.path}:${hasName}:${name}`;
-}
-/**
-* Deduplicates and merges `SourceNode` objects by `name + isExportable + isTypeOnly`.
-*
-* Unnamed sources are deduplicated by object reference. Returns a deduplicated array in original order.
-*/
-function combineSources(sources) {
-	const seen = /* @__PURE__ */ new Map();
-	for (const source of sources) {
-		const key = sourceKey(source);
-		if (!seen.has(key)) seen.set(key, source);
-	}
-	return [...seen.values()];
-}
-/**
-* Deduplicates and merges `ExportNode` objects by path and type.
+* Deduplicates and merges `ExportNode` objects by path and type.
 *
 * Named exports with the same path and `isTypeOnly` flag have their names merged into a single export.
 * Non-array exports are deduplicated by exact identity. Returns a sorted, deduplicated array.
@@ -1118,11 +677,8 @@ function combineExports(exports) {
 			if (!name.length) continue;
 			const key = pathTypeKey(path, isTypeOnly);
 			const existing = namedByPath.get(key);
-			if (existing && Array.isArray(existing.name)) {
-				const merged = new Set(existing.name);
-				for (const n of name) merged.add(n);
-				existing.name = [...merged];
-			} else {
+			if (existing && Array.isArray(existing.name)) existing.name = mergeNameArrays(existing.name, name);
+			else {
 				const newItem = {
 					...curr,
 					name: [...new Set(name)]
@@ -1145,8 +701,6 @@ function combineExports(exports) {
 *
 * Retains imports that are referenced in `source` or re-exported. Imports with the same path and
 * `isTypeOnly` flag have their names merged. Returns a sorted, deduplicated, filtered array.
-*
-* @note Use this when combining imports from multiple files to avoid duplicate declarations.
 */
 function combineImports(imports, exports, source) {
 	const exportedNames = new Set(exports.flatMap((e) => Array.isArray(e.name) ? e.name : e.name ? [e.name] : []));
@@ -1158,6 +712,11 @@ function combineImports(imports, exports, source) {
 		if (!importNameMemo.has(key)) importNameMemo.set(key, n);
 		return importNameMemo.get(key);
 	};
+	const pathsWithUsedNamedImport = /* @__PURE__ */ new Set();
+	for (const node of imports) {
+		if (!Array.isArray(node.name)) continue;
+		if (node.name.some((item) => typeof item === "string" ? isUsed(item) : isUsed(item.name ?? item.propertyName))) pathsWithUsedNamedImport.add(node.path);
+	}
 	const result = [];
 	const namedByPath = /* @__PURE__ */ new Map();
 	const seen = /* @__PURE__ */ new Set();
@@ -1175,11 +734,8 @@ function combineImports(imports, exports, source) {
 			if (!name.length) continue;
 			const key = pathTypeKey(path, isTypeOnly);
 			const existing = namedByPath.get(key);
-			if (existing && Array.isArray(existing.name)) {
-				const merged = new Set(existing.name);
-				for (const n of name) merged.add(n);
-				existing.name = [...merged];
-			} else {
+			if (existing && Array.isArray(existing.name)) existing.name = mergeNameArrays(existing.name, name);
+			else {
 				const newItem = {
 					...curr,
 					name
@@ -1188,7 +744,7 @@ function combineImports(imports, exports, source) {
 				namedByPath.set(key, newItem);
 			}
 		} else {
-			if (name && !isUsed(name)) continue;
+			if (name && !isUsed(name) && !pathsWithUsedNamedImport.has(path)) continue;
 			const key = importKey(path, name, isTypeOnly);
 			if (!seen.has(key)) {
 				result.push(curr);
@@ -1198,180 +754,245 @@ function combineImports(imports, exports, source) {
 	}
 	return result;
 }
+//#endregion
+//#region src/nodes/file.ts
 /**
-* Extracts all string content from a `CodeNode` tree recursively.
-*
-* Collects text node values, identifier references in string fields (`params`, `generics`, `returnType`, `type`),
-* and nested node content. Used internally to build the full source string for import filtering.
+* Definition for the {@link ImportNode}.
 */
-function extractStringsFromNodes(nodes) {
-	if (!nodes?.length) return "";
-	return nodes.map((node) => {
-		if (typeof node === "string") return node;
-		if (node.kind === "Text") return node.value;
-		if (node.kind === "Break") return "";
-		if (node.kind === "Jsx") return node.value;
-		const parts = [];
-		if ("params" in node && node.params) parts.push(node.params);
-		if ("generics" in node && node.generics) parts.push(Array.isArray(node.generics) ? node.generics.join(", ") : node.generics);
-		if ("returnType" in node && node.returnType) parts.push(node.returnType);
-		if ("type" in node && typeof node.type === "string") parts.push(node.type);
-		const nested = extractStringsFromNodes(node.nodes);
-		if (nested) parts.push(nested);
-		return parts.join("\n");
-	}).filter(Boolean).join("\n");
-}
+const importDef = defineNode({ kind: "Import" });
 /**
-* Resolves the schema name of a ref node, falling back through `ref` → `name` → nested `schema.name`.
-*
-* Returns `undefined` for non-ref nodes or when no name can be resolved. Use this to get a schema's
-* identifier for type definitions or error messages.
+* Definition for the {@link ExportNode}.
+*/
+const exportDef = defineNode({ kind: "Export" });
+/**
+* Definition for the {@link SourceNode}.
+*/
+const sourceDef = defineNode({ kind: "Source" });
+/**
+* Definition for the {@link FileNode}. The fully resolved builder lives in
+* `createFile`, so this definition only supplies the guard.
+*/
+const fileDef = defineNode({ kind: "File" });
+/**
+* Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
 *
-* @example
+* @example Named import
 * ```ts
-* resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Pet' })
-* // => 'Pet'
+* createImport({ name: ['useState'], path: 'react' })
+* // import { useState } from 'react'
 * ```
 */
-function resolveRefName(node) {
-	if (!node || node.type !== "ref") return void 0;
-	if (node.ref) return extractRefName(node.ref) ?? node.name ?? node.schema?.name ?? void 0;
-	return node.name ?? node.schema?.name ?? void 0;
-}
+const createImport = importDef.create;
 /**
-* Collects every named schema referenced (transitively) from a node via ref edges.
-*
-* Refs are followed by name only — the resolved `node.schema` is not traversed inline.
-* Use this to determine schema dependencies, build reference graphs, or detect what schemas need to be emitted.
+* Creates an `ExportNode` representing a language-agnostic export/public API declaration.
 *
-* @example Collect refs from a single schema
+* @example Named export
 * ```ts
-* const names = collectReferencedSchemaNames(petSchema)
-* // → Set { 'Category', 'Tag' }
+* createExport({ name: ['Pet'], path: './Pet' })
+* // export { Pet } from './Pet'
 * ```
+*/
+const createExport = exportDef.create;
+/**
+* Creates a `SourceNode` representing a fragment of source code within a file.
 *
-* @example Accumulate refs from multiple schemas into one set
+* @example
 * ```ts
-* const out = new Set<string>()
-* for (const schema of schemas) {
-*   collectReferencedSchemaNames(schema, out)
-* }
+* createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
 * ```
 */
-function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
-	if (!node) return out;
-	collect(node, { schema(child) {
-		if (child.type === "ref") {
-			const name = resolveRefName(child);
-			if (name) out.add(name);
-		}
-	} });
-	return out;
-}
+const createSource = sourceDef.create;
 /**
-* Collects the names of all top-level schemas transitively used by a set of operations.
+* Creates a fully resolved `FileNode` from a file input descriptor.
+*
+* Computes:
+* - `id` SHA256 hash of the file path
+* - `name` `baseName` without extension
+* - `extname` extension extracted from `baseName`
 *
-* An operation uses a schema when any of its parameters, request body content, or responses
-* reference it — directly or indirectly through other named schemas.
-* The walk is iterative and safe against reference cycles.
+* Deduplicates:
+* - `sources` via `combineSources`
+* - `exports` via `combineExports`
+* - `imports` via `combineImports` (also filters unused imports)
 *
-* Use this together with `include` filters to determine which schemas from `components/schemas`
-* are reachable from the allowed operations, so that schemas used only by excluded operations
-* are not generated.
+* @throws {Error} when `baseName` has no extension.
 *
-* @example Only generate schemas referenced by included operations
+* @example
 * ```ts
-* const includedOps = inputNode.operations.filter(op => resolver.resolveOptions(op, { options, include }) !== null)
-* const allowed = collectUsedSchemaNames(includedOps, inputNode.schemas)
-*
-* for (const schema of inputNode.schemas) {
-*   if (schema.name && !allowed.has(schema.name)) continue
-*   // … generate schema
-* }
+* const file = createFile({
+*   baseName: 'petStore.ts',
+*   path: 'src/models/petStore.ts',
+*   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')] })],
+*   imports: [createImport({ name: ['z'], path: 'zod' })],
+*   exports: [createExport({ name: ['Pet'], path: './petStore' })],
+* })
+* // file.id      = SHA256 hash of 'src/models/petStore.ts'
+* // file.name    = 'petStore'
+* // file.extname = '.ts'
 * ```
 *
-* @example Check whether a specific schema is needed
+* @example Copy a real file into the output verbatim
 * ```ts
-* const allowed = collectUsedSchemaNames(includedOps, inputNode.schemas)
-* allowed.has('OrderStatus') // false when no included operation references OrderStatus
+* const file = createFile({
+*   baseName: 'client.ts',
+*   path: 'src/gen/client.ts',
+*   copy: '/abs/path/to/templates/client.ts',
+* })
 * ```
 */
-function collectUsedSchemaNames(operations, schemas) {
-	const schemaMap = /* @__PURE__ */ new Map();
-	for (const schema of schemas) if (schema.name) schemaMap.set(schema.name, schema);
-	const result = /* @__PURE__ */ new Set();
-	function visitSchema(schema) {
-		const directRefs = collectReferencedSchemaNames(schema);
-		for (const name of directRefs) if (!result.has(name)) {
-			result.add(name);
-			const namedSchema = schemaMap.get(name);
-			if (namedSchema) visitSchema(namedSchema);
-		}
+function createFile(input) {
+	const extname = path.extname(input.baseName) || (input.baseName.startsWith(".") ? input.baseName : "");
+	if (!extname) throw new Error(`No extname found for ${input.baseName}`);
+	const resolvedExports = input.exports?.length ? combineExports(input.exports) : [];
+	let resolvedImports = [];
+	if (input.imports?.length) {
+		const source = extractStringsFromNodes((input.sources ?? []).flatMap((item) => item.nodes ?? [])) || void 0;
+		const combinedImports = combineImports(input.imports, resolvedExports, source);
+		const localNames = new Set((input.sources ?? []).map((item) => item.name).filter((name) => Boolean(name)));
+		const nameOf = (item) => typeof item === "string" ? item : item.name ?? item.propertyName;
+		resolvedImports = combinedImports.filter((imp) => imp.path !== input.path).flatMap((imp) => {
+			if (!Array.isArray(imp.name)) return typeof imp.name === "string" && localNames.has(imp.name) ? [] : [imp];
+			const kept = imp.name.filter((item) => !localNames.has(nameOf(item)));
+			if (!kept.length) return [];
+			return [kept.length === imp.name.length ? imp : {
+				...imp,
+				name: kept
+			}];
+		});
 	}
-	for (const op of operations) for (const schema of collect(op, {
-		depth: "shallow",
-		schema: (node) => node
-	})) visitSchema(schema);
-	return result;
+	const resolvedSources = input.sources?.length ? combineSources(input.sources) : [];
+	return {
+		kind: "File",
+		...input,
+		id: hash("sha256", input.path, "hex"),
+		name: trimExtName(input.baseName),
+		extname,
+		imports: resolvedImports,
+		exports: resolvedExports,
+		sources: resolvedSources,
+		meta: input.meta ?? {}
+	};
 }
+//#endregion
+//#region src/nodes/input.ts
 /**
-* Identifies all schemas that participate in circular dependency chains, including direct self-loops.
-*
-* Returns a Set of schema names with circular dependencies. Use this to wrap recursive schema positions
-* in deferred constructs (lazy getter, `z.lazy(() => …)`) to prevent infinite recursion when generated code runs.
-* Refs are followed by name only, keeping the algorithm linear in the schema graph size.
-*
-* @note Call this once on the full schema graph, then use `containsCircularRef()` to check individual schemas.
+* Definition for the {@link InputNode}.
 */
-function findCircularSchemas(schemas) {
-	const graph = /* @__PURE__ */ new Map();
-	for (const schema of schemas) {
-		if (!schema.name) continue;
-		graph.set(schema.name, collectReferencedSchemaNames(schema));
-	}
-	const circular = /* @__PURE__ */ new Set();
-	for (const start of graph.keys()) {
-		const visited = /* @__PURE__ */ new Set();
-		const stack = [...graph.get(start) ?? []];
-		while (stack.length > 0) {
-			const node = stack.pop();
-			if (node === start) {
-				circular.add(start);
-				break;
-			}
-			if (visited.has(node)) continue;
-			visited.add(node);
-			const next = graph.get(node);
-			if (next) for (const r of next) stack.push(r);
+const inputDef = defineNode({
+	kind: "Input",
+	defaults: {
+		schemas: [],
+		operations: [],
+		meta: {
+			circularNames: [],
+			enumNames: []
 		}
-	}
-	return circular;
-}
+	},
+	children: ["schemas", "operations"],
+	visitorKey: "input"
+});
 /**
-* Type guard returning `true` when a schema or anything nested within it contains a ref to a circular schema.
+* Creates an `InputNode`. Pass `stream: true` for the streaming variant whose `schemas` and
+* `operations` are `AsyncIterable` sources. Otherwise it builds the eager variant with array
+* `schemas`/`operations`. Both variants get the defaulted `meta`.
 *
-* Use `excludeName` to ignore refs to specific schemas (useful when self-references are handled separately).
-* Commonly used with `findCircularSchemas()` to detect where lazy wrappers are needed in code generation.
+* @example Eager
+* ```ts
+* const input = createInput()
+* // { kind: 'Input', schemas: [], operations: [] }
+* ```
 *
-* @note Returns `true` for the first matching circular ref found; use for fast dependency checks.
+* @example Streaming
+* ```ts
+* const node = createInput({ stream: true, schemas: schemasIterable, operations: operationsIterable, meta: { title: 'My API' } })
+* ```
 */
-function containsCircularRef(node, { circularSchemas, excludeName }) {
-	if (!node || circularSchemas.size === 0) return false;
-	return collect(node, { schema(child) {
-		if (child.type !== "ref") return void 0;
-		const name = resolveRefName(child);
-		return name && name !== excludeName && circularSchemas.has(name) ? true : void 0;
-	} }).length > 0;
+function createInput(options = {}) {
+	const { stream, ...overrides } = options;
+	if (stream) return {
+		kind: "Input",
+		meta: {
+			circularNames: [],
+			enumNames: []
+		},
+		...overrides
+	};
+	return inputDef.create(overrides);
 }
 //#endregion
-//#region src/factory.ts
+//#region src/nodes/requestBody.ts
+/**
+* Definition for the {@link RequestBodyNode}. Content entries are built upfront with
+* {@link createContent}, mirroring how `parameters` and `responses` take prebuilt nodes.
+*/
+const requestBodyDef = defineNode({
+	kind: "RequestBody",
+	children: ["content"]
+});
+/**
+* Creates a `RequestBodyNode`.
+*/
+const createRequestBody = requestBodyDef.create;
+//#endregion
+//#region src/nodes/operation.ts
+/**
+* Definition for the {@link OperationNode}. HTTP operations (those carrying both
+* `method` and `path`) are tagged with `protocol: 'http'`, and the request body is
+* normalized into a `RequestBodyNode`.
+*/
+const operationDef = defineNode({
+	kind: "Operation",
+	build: (props) => {
+		const { requestBody, ...rest } = props;
+		const isHttp = rest.method !== void 0 && rest.path !== void 0;
+		return {
+			tags: [],
+			parameters: [],
+			responses: [],
+			...rest,
+			...isHttp ? { protocol: "http" } : {},
+			requestBody: requestBody ? createRequestBody(requestBody) : void 0
+		};
+	},
+	children: [
+		"parameters",
+		"requestBody",
+		"responses"
+	],
+	visitorKey: "operation"
+});
+function createOperation(props) {
+	return operationDef.create(props);
+}
+//#endregion
+//#region src/nodes/output.ts
 /**
-* Syncs property/parameter schema optionality flags from `required` and `schema.nullable`.
+* Definition for the {@link OutputNode}.
+*/
+const outputDef = defineNode({
+	kind: "Output",
+	defaults: { files: [] },
+	visitorKey: "output"
+});
+/**
+* Creates an `OutputNode` with a stable default for `files`.
 *
-* - `optional` is set for non-required, non-nullable schemas.
-* - `nullish` is set for non-required, nullable schemas.
+* @example
+* ```ts
+* const output = createOutput()
+* // { kind: 'Output', files: [] }
+* ```
 */
-function syncOptionality(schema, required) {
+function createOutput(overrides = {}) {
+	return outputDef.create(overrides);
+}
+//#endregion
+//#region src/optionality.ts
+/**
+* Generic JSON Schema optionality: a non-required field is optional, and a
+* non-required nullable field is nullish.
+*/
+function optionality(schema, required) {
 	const nullable = schema.nullable ?? false;
 	return {
 		...schema,
@@ -1379,793 +1000,1155 @@ function syncOptionality(schema, required) {
 		nullish: !required && nullable ? true : void 0
 	};
 }
+//#endregion
+//#region src/nodes/parameter.ts
 /**
-* Creates an `InputNode` with stable defaults for `schemas` and `operations`.
-*
-* @example
-* ```ts
-* const input = createInput()
-* // { kind: 'Input', schemas: [], operations: [] }
-* ```
+* Definition for the {@link ParameterNode}. `required` defaults to `false`, and the schema's
+* `optional`/`nullish` flags are derived from it through {@link optionality}.
+*/
+const parameterDef = defineNode({
+	kind: "Parameter",
+	build: (props) => {
+		const required = props.required ?? false;
+		return {
+			...props,
+			required,
+			schema: optionality(props.schema, required)
+		};
+	},
+	children: ["schema"],
+	visitorKey: "parameter"
+});
+/**
+* Creates a `ParameterNode`.
 *
 * @example
 * ```ts
-* const input = createInput({ schemas: [petSchema] })
-* // keeps default operations: []
+* const param = createParameter({
+*   name: 'petId',
+*   in: 'path',
+*   required: true,
+*   schema: createSchema({ type: 'string' }),
+* })
 * ```
 */
-function createInput(overrides = {}) {
-	return {
-		schemas: [],
-		operations: [],
-		...overrides,
-		kind: "Input"
-	};
-}
+const createParameter = parameterDef.create;
+//#endregion
+//#region src/nodes/property.ts
 /**
-* Creates an `OutputNode` with a stable default for `files`.
+* Definition for the {@link PropertyNode}. `required` defaults to `false`, and the schema's
+* `optional`/`nullish` flags are derived from it through {@link optionality}.
+*/
+const propertyDef = defineNode({
+	kind: "Property",
+	build: (props) => {
+		const required = props.required ?? false;
+		return {
+			...props,
+			required,
+			schema: optionality(props.schema, required)
+		};
+	},
+	children: ["schema"],
+	visitorKey: "property"
+});
+/**
+* Creates a `PropertyNode`.
 *
 * @example
 * ```ts
-* const output = createOutput()
-* // { kind: 'Output', files: [] }
+* const property = createProperty({
+*   name: 'status',
+*   required: true,
+*   schema: createSchema({ type: 'string', nullable: true }),
+* })
+* // required=true, no optional/nullish
 * ```
+*/
+const createProperty = propertyDef.create;
+//#endregion
+//#region src/nodes/response.ts
+/**
+* Definition for the {@link ResponseNode}. A single legacy `schema` (with optional
+* `mediaType`/`keysToOmit`) is normalized into one `content` entry.
+*/
+const responseDef = defineNode({
+	kind: "Response",
+	build: (props) => {
+		const { schema, mediaType, keysToOmit, content, ...rest } = props;
+		const entries = content ?? (schema ? [createContent({
+			contentType: mediaType ?? "application/json",
+			schema,
+			keysToOmit: keysToOmit ?? null
+		})] : void 0);
+		return {
+			...rest,
+			content: entries
+		};
+	},
+	children: ["content"],
+	visitorKey: "response"
+});
+/**
+* Creates a `ResponseNode`.
 *
 * @example
 * ```ts
-* const output = createOutput({ files: [petFile] })
+* const response = createResponse({
+*   statusCode: '200',
+*   content: [createContent({ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) })],
+* })
 * ```
 */
-function createOutput(overrides = {}) {
-	return {
-		files: [],
-		...overrides,
-		kind: "Output"
-	};
+const createResponse = responseDef.create;
+//#endregion
+//#region src/nodes/schema.ts
+/**
+* Maps schema `type` to its underlying `primitive`.
+* Primitive types map to themselves and special string formats map to `'string'`.
+* Any type not listed here (such as `ref`, `enum`, `union`, `intersection`, `tuple`, `ipv4`, `ipv6`, `blob`) has no `primitive`.
+*/
+const TYPE_TO_PRIMITIVE = {
+	string: "string",
+	number: "number",
+	integer: "integer",
+	bigint: "bigint",
+	boolean: "boolean",
+	null: "null",
+	any: "any",
+	unknown: "unknown",
+	void: "void",
+	never: "never",
+	object: "object",
+	array: "array",
+	date: "date",
+	uuid: "string",
+	email: "string",
+	url: "string",
+	datetime: "string",
+	time: "string"
+};
+/**
+* Definition for the {@link SchemaNode}. Object schemas default `properties` to an
+* empty array, and `primitive` is inferred from `type` when not explicitly provided.
+*/
+const schemaDef = defineNode({
+	kind: "Schema",
+	build: (props) => {
+		if (props.type === "object") return {
+			properties: [],
+			primitive: "object",
+			...props
+		};
+		return {
+			primitive: TYPE_TO_PRIMITIVE[props.type],
+			...props
+		};
+	},
+	children: [
+		"properties",
+		"items",
+		"members",
+		"additionalProperties"
+	],
+	visitorKey: "schema"
+});
+function createSchema(props) {
+	return schemaDef.create(props);
 }
+//#endregion
+//#region src/registry.ts
+/**
+* Every node definition. Adding a node means adding its `defineNode` to one
+* `nodes/*.ts` file and listing it here. The visitor tables in `visitor.ts` derive from it.
+*/
+const nodeDefs = [
+	inputDef,
+	outputDef,
+	operationDef,
+	requestBodyDef,
+	contentDef,
+	responseDef,
+	schemaDef,
+	propertyDef,
+	parameterDef,
+	constDef,
+	typeDef,
+	functionDef,
+	arrowFunctionDef,
+	textDef,
+	breakDef,
+	jsxDef,
+	importDef,
+	exportDef,
+	sourceDef,
+	fileDef
+];
+//#endregion
+//#region src/visitor.ts
+/**
+* Child node fields per node kind, in traversal order (Babel's `VISITOR_KEYS`).
+* Derived from each definition's `children`.
+*/
+const VISITOR_KEYS = Object.fromEntries(nodeDefs.flatMap((def) => def.children ? [[def.kind, def.children]] : []));
+/**
+* Maps a node kind to the matching visitor callback name. Derived from each
+* definition's `visitorKey`.
+*/
+const VISITOR_KEY_BY_KIND = Object.fromEntries(nodeDefs.flatMap((def) => def.visitorKey ? [[def.kind, def.visitorKey]] : []));
 /**
-* Creates an `OperationNode` with default empty arrays for `tags`, `parameters`, and `responses`.
+* Creates a small async concurrency limiter.
 *
-* @example
-* ```ts
-* const operation = createOperation({
-*   operationId: 'getPetById',
-*   method: 'GET',
-*   path: '/pet/{petId}',
-* })
-* // tags, parameters, and responses are []
-* ```
+* At most `concurrency` tasks are in flight at once. Extra tasks are queued.
 *
 * @example
 * ```ts
-* const operation = createOperation({
-*   operationId: 'findPets',
-*   method: 'GET',
-*   path: '/pet/findByStatus',
-*   tags: ['pet'],
-* })
+* const limit = createLimit(2)
+* for (const task of [taskA, taskB, taskC]) {
+*   await limit(() => task())
+* }
+* // only 2 tasks run at the same time
 * ```
 */
-function createOperation(props) {
-	return {
-		tags: [],
-		parameters: [],
-		responses: [],
-		...props,
-		kind: "Operation"
+function createLimit(concurrency) {
+	let active = 0;
+	const queue = [];
+	function next() {
+		if (active < concurrency && queue.length > 0) {
+			active++;
+			queue.shift()();
+		}
+	}
+	return function limit(fn) {
+		return new Promise((resolve, reject) => {
+			queue.push(() => {
+				Promise.resolve(fn()).then(resolve, reject).finally(() => {
+					active--;
+					next();
+				});
+			});
+			next();
+		});
 	};
 }
+const visitorKeysByKind = VISITOR_KEYS;
+/**
+* Returns `true` when `value` is an AST node (an object carrying a `kind`).
+*/
+function isNode(value) {
+	return typeof value === "object" && value !== null && typeof value.kind === "string";
+}
+/**
+* Returns the immediate traversable children of `node` based on {@link VISITOR_KEYS}.
+*
+* `Schema` children are only included when `recurse` is `true`. Shallow mode skips them.
+*
+* @example
+* ```ts
+* const children = getChildren(operationNode, true)
+* // returns parameters, the request body, and responses
+* ```
+*/
+function* getChildren(node, recurse) {
+	if (node.kind === "Schema" && !recurse) return;
+	const keys = visitorKeysByKind[node.kind];
+	if (!keys) return;
+	const record = node;
+	for (const key of keys) {
+		const value = record[key];
+		if (Array.isArray(value)) {
+			for (const item of value) if (isNode(item)) yield item;
+		} else if (isNode(value)) yield value;
+	}
+}
 /**
-* Maps schema `type` to its underlying `primitive`.
-* Primitive types map to themselves; special string formats map to `'string'`.
-* Complex types (`ref`, `enum`, `union`, `intersection`, `tuple`, `blob`) are left unset.
+* Runs the visitor callback that matches `node.kind` with the traversal
+* context. The result is a replacement node, a collected value, or `undefined`
+* when no callback is registered for the kind.
+*
+* Shared by `walk`, `transform`, and `collectLazy` so node-kind dispatch lives
+* in one place. `TResult` is the caller's expected return: the same node type
+* for `transform`, the collected value type for `collectLazy`, ignored for `walk`.
 */
-const TYPE_TO_PRIMITIVE = {
-	string: "string",
-	number: "number",
-	integer: "integer",
-	bigint: "bigint",
-	boolean: "boolean",
-	null: "null",
-	any: "any",
-	unknown: "unknown",
-	void: "void",
-	never: "never",
-	object: "object",
-	array: "array",
-	date: "date",
-	uuid: "string",
-	email: "string",
-	url: "string",
-	datetime: "string",
-	time: "string"
-};
-function createSchema(props) {
-	const inferredPrimitive = TYPE_TO_PRIMITIVE[props.type];
-	if (props["type"] === "object") return {
-		properties: [],
-		primitive: "object",
-		...props,
-		kind: "Schema"
-	};
-	return {
-		primitive: inferredPrimitive,
-		...props,
-		kind: "Schema"
-	};
+function applyVisitor(node, visitor, parent) {
+	const key = VISITOR_KEY_BY_KIND[node.kind];
+	if (!key) return void 0;
+	const fn = visitor[key];
+	return fn?.(node, { parent });
 }
 /**
-* Creates a `PropertyNode`.
+* Async depth-first traversal for side effects. Visitor return values are
+* ignored. Use `transform` when you want to rewrite nodes.
 *
-* `required` defaults to `false`.
-* `schema.optional` and `schema.nullish` are derived from `required` and `schema.nullable`.
+* Sibling nodes at each depth run concurrently up to `options.concurrency`
+* (defaults to `WALK_CONCURRENCY`). Higher values overlap I/O-bound visitor
+* work. Lower values reduce memory pressure.
 *
-* @example
+* @example Log every operation
 * ```ts
-* const property = createProperty({
-*   name: 'status',
-*   schema: createSchema({ type: 'string' }),
+* await walk(root, {
+*   operation(node) {
+*     console.log(node.operationId)
+*   },
 * })
-* // required=false, schema.optional=true
 * ```
 *
-* @example
+* @example Only visit the root node
 * ```ts
-* const property = createProperty({
-*   name: 'status',
-*   required: true,
-*   schema: createSchema({ type: 'string', nullable: true }),
-* })
-* // required=true, no optional/nullish
+* await walk(root, { depth: 'shallow', input: () => {} })
 * ```
 */
-function createProperty(props) {
-	const required = props.required ?? false;
-	return {
-		...props,
-		kind: "Property",
-		required,
-		schema: syncOptionality(props.schema, required)
-	};
+async function walk(node, options) {
+	return _walk(node, options, (options.depth ?? visitorDepths.deep) === visitorDepths.deep, createLimit(options.concurrency ?? 30), void 0);
+}
+async function _walk(node, visitor, recurse, limit, parent) {
+	await limit(() => applyVisitor(node, visitor, parent));
+	let pending;
+	for (const child of getChildren(node, recurse)) (pending ??= []).push(_walk(child, visitor, recurse, limit, node));
+	if (pending) await Promise.all(pending);
+}
+function transform(node, options) {
+	const { depth, parent, ...visitor } = options;
+	return transformNode(node, visitor, (depth ?? visitorDepths.deep) === visitorDepths.deep, parent);
+}
+/**
+* Visits a single node, then immutably rebuilds its children. Returns the original
+* reference when neither the visitor nor the child rebuild changed anything, so callers
+* can detect "nothing changed" by identity and ancestors avoid reallocating.
+*/
+function transformNode(node, visitor, recurse, parent) {
+	return transformChildren(applyVisitor(node, visitor, parent) ?? node, visitor, recurse);
+}
+/**
+* Immutably rebuilds a node's children using {@link VISITOR_KEYS}, transforming
+* each child node and leaving non-node values (e.g. `additionalProperties: true`) intact.
+* `Schema` children are skipped in shallow mode.
+*/
+function transformChildren(node, visitor, recurse) {
+	if (node.kind === "Schema" && !recurse) return node;
+	const keys = visitorKeysByKind[node.kind];
+	if (!keys) return node;
+	const record = node;
+	let updates;
+	for (const key of keys) {
+		if (!(key in record)) continue;
+		const value = record[key];
+		if (Array.isArray(value)) {
+			let mapped;
+			for (const [i, item] of value.entries()) {
+				const next = isNode(item) ? transformNode(item, visitor, recurse, node) : item;
+				if (mapped) {
+					mapped.push(next);
+					continue;
+				}
+				if (next !== item) mapped = [...value.slice(0, i), next];
+			}
+			if (mapped) (updates ??= {})[key] = mapped;
+		} else if (isNode(value)) {
+			const next = transformNode(value, visitor, recurse, node);
+			if (next !== value) (updates ??= {})[key] = next;
+		}
+	}
+	return updates ? {
+		...node,
+		...updates
+	} : node;
 }
 /**
-* Creates a `ParameterNode`.
+* Lazy depth-first collection pass. Yields every non-null value returned by
+* the visitor callbacks. Use `collect` for the eager array form.
 *
-* `required` defaults to `false`.
-* Nested schema flags are set from `required` and `schema.nullable`.
-*
-* @example
+* @example Collect every operationId
 * ```ts
-* const param = createParameter({
-*   name: 'petId',
-*   in: 'path',
-*   required: true,
-*   schema: createSchema({ type: 'string' }),
-* })
+* const ids: string[] = []
+* for (const id of collectLazy<string>(root, {
+*   operation(node) {
+*     return node.operationId
+*   },
+* })) {
+*   ids.push(id)
+* }
 * ```
+*/
+function* collectLazy(node, options) {
+	const { depth, parent, ...visitor } = options;
+	yield* collectNode(node, visitor, (depth ?? visitorDepths.deep) === visitorDepths.deep, parent);
+}
+function* collectNode(node, visitor, recurse, parent) {
+	const v = applyVisitor(node, visitor, parent);
+	if (v != null) yield v;
+	for (const child of getChildren(node, recurse)) yield* collectNode(child, visitor, recurse, node);
+}
+/**
+* Eager depth-first collection pass. Gathers every non-null value the visitor
+* callbacks return into an array.
 *
-* @example
+* @example Collect every operationId
 * ```ts
-* const param = createParameter({
-*   name: 'status',
-*   in: 'query',
-*   schema: createSchema({ type: 'string', nullable: true }),
+* const ids = collect<string>(root, {
+*   operation(node) {
+*     return node.operationId
+*   },
 * })
-* // required=false, schema.nullish=true
 * ```
 */
-function createParameter(props) {
-	const required = props.required ?? false;
-	return {
-		...props,
-		kind: "Parameter",
-		required,
-		schema: syncOptionality(props.schema, required)
-	};
+function collect(node, options) {
+	return Array.from(collectLazy(node, options));
+}
+//#endregion
+//#region src/defineMacro.ts
+/**
+* Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain
+* list keeps its authored order.
+*/
+function enforceWeight(enforce) {
+	if (enforce === "pre") return 0;
+	if (enforce === "post") return 2;
+	return 1;
 }
 /**
-* Creates a `ResponseNode`.
+* Types a macro for inference and a single construction site, mirroring `definePlugin`.
+* Adds no runtime behavior.
 *
 * @example
 * ```ts
-* const response = createResponse({
-*   statusCode: '200',
-*   description: 'Success',
-*   schema: createSchema({ type: 'object', properties: [] }),
+* const macroUntagged = defineMacro({
+*   name: 'untagged',
+*   operation(node) {
+*     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }
+*   },
 * })
 * ```
 */
-function createResponse(props) {
-	return {
-		...props,
-		kind: "Response"
-	};
+function defineMacro(macro) {
+	return macro;
 }
 /**
-* Creates a `FunctionParameterNode`.
-*
-* `optional` defaults to `false`.
+* Runs every macro's callback for one node kind in order, chaining the result so each macro sees
+* the previous macro's output. Returns `undefined` when nothing changed, so `transform` keeps the
+* original reference (structural sharing).
+*/
+function chain({ macros, key, node, context }) {
+	let current = node;
+	for (const macro of macros) {
+		const callback = macro[key];
+		if (!callback) continue;
+		if (macro.when && !macro.when(current)) continue;
+		const next = callback(current, context);
+		if (next != null) current = next;
+	}
+	return current === node ? void 0 : current;
+}
+/**
+* Folds an ordered list of macros into a single {@link Visitor} that `transform` (and the per-plugin
+* transform layer in `@kubb/core`) can run. Macros are stable-sorted by `enforce`, then applied
+* sequentially per node so later macros see earlier output. This differs from a plain visitor, which
+* has no names, ordering, or composition.
 *
-* @example Required typed param
+* @example
 * ```ts
-* createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }) })
-* // → petId: string
+* const visitor = composeMacros([macroSimplifyUnion, macroDiscriminatorEnum])
+* const next = transform(root, visitor)
 * ```
+*/
+function composeMacros(macros) {
+	const ordered = [...macros].sort((a, b) => enforceWeight(a.enforce) - enforceWeight(b.enforce));
+	const visitor = {};
+	for (const key of visitorKeys) {
+		if (!ordered.some((macro) => typeof macro[key] === "function")) continue;
+		const callback = (node, context) => chain({
+			macros: ordered,
+			key,
+			node,
+			context
+		});
+		visitor[key] = callback;
+	}
+	return visitor;
+}
+/**
+* Runs a list of macros over a node tree and returns the rewritten tree. Keeps `transform`'s
+* structural sharing, so an empty or no-op macro list returns the same reference. Pass
+* `depth: 'shallow'` to rewrite the root node only.
 *
-* @example Optional param
+* @example
 * ```ts
-* createFunctionParameter({ name: 'params', type: createParamsType({ variant: 'reference', name: 'QueryParams' }), optional: true })
-* // → params?: QueryParams
+* const next = applyMacros(root, [macroIntegerToString])
 * ```
 *
-* @example Param with default (implicitly optional; cannot combine with `optional: true`)
+* @example Apply to the root node only
 * ```ts
-* createFunctionParameter({ name: 'config', type: createParamsType({ variant: 'reference', name: 'RequestConfig' }), default: '{}' })
-* // → config: RequestConfig = {}
+* const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })
 * ```
 */
-function createFunctionParameter(props) {
-	return {
-		optional: false,
-		...props,
-		kind: "FunctionParameter"
-	};
+function applyMacros(root, macros, options) {
+	if (macros.length === 0) return root;
+	return transform(root, {
+		...composeMacros(macros),
+		...options
+	});
 }
+//#endregion
+//#region src/createPrinter.ts
 /**
-* Creates a {@link TypeNode} representing a language-agnostic structured type expression.
+* Creates a schema printer: a function that takes a `SchemaNode` and emits
+* code in your target language. Each plugin that produces code from schemas
+* (TypeScript types, Zod schemas, Faker factories) ships a printer built
+* with this helper.
 *
-* Use `variant: 'struct'` for inline anonymous types and `variant: 'member'` for a single
-* named field accessed from a group type. Each language's printer renders the variant
-* into its own syntax (TypeScript, Python, C#, Kotlin, …).
+* The builder receives resolved options and returns:
 *
-* @example Reference type (TypeScript: `QueryParams`)
-* ```ts
-* createParamsType({ variant: 'reference', name: 'QueryParams' })
-* ```
+* - `name` unique identifier for the printer.
+* - `options` stored on the returned printer instance.
+* - `nodes` map of `SchemaType` → handler. Handlers return the rendered
+*   output (a string, a TypeScript AST node, ...) for that schema type.
+* - `overrides` (optional), user-supplied handlers that win over `nodes`.
+*   An override can call `this.base(node)` to reuse the handler it replaced.
+* - `print` (optional), top-level override exposed as `printer.print`.
+*   Use `this.transform(node)` inside it to dispatch to `nodes` recursively.
 *
-* @example Struct type (TypeScript: `{ petId: string }`)
-* ```ts
-* createParamsType({ variant: 'struct', properties: [{ name: 'petId', optional: false, type: createParamsType({ variant: 'reference', name: 'string' }) }] })
-* ```
+* Without a `print` override, `printer.print` falls back to `printer.transform`
+* (the node-level dispatcher).
 *
-* @example Member type (TypeScript: `DeletePetPathParams['petId']`)
+* @example Tiny Zod printer
 * ```ts
-* createParamsType({ variant: 'member', base: 'DeletePetPathParams', key: 'petId' })
+* import { createPrinter, type PrinterFactoryOptions } from '@kubb/ast'
+*
+* type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
+*
+* export const zodPrinter = createPrinter<PrinterZod>((options) => ({
+*   name: 'zod',
+*   options: { strict: options.strict ?? true },
+*   nodes: {
+*     string: () => 'z.string()',
+*     object(node) {
+*       const props = node.properties
+*         .map((p) => `${p.name}: ${this.transform(p.schema)}`)
+*         .join(', ')
+*       return `z.object({ ${props} })`
+*     },
+*   },
+* }))
 * ```
 */
-function createParamsType(props) {
-	return {
-		...props,
-		kind: "ParamsType"
+function createPrinter(build) {
+	return (options) => {
+		const { name, options: resolvedOptions, nodes, overrides, print: printOverride } = build(options ?? {});
+		const merged = overrides ? {
+			...nodes,
+			...overrides
+		} : nodes;
+		const context = {
+			options: resolvedOptions,
+			transform: (node) => {
+				const handler = merged[node.type];
+				if (!handler) return null;
+				return handler.call(context, node);
+			},
+			base: (node) => {
+				const handler = nodes[node.type];
+				if (!handler) return null;
+				return handler.call(context, node);
+			}
+		};
+		return {
+			name,
+			options: resolvedOptions,
+			transform: context.transform,
+			print: printOverride ? printOverride.bind(context) : context.transform
+		};
 	};
 }
+//#endregion
+//#region src/utils/codegen.ts
 /**
-* Creates a `ParameterGroupNode` representing a group of related parameters treated as a unit.
+* Builds a JSDoc comment block from an array of lines. Returns `fallback` when there are no
+* comments.
 *
-* @example Grouped param (TypeScript declaration)
+* @example
 * ```ts
-* createParameterGroup({
-*   properties: [
-*     createFunctionParameter({ name: 'id', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false }),
-*     createFunctionParameter({ name: 'name', type: createParamsType({ variant: 'reference', name: 'string' }), optional: true }),
-*   ],
-*   default: '{}',
-* })
-* // declaration → { id, name? }: { id: string; name?: string } = {}
-* // call        → { id, name }
+* buildJSDoc(['@type string', '@example hello'])
+* // '/**\n   * @type string\n   * @example hello\n   *\/\n  '
 * ```
+*/
+function buildJSDoc(comments, options = {}) {
+	const { indent = "   * ", suffix = "\n  ", fallback = "  " } = options;
+	if (comments.length === 0) return fallback;
+	return `/**\n${comments.map((c) => `${indent}${c}`).join("\n")}\n   */${suffix}`;
+}
+/**
+* Indents every non-empty line of `text` by one indent level, leaving blank lines empty.
+*/
+function indentLines(text) {
+	if (!text) return "";
+	return text.split("\n").map((line) => line.trim() ? `  ${line}` : "").join("\n");
+}
+/**
+* Renders an object key, quoting it with single quotes only when it is not a valid identifier.
+* Reserved words and globals (`name`, `class`, …) are valid bare keys and stay unquoted.
 *
-* @example Inline (spread) — children emitted as individual top-level parameters
+* @example
 * ```ts
-* createParameterGroup({
-*   properties: [createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false })],
-*   inline: true,
-* })
-* // declaration → petId: string
-* // call        → petId
+* objectKey('name')    // 'name'
+* objectKey('x-total') // "'x-total'"
 * ```
 */
-function createParameterGroup(props) {
-	return {
-		...props,
-		kind: "ParameterGroup"
-	};
+function objectKey(name) {
+	return isIdentifier(name) ? name : singleQuote(name);
 }
 /**
-* Creates a `FunctionParametersNode` from an ordered list of parameters.
+* Assembles a multi-line object literal from already-rendered `entries`, indenting each entry one
+* level and closing the brace at column zero. Entries that are themselves multi-line objects indent
+* cumulatively. Each entry ends with a trailing comma to match the formatter's multi-line style.
 *
 * @example
 * ```ts
-* createFunctionParameters({
-*   params: [
-*     createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false }),
-*     createFunctionParameter({ name: 'config', type: createParamsType({ variant: 'reference', name: 'RequestConfig' }), optional: false, default: '{}' }),
-*   ],
-* })
+* buildObject(['id: z.number()', 'name: z.string()'])
+* // '{\n  id: z.number(),\n  name: z.string(),\n}'
 * ```
+*/
+function buildObject(entries) {
+	if (entries.length === 0) return "{}";
+	return `{\n${entries.map((entry) => `${indentLines(entry)},`).join("\n")}\n}`;
+}
+/**
+* Assembles a bracketed list (array by default) from already-rendered `items`. Keeps everything on
+* one line when no item spans multiple lines, and otherwise puts each item on its own line, indented
+* one level with a trailing comma and the closing bracket at column zero. Used for member lists such
+* as `z.union([…])` and `z.array([…])`.
 *
 * @example
 * ```ts
-* const empty = createFunctionParameters()
-* // { kind: 'FunctionParameters', params: [] }
+* buildList(['z.string()', 'z.number()'])
+* // '[z.string(), z.number()]'
 * ```
 */
-function createFunctionParameters(props = {}) {
-	return {
-		params: [],
-		...props,
-		kind: "FunctionParameters"
-	};
+function buildList(items, brackets = ["[", "]"]) {
+	const [open, close] = brackets;
+	if (items.length === 0) return `${open}${close}`;
+	if (!items.some((item) => item.includes("\n"))) return `${open}${items.join(", ")}${close}`;
+	return `${open}\n${items.map((item) => `${indentLines(item)},`).join("\n")}\n${close}`;
+}
+//#endregion
+//#region src/utils/refs.ts
+const plainStringTypes = /* @__PURE__ */ new Set([
+	"string",
+	"uuid",
+	"email",
+	"url",
+	"datetime"
+]);
+/**
+* Returns the last path segment of a reference string.
+*
+* @example
+* `extractRefName('#/components/schemas/Pet') // 'Pet'`
+*/
+function extractRefName(ref) {
+	return ref.split("/").at(-1) ?? ref;
 }
 /**
-* Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
+* Resolves the schema name of a ref node. Uses the last segment of `ref` when set, otherwise falls
+* back to `name` then nested `schema.name`.
 *
-* @example Named import
-* ```ts
-* createImport({ name: ['useState'], path: 'react' })
-* // import { useState } from 'react'
-* ```
+* Returns `null` for non-ref nodes or when no name resolves.
 *
-* @example Type-only import
-* ```ts
-* createImport({ name: ['FC'], path: 'react', isTypeOnly: true })
-* // import type { FC } from 'react'
-* ```
+* @example
+* `resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Pet' }) // 'Pet'`
 */
-function createImport(props) {
-	return {
-		...props,
-		kind: "Import"
-	};
+function resolveRefName(node) {
+	if (!node || node.type !== "ref") return null;
+	if (node.ref) return extractRefName(node.ref) ?? node.name ?? node.schema?.name ?? null;
+	return node.name ?? node.schema?.name ?? null;
 }
 /**
-* Creates an `ExportNode` representing a language-agnostic export/public API declaration.
+* Builds a PascalCase child schema name by joining a parent name and property name.
+* Returns `null` when there is no parent to nest under.
 *
-* @example Named export
-* ```ts
-* createExport({ name: ['Pet'], path: './Pet' })
-* // export { Pet } from './Pet'
-* ```
+* @example Nested under a parent
+* `childName('Order', 'shipping_address') // 'OrderShippingAddress'`
 *
-* @example Wildcard export
-* ```ts
-* createExport({ path: './utils' })
-* // export * from './utils'
-* ```
+* @example No parent
+* `childName(undefined, 'params') // null`
 */
-function createExport(props) {
-	return {
-		...props,
-		kind: "Export"
-	};
+function childName(parentName, propName) {
+	return parentName ? pascalCase([parentName, propName].join(" ")) : null;
 }
 /**
-* Creates a `SourceNode` representing a fragment of source code within a file.
+* Builds a PascalCase enum name from the parent name, property name, and a suffix, skipping any
+* empty parts.
 *
 * @example
-* ```ts
-* createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
-* ```
+* `enumPropName('Order', 'status', 'enum') // 'OrderStatusEnum'`
 */
-function createSource(props) {
-	return {
-		...props,
-		kind: "Source"
-	};
+function enumPropName(parentName, propName, enumSuffix) {
+	return pascalCase([
+		parentName,
+		propName,
+		enumSuffix
+	].filter(Boolean).join(" "));
 }
 /**
-* Creates a fully resolved `FileNode` from a file input descriptor.
-*
-* Computes:
-* - `id` — SHA256 hash of the file path
-* - `name` — `baseName` without extension
-* - `extname` — extension extracted from `baseName`
-*
-* Deduplicates:
-* - `sources` via `combineSources`
-* - `exports` via `combineExports`
-* - `imports` via `combineImports` (also filters unused imports)
+* Merges a ref node with its resolved schema, giving usage-site fields precedence.
 *
-* @throws {Error} when `baseName` has no extension.
+* Every field set on the ref node except `kind`, `type`, `name`, `ref`, and `schema` overrides the
+* same field in the resolved `node.schema` (for example `description`, `nullable`, `readOnly`,
+* `deprecated`). Fields left `undefined` on the ref do not shadow the resolved schema. Non-ref
+* nodes and refs without a resolved `schema` are returned unchanged.
 *
 * @example
 * ```ts
-* const file = createFile({
-*   baseName: 'petStore.ts',
-*   path: 'src/models/petStore.ts',
-*   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')] })],
-*   imports: [createImport({ name: ['z'], path: 'zod' })],
-*   exports: [createExport({ name: ['Pet'], path: './petStore' })],
-* })
-* // file.id      = SHA256 hash of 'src/models/petStore.ts'
-* // file.name    = 'petStore'
-* // file.extname = '.ts'
+* const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A cute pet' })
+* const merged = syncSchemaRef(ref) // merges with resolved Pet schema
 * ```
 */
-function createFile(input) {
-	const extname = path.extname(input.baseName) || (input.baseName.startsWith(".") ? input.baseName : "");
-	if (!extname) throw new Error(`No extname found for ${input.baseName}`);
-	const source = (input.sources ?? []).flatMap((item) => item.nodes ?? []).map((node) => extractStringsFromNodes([node])).filter(Boolean).join("\n\n");
-	const resolvedExports = input.exports?.length ? combineExports(input.exports) : [];
-	const resolvedImports = input.imports?.length ? combineImports(input.imports, resolvedExports, source || void 0) : [];
-	const resolvedSources = input.sources?.length ? combineSources(input.sources) : [];
-	return {
-		kind: "File",
-		...input,
-		id: createHash("sha256").update(input.path).digest("hex"),
-		name: trimExtName(input.baseName),
-		extname,
-		imports: resolvedImports,
-		exports: resolvedExports,
-		sources: resolvedSources,
-		meta: input.meta ?? {}
-	};
+function syncSchemaRef(node) {
+	const ref = narrowSchema(node, "ref");
+	if (!ref) return node;
+	if (!ref.schema) return node;
+	const { kind: _kind, type: _type, name: _name, ref: _ref, schema: _schema, ...overrides } = ref;
+	const definedOverrides = Object.fromEntries(Object.entries(overrides).filter(([, v]) => v !== void 0));
+	return createSchema({
+		...ref.schema,
+		...definedOverrides
+	});
+}
+/**
+* Type guard that returns `true` when a schema emits as a plain `string` type.
+*
+* Covers `string`, `uuid`, `email`, `url`, and `datetime` types. For `date` and `time`
+* types, returns `true` only when `representation` is `'string'` rather than `'date'`.
+*/
+function isStringType(node) {
+	if (plainStringTypes.has(node.type)) return true;
+	const temporal = narrowSchema(node, "date") ?? narrowSchema(node, "time");
+	if (temporal) return temporal.representation !== "date";
+	return false;
 }
+//#endregion
+//#region src/utils/schemaMerge.ts
 /**
-* Creates a `ConstNode` representing a TypeScript `const` declaration.
-*
-* Mirrors the `Const` component from `@kubb/renderer-jsx`.
-* The component's `children` are represented as `nodes`.
+* Merges a run of adjacent anonymous object members into one. Named or non-object members break the
+* run and pass through unchanged. The merge follows member order, so callers control which members
+* combine by where they place them in the sequence.
 *
-* @example Simple constant
-* ```ts
-* createConst({ name: 'pet' })
-* // const pet = ...
-* ```
-*
-* @example Exported constant with type and `as const`
+* @example
 * ```ts
-* createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
-* // export const pets: Pet[] = ... as const
+* const merged = [...mergeAdjacentObjectsLazy([objectA, objectB])]
 * ```
+*/
+function* mergeAdjacentObjectsLazy(members) {
+	let acc;
+	for (const member of members) {
+		const objectMember = narrowSchema(member, "object");
+		if (objectMember && !objectMember.name && acc !== void 0) {
+			const accObject = narrowSchema(acc, "object");
+			if (accObject && !accObject.name) {
+				acc = createSchema({
+					...accObject,
+					properties: [...accObject.properties ?? [], ...objectMember.properties ?? []]
+				});
+				continue;
+			}
+		}
+		if (acc !== void 0) yield acc;
+		acc = member;
+	}
+	if (acc !== void 0) yield acc;
+}
+//#endregion
+//#region src/utils/strings.ts
+/**
+* Strips a single matching pair of `"..."`, `'...'`, or `` `...` `` from both ends of `text`.
+* Returns the string unchanged when no balanced quote pair is found.
 *
-* @example With JSDoc and child nodes
+* @example
 * ```ts
-* createConst({
-*   name: 'config',
-*   export: true,
-*   JSDoc: { comments: ['@description App configuration'] },
-*   nodes: [],
-* })
+* trimQuotes('"hello"') // 'hello'
+* trimQuotes('hello')   // 'hello'
 * ```
 */
-function createConst(props) {
-	return {
-		...props,
-		kind: "Const"
-	};
+function trimQuotes(text) {
+	if (text.length >= 2) {
+		const first = text[0];
+		const last = text[text.length - 1];
+		if (first === "\"" && last === "\"" || first === "'" && last === "'" || first === "`" && last === "`") return text.slice(1, -1);
+	}
+	return text;
 }
 /**
-* Creates a `TypeNode` representing a TypeScript `type` alias declaration.
-*
-* Mirrors the `Type` component from `@kubb/renderer-jsx`.
-* The component's `children` are represented as `nodes`.
+* Serializes a primitive to a single-quoted string literal, stripping any surrounding quotes first.
 *
-* @example Simple type alias
-* ```ts
-* createType({ name: 'Pet' })
-* // type Pet = ...
-* ```
+* Escaping runs through `JSON.stringify`, then the result switches to single quotes so the generated
+* code matches the repo style without a formatter.
 *
-* @example Exported type with JSDoc
+* @example
 * ```ts
-* createType({
-*   name: 'PetStatus',
-*   export: true,
-*   JSDoc: { comments: ['@description Status of a pet'] },
-* })
-* // export type PetStatus = ...
+* stringify('hello')   // "'hello'"
+* stringify('"hello"') // "'hello'"
 * ```
 */
-function createType(props) {
-	return {
-		...props,
-		kind: "Type"
-	};
+function stringify(value) {
+	if (value === void 0 || value === null) return "''";
+	return `'${JSON.stringify(trimQuotes(value.toString())).slice(1, -1).replace(/\\"/g, "\"").replace(/'/g, "\\'")}'`;
 }
 /**
-* Creates a `FunctionNode` representing a TypeScript `function` declaration.
+* Escapes characters that are not allowed inside JS string literals, covering quotes, backslashes,
+* and the Unicode line terminators U+2028 and U+2029.
 *
-* Mirrors the `Function` component from `@kubb/renderer-jsx`.
-* The component's `children` are represented as `nodes`.
+* @see http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
 *
-* @example Simple function
+* @example
 * ```ts
-* createFunction({ name: 'getPet' })
-* // function getPet() { ... }
+* jsStringEscape('say "hi"\nbye') // 'say \\"hi\\"\\nbye'
 * ```
+*/
+function jsStringEscape(input) {
+	return `${input}`.replace(/["'\\\n\r\u2028\u2029]/g, (character) => {
+		switch (character) {
+			case "\"":
+			case "'":
+			case "\\": return `\\${character}`;
+			case "\n": return "\\n";
+			case "\r": return "\\r";
+			case "\u2028": return "\\u2028";
+			case "\u2029": return "\\u2029";
+			default: return "";
+		}
+	});
+}
+/**
+* Converts a pattern string into a `new RegExp(...)` constructor call or a regex literal string.
+* Inline flags expressed as a `^(?im)` prefix are extracted and applied to the resulting expression.
+* Pass `null` as the second argument to emit a `/pattern/flags` literal instead.
 *
-* @example Exported async function with return type
+* @example
 * ```ts
-* createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
-* // export async function fetchPet(): Promise<Pet> { ... }
+* toRegExpString('^(?im)foo')       // 'new RegExp("^foo", "im")'
+* toRegExpString('^(?im)foo', null) // '/^foo/im'
 * ```
+*/
+function toRegExpString(text, func = "RegExp") {
+	const raw = trimQuotes(text);
+	const match = raw.match(/^\^(\(\?([igmsuy]+)\))/i);
+	const replacementTarget = match?.[1] ?? "";
+	const matchedFlags = match?.[2];
+	const cleaned = raw.replace(/^\\?\//, "").replace(/\\?\/$/, "").replace(replacementTarget, "");
+	const { source, flags } = new RegExp(cleaned, matchedFlags);
+	if (func === null) return `/${source}/${flags}`;
+	return `new ${func}(${JSON.stringify(source)}${flags ? `, ${JSON.stringify(flags)}` : ""})`;
+}
+/**
+* Renders a plain object as multi-line `key: value` source for embedding in generated code. Nested
+* objects recurse with fixed indentation, so the result drops straight into an object literal
+* without re-parsing.
 *
-* @example Function with generics and params
+* @example
 * ```ts
-* createFunction({
-*   name: 'identity',
-*   export: true,
-*   generics: ['T'],
-*   params: 'value: T',
-*   returnType: 'T',
-* })
-* // export function identity<T>(value: T): T { ... }
+* stringifyObject({ foo: 'bar', nested: { a: 1 } })
+* // 'foo: bar,\nnested: {\n        a: 1\n      }'
 * ```
 */
-function createFunction(props) {
-	return {
-		...props,
-		kind: "Function"
-	};
+function stringifyObject(value) {
+	return Object.entries(value).map(([key, val]) => {
+		if (val !== null && typeof val === "object") return `${key}: {\n        ${stringifyObject(val)}\n      }`;
+		return `${key}: ${val}`;
+	}).filter(Boolean).join(",\n");
 }
 /**
-* Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
+* Renders a dotted path or string array as an optional-chaining accessor expression rooted at
+* `accessor`. Returns `null` for an empty path.
 *
-* Mirrors the `Function.Arrow` component from `@kubb/renderer-jsx`.
-* The component's `children` are represented as `nodes`.
-*
-* @example Simple arrow function
+* @example
 * ```ts
-* createArrowFunction({ name: 'getPet' })
-* // const getPet = () => { ... }
+* getNestedAccessor('pagination.next.id', 'lastPage')
+* // "lastPage?.['pagination']?.['next']?.['id']"
 * ```
+*/
+function getNestedAccessor(param, accessor) {
+	const parts = Array.isArray(param) ? param : param.split(".");
+	if (parts.length === 0 || parts.length === 1 && parts[0] === "") return null;
+	return `${accessor}?.['${`${parts.join("']?.['")}']`}`;
+}
+//#endregion
+//#region src/utils/schemaGraph.ts
+/**
+* Memoized inner pass that walks a single node and returns the names of every schema it references.
+*/
+const collectSchemaRefs = memoize(/* @__PURE__ */ new WeakMap(), (node) => {
+	const refs = /* @__PURE__ */ new Set();
+	collect(node, { schema(child) {
+		if (child.type === "ref") {
+			const name = resolveRefName(child);
+			if (name) refs.add(name);
+		}
+	} });
+	return refs;
+});
+/**
+* Collects the names of every ref found anywhere inside a node's own subtree.
+*
+* Each ref contributes its name only, so the schema it points to is never traversed here. Pass `out`
+* to accumulate names from several nodes into one set.
 *
-* @example Single-line exported arrow function
+* @example Collect refs from a single schema
 * ```ts
-* createArrowFunction({ name: 'double', export: true, params: 'n: number', singleLine: true })
-* // export const double = (n: number) => ...
+* const names = collectReferencedSchemaNames(petSchema)
+* // Set { 'Category', 'Tag' }
 * ```
 *
-* @example Async arrow function with generics
+* @example Accumulate refs from multiple schemas into one set
 * ```ts
-* createArrowFunction({
-*   name: 'fetchPet',
-*   export: true,
-*   async: true,
-*   generics: ['T'],
-*   params: 'id: string',
-*   returnType: 'T',
-* })
-* // export const fetchPet = async <T>(id: string): Promise<T> => { ... }
+* const out = new Set<string>()
+* for (const schema of schemas) {
+*   collectReferencedSchemaNames(schema, out)
+* }
 * ```
 */
-function createArrowFunction(props) {
-	return {
-		...props,
-		kind: "ArrowFunction"
-	};
+function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
+	if (!node) return out;
+	for (const name of collectSchemaRefs(node)) out.add(name);
+	return out;
 }
 /**
-* Creates a {@link TextNode} representing a raw string fragment in the source output.
-*
-* Use this instead of bare strings when building `nodes` arrays so that every
-* entry in the array is a typed {@link CodeNode}.
-*
-* @example
-* ```ts
-* createText('return fetch(id)')
-* // { kind: 'Text', value: 'return fetch(id)' }
-* ```
+* Memoized two-level cache keyed first on the operations array, then on the schemas array.
 */
-function createText(value) {
-	return {
-		value,
-		kind: "Text"
-	};
+const collectUsedSchemaNamesMemo = memoize(/* @__PURE__ */ new WeakMap(), (ops) => memoize(/* @__PURE__ */ new WeakMap(), (schemas) => computeUsedSchemaNames(ops, schemas)));
+function computeUsedSchemaNames(operations, schemas) {
+	const schemaMap = /* @__PURE__ */ new Map();
+	for (const schema of schemas) if (schema.name) schemaMap.set(schema.name, schema);
+	const result = /* @__PURE__ */ new Set();
+	function visitSchema(schema) {
+		const directRefs = collectReferencedSchemaNames(schema);
+		for (const name of directRefs) if (!result.has(name)) {
+			result.add(name);
+			const namedSchema = schemaMap.get(name);
+			if (namedSchema) visitSchema(namedSchema);
+		}
+	}
+	for (const op of operations) for (const schema of collectLazy(op, {
+		depth: "shallow",
+		schema: (node) => node
+	})) visitSchema(schema);
+	return result;
 }
 /**
-* Creates a {@link BreakNode} representing a line break in the source output.
+* Collects the names of all top-level schemas transitively used by a set of operations.
 *
-* Corresponds to `<br/>` in JSX components. Prints as an empty string which,
-* when joined with `\n` by `printNodes`, produces a blank line.
+* An operation uses a schema when its parameters, request body, or responses reference it, directly
+* or through other named schemas. Once a name is added to the result it is not revisited, so
+* reference cycles terminate.
 *
-* @example
+* Pair it with `include` filters so schemas reachable only from excluded operations stay ungenerated.
+*
+* @example Only generate schemas referenced by included operations
 * ```ts
-* createBreak()
-* // { kind: 'Break' }
+* const includedOps = operations.filter((op) => resolver.resolveOptions(op, { options, include }) !== null)
+* const allowed = collectUsedSchemaNames(includedOps, schemas)
+*
+* for (const schema of schemas) {
+*   if (schema.name && !allowed.has(schema.name)) continue
+*   // generate schema
+* }
 * ```
 */
-function createBreak() {
-	return { kind: "Break" };
+function collectUsedSchemaNames(operations, schemas) {
+	return collectUsedSchemaNamesMemo(operations)(schemas);
 }
+const EMPTY_CIRCULAR_SET = /* @__PURE__ */ new Set();
+const findCircularSchemasMemo = memoize(/* @__PURE__ */ new WeakMap(), (schemas) => {
+	const graph = /* @__PURE__ */ new Map();
+	for (const schema of schemas) {
+		if (!schema.name) continue;
+		graph.set(schema.name, collectReferencedSchemaNames(schema));
+	}
+	const circular = /* @__PURE__ */ new Set();
+	for (const start of graph.keys()) {
+		const visited = /* @__PURE__ */ new Set();
+		const stack = [...graph.get(start) ?? []];
+		while (stack.length > 0) {
+			const node = stack.pop();
+			if (node === start) {
+				circular.add(start);
+				break;
+			}
+			if (visited.has(node)) continue;
+			visited.add(node);
+			const next = graph.get(node);
+			if (next) for (const r of next) stack.push(r);
+		}
+	}
+	return circular;
+});
 /**
-* Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
+* Finds every schema that takes part in a circular dependency chain, including direct self-loops.
 *
-* Use this to embed JSX markup (including fragments `<>…</>`) directly in generated code.
+* Wrap the returned schema positions in a deferred construct (a lazy getter or `z.lazy(() => …)`) so
+* the generated code does not recurse forever. Refs are followed by name only, so the walk stays
+* linear in the size of the schema graph.
 *
-* @example
-* ```ts
-* createJsx('<>\n  <a href={href}>Open</a>\n</>')
-* // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
-* ```
+* @note Call this once on the full graph, then check individual schemas with `containsCircularRef()`.
 */
-function createJsx(value) {
-	return {
-		value,
-		kind: "Jsx"
-	};
+function findCircularSchemas(schemas) {
+	if (schemas.length === 0) return EMPTY_CIRCULAR_SET;
+	return findCircularSchemasMemo(schemas);
 }
-//#endregion
-//#region src/printer.ts
 /**
-* Creates a schema printer factory.
-*
-* This function wraps a builder and makes options optional at call sites.
+* Returns `true` when a schema, or anything nested inside it, references a circular schema.
 *
-* The builder receives resolved options and returns:
-* - `name` — a unique identifier for the printer
-* - `options` — options stored on the returned printer instance
-* - `nodes` — a map of `SchemaType` → handler functions that convert a `SchemaNode` to `TOutput`
-* - `print` _(optional)_ — top-level override exposed as `printer.print`
-*   - Inside this function, use `this.transform(node)` to dispatch to the `nodes` map
-*   - This keeps recursion safe and avoids self-calls
-*
-* When no `print` override is provided, `printer.print` falls back to `printer.transform` (the node-level dispatcher).
-*
-* @example Basic usage — Zod schema printer
-* ```ts
-* type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
+* Pass `excludeName` to skip refs to a specific schema, which helps when self-references are handled
+* on their own. Pair it with `findCircularSchemas()` to decide where lazy wrappers go.
 *
-* export const zodPrinter = definePrinter<PrinterZod>((options) => ({
-*   name: 'zod',
-*   options: { strict: options.strict ?? true },
-*   nodes: {
-*     string: () => 'z.string()',
-*     object(node) {
-*       const props = node.properties.map(p => `${p.name}: ${this.transform(p.schema)}`).join(', ')
-*       return `z.object({ ${props} })`
-*     },
-*   },
-* }))
-* ```
+* @note Stops at the first matching circular ref.
 */
-function definePrinter(build) {
-	return createPrinterFactory((node) => node.type)(build);
+function containsCircularRef(node, { circularSchemas, excludeName }) {
+	if (!node || circularSchemas.size === 0) return false;
+	for (const _ of collectLazy(node, { schema(child) {
+		if (child.type !== "ref") return null;
+		const name = resolveRefName(child);
+		return name && name !== excludeName && circularSchemas.has(name) ? true : null;
+	} })) return true;
+	return false;
 }
+//#endregion
+//#region src/utils/schemaTraversal.ts
 /**
-* Generic printer-factory function used by `definePrinter` and `defineFunctionPrinter`.
-**
+* Maps each property of an object schema to its transformed output. Pairs every result with the
+* original property so the printer keeps full control over modifiers, getters, and key syntax.
+*
 * @example
 * ```ts
-* export const defineFunctionPrinter = createPrinterFactory<FunctionNode, FunctionNodeType, FunctionNodeByType>(
-*   (node) => kindToHandlerKey[node.kind],
-* )
+* const entries = mapSchemaProperties(node, (schema) => this.transform(schema))
+* // entries: [{ name: 'id', property, output: 'z.number()' }, ...]
 * ```
 */
-function createPrinterFactory(getKey) {
-	return function(build) {
-		return (options) => {
-			const { name, options: resolvedOptions, nodes, print: printOverride } = build(options ?? {});
-			const context = {
-				options: resolvedOptions,
-				transform: (node) => {
-					const key = getKey(node);
-					if (key === void 0) return null;
-					const handler = nodes[key];
-					if (!handler) return null;
-					return handler.call(context, node);
-				}
-			};
-			return {
-				name,
-				options: resolvedOptions,
-				transform: context.transform,
-				print: printOverride ? printOverride.bind(context) : context.transform
-			};
-		};
-	};
-}
-//#endregion
-//#region src/resolvers.ts
-function findDiscriminator(mapping, ref) {
-	if (!mapping || !ref) return null;
-	return Object.entries(mapping).find(([, value]) => value === ref)?.[0] ?? null;
-}
-function childName(parentName, propName) {
-	return parentName ? pascalCase([parentName, propName].join(" ")) : null;
+function mapSchemaProperties(node, transform) {
+	return node.properties.map((property) => ({
+		name: property.name,
+		property,
+		output: transform(property.schema)
+	}));
 }
-function enumPropName(parentName, propName, enumSuffix) {
-	return pascalCase([
-		parentName,
-		propName,
-		enumSuffix
-	].filter(Boolean).join(" "));
+/**
+* Maps each member of a union or intersection schema to its transformed output, pairing every
+* result with the original member.
+*/
+function mapSchemaMembers(node, transform) {
+	return (node.members ?? []).map((schema) => ({
+		schema,
+		output: transform(schema)
+	}));
 }
 /**
-* Collects import entries for all `ref` schema nodes in `node`.
+* Maps each item of an array or tuple schema to its transformed output, pairing every result with
+* the original item.
 */
-function collectImports({ node, nameMapping, resolve }) {
-	return collect(node, { schema(schemaNode) {
-		const schemaRef = narrowSchema(schemaNode, "ref");
-		if (!schemaRef?.ref) return;
-		const rawName = extractRefName(schemaRef.ref);
-		const result = resolve(nameMapping.get(rawName) ?? rawName);
-		if (!result) return;
-		return result;
-	} });
+function mapSchemaItems(node, transform) {
+	return (node.items ?? []).map((schema) => ({
+		schema,
+		output: transform(schema)
+	}));
 }
-//#endregion
-//#region src/transformers.ts
 /**
-* Replaces a discriminator property's schema with a string enum of allowed values.
-*
-* If `node` is not an object schema, or if the property does not exist, the input
-* node is returned as-is.
+* Emits a lazy getter for a circular-ref property position, `get name() { return body }`. The key
+* is quoted only when it is not a valid identifier. Used by the string printers to defer evaluation
+* of a recursive schema until first access.
 *
 * @example
 * ```ts
-* const schema = createSchema({
-*   type: 'object',
-*   properties: [createProperty({ name: 'type', required: true, schema: createSchema({ type: 'string' }) })],
-* })
-* const result = setDiscriminatorEnum({ node: schema, propertyName: 'type', values: ['dog', 'cat'] })
+* lazyGetter({ name: 'parent', body: 'z.lazy(() => Pet)' })
+* // "get parent() { return z.lazy(() => Pet) }"
 * ```
 */
-function setDiscriminatorEnum({ node, propertyName, values, enumName }) {
-	const objectNode = narrowSchema(node, "object");
-	if (!objectNode?.properties?.length) return node;
-	if (!objectNode.properties.some((prop) => prop.name === propertyName)) return node;
-	return createSchema({
-		...objectNode,
-		properties: objectNode.properties.map((prop) => {
-			if (prop.name !== propertyName) return prop;
-			return createProperty({
-				...prop,
-				schema: createSchema({
-					type: "enum",
-					primitive: "string",
-					enumValues: values,
-					name: enumName,
-					readOnly: prop.schema.readOnly,
-					writeOnly: prop.schema.writeOnly
+function lazyGetter({ name, body }) {
+	return `get ${objectKey(name)}() { return ${body} }`;
+}
+//#endregion
+//#region src/macros/macroDiscriminatorEnum.ts
+/**
+* Builds a macro that replaces a discriminator property's schema with a string enum of the given
+* values. Object schemas that lack the property are returned unchanged.
+*
+* @example
+* ```ts
+* const macro = macroDiscriminatorEnum({ propertyName: 'type', values: ['dog', 'cat'] })
+* const next = applyMacros(objectSchema, [macro], { depth: 'shallow' })
+* ```
+*/
+function macroDiscriminatorEnum({ propertyName, values, enumName }) {
+	return defineMacro({
+		name: "discriminator-enum",
+		schema(node) {
+			const objectNode = narrowSchema(node, "object");
+			if (!objectNode?.properties?.length) return void 0;
+			if (!objectNode.properties.some((prop) => prop.name === propertyName)) return void 0;
+			return createSchema({
+				...objectNode,
+				properties: objectNode.properties.map((prop) => {
+					if (prop.name !== propertyName) return prop;
+					return createProperty({
+						...prop,
+						schema: createSchema({
+							type: "enum",
+							primitive: "string",
+							enumValues: values,
+							name: enumName,
+							readOnly: prop.schema.readOnly,
+							writeOnly: prop.schema.writeOnly
+						})
+					});
 				})
 			});
-		})
+		}
 	});
 }
+//#endregion
+//#region src/macros/macroEnumName.ts
 /**
-* Merges adjacent anonymous object members into a single anonymous object member.
+* Builds a macro that names an inline enum schema from its parent and property name. Boolean enums
+* are left anonymous. Non-enum nodes are returned unchanged.
 *
 * @example
 * ```ts
-* const merged = mergeAdjacentObjects([
-*   createSchema({ type: 'object', properties: [createProperty({ name: 'a', schema: createSchema({ type: 'string' }) })] }),
-*   createSchema({ type: 'object', properties: [createProperty({ name: 'b', schema: createSchema({ type: 'number' }) })] }),
-* ])
+* const macro = macroEnumName({ parentName: 'Pet', propName: 'status', enumSuffix: 'enum' })
+* const named = applyMacros(propSchema, [macro], { depth: 'shallow' })
 * ```
 */
-function mergeAdjacentObjects(members) {
-	return members.reduce((acc, member) => {
-		const objectMember = narrowSchema(member, "object");
-		if (objectMember && !objectMember.name) {
-			const previous = acc.at(-1);
-			const previousObject = previous ? narrowSchema(previous, "object") : void 0;
-			if (previousObject && !previousObject.name) {
-				acc[acc.length - 1] = createSchema({
-					...previousObject,
-					properties: [...previousObject.properties ?? [], ...objectMember.properties ?? []]
-				});
-				return acc;
-			}
+function macroEnumName({ parentName, propName, enumSuffix }) {
+	return defineMacro({
+		name: "enum-name",
+		schema(node) {
+			const enumNode = narrowSchema(node, "enum");
+			if (enumNode?.primitive === "boolean") return {
+				...node,
+				name: null
+			};
+			if (enumNode) return {
+				...node,
+				name: enumPropName(parentName, propName, enumSuffix)
+			};
 		}
-		acc.push(member);
-		return acc;
-	}, []);
+	});
 }
+//#endregion
+//#region src/macros/macroSimplifyUnion.ts
 /**
-* Removes enum members that are covered by broader scalar primitives in the same union.
-*
-* @example
-* ```ts
-* const simplified = simplifyUnion([
-*   createSchema({ type: 'enum', primitive: 'string', enumValues: ['active'] }),
-*   createSchema({ type: 'string' }),
-* ])
-* // keeps only string member
-* ```
+* Scalar primitive schema types used for union simplification and type narrowing.
+*/
+const SCALAR_PRIMITIVE_TYPES = /* @__PURE__ */ new Set([
+	"string",
+	"number",
+	"integer",
+	"bigint",
+	"boolean"
+]);
+function isScalarPrimitive(type) {
+	return SCALAR_PRIMITIVE_TYPES.has(type);
+}
+/**
+* Filters union members, dropping enum members that a broader scalar primitive already covers.
 */
-function simplifyUnion(members) {
+function simplifyUnionMembers(members) {
 	const scalarPrimitives = new Set(members.filter((member) => isScalarPrimitive(member.type)).map((m) => m.type));
 	if (!scalarPrimitives.size) return members;
 	return members.filter((member) => {
@@ -2179,19 +2162,144 @@ function simplifyUnion(members) {
 		return true;
 	});
 }
-function setEnumName(propNode, parentName, propName, enumSuffix) {
-	const enumNode = narrowSchema(propNode, "enum");
-	if (enumNode?.primitive === "boolean") return {
-		...propNode,
-		name: void 0
-	};
-	if (enumNode) return {
-		...propNode,
-		name: enumPropName(parentName, propName, enumSuffix)
+/**
+* Removes union members a broader scalar primitive already covers, such as a multi-value string enum
+* sitting next to a plain `string`. Single-value enums are kept.
+*
+* @example
+* ```ts
+* const next = applyMacros(unionSchema, [macroSimplifyUnion], { depth: 'shallow' })
+* ```
+*/
+const macroSimplifyUnion = defineMacro({
+	name: "simplify-union",
+	schema(node) {
+		const unionNode = narrowSchema(node, "union");
+		if (!unionNode?.members?.length) return void 0;
+		const simplified = simplifyUnionMembers(unionNode.members);
+		if (simplified.length === unionNode.members.length) return void 0;
+		return {
+			...unionNode,
+			members: simplified
+		};
+	}
+});
+//#endregion
+//#region src/factory.ts
+var factory_exports = /* @__PURE__ */ __exportAll({
+	createArrowFunction: () => createArrowFunction,
+	createBreak: () => createBreak,
+	createConst: () => createConst,
+	createContent: () => createContent,
+	createExport: () => createExport,
+	createFile: () => createFile,
+	createFunction: () => createFunction,
+	createImport: () => createImport,
+	createInput: () => createInput,
+	createJsx: () => createJsx,
+	createOperation: () => createOperation,
+	createOutput: () => createOutput,
+	createParameter: () => createParameter,
+	createProperty: () => createProperty,
+	createRequestBody: () => createRequestBody,
+	createResponse: () => createResponse,
+	createSchema: () => createSchema,
+	createSource: () => createSource,
+	createText: () => createText,
+	createType: () => createType,
+	update: () => update
+});
+/**
+* Identity-preserving node update: returns `node` unchanged when every field in
+* `changes` already equals (by reference) the current value, otherwise a new node
+* with the changes applied.
+*
+* Mirrors the TypeScript compiler's `factory.updateX` contract. Pair it with the
+* structural sharing in {@link transform} so a no-op rewrite does not allocate and
+* downstream passes can detect "nothing changed" by identity. Comparison is shallow,
+* so a structurally equal but newly allocated array or object counts as a change.
+*
+* @example
+* ```ts
+* update(node, { name: node.name })        // -> same `node` reference
+* update(node, { name: 'renamed' })        // -> new node, `name` replaced
+* ```
+*/
+function update(node, changes) {
+	for (const key in changes) if (changes[key] !== node[key]) return {
+		...node,
+		...changes
 	};
-	return propNode;
+	return node;
 }
 //#endregion
-export { caseParams, childName, collect, collectImports, collectReferencedSchemaNames, collectUsedSchemaNames, containsCircularRef, createArrowFunction, createBreak, createConst, createDiscriminantNode, createExport, createFile, createFunction, createFunctionParameter, createFunctionParameters, createImport, createInput, createJsx, createOperation, createOperationParams, createOutput, createParameter, createParameterGroup, createParamsType, createPrinterFactory, createProperty, createResponse, createSchema, createSource, createText, createType, definePrinter, enumPropName, extractRefName, extractStringsFromNodes, findCircularSchemas, findDiscriminator, httpMethods, isInputNode, isOperationNode, isOutputNode, isScalarPrimitive, isSchemaNode, isStringType, mediaTypes, mergeAdjacentObjects, narrowSchema, nodeKinds, resolveRefName, schemaTypes, setDiscriminatorEnum, setEnumName, simplifyUnion, syncOptionality, syncSchemaRef, transform, walk };
+//#region src/exports.ts
+var exports_exports = /* @__PURE__ */ __exportAll({
+	applyMacros: () => applyMacros,
+	arrowFunctionDef: () => arrowFunctionDef,
+	breakDef: () => breakDef,
+	buildJSDoc: () => buildJSDoc,
+	buildList: () => buildList,
+	buildObject: () => buildObject,
+	childName: () => childName,
+	collect: () => collect,
+	collectUsedSchemaNames: () => collectUsedSchemaNames,
+	composeMacros: () => composeMacros,
+	constDef: () => constDef,
+	containsCircularRef: () => containsCircularRef,
+	contentDef: () => contentDef,
+	createPrinter: () => createPrinter,
+	defineDialect: () => defineDialect,
+	defineMacro: () => defineMacro,
+	defineNode: () => defineNode,
+	enumPropName: () => enumPropName,
+	exportDef: () => exportDef,
+	extractRefName: () => extractRefName,
+	extractStringsFromNodes: () => extractStringsFromNodes,
+	factory: () => factory_exports,
+	fileDef: () => fileDef,
+	findCircularSchemas: () => findCircularSchemas,
+	functionDef: () => functionDef,
+	getNestedAccessor: () => getNestedAccessor,
+	importDef: () => importDef,
+	inputDef: () => inputDef,
+	isHttpOperationNode: () => isHttpOperationNode,
+	isStringType: () => isStringType,
+	isValidVarName: () => isValidVarName,
+	jsStringEscape: () => jsStringEscape,
+	jsxDef: () => jsxDef,
+	lazyGetter: () => lazyGetter,
+	macroDiscriminatorEnum: () => macroDiscriminatorEnum,
+	macroEnumName: () => macroEnumName,
+	macroSimplifyUnion: () => macroSimplifyUnion,
+	mapSchemaItems: () => mapSchemaItems,
+	mapSchemaMembers: () => mapSchemaMembers,
+	mapSchemaProperties: () => mapSchemaProperties,
+	mergeAdjacentObjectsLazy: () => mergeAdjacentObjectsLazy,
+	narrowSchema: () => narrowSchema,
+	nodeDefs: () => nodeDefs,
+	objectKey: () => objectKey,
+	operationDef: () => operationDef,
+	optionality: () => optionality,
+	outputDef: () => outputDef,
+	parameterDef: () => parameterDef,
+	propertyDef: () => propertyDef,
+	requestBodyDef: () => requestBodyDef,
+	responseDef: () => responseDef,
+	schemaDef: () => schemaDef,
+	schemaTypes: () => schemaTypes,
+	sourceDef: () => sourceDef,
+	stringify: () => stringify,
+	stringifyObject: () => stringifyObject,
+	syncSchemaRef: () => syncSchemaRef,
+	textDef: () => textDef,
+	toRegExpString: () => toRegExpString,
+	transform: () => transform,
+	trimQuotes: () => trimQuotes,
+	typeDef: () => typeDef,
+	walk: () => walk
+});
+//#endregion
+export { applyMacros, arrowFunctionDef, exports_exports as ast, breakDef, buildJSDoc, buildList, buildObject, childName, collect, collectUsedSchemaNames, composeMacros, constDef, containsCircularRef, contentDef, createPrinter, defineDialect, defineMacro, defineNode, enumPropName, exportDef, extractRefName, extractStringsFromNodes, factory_exports as factory, fileDef, findCircularSchemas, functionDef, getNestedAccessor, importDef, inputDef, isHttpOperationNode, isStringType, isValidVarName, jsStringEscape, jsxDef, lazyGetter, macroDiscriminatorEnum, macroEnumName, macroSimplifyUnion, mapSchemaItems, mapSchemaMembers, mapSchemaProperties, mergeAdjacentObjectsLazy, narrowSchema, nodeDefs, objectKey, operationDef, optionality, outputDef, parameterDef, propertyDef, requestBodyDef, responseDef, schemaDef, schemaTypes, sourceDef, stringify, stringifyObject, syncSchemaRef, textDef, toRegExpString, transform, trimQuotes, typeDef, walk };
 
 //# sourceMappingURL=index.js.map