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

package/dist/index.js

@@ -1,36 +1,15 @@
-import "./chunk--u3MIqq1.js";
-import { createHash } from "node:crypto";
+import { t as __exportAll } from "./rolldown-runtime-CNktS9qV.js";
+import { hash } from "node:crypto";
 import path from "node:path";
 //#region src/constants.ts
 const visitorDepths = {
 	shallow: "shallow",
 	deep: "deep"
 };
-const nodeKinds = {
-	input: "Input",
-	output: "Output",
-	operation: "Operation",
-	schema: "Schema",
-	property: "Property",
-	parameter: "Parameter",
-	response: "Response",
-	functionParameter: "FunctionParameter",
-	parameterGroup: "ParameterGroup",
-	functionParameters: "FunctionParameters",
-	type: "Type",
-	file: "File",
-	import: "Import",
-	export: "Export",
-	source: "Source",
-	text: "Text",
-	break: "Break"
-};
 /**
 * Schema type discriminators used by all AST schema nodes.
 *
-* These values serve as stable discriminators across the AST (e.g., `schema.type === schemaTypes.object`).
-* Grouped by category: primitives (`string`, `number`, `boolean`), structural types (`object`, `array`, `union`),
-* and format-specific types (`date`, `uuid`, `email`). Use `isScalarPrimitive()` to check for scalar types.
+* Each value is a stable discriminator across the AST (for example `schema.type === schemaTypes.object`).
 */
 const schemaTypes = {
 	/**
@@ -50,7 +29,7 @@ const schemaTypes = {
 	*/
 	bigint: "bigint",
 	/**
-	* Boolean value
+	* Boolean value.
 	*/
 	boolean: "boolean",
 	/**
@@ -138,929 +117,364 @@ const schemaTypes = {
 	*/
 	never: "never"
 };
+//#endregion
+//#region src/defineDialect.ts
 /**
-* Scalar primitive schema types used for union simplification and type narrowing.
+* Types a {@link Dialect} for an adapter. Adds no runtime behavior and only pins the
+* dialect's type for inference.
 *
-* Use `isScalarPrimitive()` to safely check whether a type is a scalar primitive.
+* @example
+* ```ts
+* export const oasDialect = defineDialect({
+*   name: 'oas',
+*   schema: {
+*     isNullable,
+*     isReference,
+*     isDiscriminator,
+*     isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',
+*     resolveRef,
+*   },
+* })
+* ```
 */
-const SCALAR_PRIMITIVE_TYPES = new Set([
-	"string",
-	"number",
-	"integer",
-	"bigint",
-	"boolean"
-]);
+function defineDialect(dialect) {
+	return dialect;
+}
+//#endregion
+//#region src/guards.ts
 /**
-* Type guard that returns `true` when `type` is a scalar primitive schema type.
+* Narrows a `SchemaNode` to the variant that matches `type`.
 *
-* Use this to check if a schema type can be directly assigned without wrapping (e.g., `string | number | boolean`).
+* @example
+* ```ts
+* const schema = createSchema({ type: 'string' })
+* const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | null
+* ```
 */
-function isScalarPrimitive(type) {
-	return SCALAR_PRIMITIVE_TYPES.has(type);
+function narrowSchema(node, type) {
+	return node?.type === type ? node : null;
 }
 /**
-* HTTP method identifiers used by operation nodes.
+* Narrows an `OperationNode` to an `HttpOperationNode` so `method` and `path` are present.
 *
-* Includes all standard HTTP methods (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS, TRACE).
+* @example
+* ```ts
+* if (isHttpOperationNode(node)) {
+*   console.log(node.method, node.path)
+* }
+* ```
 */
-const httpMethods = {
-	get: "GET",
-	post: "POST",
-	put: "PUT",
-	patch: "PATCH",
-	delete: "DELETE",
-	head: "HEAD",
-	options: "OPTIONS",
-	trace: "TRACE"
-};
-/**
-* 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}`;
 }
@@ -1075,19 +489,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();
@@ -1098,6 +512,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.
@@ -1118,11 +542,8 @@ function combineExports(exports) {
 			if (!name.length) continue;
 			const key = pathTypeKey(path, isTypeOnly);
 			const existing = namedByPath.get(key);
-			if (existing && Array.isArray(existing.name)) {
-				const merged = new Set(existing.name);
-				for (const n of name) merged.add(n);
-				existing.name = [...merged];
-			} else {
+			if (existing && Array.isArray(existing.name)) existing.name = mergeNameArrays(existing.name, name);
+			else {
 				const newItem = {
 					...curr,
 					name: [...new Set(name)]
@@ -1145,8 +566,6 @@ function combineExports(exports) {
 *
 * Retains imports that are referenced in `source` or re-exported. Imports with the same path and
 * `isTypeOnly` flag have their names merged. Returns a sorted, deduplicated, filtered array.
-*
-* @note Use this when combining imports from multiple files to avoid duplicate declarations.
 */
 function combineImports(imports, exports, source) {
 	const exportedNames = new Set(exports.flatMap((e) => Array.isArray(e.name) ? e.name : e.name ? [e.name] : []));
@@ -1158,6 +577,11 @@ function combineImports(imports, exports, source) {
 		if (!importNameMemo.has(key)) importNameMemo.set(key, n);
 		return importNameMemo.get(key);
 	};
+	const pathsWithUsedNamedImport = /* @__PURE__ */ new Set();
+	for (const node of imports) {
+		if (!Array.isArray(node.name)) continue;
+		if (node.name.some((item) => typeof item === "string" ? isUsed(item) : isUsed(item.name ?? item.propertyName))) pathsWithUsedNamedImport.add(node.path);
+	}
 	const result = [];
 	const namedByPath = /* @__PURE__ */ new Map();
 	const seen = /* @__PURE__ */ new Set();
@@ -1175,11 +599,8 @@ function combineImports(imports, exports, source) {
 			if (!name.length) continue;
 			const key = pathTypeKey(path, isTypeOnly);
 			const existing = namedByPath.get(key);
-			if (existing && Array.isArray(existing.name)) {
-				const merged = new Set(existing.name);
-				for (const n of name) merged.add(n);
-				existing.name = [...merged];
-			} else {
+			if (existing && Array.isArray(existing.name)) existing.name = mergeNameArrays(existing.name, name);
+			else {
 				const newItem = {
 					...curr,
 					name
@@ -1188,7 +609,7 @@ function combineImports(imports, exports, source) {
 				namedByPath.set(key, newItem);
 			}
 		} else {
-			if (name && !isUsed(name)) continue;
+			if (name && !isUsed(name) && !pathsWithUsedNamedImport.has(path)) continue;
 			const key = importKey(path, name, isTypeOnly);
 			if (!seen.has(key)) {
 				result.push(curr);
@@ -1198,210 +619,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 = path.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: 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`.
 *
@@ -1410,55 +839,131 @@ function createInput(overrides = {}) {
 * const output = createOutput()
 * // { kind: 'Output', files: [] }
 * ```
-*
-* @example
-* ```ts
-* const output = createOutput({ files: [petFile] })
-* ```
 */
 function createOutput(overrides = {}) {
-	return {
-		files: [],
-		...overrides,
-		kind: "Output"
-	};
+	return outputDef.create(overrides);
 }
+//#endregion
+//#region src/optionality.ts
 /**
-* Creates an `OperationNode` with default empty arrays for `tags`, `parameters`, and `responses`.
-*
-* @example
-* ```ts
-* const operation = createOperation({
-*   operationId: 'getPetById',
-*   method: 'GET',
-*   path: '/pet/{petId}',
-* })
-* // tags, parameters, and responses are []
+* Generic JSON Schema optionality: a non-required field is optional, and a
+* non-required nullable field is nullish.
+*/
+function optionality(schema, required) {
+	const nullable = schema.nullable ?? false;
+	return {
+		...schema,
+		optional: !required && !nullable ? true : void 0,
+		nullish: !required && nullable ? true : void 0
+	};
+}
+//#endregion
+//#region src/nodes/parameter.ts
+/**
+* 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 param = createParameter({
+*   name: 'petId',
+*   in: 'path',
+*   required: true,
+*   schema: createSchema({ type: 'string' }),
+* })
+* ```
+*/
+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 property = createProperty({
+*   name: 'status',
+*   required: true,
+*   schema: createSchema({ type: 'string', nullable: true }),
+* })
+* // required=true, no optional/nullish
 * ```
+*/
+const createProperty = propertyDef.create;
+//#endregion
+//#region src/nodes/response.ts
+/**
+* Definition for the {@link ResponseNode}. A single legacy `schema` (with optional
+* `mediaType`/`keysToOmit`) is normalized into one `content` entry.
+*/
+const responseDef = defineNode({
+	kind: "Response",
+	build: (props) => {
+		const { schema, mediaType, keysToOmit, content, ...rest } = props;
+		const entries = content ?? (schema ? [createContent({
+			contentType: mediaType ?? "application/json",
+			schema,
+			keysToOmit: keysToOmit ?? null
+		})] : void 0);
+		return {
+			...rest,
+			content: entries
+		};
+	},
+	children: ["content"],
+	visitorKey: "response"
+});
+/**
+* Creates a `ResponseNode`.
 *
 * @example
 * ```ts
-* const operation = createOperation({
-*   operationId: 'findPets',
-*   method: 'GET',
-*   path: '/pet/findByStatus',
-*   tags: ['pet'],
+* const response = createResponse({
+*   statusCode: '200',
+*   content: [createContent({ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) })],
 * })
 * ```
 */
-function createOperation(props) {
-	return {
-		tags: [],
-		parameters: [],
-		responses: [],
-		...props,
-		kind: "Operation"
-	};
-}
+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",
@@ -1480,692 +985,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
+/**
+* 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";
 }
 /**
-* Creates a `PropertyNode`.
+* 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
 /**
-* Creates a `ResponseNode`.
+* 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;
+}
+/**
+* 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`
+* Merges a ref node with its resolved schema, giving usage-site fields precedence.
 *
-* Deduplicates:
-* - `sources` via `combineSources`
-* - `exports` via `combineExports`
-* - `imports` via `combineImports` (also filters unused imports)
-*
-* @throws {Error} when `baseName` has no extension.
+* Every field set on the ref node except `kind`, `type`, `name`, `ref`, and `schema` overrides the
+* same field in the resolved `node.schema` (for example `description`, `nullable`, `readOnly`,
+* `deprecated`). Fields left `undefined` on the ref do not shadow the resolved schema. Non-ref
+* nodes and refs without a resolved `schema` are returned unchanged.
 *
 * @example
 * ```ts
-* const file = createFile({
-*   baseName: 'petStore.ts',
-*   path: 'src/models/petStore.ts',
-*   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')] })],
-*   imports: [createImport({ name: ['z'], path: 'zod' })],
-*   exports: [createExport({ name: ['Pet'], path: './petStore' })],
-* })
-* // file.id      = SHA256 hash of 'src/models/petStore.ts'
-* // file.name    = 'petStore'
-* // file.extname = '.ts'
+* const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A cute pet' })
+* const merged = syncSchemaRef(ref) // merges with resolved Pet schema
 * ```
 */
-function createFile(input) {
-	const extname = path.extname(input.baseName) || (input.baseName.startsWith(".") ? input.baseName : "");
-	if (!extname) throw new Error(`No extname found for ${input.baseName}`);
-	const source = (input.sources ?? []).flatMap((item) => item.nodes ?? []).map((node) => extractStringsFromNodes([node])).filter(Boolean).join("\n\n");
-	const resolvedExports = input.exports?.length ? combineExports(input.exports) : [];
-	const resolvedImports = input.imports?.length ? combineImports(input.imports, resolvedExports, source || void 0) : [];
-	const resolvedSources = input.sources?.length ? combineSources(input.sources) : [];
-	return {
-		kind: "File",
-		...input,
-		id: createHash("sha256").update(input.path).digest("hex"),
-		name: trimExtName(input.baseName),
-		extname,
-		imports: resolvedImports,
-		exports: resolvedExports,
-		sources: resolvedSources,
-		meta: input.meta ?? {}
-	};
+function syncSchemaRef(node) {
+	const ref = narrowSchema(node, "ref");
+	if (!ref) return node;
+	if (!ref.schema) return node;
+	const { kind: _kind, type: _type, name: _name, ref: _ref, schema: _schema, ...overrides } = ref;
+	const definedOverrides = Object.fromEntries(Object.entries(overrides).filter(([, v]) => v !== void 0));
+	return createSchema({
+		...ref.schema,
+		...definedOverrides
+	});
 }
 /**
-* 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`.
-*
-* @example Simple function
-* ```ts
-* createFunction({ name: 'getPet' })
-* // function getPet() { ... }
-* ```
+* 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 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.
-*
-* 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
+* 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.
 *
-* 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
+/**
+* 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);
 }
 /**
-* 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
-* ```
+* Filters union members, dropping enum members that a broader scalar primitive already covers.
 */
-function simplifyUnion(members) {
+function simplifyUnionMembers(members) {
 	const scalarPrimitives = new Set(members.filter((member) => isScalarPrimitive(member.type)).map((m) => m.type));
 	if (!scalarPrimitives.size) return members;
 	return members.filter((member) => {
@@ -2179,19 +1755,134 @@ function simplifyUnion(members) {
 		return true;
 	});
 }
-function setEnumName(propNode, parentName, propName, enumSuffix) {
-	const enumNode = narrowSchema(propNode, "enum");
-	if (enumNode?.primitive === "boolean") return {
-		...propNode,
-		name: void 0
-	};
-	if (enumNode) return {
-		...propNode,
-		name: enumPropName(parentName, propName, enumSuffix)
+/**
+* Removes union members a broader scalar primitive already covers, such as a multi-value string enum
+* sitting next to a plain `string`. Single-value enums are kept.
+*
+* @example
+* ```ts
+* const next = applyMacros(unionSchema, [macroSimplifyUnion], { depth: 'shallow' })
+* ```
+*/
+const macroSimplifyUnion = defineMacro({
+	name: "simplify-union",
+	schema(node) {
+		const unionNode = narrowSchema(node, "union");
+		if (!unionNode?.members?.length) return void 0;
+		const simplified = simplifyUnionMembers(unionNode.members);
+		if (simplified.length === unionNode.members.length) return void 0;
+		return {
+			...unionNode,
+			members: simplified
+		};
+	}
+});
+//#endregion
+//#region src/factory.ts
+var factory_exports = /* @__PURE__ */ __exportAll({
+	createArrowFunction: () => createArrowFunction,
+	createBreak: () => createBreak,
+	createConst: () => createConst,
+	createContent: () => createContent,
+	createExport: () => createExport,
+	createFile: () => createFile,
+	createFunction: () => createFunction,
+	createImport: () => createImport,
+	createInput: () => createInput,
+	createJsx: () => createJsx,
+	createOperation: () => createOperation,
+	createOutput: () => createOutput,
+	createParameter: () => createParameter,
+	createProperty: () => createProperty,
+	createRequestBody: () => createRequestBody,
+	createResponse: () => createResponse,
+	createSchema: () => createSchema,
+	createSource: () => createSource,
+	createText: () => createText,
+	createType: () => createType,
+	update: () => update
+});
+/**
+* Identity-preserving node update: returns `node` unchanged when every field in
+* `changes` already equals (by reference) the current value, otherwise a new node
+* with the changes applied.
+*
+* Mirrors the TypeScript compiler's `factory.updateX` contract. Pair it with the
+* structural sharing in {@link transform} so a no-op rewrite does not allocate and
+* downstream passes can detect "nothing changed" by identity. Comparison is shallow,
+* so a structurally equal but newly allocated array or object counts as a change.
+*
+* @example
+* ```ts
+* update(node, { name: node.name })        // -> same `node` reference
+* update(node, { name: 'renamed' })        // -> new node, `name` replaced
+* ```
+*/
+function update(node, changes) {
+	for (const key in changes) if (changes[key] !== node[key]) return {
+		...node,
+		...changes
 	};
-	return propNode;
+	return node;
 }
 //#endregion
-export { caseParams, childName, collect, collectImports, collectReferencedSchemaNames, collectUsedSchemaNames, containsCircularRef, createArrowFunction, createBreak, createConst, createDiscriminantNode, createExport, createFile, createFunction, createFunctionParameter, createFunctionParameters, createImport, createInput, createJsx, createOperation, createOperationParams, createOutput, createParameter, createParameterGroup, createParamsType, createPrinterFactory, createProperty, createResponse, createSchema, createSource, createText, createType, definePrinter, enumPropName, extractRefName, extractStringsFromNodes, findCircularSchemas, findDiscriminator, httpMethods, isInputNode, isOperationNode, isOutputNode, isScalarPrimitive, isSchemaNode, isStringType, mediaTypes, mergeAdjacentObjects, narrowSchema, nodeKinds, resolveRefName, schemaTypes, setDiscriminatorEnum, setEnumName, simplifyUnion, syncOptionality, syncSchemaRef, transform, walk };
+//#region src/exports.ts
+var exports_exports = /* @__PURE__ */ __exportAll({
+	applyMacros: () => applyMacros,
+	arrowFunctionDef: () => arrowFunctionDef,
+	breakDef: () => breakDef,
+	childName: () => childName,
+	collect: () => collect,
+	collectUsedSchemaNames: () => collectUsedSchemaNames,
+	combineExports: () => combineExports,
+	combineImports: () => combineImports,
+	combineSources: () => combineSources,
+	composeMacros: () => composeMacros,
+	constDef: () => constDef,
+	containsCircularRef: () => containsCircularRef,
+	contentDef: () => contentDef,
+	createPrinter: () => createPrinter,
+	defineDialect: () => defineDialect,
+	defineMacro: () => defineMacro,
+	defineNode: () => defineNode,
+	enumPropName: () => enumPropName,
+	exportDef: () => exportDef,
+	extractRefName: () => extractRefName,
+	extractStringsFromNodes: () => extractStringsFromNodes,
+	factory: () => factory_exports,
+	fileDef: () => fileDef,
+	findCircularSchemas: () => findCircularSchemas,
+	functionDef: () => functionDef,
+	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
+export { applyMacros, arrowFunctionDef, exports_exports as ast, breakDef, childName, collect, collectUsedSchemaNames, combineExports, combineImports, combineSources, composeMacros, constDef, containsCircularRef, contentDef, createPrinter, defineDialect, defineMacro, defineNode, enumPropName, exportDef, extractRefName, extractStringsFromNodes, factory_exports as factory, fileDef, findCircularSchemas, functionDef, importDef, inputDef, isHttpOperationNode, isStringType, jsxDef, macroDiscriminatorEnum, macroEnumName, macroSimplifyUnion, mapSchemaItems, mapSchemaMembers, mapSchemaProperties, mergeAdjacentObjectsLazy, narrowSchema, nodeDefs, operationDef, optionality, outputDef, parameterDef, propertyDef, requestBodyDef, responseDef, schemaDef, schemaTypes, sourceDef, syncSchemaRef, textDef, transform, typeDef };
 
 //# sourceMappingURL=index.js.map