@kubb/ast 5.0.0-beta.9 → 5.0.0-beta.93

package/dist/index.cjs

@@ -6,6 +6,15 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
 		key = keys[i];
@@ -29,31 +38,10 @@ 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 = {
 	/**
@@ -73,7 +61,7 @@ const schemaTypes = {
 	*/
 	bigint: "bigint",
 	/**
-	* Boolean value
+	* Boolean value.
 	*/
 	boolean: "boolean",
 	/**
@@ -161,929 +149,341 @@ const schemaTypes = {
 	*/
 	never: "never"
 };
+//#endregion
+//#region src/guards.ts
 /**
-* Scalar primitive schema types used for union simplification and type narrowing.
-*
-* Use `isScalarPrimitive()` to safely check whether a type is a scalar primitive.
-*/
-const SCALAR_PRIMITIVE_TYPES = new Set([
-	"string",
-	"number",
-	"integer",
-	"bigint",
-	"boolean"
-]);
-/**
-* 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"
-};
-/**
-* 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"
-};
+function isHttpOperationNode(node) {
+	return node.protocol === "http" || node.method !== void 0 && node.path !== void 0;
+}
 //#endregion
-//#region ../../internals/utils/src/casing.ts
+//#region src/defineNode.ts
 /**
-* Shared implementation for camelCase and PascalCase conversion.
-* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
-* and capitalizes each word according to `pascal`.
-*
-* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+* Visitor callback names, one per traversable node kind, in traversal order.
+* Kept in sync with the keys of `Visitor` in `visitor.ts`.
 */
-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);
-	}).join("").replace(/[^a-zA-Z0-9]/g, "");
-}
+const visitorKeys = [
+	"input",
+	"output",
+	"operation",
+	"schema",
+	"property",
+	"parameter",
+	"response"
+];
 /**
-* 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.
-*
-* Only splits on dots followed by a letter so that version numbers
-* embedded in operationIds (e.g. `v2025.0`) are kept intact.
-*
-* 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.
+* Builds a type guard that matches nodes of the given `kind`.
 */
-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("/");
-}
-/**
-* Converts `text` to camelCase.
-* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
-*
-* @example
-* camelCase('hello-world')                   // 'helloWorld'
-* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
-*/
-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 isKind(kind) {
+	return (node) => node?.kind === kind;
 }
 /**
-* Converts `text` to PascalCase.
-* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
+* 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
-* 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);
-}
-//#endregion
-//#region ../../internals/utils/src/reserved.ts
-/**
-* JavaScript and Java reserved words.
-* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
-*/
-const reservedWords = new Set([
-	"abstract",
-	"arguments",
-	"boolean",
-	"break",
-	"byte",
-	"case",
-	"catch",
-	"char",
-	"class",
-	"const",
-	"continue",
-	"debugger",
-	"default",
-	"delete",
-	"do",
-	"double",
-	"else",
-	"enum",
-	"eval",
-	"export",
-	"extends",
-	"false",
-	"final",
-	"finally",
-	"float",
-	"for",
-	"function",
-	"goto",
-	"if",
-	"implements",
-	"import",
-	"in",
-	"instanceof",
-	"int",
-	"interface",
-	"let",
-	"long",
-	"native",
-	"new",
-	"null",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"return",
-	"short",
-	"static",
-	"super",
-	"switch",
-	"synchronized",
-	"this",
-	"throw",
-	"throws",
-	"transient",
-	"true",
-	"try",
-	"typeof",
-	"var",
-	"void",
-	"volatile",
-	"while",
-	"with",
-	"yield",
-	"Array",
-	"Date",
-	"hasOwnProperty",
-	"Infinity",
-	"isFinite",
-	"isNaN",
-	"isPrototypeOf",
-	"length",
-	"Math",
-	"name",
-	"NaN",
-	"Number",
-	"Object",
-	"prototype",
-	"String",
-	"toString",
-	"undefined",
-	"valueOf"
-]);
-/**
-* Returns `true` when `name` is a syntactically valid JavaScript variable name.
+* @example Simple node
+* ```ts
+* const importDef = defineNode<ImportNode>({ kind: 'Import' })
+* const createImport = importDef.create
+* ```
 *
-* @example
+* @example Node with a build hook
 * ```ts
-* isValidVarName('status')  // true
-* isValidVarName('class')   // false (reserved word)
-* isValidVarName('42foo')   // false (starts with digit)
+* const propertyDef = defineNode<PropertyNode, UserPropertyNode>({
+*   kind: 'Property',
+*   build: (props) => ({ ...props, required: props.required ?? false }),
+*   children: ['schema'],
+*   visitorKey: 'property',
+* })
 * ```
 */
-function isValidVarName(name) {
-	if (!name || reservedWords.has(name)) return false;
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+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 ../../internals/utils/src/string.ts
+//#region src/nodes/code.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.
-*
-* @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'
+* Definition for the {@link ConstNode}.
 */
-function trimExtName(text) {
-	const dotIndex = text.lastIndexOf(".");
-	if (dotIndex > 0 && !text.includes("/", dotIndex)) return text.slice(0, dotIndex);
-	return text;
-}
-//#endregion
-//#region src/guards.ts
+const constDef = defineNode({ kind: "Const" });
 /**
-* Narrows a `SchemaNode` to the variant that matches `type`.
+* 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
+* @example Exported constant with type and `as const`
 * ```ts
-* const schema = createSchema({ type: 'string' })
-* const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | undefined
+* createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
+* // export const pets: Pet[] = ... as const
 * ```
 */
-function narrowSchema(node, type) {
-	return node?.type === type ? node : void 0;
-}
-function isKind(kind) {
-	return (node) => node.kind === kind;
-}
+const createConst = constDef.create;
 /**
-* Returns `true` when the input is an `InputNode`.
+* Creates a `TypeNode` representing a TypeScript `type` alias declaration.
 *
 * @example
 * ```ts
-* if (isInputNode(node)) {
-*   console.log(node.schemas.length)
-* }
+* createType({ name: 'Pet', export: true })
+* // export type Pet = ...
 * ```
 */
-const isInputNode = isKind("Input");
+const createType = typeDef.create;
 /**
-* Returns `true` when the input is an `OutputNode`.
+* Creates a `FunctionNode` representing a TypeScript `function` declaration.
 *
 * @example
 * ```ts
-* if (isOutputNode(node)) {
-*   console.log(node.files.length)
-* }
+* createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
+* // export async function fetchPet(): Promise<Pet> { ... }
 * ```
 */
-const isOutputNode = isKind("Output");
+const createFunction = functionDef.create;
 /**
-* Returns `true` when the input is an `OperationNode`.
+* Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
 *
 * @example
 * ```ts
-* if (isOperationNode(node)) {
-*   console.log(node.operationId)
-* }
+* createArrowFunction({ name: 'double', export: true, params: 'n: number', singleLine: true })
+* // export const double = (n: number) => ...
 * ```
 */
-const isOperationNode = isKind("Operation");
+const createArrowFunction = arrowFunctionDef.create;
 /**
-* Returns `true` when the input is a `SchemaNode`.
+* Creates a {@link TextNode} representing a raw string fragment in the source output.
 *
 * @example
 * ```ts
-* if (isSchemaNode(node)) {
-*   console.log(node.type)
-* }
+* createText('return fetch(id)')
+* // { kind: 'Text', value: 'return fetch(id)' }
 * ```
 */
-const isSchemaNode = isKind("Schema");
-//#endregion
-//#region src/refs.ts
+const createText = textDef.create;
 /**
-* Returns the last path segment of a reference string.
-*
-* Example: `#/components/schemas/Pet` becomes `Pet`.
+* Creates a {@link BreakNode} representing a line break in the source output.
 *
 * @example
 * ```ts
-* extractRefName('#/components/schemas/Pet') // 'Pet'
+* createBreak()
+* // { kind: 'Break' }
 * ```
 */
-function extractRefName(ref) {
-	return ref.split("/").at(-1) ?? ref;
+function createBreak() {
+	return breakDef.create();
 }
-//#endregion
-//#region src/visitor.ts
 /**
-* Creates a small async concurrency limiter.
-*
-* At most `concurrency` tasks are in flight at once. Extra tasks are queued.
+* Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
 *
 * @example
 * ```ts
-* const limit = createLimit(2)
-* for (const task of [taskA, taskB, taskC]) {
-*   await limit(() => task())
-* }
-* // only 2 tasks run at the same time
+* createJsx('<>\n  <a href={href}>Open</a>\n</>')
+* // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
 * ```
 */
-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 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
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+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;
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 /**
-* Returns the immediate traversable children of `node`.
+* Converts `text` to PascalCase.
 *
-* For `Schema` nodes, children (`properties`, `items`, `members`, and non-boolean
-* `additionalProperties`) are only included
-* when `recurse` is `true`; shallow mode skips them.
+* @example Word boundaries
+* `pascalCase('hello-world') // 'HelloWorld'`
 *
-* @example
-* ```ts
-* const children = getChildren(operationNode, true)
-* // returns parameters, requestBody schema (if present), and responses
-* ```
+* @example With a suffix
+* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
 */
-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 [];
-	}
+function pascalCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
+//#endregion
+//#region ../../internals/utils/src/fs.ts
 /**
-* 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)
-*   },
-* })
-* ```
+* 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
-* ```ts
-* // Visit only the current node
-* await walk(root, { depth: 'shallow', root: () => {} })
-* ```
+* 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'
 */
-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;
-	}
+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
 /**
-* Runs a depth-first synchronous collection pass.
+* Wraps `factory` with a keyed cache backed by the provided store.
 *
-* Non-`undefined` values returned by visitor callbacks are appended to the result.
+* 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.
 *
-* @example
+* 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 ids = collect(root, {
-*   operation(node) {
-*     return node.operationId
-*   },
-* })
+* const cache = new WeakMap<SchemaNode, Set<string>>()
+* const getRefs = memoize(cache, (node) => collectRefs(node))
 * ```
 *
-* @example
+* @example Single Map key (primitive)
 * ```ts
-* // Collect from only the current node
-* const values = collect(root, { depth: 'shallow', root: () => 'root' })
+* const cache = new Map<string, Resolver>()
+* const getResolver = memoize(cache, (name) => buildResolver(name))
 * ```
-*/
-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
+* @example Two-level (object + primitive)
 * ```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
+* const outer = new WeakMap<Params[], Map<string, Params[]>>()
+* const fn = memoize(outer, (params) => memoize(new Map(), (key) => transform(params, key)))
+* fn(params)('camelcase')
 * ```
 */
-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
-	});
+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 src/utils/extractStringsFromNodes.ts
 /**
-* Type guard that returns `true` when a schema emits as a plain `string` type.
+* Extracts all string content from a `CodeNode` tree recursively.
 *
-* Covers `string`, `uuid`, `email`, `url`, and `datetime` types. For `date` and `time`
-* types, returns `true` only when `representation` is `'string'` rather than `'date'`.
+* 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.
 */
-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)
-			}));
+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 (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
-		}));
+		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"));
 	}
-	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
-			})
-		}))
-	});
+	return collected.join("\n");
 }
+//#endregion
+//#region src/utils/combineFileMembers.ts
 function sourceKey(source) {
 	return `${source.name ?? extractStringsFromNodes(source.nodes)}:${source.isExportable ?? false}:${source.isTypeOnly ?? false}`;
 }
@@ -1098,19 +498,19 @@ function importKey(path, name, isTypeOnly) {
 }
 /**
 * 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.
+* 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 ?? "";
+	const name = Array.isArray(node.name) ? node.name.toSorted().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.
+* 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.
 */
 function combineSources(sources) {
 	const seen = /* @__PURE__ */ new Map();
@@ -1121,6 +521,16 @@ function combineSources(sources) {
 	return [...seen.values()];
 }
 /**
+* Merges `incoming` names into `existing`, preserving order and dropping duplicates.
+*
+* Shared by `combineExports` and `combineImports` for the same-path name-merge case.
+*/
+function mergeNameArrays(existing, incoming) {
+	const merged = new Set(existing);
+	for (const name of incoming) merged.add(name);
+	return [...merged];
+}
+/**
 * 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.
@@ -1141,11 +551,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)]
@@ -1168,8 +575,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] : []));
@@ -1181,6 +586,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();
@@ -1198,11 +608,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
@@ -1211,7 +618,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);
@@ -1221,210 +628,218 @@ 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.
 *
-* 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.
+* Computes:
+* - `id` SHA256 hash of the file path
+* - `name` `baseName` without extension
+* - `extname` extension extracted from `baseName`
 *
-* 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.
+* Deduplicates:
+* - `sources` via `combineSources`
+* - `exports` via `combineExports`
+* - `imports` via `combineImports` (also filters unused imports)
 *
-* @example Only generate schemas referenced by included operations
-* ```ts
-* const includedOps = inputNode.operations.filter(op => resolver.resolveOptions(op, { options, include }) !== null)
-* const allowed = collectUsedSchemaNames(includedOps, inputNode.schemas)
+* @throws {Error} when `baseName` has no extension.
 *
-* for (const schema of inputNode.schemas) {
-*   if (schema.name && !allowed.has(schema.name)) continue
-*   // … generate schema
-* }
+* @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'
 * ```
 *
-* @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);
-		}
-	}
-	for (const op of operations) for (const schema of collect(op, {
-		depth: "shallow",
-		schema: (node) => node
-	})) visitSchema(schema);
-	return result;
-}
-/**
-* 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.
-*/
-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);
+function createFile(input) {
+	const extname = node_path.default.extname(input.baseName);
+	if (!extname) throw new Error(`No extname found for ${input.baseName}`);
+	const resolvedExports = input.exports?.length ? combineExports(input.exports) : [];
+	const resolvedImports = (() => {
+		if (!input.imports?.length) return [];
+		const sourceParts = [];
+		const localNames = /* @__PURE__ */ new Set();
+		for (const item of input.sources ?? []) {
+			const extracted = item.nodes && extractStringsFromNodes(item.nodes);
+			if (extracted) sourceParts.push(extracted);
+			if (item.name) localNames.add(item.name);
 		}
-	}
-	return circular;
-}
-/**
-* Type guard returning `true` when a schema or anything nested within it contains a ref to a circular schema.
-*
-* 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.
-*
-* @note Returns `true` for the first matching circular ref found; use for fast dependency checks.
-*/
-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;
+		const source = sourceParts.join("\n") || void 0;
+		const combinedImports = combineImports(input.imports, resolvedExports, source);
+		const nameOf = (item) => typeof item === "string" ? item : item.name ?? item.propertyName;
+		return combinedImports.flatMap((imp) => {
+			if (imp.path === input.path) return [];
+			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
+			}];
+		});
+	})();
+	const resolvedSources = input.sources?.length ? combineSources(input.sources) : [];
+	return {
+		kind: "File",
+		...input,
+		id: (0, node_crypto.hash)("sha256", input.path, "hex"),
+		name: trimExtName(input.baseName),
+		extname,
+		imports: resolvedImports,
+		exports: resolvedExports,
+		sources: resolvedSources,
+		meta: input.meta ?? {}
+	};
 }
 //#endregion
-//#region src/factory.ts
+//#region src/nodes/input.ts
 /**
-* Syncs property/parameter schema optionality flags from `required` and `schema.nullable`.
-*
-* - `optional` is set for non-required, non-nullable schemas.
-* - `nullish` is set for non-required, nullable schemas.
+* Definition for the {@link InputNode}.
 */
-function syncOptionality(schema, required) {
-	const nullable = schema.nullable ?? false;
-	return {
-		...schema,
-		optional: !required && !nullable ? true : void 0,
-		nullish: !required && nullable ? true : void 0
-	};
-}
+const inputDef = defineNode({
+	kind: "Input",
+	defaults: {
+		schemas: [],
+		operations: [],
+		meta: {
+			circularNames: [],
+			enumNames: []
+		}
+	},
+	children: ["schemas", "operations"],
+	visitorKey: "input"
+});
 /**
-* Creates an `InputNode` with stable defaults for `schemas` and `operations`.
+* Creates an `InputNode`, defaulting `schemas`/`operations` to empty arrays and `meta` per
+* {@link inputDef}.
 *
 * @example
 * ```ts
 * const input = createInput()
 * // { kind: 'Input', schemas: [], operations: [] }
 * ```
-*
-* @example
-* ```ts
-* const input = createInput({ schemas: [petSchema] })
-* // keeps default operations: []
-* ```
 */
 function createInput(overrides = {}) {
-	return {
-		schemas: [],
-		operations: [],
-		...overrides,
-		kind: "Input"
-	};
+	return inputDef.create(overrides);
+}
+//#endregion
+//#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
+/**
+* Definition for the {@link OutputNode}.
+*/
+const outputDef = defineNode({
+	kind: "Output",
+	defaults: { files: [] },
+	visitorKey: "output"
+});
 /**
 * Creates an `OutputNode` with a stable default for `files`.
 *
@@ -1433,55 +848,131 @@ function createInput(overrides = {}) {
 * const output = createOutput()
 * // { kind: 'Output', files: [] }
 * ```
-*
-* @example
-* ```ts
-* const output = createOutput({ files: [petFile] })
-* ```
 */
 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 {
-		files: [],
-		...overrides,
-		kind: "Output"
+		...schema,
+		optional: !required && !nullable ? true : void 0,
+		nullish: !required && nullable ? true : void 0
 	};
 }
+//#endregion
+//#region src/nodes/parameter.ts
 /**
-* Creates an `OperationNode` with default empty arrays for `tags`, `parameters`, and `responses`.
+* 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 operation = createOperation({
-*   operationId: 'getPetById',
-*   method: 'GET',
-*   path: '/pet/{petId}',
+* const param = createParameter({
+*   name: 'petId',
+*   in: 'path',
+*   required: true,
+*   schema: createSchema({ type: 'string' }),
 * })
-* // tags, parameters, and responses are []
 * ```
+*/
+const createParameter = parameterDef.create;
+//#endregion
+//#region src/nodes/property.ts
+/**
+* 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 operation = createOperation({
-*   operationId: 'findPets',
-*   method: 'GET',
-*   path: '/pet/findByStatus',
-*   tags: ['pet'],
+* const property = createProperty({
+*   name: 'status',
+*   required: true,
+*   schema: createSchema({ type: 'string', nullable: true }),
 * })
+* // required=true, no optional/nullish
 * ```
 */
-function createOperation(props) {
-	return {
-		tags: [],
-		parameters: [],
-		responses: [],
-		...props,
-		kind: "Operation"
-	};
-}
+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 response = createResponse({
+*   statusCode: '200',
+*   content: [createContent({ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) })],
+* })
+* ```
+*/
+const createResponse = responseDef.create;
+//#endregion
+//#region src/nodes/schema.ts
 /**
 * 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.
+* 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",
@@ -1503,692 +994,763 @@ const TYPE_TO_PRIMITIVE = {
 	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) {
-	const inferredPrimitive = TYPE_TO_PRIMITIVE[props.type];
-	if (props["type"] === "object") return {
-		properties: [],
-		primitive: "object",
-		...props,
-		kind: "Schema"
-	};
-	return {
-		primitive: inferredPrimitive,
-		...props,
-		kind: "Schema"
-	};
+	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
 /**
-* Creates a `PropertyNode`.
+* 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]] : []));
+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}.
 *
-* `required` defaults to `false`.
-* `schema.optional` and `schema.nullish` are derived from `required` and `schema.nullable`.
+* `Schema` children are only included when `recurse` is `true`. Shallow mode skips them.
 *
 * @example
 * ```ts
-* const property = createProperty({
-*   name: 'status',
-*   schema: createSchema({ type: 'string' }),
-* })
-* // required=false, schema.optional=true
-* ```
+* 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;
+	}
+}
+/**
+* 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.
 *
-* @example
-* ```ts
-* const property = createProperty({
-*   name: 'status',
-*   required: true,
-*   schema: createSchema({ type: 'string', nullable: true }),
-* })
-* // required=true, no optional/nullish
-* ```
+* Shared by `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`.
 */
-function createProperty(props) {
-	const required = props.required ?? false;
-	return {
-		...props,
-		kind: "Property",
-		required,
-		schema: syncOptionality(props.schema, required)
-	};
+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 });
+}
+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' })
-* ```
-*/
-function createParamsType(props) {
-	return {
-		...props,
-		kind: "ParamsType"
-	};
-}
-/**
-* Creates a `ParameterGroupNode` representing a group of related parameters treated as a unit.
+* import { createPrinter, type PrinterFactoryOptions } from '@kubb/ast'
 *
-* @example Grouped param (TypeScript declaration)
-* ```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 }
-* ```
+* type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
 *
-* @example Inline (spread) — children emitted as individual top-level parameters
-* ```ts
-* createParameterGroup({
-*   properties: [createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false })],
-*   inline: true,
-* })
-* // declaration → petId: string
-* // call        → petId
+* 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 createParameterGroup(props) {
-	return {
-		...props,
-		kind: "ParameterGroup"
+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/mergeAdjacentSchemas.ts
 /**
-* Creates a `FunctionParametersNode` from an ordered list of parameters.
+* 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
 * ```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: '{}' }),
-*   ],
-* })
+* 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/refs.ts
+const plainStringTypes = /* @__PURE__ */ new Set([
+	"string",
+	"uuid",
+	"email",
+	"url",
+	"datetime"
+]);
+/**
+* Returns the last path segment of a reference string.
 *
 * @example
-* ```ts
-* const empty = createFunctionParameters()
-* // { kind: 'FunctionParameters', params: [] }
-* ```
+* `extractRefName('#/components/schemas/Pet') // 'Pet'`
 */
-function createFunctionParameters(props = {}) {
-	return {
-		params: [],
-		...props,
-		kind: "FunctionParameters"
-	};
+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 = node_path.default.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: (0, node_crypto.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
+	});
 }
 /**
-* Creates a `ConstNode` representing a TypeScript `const` declaration.
-*
-* Mirrors the `Const` component from `@kubb/renderer-jsx`.
-* The component's `children` are represented as `nodes`.
-*
-* @example Simple constant
-* ```ts
-* createConst({ name: 'pet' })
-* // const pet = ...
-* ```
-*
-* @example Exported constant with type and `as const`
-* ```ts
-* createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
-* // export const pets: Pet[] = ... as const
-* ```
+* Type guard that returns `true` when a schema emits as a plain `string` type.
 *
-* @example With JSDoc and child nodes
-* ```ts
-* createConst({
-*   name: 'config',
-*   export: true,
-*   JSDoc: { comments: ['@description App configuration'] },
-*   nodes: [],
-* })
-* ```
+* Covers `string`, `uuid`, `email`, `url`, and `datetime` types. For `date` and `time`
+* types, returns `true` only when `representation` is `'string'` rather than `'date'`.
 */
-function createConst(props) {
-	return {
-		...props,
-		kind: "Const"
-	};
+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/schemaGraph.ts
 /**
-* 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`.
-*
-* @example Simple type alias
-* ```ts
-* createType({ name: 'Pet' })
-* // type Pet = ...
-* ```
-*
-* @example Exported type with JSDoc
-* ```ts
-* createType({
-*   name: 'PetStatus',
-*   export: true,
-*   JSDoc: { comments: ['@description Status of a pet'] },
-* })
-* // export type PetStatus = ...
-* ```
+* Memoized inner pass that walks a single node and returns the names of every schema it references.
 */
-function createType(props) {
-	return {
-		...props,
-		kind: "Type"
-	};
-}
+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;
+});
 /**
-* Creates a `FunctionNode` representing a TypeScript `function` declaration.
+* Collects the names of every ref found anywhere inside a node's own subtree.
 *
-* Mirrors the `Function` component from `@kubb/renderer-jsx`.
-* The component's `children` are represented as `nodes`.
+* 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 Simple function
-* ```ts
-* createFunction({ name: 'getPet' })
-* // function getPet() { ... }
-* ```
-*
-* @example Exported async function with return type
+* @example Collect refs from a single schema
 * ```ts
-* createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
-* // export async function fetchPet(): Promise<Pet> { ... }
+* const names = collectReferencedSchemaNames(petSchema)
+* // Set { 'Category', 'Tag' }
 * ```
 *
-* @example Function with generics and params
+* @example Accumulate refs from multiple schemas into one set
 * ```ts
-* createFunction({
-*   name: 'identity',
-*   export: true,
-*   generics: ['T'],
-*   params: 'value: T',
-*   returnType: 'T',
-* })
-* // export function identity<T>(value: T): T { ... }
+* const out = new Set<string>()
+* for (const schema of schemas) {
+*   collectReferencedSchemaNames(schema, out)
+* }
 * ```
 */
-function createFunction(props) {
-	return {
-		...props,
-		kind: "Function"
-	};
+function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
+	if (!node) return out;
+	for (const name of collectSchemaRefs(node)) out.add(name);
+	return out;
 }
 /**
-* Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
-*
-* Mirrors the `Function.Arrow` component from `@kubb/renderer-jsx`.
-* The component's `children` are represented as `nodes`.
-*
-* @example Simple arrow function
-* ```ts
-* createArrowFunction({ name: 'getPet' })
-* // const getPet = () => { ... }
-* ```
-*
-* @example Single-line exported arrow function
-* ```ts
-* createArrowFunction({ name: 'double', export: true, params: 'n: number', singleLine: true })
-* // export const double = (n: number) => ...
-* ```
-*
-* @example Async arrow function with generics
-* ```ts
-* createArrowFunction({
-*   name: 'fetchPet',
-*   export: true,
-*   async: true,
-*   generics: ['T'],
-*   params: 'id: string',
-*   returnType: 'T',
-* })
-* // export const fetchPet = async <T>(id: string): Promise<T> => { ... }
-* ```
+* Memoized two-level cache keyed first on the operations array, then on the schemas array.
 */
-function createArrowFunction(props) {
-	return {
-		...props,
-		kind: "ArrowFunction"
-	};
+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 TextNode} representing a raw string fragment in the source output.
+* Collects the names of all top-level schemas transitively used by a set of operations.
 *
-* Use this instead of bare strings when building `nodes` arrays so that every
-* entry in the array is a typed {@link CodeNode}.
+* 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
-* createText('return fetch(id)')
-* // { kind: 'Text', value: 'return fetch(id)' }
+* const includedOps = operations.filter((op) => resolver.default.options(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 createText(value) {
-	return {
-		value,
-		kind: "Text"
-	};
+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 BreakNode} representing a line break in the source output.
+* Finds every schema that takes part in a circular dependency chain, including direct self-loops.
 *
-* Corresponds to `<br/>` in JSX components. Prints as an empty string which,
-* when joined with `\n` by `printNodes`, produces a blank line.
+* 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
-* createBreak()
-* // { kind: 'Break' }
-* ```
+* @note Call this once on the full graph, then check individual schemas with `containsCircularRef()`.
 */
-function createBreak() {
-	return { kind: "Break" };
+function findCircularSchemas(schemas) {
+	if (schemas.length === 0) return EMPTY_CIRCULAR_SET;
+	return findCircularSchemasMemo(schemas);
 }
 /**
-* Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
+* Returns `true` when a schema, or anything nested inside it, references a circular schema.
 *
-* Use this to embed JSX markup (including fragments `<>…</>`) directly in generated code.
+* 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.
 *
-* @example
-* ```ts
-* createJsx('<>\n  <a href={href}>Open</a>\n</>')
-* // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
-* ```
+* @note Stops at the first matching circular ref.
 */
-function createJsx(value) {
-	return {
-		value,
-		kind: "Jsx"
-	};
+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/printer.ts
+//#region src/utils/schemaTraversal.ts
 /**
-* Creates a schema printer factory.
-*
-* This function wraps a builder and makes options optional at call sites.
+* 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.
 *
-* 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
+* @example
 * ```ts
-* type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
-*
-* 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} })`
-*     },
-*   },
-* }))
+* const entries = mapSchemaProperties(node, (schema) => this.transform(schema))
+* // entries: [{ name: 'id', property, output: 'z.number()' }, ...]
 * ```
 */
-function definePrinter(build) {
-	return createPrinterFactory((node) => node.type)(build);
+function mapSchemaProperties(node, transform) {
+	return node.properties.map((property) => ({
+		name: property.name,
+		property,
+		output: transform(property.schema)
+	}));
 }
 /**
-* Generic printer-factory function used by `definePrinter` and `defineFunctionPrinter`.
-**
-* @example
-* ```ts
-* export const defineFunctionPrinter = createPrinterFactory<FunctionNode, FunctionNodeType, FunctionNodeByType>(
-*   (node) => kindToHandlerKey[node.kind],
-* )
-* ```
+* Maps each member of a union or intersection schema to its transformed output, pairing every
+* result with the original member.
 */
-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 enumPropName(parentName, propName, enumSuffix) {
-	return pascalCase([
-		parentName,
-		propName,
-		enumSuffix
-	].filter(Boolean).join(" "));
+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
+//#region src/macros/macroDiscriminatorEnum.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.
+* 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 schema = createSchema({
-*   type: 'object',
-*   properties: [createProperty({ name: 'type', required: true, schema: createSchema({ type: 'string' }) })],
-* })
-* const result = setDiscriminatorEnum({ node: schema, propertyName: 'type', values: ['dog', 'cat'] })
-* ```
-*/
-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
+* 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) => {
@@ -2202,76 +1764,195 @@ 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
-exports.caseParams = caseParams;
+//#region src/exports.ts
+var exports_exports = /* @__PURE__ */ __exportAll({
+	applyMacros: () => applyMacros,
+	arrowFunctionDef: () => arrowFunctionDef,
+	breakDef: () => breakDef,
+	childName: () => childName,
+	collect: () => collect,
+	collectUsedSchemaNames: () => collectUsedSchemaNames,
+	combineExports: () => combineExports,
+	combineImports: () => combineImports,
+	combineSources: () => combineSources,
+	composeMacros: () => composeMacros,
+	constDef: () => constDef,
+	containsCircularRef: () => containsCircularRef,
+	contentDef: () => contentDef,
+	createPrinter: () => createPrinter,
+	defineMacro: () => defineMacro,
+	defineNode: () => defineNode,
+	enumPropName: () => enumPropName,
+	exportDef: () => exportDef,
+	extractRefName: () => extractRefName,
+	extractStringsFromNodes: () => extractStringsFromNodes,
+	factory: () => factory_exports,
+	fileDef: () => fileDef,
+	findCircularSchemas: () => findCircularSchemas,
+	functionDef: () => functionDef,
+	importDef: () => importDef,
+	inputDef: () => inputDef,
+	isHttpOperationNode: () => isHttpOperationNode,
+	isStringType: () => isStringType,
+	jsxDef: () => jsxDef,
+	macroDiscriminatorEnum: () => macroDiscriminatorEnum,
+	macroEnumName: () => macroEnumName,
+	macroSimplifyUnion: () => macroSimplifyUnion,
+	mapSchemaItems: () => mapSchemaItems,
+	mapSchemaMembers: () => mapSchemaMembers,
+	mapSchemaProperties: () => mapSchemaProperties,
+	mergeAdjacentObjectsLazy: () => mergeAdjacentObjectsLazy,
+	narrowSchema: () => narrowSchema,
+	nodeDefs: () => nodeDefs,
+	operationDef: () => operationDef,
+	optionality: () => optionality,
+	outputDef: () => outputDef,
+	parameterDef: () => parameterDef,
+	propertyDef: () => propertyDef,
+	requestBodyDef: () => requestBodyDef,
+	responseDef: () => responseDef,
+	schemaDef: () => schemaDef,
+	schemaTypes: () => schemaTypes,
+	sourceDef: () => sourceDef,
+	syncSchemaRef: () => syncSchemaRef,
+	textDef: () => textDef,
+	transform: () => transform,
+	typeDef: () => typeDef
+});
+//#endregion
+exports.applyMacros = applyMacros;
+exports.arrowFunctionDef = arrowFunctionDef;
+Object.defineProperty(exports, "ast", {
+	enumerable: true,
+	get: function() {
+		return exports_exports;
+	}
+});
+exports.breakDef = breakDef;
 exports.childName = childName;
 exports.collect = collect;
-exports.collectImports = collectImports;
-exports.collectReferencedSchemaNames = collectReferencedSchemaNames;
 exports.collectUsedSchemaNames = collectUsedSchemaNames;
+exports.combineExports = combineExports;
+exports.combineImports = combineImports;
+exports.combineSources = combineSources;
+exports.composeMacros = composeMacros;
+exports.constDef = constDef;
 exports.containsCircularRef = containsCircularRef;
-exports.createArrowFunction = createArrowFunction;
-exports.createBreak = createBreak;
-exports.createConst = createConst;
-exports.createDiscriminantNode = createDiscriminantNode;
-exports.createExport = createExport;
-exports.createFile = createFile;
-exports.createFunction = createFunction;
-exports.createFunctionParameter = createFunctionParameter;
-exports.createFunctionParameters = createFunctionParameters;
-exports.createImport = createImport;
-exports.createInput = createInput;
-exports.createJsx = createJsx;
-exports.createOperation = createOperation;
-exports.createOperationParams = createOperationParams;
-exports.createOutput = createOutput;
-exports.createParameter = createParameter;
-exports.createParameterGroup = createParameterGroup;
-exports.createParamsType = createParamsType;
-exports.createPrinterFactory = createPrinterFactory;
-exports.createProperty = createProperty;
-exports.createResponse = createResponse;
-exports.createSchema = createSchema;
-exports.createSource = createSource;
-exports.createText = createText;
-exports.createType = createType;
-exports.definePrinter = definePrinter;
+exports.contentDef = contentDef;
+exports.createPrinter = createPrinter;
+exports.defineMacro = defineMacro;
+exports.defineNode = defineNode;
 exports.enumPropName = enumPropName;
+exports.exportDef = exportDef;
 exports.extractRefName = extractRefName;
 exports.extractStringsFromNodes = extractStringsFromNodes;
+Object.defineProperty(exports, "factory", {
+	enumerable: true,
+	get: function() {
+		return factory_exports;
+	}
+});
+exports.fileDef = fileDef;
 exports.findCircularSchemas = findCircularSchemas;
-exports.findDiscriminator = findDiscriminator;
-exports.httpMethods = httpMethods;
-exports.isInputNode = isInputNode;
-exports.isOperationNode = isOperationNode;
-exports.isOutputNode = isOutputNode;
-exports.isScalarPrimitive = isScalarPrimitive;
-exports.isSchemaNode = isSchemaNode;
+exports.functionDef = functionDef;
+exports.importDef = importDef;
+exports.inputDef = inputDef;
+exports.isHttpOperationNode = isHttpOperationNode;
 exports.isStringType = isStringType;
-exports.mediaTypes = mediaTypes;
-exports.mergeAdjacentObjects = mergeAdjacentObjects;
+exports.jsxDef = jsxDef;
+exports.macroDiscriminatorEnum = macroDiscriminatorEnum;
+exports.macroEnumName = macroEnumName;
+exports.macroSimplifyUnion = macroSimplifyUnion;
+exports.mapSchemaItems = mapSchemaItems;
+exports.mapSchemaMembers = mapSchemaMembers;
+exports.mapSchemaProperties = mapSchemaProperties;
+exports.mergeAdjacentObjectsLazy = mergeAdjacentObjectsLazy;
 exports.narrowSchema = narrowSchema;
-exports.nodeKinds = nodeKinds;
-exports.resolveRefName = resolveRefName;
+exports.nodeDefs = nodeDefs;
+exports.operationDef = operationDef;
+exports.optionality = optionality;
+exports.outputDef = outputDef;
+exports.parameterDef = parameterDef;
+exports.propertyDef = propertyDef;
+exports.requestBodyDef = requestBodyDef;
+exports.responseDef = responseDef;
+exports.schemaDef = schemaDef;
 exports.schemaTypes = schemaTypes;
-exports.setDiscriminatorEnum = setDiscriminatorEnum;
-exports.setEnumName = setEnumName;
-exports.simplifyUnion = simplifyUnion;
-exports.syncOptionality = syncOptionality;
+exports.sourceDef = sourceDef;
 exports.syncSchemaRef = syncSchemaRef;
+exports.textDef = textDef;
 exports.transform = transform;
-exports.walk = walk;
+exports.typeDef = typeDef;
 
 //# sourceMappingURL=index.cjs.map