@kubb/ast 5.0.0-alpha.7 → 5.0.0-alpha.71

package/dist/index.js

@@ -1,44 +1,163 @@
 import "./chunk--u3MIqq1.js";
-import { parseArgs, styleText } from "node:util";
+import { createHash } from "node:crypto";
+import path from "node:path";
 //#region src/constants.ts
 const visitorDepths = {
 	shallow: "shallow",
 	deep: "deep"
 };
 const nodeKinds = {
-	root: "Root",
+	input: "Input",
+	output: "Output",
 	operation: "Operation",
 	schema: "Schema",
 	property: "Property",
 	parameter: "Parameter",
-	response: "Response"
+	response: "Response",
+	functionParameter: "FunctionParameter",
+	parameterGroup: "ParameterGroup",
+	functionParameters: "FunctionParameters",
+	type: "Type",
+	file: "File",
+	import: "Import",
+	export: "Export",
+	source: "Source",
+	text: "Text",
+	break: "Break"
 };
+/**
+* Canonical schema type strings used by AST schema nodes.
+*
+* These values are used across the AST as stable discriminators
+* (for example `schema.type === schemaTypes.object`).
+*
+* The map is grouped by intent:
+* - primitives (`string`, `number`, `boolean`, ...)
+* - structural/composite (`object`, `array`, `union`, ...)
+* - special OpenAPI-oriented types (`ref`, `datetime`, `uuid`, ...)
+*/
 const schemaTypes = {
+	/**
+	* Text value.
+	*/
 	string: "string",
+	/**
+	* Floating-point number (`float`, `double`).
+	*/
 	number: "number",
+	/**
+	* Whole number (`int32`). Use `bigint` for `int64`.
+	*/
 	integer: "integer",
+	/**
+	* 64-bit integer (`int64`). Only used when `integerType` is set to `'bigint'`.
+	*/
 	bigint: "bigint",
+	/**
+	* Boolean value
+	*/
 	boolean: "boolean",
+	/**
+	* Explicit null value.
+	*/
 	null: "null",
+	/**
+	* Any value (no type restriction).
+	*/
 	any: "any",
+	/**
+	* Unknown value (must be narrowed before usage).
+	*/
 	unknown: "unknown",
+	/**
+	* No return value (`void`).
+	*/
 	void: "void",
+	/**
+	* Object with named properties.
+	*/
 	object: "object",
+	/**
+	* Sequential list of items.
+	*/
 	array: "array",
+	/**
+	* Fixed-length list with position-specific items.
+	*/
 	tuple: "tuple",
+	/**
+	* "One of" multiple schema members.
+	*/
 	union: "union",
+	/**
+	* "All of" multiple schema members.
+	*/
 	intersection: "intersection",
+	/**
+	* Enum schema.
+	*/
 	enum: "enum",
+	/**
+	* Reference to another schema.
+	*/
 	ref: "ref",
+	/**
+	* Calendar date (for example `2026-03-24`).
+	*/
 	date: "date",
+	/**
+	* Date-time value (for example `2026-03-24T09:00:00Z`).
+	*/
 	datetime: "datetime",
+	/**
+	* Time-only value (for example `09:00:00`).
+	*/
 	time: "time",
+	/**
+	* UUID value.
+	*/
 	uuid: "uuid",
+	/**
+	* Email address value.
+	*/
 	email: "email",
+	/**
+	* URL value.
+	*/
 	url: "url",
+	/**
+	* IPv4 address value.
+	*/
+	ipv4: "ipv4",
+	/**
+	* IPv6 address value.
+	*/
+	ipv6: "ipv6",
+	/**
+	* Binary/blob value.
+	*/
 	blob: "blob",
+	/**
+	* Impossible value (`never`).
+	*/
 	never: "never"
 };
+/**
+* Primitive scalar schema types used when simplifying union members.
+*/
+const SCALAR_PRIMITIVE_TYPES = new Set([
+	"string",
+	"number",
+	"integer",
+	"bigint",
+	"boolean"
+]);
+/**
+* Returns `true` when `type` is a scalar primitive schema type.
+*/
+function isScalarPrimitive(type) {
+	return SCALAR_PRIMITIVE_TYPES.has(type);
+}
 const httpMethods = {
 	get: "GET",
 	post: "POST",
@@ -71,196 +190,7 @@ const mediaTypes = {
 	videoMp4: "video/mp4"
 };
 //#endregion
-//#region src/factory.ts
-/**
-* Creates a `RootNode`.
-*/
-function createRoot(overrides = {}) {
-	return {
-		schemas: [],
-		operations: [],
-		...overrides,
-		kind: "Root"
-	};
-}
-/**
-* Creates an `OperationNode`.
-*/
-function createOperation(props) {
-	return {
-		tags: [],
-		parameters: [],
-		responses: [],
-		...props,
-		kind: "Operation"
-	};
-}
-function createSchema(props) {
-	if (props["type"] === "object") return {
-		properties: [],
-		...props,
-		kind: "Schema"
-	};
-	return {
-		...props,
-		kind: "Schema"
-	};
-}
-/**
-* Creates a `PropertyNode`. `required` defaults to `false`.
-*/
-function createProperty(props) {
-	return {
-		required: false,
-		...props,
-		kind: "Property"
-	};
-}
-/**
-* Creates a `ParameterNode`. `required` defaults to `false`.
-*/
-function createParameter(props) {
-	return {
-		required: false,
-		...props,
-		kind: "Parameter"
-	};
-}
-/**
-* Creates a `ResponseNode`.
-*/
-function createResponse(props) {
-	return {
-		...props,
-		kind: "Response"
-	};
-}
-//#endregion
-//#region src/guards.ts
-/**
-* Narrows a `SchemaNode` to the specific variant matching `type`.
-*/
-function narrowSchema(node, type) {
-	return node?.type === type ? node : void 0;
-}
-function isKind(kind) {
-	return (node) => node.kind === kind;
-}
-/**
-* Type guard for `RootNode`.
-*/
-const isRootNode = isKind("Root");
-/**
-* Type guard for `OperationNode`.
-*/
-const isOperationNode = isKind("Operation");
-/**
-* Type guard for `SchemaNode`.
-*/
-const isSchemaNode = isKind("Schema");
-/**
-* Type guard for `PropertyNode`.
-*/
-const isPropertyNode = isKind("Property");
-/**
-* Type guard for `ParameterNode`.
-*/
-const isParameterNode = isKind("Parameter");
-/**
-* Type guard for `ResponseNode`.
-*/
-const isResponseNode = isKind("Response");
-//#endregion
-//#region src/printer.ts
-/**
-* Creates a named printer factory. Mirrors the `definePlugin` / `defineAdapter` pattern
-* from `@kubb/core` — wraps a builder to make options optional and separates raw options
-* from resolved options.
-*
-* 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)_ — a root-level override that becomes the public `printer.print`.
-*   Inside it, `this.print(node)` still dispatches to the `nodes` map — safe recursion, no infinite loop.
-*
-* When no `print` override is provided, `printer.print` is the node-level dispatcher directly.
-*
-* @example Basic usage — Zod schema printer
-* ```ts
-* type ZodPrinter = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
-*
-* export const zodPrinter = definePrinter<ZodPrinter>((options) => ({
-*   name: 'zod',
-*   options: { strict: options.strict ?? true },
-*   nodes: {
-*     string: () => 'z.string()',
-*     object(node) {
-*       const props = node.properties.map(p => `${p.name}: ${this.print(p.schema)}`).join(', ')
-*       return `z.object({ ${props} })`
-*     },
-*   },
-* }))
-* ```
-*
-* @example With a root-level `print` override to wrap output in a full declaration
-* ```ts
-* type TsPrinter = PrinterFactoryOptions<'ts', { typeName?: string }, ts.TypeNode, ts.Node>
-*
-* export const printerTs = definePrinter<TsPrinter>((options) => ({
-*   name: 'ts',
-*   options,
-*   nodes: { string: () => factory.keywordTypeNodes.string },
-*   print(node) {
-*     const type = this.print(node) // calls the node-level dispatcher
-*     if (!type || !this.options.typeName) return type
-*     return factory.createTypeAliasDeclaration(this.options.typeName, type)
-*   },
-* }))
-* ```
-*/
-function definePrinter(build) {
-	return (options) => {
-		const { name, options: resolvedOptions, nodes, print: printOverride } = build(options ?? {});
-		const context = {
-			options: resolvedOptions,
-			print: (node) => {
-				const handler = nodes[node.type];
-				if (!handler) return void 0;
-				return handler.call(context, node);
-			}
-		};
-		return {
-			name,
-			options: resolvedOptions,
-			print: printOverride ? printOverride.bind(context) : context.print
-		};
-	};
-}
-//#endregion
-//#region src/refs.ts
-/**
-* Indexes named schemas from `root.schemas` by name. Unnamed schemas are skipped.
-*/
-function buildRefMap(root) {
-	const map = /* @__PURE__ */ new Map();
-	for (const schema of root.schemas) if (schema.name) map.set(schema.name, schema);
-	return map;
-}
-/**
-* Looks up a schema by name. Prefer over `RefMap.get()` to keep the resolution strategy swappable.
-*/
-function resolveRef(refMap, ref) {
-	return refMap.get(ref);
-}
-/**
-* Converts a `RefMap` to a plain object.
-*/
-function refMapToObject(refMap) {
-	return Object.fromEntries(refMap);
-}
-//#endregion
-//#region ../../internals/utils/dist/index.js
+//#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
 * Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
@@ -279,10 +209,19 @@ function toCamelOrPascal(text, pascal) {
 * 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.
 */
 function applyToFileParts(text, transformPart) {
-	const parts = text.split(".");
-	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+	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.
@@ -299,214 +238,32 @@ function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
 	} : {}));
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
 }
-/** Returns a `CLIAdapter` with type inference. Pass a different adapter to `createCLI` to swap the CLI engine. */
-function defineCLIAdapter(adapter) {
-	return adapter;
-}
-/**
-* Serializes `CommandDefinition[]` to a plain, JSON-serializable structure.
-* Use to expose CLI capabilities to AI agents or MCP tools.
-*/
-function getCommandSchema(defs) {
-	return defs.map(serializeCommand);
-}
-function serializeCommand(def) {
-	return {
-		name: def.name,
-		description: def.description,
-		arguments: def.arguments,
-		options: serializeOptions(def.options ?? {}),
-		subCommands: def.subCommands ? def.subCommands.map(serializeCommand) : []
-	};
-}
-function serializeOptions(options) {
-	return Object.entries(options).map(([name, opt]) => {
-		return {
-			name,
-			flags: `${opt.short ? `-${opt.short}, ` : ""}--${name}${opt.type === "string" ? ` <${opt.hint ?? name}>` : ""}`,
-			type: opt.type,
-			description: opt.description,
-			...opt.default !== void 0 ? { default: opt.default } : {},
-			...opt.hint ? { hint: opt.hint } : {},
-			...opt.enum ? { enum: opt.enum } : {},
-			...opt.required ? { required: opt.required } : {}
-		};
-	});
-}
-/** Prints formatted help output for a command using its `CommandDefinition`. */
-function renderHelp(def, parentName) {
-	const schema = getCommandSchema([def])[0];
-	const programName = parentName ? `${parentName} ${schema.name}` : schema.name;
-	const argsPart = schema.arguments?.length ? ` ${schema.arguments.join(" ")}` : "";
-	const subCmdPart = schema.subCommands.length ? " <command>" : "";
-	console.log(`\n${styleText("bold", "Usage:")} ${programName}${argsPart}${subCmdPart} [options]\n`);
-	if (schema.description) console.log(`  ${schema.description}\n`);
-	if (schema.subCommands.length) {
-		console.log(styleText("bold", "Commands:"));
-		for (const sub of schema.subCommands) console.log(`  ${styleText("cyan", sub.name.padEnd(16))}${sub.description}`);
-		console.log();
-	}
-	const options = [...schema.options, {
-		name: "help",
-		flags: "-h, --help",
-		type: "boolean",
-		description: "Show help"
-	}];
-	console.log(styleText("bold", "Options:"));
-	for (const opt of options) {
-		const flags = styleText("cyan", opt.flags.padEnd(30));
-		const defaultPart = opt.default !== void 0 ? styleText("dim", ` (default: ${opt.default})`) : "";
-		console.log(`  ${flags}${opt.description}${defaultPart}`);
-	}
-	console.log();
-}
-function buildParseOptions(def) {
-	const result = { help: {
-		type: "boolean",
-		short: "h"
-	} };
-	for (const [name, opt] of Object.entries(def.options ?? {})) result[name] = {
-		type: opt.type,
-		...opt.short ? { short: opt.short } : {},
-		...opt.default !== void 0 ? { default: opt.default } : {}
-	};
-	return result;
-}
-async function runCommand(def, argv, parentName) {
-	const parseOptions = buildParseOptions(def);
-	let parsed;
-	try {
-		const result = parseArgs({
-			args: argv,
-			options: parseOptions,
-			allowPositionals: true,
-			strict: false
-		});
-		parsed = {
-			values: result.values,
-			positionals: result.positionals
-		};
-	} catch {
-		renderHelp(def, parentName);
-		process.exit(1);
-	}
-	if (parsed.values["help"]) {
-		renderHelp(def, parentName);
-		process.exit(0);
-	}
-	for (const [name, opt] of Object.entries(def.options ?? {})) if (opt.required && parsed.values[name] === void 0) {
-		console.error(styleText("red", `Error: --${name} is required`));
-		renderHelp(def, parentName);
-		process.exit(1);
-	}
-	if (!def.run) {
-		renderHelp(def, parentName);
-		process.exit(0);
-	}
-	try {
-		await def.run(parsed);
-	} catch (err) {
-		console.error(styleText("red", `Error: ${err instanceof Error ? err.message : String(err)}`));
-		renderHelp(def, parentName);
-		process.exit(1);
-	}
-}
-function printRootHelp(programName, version, defs) {
-	console.log(`\n${styleText("bold", "Usage:")} ${programName} <command> [options]\n`);
-	console.log(`  Kubb generation — v${version}\n`);
-	console.log(styleText("bold", "Commands:"));
-	for (const def of defs) console.log(`  ${styleText("cyan", def.name.padEnd(16))}${def.description}`);
-	console.log();
-	console.log(styleText("bold", "Options:"));
-	console.log(`  ${styleText("cyan", "-v, --version".padEnd(30))}Show version number`);
-	console.log(`  ${styleText("cyan", "-h, --help".padEnd(30))}Show help`);
-	console.log();
-	console.log(`Run ${styleText("cyan", `${programName} <command> --help`)} for command-specific help.\n`);
-}
-defineCLIAdapter({
-	renderHelp(def, parentName) {
-		renderHelp(def, parentName);
-	},
-	async run(defs, argv, opts) {
-		const { programName, defaultCommandName, version } = opts;
-		const args = argv.length >= 2 && argv[0]?.includes("node") ? argv.slice(2) : argv;
-		if (args[0] === "--version" || args[0] === "-v") {
-			console.log(version);
-			process.exit(0);
-		}
-		if (args[0] === "--help" || args[0] === "-h") {
-			printRootHelp(programName, version, defs);
-			process.exit(0);
-		}
-		if (args.length === 0) {
-			const defaultDef = defs.find((d) => d.name === defaultCommandName);
-			if (defaultDef?.run) await runCommand(defaultDef, [], programName);
-			else printRootHelp(programName, version, defs);
-			return;
-		}
-		const [first, ...rest] = args;
-		const isKnownSubcommand = defs.some((d) => d.name === first);
-		let def;
-		let commandArgv;
-		let parentName;
-		if (isKnownSubcommand) {
-			def = defs.find((d) => d.name === first);
-			commandArgv = rest;
-			parentName = programName;
-		} else {
-			def = defs.find((d) => d.name === defaultCommandName);
-			commandArgv = args;
-			parentName = programName;
-		}
-		if (!def) {
-			console.error(`Unknown command: ${first}`);
-			printRootHelp(programName, version, defs);
-			process.exit(1);
-		}
-		if (def.subCommands?.length) {
-			const [subName, ...subRest] = commandArgv;
-			const subDef = def.subCommands.find((s) => s.name === subName);
-			if (subName === "--help" || subName === "-h") {
-				renderHelp(def, parentName);
-				process.exit(0);
-			}
-			if (!subDef) {
-				renderHelp(def, parentName);
-				process.exit(subName ? 1 : 0);
-			}
-			await runCommand(subDef, subRest, `${parentName} ${def.name}`);
-			return;
-		}
-		await runCommand(def, commandArgv, parentName);
-	}
-});
-/**
-* Parses a CSS hex color string (`#RGB`) into its RGB channels.
-* Falls back to `255` for any channel that cannot be parsed.
-*/
-function parseHex(color) {
-	const int = Number.parseInt(color.replace("#", ""), 16);
-	return Number.isNaN(int) ? {
-		r: 255,
-		g: 255,
-		b: 255
-	} : {
-		r: int >> 16 & 255,
-		g: int >> 8 & 255,
-		b: int & 255
-	};
-}
 /**
-* Returns a function that wraps a string in a 24-bit ANSI true-color escape sequence
-* for the given hex color.
+* Converts `text` to PascalCase.
+* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
+*
+* @example
+* pascalCase('hello-world')                  // 'HelloWorld'
+* pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'
 */
-function hex(color) {
-	const { r, g, b } = parseHex(color);
-	return (text) => `\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`;
+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);
 }
-hex("#F55A17"), hex("#F5A217"), hex("#F58517"), hex("#B45309"), hex("#FFFFFF"), hex("#adadc6"), hex("#FDA4AF");
+//#endregion
+//#region ../../internals/utils/src/reserved.ts
 /**
 * Returns `true` when `name` is a syntactically valid JavaScript variable name.
+*
+* @example
+* ```ts
+* isValidVarName('status')  // true
+* isValidVarName('class')   // false (reserved word)
+* isValidVarName('42foo')   // false (starts with digit)
+* ```
 */
 function isValidVarName(name) {
 	try {
@@ -517,85 +274,161 @@ function isValidVarName(name) {
 	return true;
 }
 //#endregion
-//#region src/utils.ts
-const plainStringTypes = new Set([
-	"string",
-	"uuid",
-	"email",
-	"url",
-	"datetime"
-]);
+//#region ../../internals/utils/src/string.ts
 /**
-* Returns `true` when a schema node will be represented as a plain string in generated code.
+* 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.
 *
-* - `string`, `uuid`, `email`, `url`, `datetime` are always plain strings.
-* - `date` and `time` are plain strings when their `representation` is `'string'` rather than `'date'`.
+* @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'
 */
-function isPlainStringType(node) {
-	if (plainStringTypes.has(node.type)) return true;
-	const temporal = narrowSchema(node, "date") ?? narrowSchema(node, "time");
-	if (temporal) return temporal.representation !== "date";
-	return false;
+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
 /**
-* Transforms the `name` field of each parameter node according to the given casing strategy.
-*
-* The original `params` array is never mutated — a new array of cloned nodes is returned.
-* When no `casing` is provided the original array is returned as-is.
+* Narrows a `SchemaNode` to the variant that matches `type`.
 *
-* Use this before passing parameters to schema builders so that property keys
-* in the generated output match the desired casing while the original
-* `OperationNode.parameters` array remains untouched for other consumers.
+* @example
+* ```ts
+* const schema = createSchema({ type: 'string' })
+* const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | undefined
+* ```
 */
-function applyParamsCasing(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
-		};
-	});
+function narrowSchema(node, type) {
+	return node?.type === type ? node : void 0;
+}
+function isKind(kind) {
+	return (node) => node.kind === kind;
 }
-//#endregion
-//#region src/visitor.ts
 /**
-* Creates a concurrency-limiting wrapper. At most `concurrency` promises may be
-* in-flight simultaneously; additional calls are queued and dispatched as slots free.
+* Returns `true` when the input is an `InputNode`.
+*
+* @example
+* ```ts
+* if (isInputNode(node)) {
+*   console.log(node.schemas.length)
+* }
+* ```
 */
-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 isInputNode = isKind("Input");
 /**
-* Returns the immediate traversable children of `node`.
+* Returns `true` when the input is an `OutputNode`.
 *
-* For `Schema` nodes, children (properties, items, members) are only included
-* when `recurse` is `true`; shallow traversal omits them entirely.
+* @example
+* ```ts
+* if (isOutputNode(node)) {
+*   console.log(node.files.length)
+* }
+* ```
 */
-function getChildren(node, recurse) {
-	switch (node.kind) {
-		case "Root": return [...node.schemas, ...node.operations];
+const isOutputNode = isKind("Output");
+/**
+* Returns `true` when the input is an `OperationNode`.
+*
+* @example
+* ```ts
+* if (isOperationNode(node)) {
+*   console.log(node.operationId)
+* }
+* ```
+*/
+const isOperationNode = isKind("Operation");
+/**
+* Returns `true` when the input is a `SchemaNode`.
+*
+* @example
+* ```ts
+* if (isSchemaNode(node)) {
+*   console.log(node.type)
+* }
+* ```
+*/
+const isSchemaNode = isKind("Schema");
+isKind("Property");
+isKind("Parameter");
+isKind("Response");
+isKind("FunctionParameter");
+isKind("ParameterGroup");
+isKind("FunctionParameters");
+//#endregion
+//#region src/refs.ts
+/**
+* Returns the last path segment of a reference string.
+*
+* Example: `#/components/schemas/Pet` becomes `Pet`.
+*
+* @example
+* ```ts
+* extractRefName('#/components/schemas/Pet') // 'Pet'
+* ```
+*/
+function extractRefName(ref) {
+	return ref.split("/").at(-1) ?? ref;
+}
+//#endregion
+//#region src/visitor.ts
+/**
+* Creates a small async concurrency limiter.
+*
+* At most `concurrency` tasks are in flight at once. Extra tasks are queued.
+*
+* @example
+* ```ts
+* const limit = createLimit(2)
+* for (const task of [taskA, taskB, taskC]) {
+*   await limit(() => task())
+* }
+* // only 2 tasks run at the same time
+* ```
+*/
+function createLimit(concurrency) {
+	let active = 0;
+	const queue = [];
+	function next() {
+		if (active < concurrency && queue.length > 0) {
+			active++;
+			queue.shift()();
+		}
+	}
+	return function limit(fn) {
+		return new Promise((resolve, reject) => {
+			queue.push(() => {
+				Promise.resolve(fn()).then(resolve, reject).finally(() => {
+					active--;
+					next();
+				});
+			});
+			next();
+		});
+	};
+}
+/**
+* Returns the immediate traversable children of `node`.
+*
+* For `Schema` nodes, children (`properties`, `items`, `members`, and non-boolean
+* `additionalProperties`) are only included
+* when `recurse` is `true`; shallow mode skips them.
+*
+* @example
+* ```ts
+* const children = getChildren(operationNode, true)
+* // returns parameters, requestBody schema (if present), and responses
+* ```
+*/
+function getChildren(node, recurse) {
+	switch (node.kind) {
+		case "Input": return [...node.schemas, ...node.operations];
+		case "Output": return [];
 		case "Operation": return [
 			...node.parameters,
-			...node.requestBody ? [node.requestBody] : [],
+			...node.requestBody?.content?.flatMap((c) => c.schema ? [c.schema] : []) ?? [],
 			...node.responses
 		];
 		case "Schema": {
@@ -604,143 +437,1648 @@ function getChildren(node, recurse) {
 			if ("properties" in node && node.properties.length > 0) children.push(...node.properties);
 			if ("items" in node && node.items) children.push(...node.items);
 			if ("members" in node && node.members) children.push(...node.members);
+			if ("additionalProperties" in node && node.additionalProperties && node.additionalProperties !== true) children.push(node.additionalProperties);
 			return children;
 		}
 		case "Property": return [node.schema];
 		case "Parameter": return [node.schema];
 		case "Response": return node.schema ? [node.schema] : [];
+		case "FunctionParameter":
+		case "ParameterGroup":
+		case "FunctionParameters":
+		case "Type": return [];
+		default: return [];
 	}
 }
 /**
 * Depth-first traversal for side effects. Visitor return values are ignored.
-* Sibling nodes at each level are visited concurrently up to `options.concurrency` (default: 30).
+* Sibling nodes at each level are visited concurrently up to `options.concurrency`
+* (default: `WALK_CONCURRENCY`).
+*
+* @example
+* ```ts
+* await walk(root, {
+*   operation(node) {
+*     console.log(node.operationId)
+*   },
+* })
+* ```
+*
+* @example
+* ```ts
+* // Visit only the current node
+* await walk(root, { depth: 'shallow', root: () => {} })
+* ```
 */
-async function walk(node, visitor, options = {}) {
-	return _walk(node, visitor, (options.depth ?? visitorDepths.deep) === visitorDepths.deep, createLimit(options.concurrency ?? 30));
+async function walk(node, options) {
+	return _walk(node, options, (options.depth ?? visitorDepths.deep) === visitorDepths.deep, createLimit(options.concurrency ?? 30), void 0);
 }
-/**
-* Internal recursive walk implementation — calls visitor then recurses into children.
-*/
-async function _walk(node, visitor, recurse, limit) {
+async function _walk(node, visitor, recurse, limit, parent) {
 	switch (node.kind) {
-		case "Root":
-			await limit(() => visitor.root?.(node));
+		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));
+			await limit(() => visitor.operation?.(node, { parent }));
 			break;
 		case "Schema":
-			await limit(() => visitor.schema?.(node));
+			await limit(() => visitor.schema?.(node, { parent }));
 			break;
 		case "Property":
-			await limit(() => visitor.property?.(node));
+			await limit(() => visitor.property?.(node, { parent }));
 			break;
 		case "Parameter":
-			await limit(() => visitor.parameter?.(node));
+			await limit(() => visitor.parameter?.(node, { parent }));
 			break;
 		case "Response":
-			await limit(() => visitor.response?.(node));
+			await limit(() => visitor.response?.(node, { parent }));
 			break;
+		case "FunctionParameter":
+		case "ParameterGroup":
+		case "FunctionParameters": break;
 	}
 	const children = getChildren(node, recurse);
-	await Promise.all(children.map((child) => _walk(child, visitor, recurse, limit)));
+	for (const child of children) await _walk(child, visitor, recurse, limit, node);
 }
-function transform(node, visitor, options = {}) {
-	const recurse = (options.depth ?? visitorDepths.deep) === visitorDepths.deep;
+function transform(node, options) {
+	const { depth, parent, ...visitor } = options;
+	const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep;
 	switch (node.kind) {
-		case "Root": {
-			let root = node;
-			const replaced = visitor.root?.(root);
-			if (replaced) root = replaced;
+		case "Input": {
+			let input = node;
+			const replaced = visitor.input?.(input, { parent });
+			if (replaced) input = replaced;
 			return {
-				...root,
-				schemas: root.schemas.map((s) => transform(s, visitor, options)),
-				operations: root.operations.map((op) => transform(op, visitor, options))
+				...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);
+			const replaced = visitor.operation?.(op, { parent });
 			if (replaced) op = replaced;
 			return {
 				...op,
-				parameters: op.parameters.map((p) => transform(p, visitor, options)),
-				requestBody: op.requestBody ? transform(op.requestBody, visitor, options) : void 0,
-				responses: op.responses.map((r) => transform(r, visitor, options))
+				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);
+			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, visitor, options)) } : {},
-				..."items" in schema && recurse ? { items: schema.items?.map((i) => transform(i, visitor, options)) } : {},
-				..."members" in schema && recurse ? { members: schema.members?.map((m) => transform(m, visitor, options)) } : {}
+				..."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);
+			const replaced = visitor.property?.(prop, { parent });
 			if (replaced) prop = replaced;
-			return {
+			return createProperty({
 				...prop,
-				schema: transform(prop.schema, visitor, options)
-			};
+				schema: transform(prop.schema, {
+					...options,
+					parent: prop
+				})
+			});
 		}
 		case "Parameter": {
 			let param = node;
-			const replaced = visitor.parameter?.(param);
+			const replaced = visitor.parameter?.(param, { parent });
 			if (replaced) param = replaced;
-			return {
+			return createParameter({
 				...param,
-				schema: transform(param.schema, visitor, options)
-			};
+				schema: transform(param.schema, {
+					...options,
+					parent: param
+				})
+			});
 		}
 		case "Response": {
 			let response = node;
-			const replaced = visitor.response?.(response);
+			const replaced = visitor.response?.(response, { parent });
 			if (replaced) response = replaced;
 			return {
 				...response,
-				schema: response.schema ? transform(response.schema, visitor, options) : void 0
+				schema: transform(response.schema, {
+					...options,
+					parent: response
+				})
 			};
 		}
+		case "FunctionParameter":
+		case "ParameterGroup":
+		case "FunctionParameters":
+		case "Type": return node;
+		default: return node;
 	}
 }
 /**
-* Depth-first synchronous reduction. Collects non-`undefined` visitor return values into an array.
+* Runs a depth-first synchronous collection pass.
+*
+* Non-`undefined` values returned by visitor callbacks are appended to the result.
+*
+* @example
+* ```ts
+* const ids = collect(root, {
+*   operation(node) {
+*     return node.operationId
+*   },
+* })
+* ```
+*
+* @example
+* ```ts
+* // Collect from only the current node
+* const values = collect(root, { depth: 'shallow', root: () => 'root' })
+* ```
 */
-function collect(node, visitor, options = {}) {
-	const recurse = (options.depth ?? visitorDepths.deep) === visitorDepths.deep;
+function collect(node, options) {
+	const { depth, parent, ...visitor } = options;
+	const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep;
 	const results = [];
 	let v;
 	switch (node.kind) {
-		case "Root":
-			v = visitor.root?.(node);
+		case "Input":
+			v = visitor.input?.(node, { parent });
+			break;
+		case "Output":
+			v = visitor.output?.(node, { parent });
 			break;
 		case "Operation":
-			v = visitor.operation?.(node);
+			v = visitor.operation?.(node, { parent });
 			break;
 		case "Schema":
-			v = visitor.schema?.(node);
+			v = visitor.schema?.(node, { parent });
 			break;
 		case "Property":
-			v = visitor.property?.(node);
+			v = visitor.property?.(node, { parent });
 			break;
 		case "Parameter":
-			v = visitor.parameter?.(node);
+			v = visitor.parameter?.(node, { parent });
 			break;
 		case "Response":
-			v = visitor.response?.(node);
+			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, visitor, options)) results.push(item);
+	for (const child of getChildren(node, recurse)) for (const item of collect(child, {
+		...options,
+		parent: node
+	})) results.push(item);
 	return results;
 }
 //#endregion
-export { applyParamsCasing, buildRefMap, collect, createOperation, createParameter, createProperty, createResponse, createRoot, createSchema, definePrinter, httpMethods, isOperationNode, isParameterNode, isPlainStringType, isPropertyNode, isResponseNode, isRootNode, isSchemaNode, mediaTypes, narrowSchema, nodeKinds, refMapToObject, resolveRef, schemaTypes, transform, walk };
+//#region src/utils.ts
+const plainStringTypes = new Set([
+	"string",
+	"uuid",
+	"email",
+	"url",
+	"datetime"
+]);
+/**
+* Returns a merged schema view for a ref node, combining the resolved `node.schema`
+* (base from the referenced definition) with any usage-site sibling fields set directly
+* on the ref node (description, readOnly, nullable, deprecated, etc.).
+*
+* Usage-site fields take precedence over the resolved schema's own fields when both are defined.
+*
+* For non-ref nodes the node itself is returned unchanged.
+*/
+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
+	});
+}
+/**
+* Returns `true` when a schema is emitted as a plain `string` type.
+*
+* - `string`, `uuid`, `email`, `url`, `datetime` are always plain strings.
+* - `date` and `time` are plain strings when their `representation` is `'string'` rather than `'date'`.
+*
+* @example
+* ```ts
+* isStringType(createSchema({ type: 'uuid' }))                          // true
+* isStringType(createSchema({ type: 'date', representation: 'date' }))  // false
+* ```
+*/
+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.
+*
+* The input array is not mutated.
+* If `casing` is not set, the original array is returned unchanged.
+*
+* Use this before passing parameters to schema builders so that property keys
+* in generated output match the desired casing while preserving
+* `OperationNode.parameters` for other consumers.
+*
+* @example
+* ```ts
+* const params = [createParameter({ name: 'pet_id', in: 'query', schema: createSchema({ type: 'string' }) })]
+* const cased = caseParams(params, 'camelcase')
+* // cased[0].name === 'petId'
+* ```
+*/
+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 {@link OperationNode} into a {@link FunctionParametersNode}.
+*
+* Centralizes the per-plugin `getParams()` pattern. Provide a `resolver` for
+* type resolution and `extraParams` for plugin-specific trailing parameters.
+*
+* @example
+* ```ts
+* const params = createOperationParams(node, {
+*   paramsType: 'inline',
+*   pathParamsType: 'inline',
+*   resolver: tsResolver,
+*   extraParams: [createFunctionParameter({ name: 'options', type: createParamsType({ variant: 'reference', name: 'Partial<RequestOptions>' }), default: '{}' })],
+* })
+* ```
+*/
+function createOperationParams(node, options) {
+	const { paramsType, pathParamsType, paramsCasing, resolver, pathParamsDefault, extraParams = [], paramNames, typeWrapper } = options;
+	const dataName = paramNames?.data ?? "data";
+	const paramsName = paramNames?.params ?? "params";
+	const headersName = paramNames?.headers ?? "headers";
+	const pathName = paramNames?.path ?? "pathParams";
+	const wrapType = (type) => createParamsType({
+		variant: "reference",
+		name: typeWrapper ? typeWrapper(type) : type
+	});
+	const wrapTypeNode = (type) => type.kind === "ParamsType" && type.variant === "reference" ? wrapType(type.name) : type;
+	const casedParams = caseParams(node.parameters, paramsCasing);
+	const pathParams = casedParams.filter((p) => p.in === "path");
+	const queryParams = casedParams.filter((p) => p.in === "query");
+	const headerParams = casedParams.filter((p) => p.in === "header");
+	const bodyType = node.requestBody?.content?.[0]?.schema ? wrapType(resolver?.resolveDataName(node) ?? "unknown") : void 0;
+	const bodyRequired = node.requestBody?.required ?? false;
+	const queryGroupType = resolver ? resolveGroupType({
+		node,
+		params: queryParams,
+		groupMethod: resolver.resolveQueryParamsName,
+		resolver
+	}) : void 0;
+	const headerGroupType = resolver ? resolveGroupType({
+		node,
+		params: headerParams,
+		groupMethod: resolver.resolveHeaderParamsName,
+		resolver
+	}) : void 0;
+	const params = [];
+	if (paramsType === "object") {
+		const children = [
+			...pathParams.map((p) => {
+				const type = resolveParamsType({
+					node,
+					param: p,
+					resolver
+				});
+				return createFunctionParameter({
+					name: p.name,
+					type: wrapTypeNode(type),
+					optional: !p.required
+				});
+			}),
+			...bodyType ? [createFunctionParameter({
+				name: dataName,
+				type: bodyType,
+				optional: !bodyRequired
+			})] : [],
+			...buildGroupParam({
+				name: paramsName,
+				node,
+				params: queryParams,
+				groupType: queryGroupType,
+				resolver,
+				wrapType
+			}),
+			...buildGroupParam({
+				name: headersName,
+				node,
+				params: headerParams,
+				groupType: headerGroupType,
+				resolver,
+				wrapType
+			})
+		];
+		if (children.length) params.push(createParameterGroup({
+			properties: children,
+			default: children.every((c) => c.optional) ? "{}" : void 0
+		}));
+	} else {
+		if (pathParams.length) if (pathParamsType === "inlineSpread") {
+			const spreadType = resolver?.resolvePathParamsName(node, pathParams[0]) ?? void 0;
+			params.push(createFunctionParameter({
+				name: pathName,
+				type: spreadType ? wrapType(spreadType) : void 0,
+				rest: true
+			}));
+		} else {
+			const pathChildren = pathParams.map((p) => {
+				const type = resolveParamsType({
+					node,
+					param: p,
+					resolver
+				});
+				return createFunctionParameter({
+					name: p.name,
+					type: wrapTypeNode(type),
+					optional: !p.required
+				});
+			});
+			params.push(createParameterGroup({
+				properties: pathChildren,
+				inline: pathParamsType === "inline",
+				default: pathParamsDefault ?? (pathChildren.every((c) => c.optional) ? "{}" : void 0)
+			}));
+		}
+		if (bodyType) params.push(createFunctionParameter({
+			name: dataName,
+			type: bodyType,
+			optional: !bodyRequired
+		}));
+		params.push(...buildGroupParam({
+			name: paramsName,
+			node,
+			params: queryParams,
+			groupType: queryGroupType,
+			resolver,
+			wrapType
+		}));
+		params.push(...buildGroupParam({
+			name: headersName,
+			node,
+			params: headerParams,
+			groupType: headerGroupType,
+			resolver,
+			wrapType
+		}));
+	}
+	params.push(...extraParams);
+	return createFunctionParameters({ params });
+}
+/**
+* Builds a single {@link FunctionParameterNode} for a query or header group.
+* Returns an empty array when there are no params to emit.
+*
+* If a pre-resolved `groupType` is provided it emits `name: GroupType`.
+* Otherwise, it builds an inline struct from the individual params.
+*/
+function buildGroupParam({ name, node, params, groupType, resolver, wrapType }) {
+	if (groupType) return [createFunctionParameter({
+		name,
+		type: groupType.type.kind === "ParamsType" && groupType.type.variant === "reference" ? wrapType(groupType.type.name) : groupType.type,
+		optional: groupType.optional
+	})];
+	if (params.length) return [createFunctionParameter({
+		name,
+		type: toStructType({
+			node,
+			params,
+			resolver
+		}),
+		optional: params.every((p) => !p.required)
+	})];
+	return [];
+}
+/**
+* Derives a {@link ParamGroupType} from the resolver's group method.
+* Returns `undefined` when the group name equals the individual param name (no real group).
+*/
+function resolveGroupType({ node, params, groupMethod, resolver }) {
+	if (!params.length) return;
+	const firstParam = params[0];
+	const groupName = groupMethod.call(resolver, node, firstParam);
+	if (groupName === resolver.resolveParamName(node, firstParam)) return;
+	const allOptional = params.every((p) => !p.required);
+	return {
+		type: createParamsType({
+			variant: "reference",
+			name: groupName
+		}),
+		optional: allOptional
+	};
+}
+/**
+* Builds a {@link TypeNode} with `variant: 'struct'` for an inline anonymous type grouping named fields.
+*
+* Used when query or header parameters have no dedicated group type name.
+* Each language printer renders this appropriately (TypeScript: `{ petId: string; name?: string }`).
+*/
+function toStructType({ node, params, resolver }) {
+	return createParamsType({
+		variant: "struct",
+		properties: params.map((p) => ({
+			name: p.name,
+			optional: !p.required,
+			type: resolveParamsType({
+				node,
+				param: p,
+				resolver
+			})
+		}))
+	});
+}
+function sourceKey(source) {
+	return `${source.name ?? extractStringsFromNodes(source.nodes)}:${source.isExportable ?? false}:${source.isTypeOnly ?? false}`;
+}
+function pathTypeKey(path, isTypeOnly) {
+	return `${path}:${isTypeOnly ?? false}`;
+}
+function exportKey(path, name, isTypeOnly, asAlias) {
+	return `${path}:${name ?? ""}:${isTypeOnly ?? false}:${asAlias ?? ""}`;
+}
+function importKey(path, name, isTypeOnly) {
+	return `${path}:${name ?? ""}:${isTypeOnly ?? false}`;
+}
+/**
+* Computes a multi-level sort key for exports and imports:
+* non-array names first (wildcards/namespace aliases); type-only before value; alphabetical path; unnamed before named.
+*/
+function sortKey(node) {
+	const isArray = Array.isArray(node.name) ? "1" : "0";
+	const typeOnly = node.isTypeOnly ? "0" : "1";
+	const hasName = node.name != null ? "1" : "0";
+	const name = Array.isArray(node.name) ? [...node.name].sort().join("\0") : node.name ?? "";
+	return `${isArray}:${typeOnly}:${node.path}:${hasName}:${name}`;
+}
+/**
+* Deduplicates an array of `SourceNode` objects.
+* Named sources are deduplicated by `name + isExportable + isTypeOnly`.
+* Unnamed sources are deduplicated by object reference.
+*/
+function combineSources(sources) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		const key = sourceKey(source);
+		if (!seen.has(key)) seen.set(key, source);
+	}
+	return [...seen.values()];
+}
+/**
+* Deduplicates and merges an array of `ExportNode` objects.
+* Exports with the same path and `isTypeOnly` flag have their names merged.
+*/
+function combineExports(exports) {
+	const result = [];
+	const namedByPath = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	const keyed = exports.map((node) => ({
+		node,
+		key: sortKey(node)
+	}));
+	keyed.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+	for (const { node: curr } of keyed) {
+		const { name, path, isTypeOnly, asAlias } = curr;
+		if (Array.isArray(name)) {
+			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 {
+				const newItem = {
+					...curr,
+					name: [...new Set(name)]
+				};
+				result.push(newItem);
+				namedByPath.set(key, newItem);
+			}
+		} else {
+			const key = exportKey(path, name, isTypeOnly, asAlias);
+			if (!seen.has(key)) {
+				result.push(curr);
+				seen.add(key);
+			}
+		}
+	}
+	return result;
+}
+/**
+* Deduplicates and merges an array of `ImportNode` objects.
+* Filters out unused imports (names not referenced in `source` or re-exported).
+* Imports with the same path and `isTypeOnly` flag have their names merged.
+*/
+function combineImports(imports, exports, source) {
+	const exportedNames = new Set(exports.flatMap((e) => Array.isArray(e.name) ? e.name : e.name ? [e.name] : []));
+	const isUsed = (importName) => !source || source.includes(importName) || exportedNames.has(importName);
+	const result = [];
+	const namedByPath = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	const keyed = imports.map((node) => ({
+		node,
+		key: sortKey(node)
+	}));
+	keyed.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+	for (const { node: curr } of keyed) {
+		if (curr.path === curr.root) continue;
+		const { path, isTypeOnly } = curr;
+		let { name } = curr;
+		if (Array.isArray(name)) {
+			name = [...new Set(name)].filter((item) => typeof item === "string" ? isUsed(item) : isUsed(item.propertyName));
+			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 {
+				const newItem = {
+					...curr,
+					name
+				};
+				result.push(newItem);
+				namedByPath.set(key, newItem);
+			}
+		} else {
+			if (name && !isUsed(name)) continue;
+			const key = importKey(path, name, isTypeOnly);
+			if (!seen.has(key)) {
+				result.push(curr);
+				seen.add(key);
+			}
+		}
+	}
+	return result;
+}
+/**
+* Recursively extracts all string content embedded in a {@link CodeNode} tree.
+*
+* Includes text node values, and string attribute fields (`params`, `generics`,
+* `returnType`, `type`) that may reference identifiers needing imports.
+* Used by `createFile` to build the full source string for import filtering.
+*/
+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");
+}
+/**
+* Resolves the referenced 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.
+*
+* @example
+* ```ts
+* resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Pet' })
+* // => 'Pet'
+* ```
+*/
+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;
+}
+/**
+* Recursively collects every named schema referenced (transitively) from
+* `node` via `ref` edges. Refs are followed by name only — the resolved
+* `node.schema` of a ref is not traversed inline.
+*
+* @example
+* ```ts
+* const refs = collectReferencedSchemaNames(petSchema)
+* // => Set { 'Cat', 'Dog' }
+* ```
+*/
+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;
+}
+/**
+* Identifies every named schema that participates in a circular dependency
+* chain — including direct self-loops (e.g. `TreeNode → TreeNode`) and indirect
+* cycles spanning multiple schemas (e.g. `Pet → Cat → Pet`).
+*
+* The returned set contains schema names. Plugins that translate schemas into
+* a host language can use this to wrap recursive positions in a deferred
+* construct (lazy getter, `z.lazy(() => …)`, etc.) and avoid runtime stack
+* overflows when the generated code is executed.
+*
+* Refs are followed by name only — `node.schema` (the resolved referent) is
+* not traversed inline, which keeps the algorithm linear in the size of the
+* schema graph.
+*
+* @example
+* ```ts
+* const circular = findCircularSchemas(inputNode.schemas)
+* if (circular.has('Pet')) {
+*   // emit lazy wrapper for any property whose schema references Pet
+* }
+* ```
+*/
+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);
+		}
+	}
+	return circular;
+}
+/**
+* Returns true when `node` (or anything nested within it) carries a `ref`
+* whose resolved name belongs to `circularSchemas`.
+*
+* When `excludeName` is provided, refs to that name are ignored — useful
+* when self-references are already handled separately from cross-schema
+* cycles (e.g. the faker plugin emits `undefined as any` for direct
+* self-recursion but a lazy getter for indirect cycles).
+*
+* @example
+* ```ts
+* const circular = findCircularSchemas(schemas)
+* if (containsCircularRef(property.schema, { circularSchemas: circular, excludeName: 'Pet' })) {
+*   // emit `get foo() { return fakeCat() }` instead of eager call
+* }
+* ```
+*/
+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;
+}
+//#endregion
+//#region src/factory.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.
+*/
+function syncOptionality(schema, required) {
+	const nullable = schema.nullable ?? false;
+	return {
+		...schema,
+		optional: !required && !nullable ? true : void 0,
+		nullish: !required && nullable ? true : void 0
+	};
+}
+/**
+* Creates an `InputNode` with stable defaults for `schemas` and `operations`.
+*
+* @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"
+	};
+}
+/**
+* Creates an `OutputNode` with a stable default for `files`.
+*
+* @example
+* ```ts
+* const output = createOutput()
+* // { kind: 'Output', files: [] }
+* ```
+*
+* @example
+* ```ts
+* const output = createOutput({ files: [petFile] })
+* ```
+*/
+function createOutput(overrides = {}) {
+	return {
+		files: [],
+		...overrides,
+		kind: "Output"
+	};
+}
+/**
+* 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 []
+* ```
+*
+* @example
+* ```ts
+* const operation = createOperation({
+*   operationId: 'findPets',
+*   method: 'GET',
+*   path: '/pet/findByStatus',
+*   tags: ['pet'],
+* })
+* ```
+*/
+function createOperation(props) {
+	return {
+		tags: [],
+		parameters: [],
+		responses: [],
+		...props,
+		kind: "Operation"
+	};
+}
+/**
+* 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.
+*/
+const TYPE_TO_PRIMITIVE = {
+	string: "string",
+	number: "number",
+	integer: "integer",
+	bigint: "bigint",
+	boolean: "boolean",
+	null: "null",
+	any: "any",
+	unknown: "unknown",
+	void: "void",
+	never: "never",
+	object: "object",
+	array: "array",
+	date: "date",
+	uuid: "string",
+	email: "string",
+	url: "string",
+	datetime: "string",
+	time: "string"
+};
+function createSchema(props) {
+	const inferredPrimitive = TYPE_TO_PRIMITIVE[props.type];
+	if (props["type"] === "object") return {
+		properties: [],
+		primitive: "object",
+		...props,
+		kind: "Schema"
+	};
+	return {
+		primitive: inferredPrimitive,
+		...props,
+		kind: "Schema"
+	};
+}
+/**
+* Creates a `PropertyNode`.
+*
+* `required` defaults to `false`.
+* `schema.optional` and `schema.nullish` are derived from `required` and `schema.nullable`.
+*
+* @example
+* ```ts
+* const property = createProperty({
+*   name: 'status',
+*   schema: createSchema({ type: 'string' }),
+* })
+* // required=false, schema.optional=true
+* ```
+*
+* @example
+* ```ts
+* const property = createProperty({
+*   name: 'status',
+*   required: true,
+*   schema: createSchema({ type: 'string', nullable: true }),
+* })
+* // required=true, no optional/nullish
+* ```
+*/
+function createProperty(props) {
+	const required = props.required ?? false;
+	return {
+		...props,
+		kind: "Property",
+		required,
+		schema: syncOptionality(props.schema, required)
+	};
+}
+/**
+* Creates a `ParameterNode`.
+*
+* `required` defaults to `false`.
+* Nested schema flags are set from `required` and `schema.nullable`.
+*
+* @example
+* ```ts
+* const param = createParameter({
+*   name: 'petId',
+*   in: 'path',
+*   required: true,
+*   schema: createSchema({ type: 'string' }),
+* })
+* ```
+*
+* @example
+* ```ts
+* const param = createParameter({
+*   name: 'status',
+*   in: 'query',
+*   schema: createSchema({ type: 'string', nullable: true }),
+* })
+* // required=false, schema.nullish=true
+* ```
+*/
+function createParameter(props) {
+	const required = props.required ?? false;
+	return {
+		...props,
+		kind: "Parameter",
+		required,
+		schema: syncOptionality(props.schema, required)
+	};
+}
+/**
+* Creates a `ResponseNode`.
+*
+* @example
+* ```ts
+* const response = createResponse({
+*   statusCode: '200',
+*   description: 'Success',
+*   schema: createSchema({ type: 'object', properties: [] }),
+* })
+* ```
+*/
+function createResponse(props) {
+	return {
+		...props,
+		kind: "Response"
+	};
+}
+/**
+* Creates a `FunctionParameterNode`.
+*
+* `optional` defaults to `false`.
+*
+* @example Required typed param
+* ```ts
+* createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }) })
+* // → petId: string
+* ```
+*
+* @example Optional param
+* ```ts
+* createFunctionParameter({ name: 'params', type: createParamsType({ variant: 'reference', name: 'QueryParams' }), optional: true })
+* // → params?: QueryParams
+* ```
+*
+* @example Param with default (implicitly optional; cannot combine with `optional: true`)
+* ```ts
+* createFunctionParameter({ name: 'config', type: createParamsType({ variant: 'reference', name: 'RequestConfig' }), default: '{}' })
+* // → config: RequestConfig = {}
+* ```
+*/
+function createFunctionParameter(props) {
+	return {
+		optional: false,
+		...props,
+		kind: "FunctionParameter"
+	};
+}
+/**
+* Creates a {@link TypeNode} representing a language-agnostic structured type expression.
+*
+* 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, …).
+*
+* @example Reference type (TypeScript: `QueryParams`)
+* ```ts
+* createParamsType({ variant: 'reference', name: 'QueryParams' })
+* ```
+*
+* @example Struct type (TypeScript: `{ petId: string }`)
+* ```ts
+* createParamsType({ variant: 'struct', properties: [{ name: 'petId', optional: false, type: createParamsType({ variant: 'reference', name: 'string' }) }] })
+* ```
+*
+* @example Member type (TypeScript: `DeletePetPathParams['petId']`)
+* ```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.
+*
+* @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 }
+* ```
+*
+* @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
+* ```
+*/
+function createParameterGroup(props) {
+	return {
+		...props,
+		kind: "ParameterGroup"
+	};
+}
+/**
+* Creates a `FunctionParametersNode` from an ordered list of parameters.
+*
+* @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: '{}' }),
+*   ],
+* })
+* ```
+*
+* @example
+* ```ts
+* const empty = createFunctionParameters()
+* // { kind: 'FunctionParameters', params: [] }
+* ```
+*/
+function createFunctionParameters(props = {}) {
+	return {
+		params: [],
+		...props,
+		kind: "FunctionParameters"
+	};
+}
+/**
+* Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
+*
+* @example Named import
+* ```ts
+* createImport({ name: ['useState'], path: 'react' })
+* // import { useState } from 'react'
+* ```
+*
+* @example Type-only import
+* ```ts
+* createImport({ name: ['FC'], path: 'react', isTypeOnly: true })
+* // import type { FC } from 'react'
+* ```
+*/
+function createImport(props) {
+	return {
+		...props,
+		kind: "Import"
+	};
+}
+/**
+* Creates an `ExportNode` representing a language-agnostic export/public API declaration.
+*
+* @example Named export
+* ```ts
+* createExport({ name: ['Pet'], path: './Pet' })
+* // export { Pet } from './Pet'
+* ```
+*
+* @example Wildcard export
+* ```ts
+* createExport({ path: './utils' })
+* // export * from './utils'
+* ```
+*/
+function createExport(props) {
+	return {
+		...props,
+		kind: "Export"
+	};
+}
+/**
+* Creates a `SourceNode` representing a fragment of source code within a file.
+*
+* @example
+* ```ts
+* createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
+* ```
+*/
+function createSource(props) {
+	return {
+		...props,
+		kind: "Source"
+	};
+}
+/**
+* Creates a fully resolved `FileNode` from a file input descriptor.
+*
+* Computes:
+* - `id` — SHA256 hash of the file path
+* - `name` — `baseName` without extension
+* - `extname` — extension extracted from `baseName`
+*
+* Deduplicates:
+* - `sources` via `combineSources`
+* - `exports` via `combineExports`
+* - `imports` via `combineImports` (also filters unused imports)
+*
+* @throws {Error} when `baseName` has no extension.
+*
+* @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'
+* ```
+*/
+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 ?? {}
+	};
+}
+/**
+* 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
+* ```
+*
+* @example With JSDoc and child nodes
+* ```ts
+* createConst({
+*   name: 'config',
+*   export: true,
+*   JSDoc: { comments: ['@description App configuration'] },
+*   nodes: [],
+* })
+* ```
+*/
+function createConst(props) {
+	return {
+		...props,
+		kind: "Const"
+	};
+}
+/**
+* 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 = ...
+* ```
+*/
+function createType(props) {
+	return {
+		...props,
+		kind: "Type"
+	};
+}
+/**
+* Creates a `FunctionNode` representing a TypeScript `function` declaration.
+*
+* 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() { ... }
+* ```
+*
+* @example Exported async function with return type
+* ```ts
+* createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
+* // export async function fetchPet(): Promise<Pet> { ... }
+* ```
+*
+* @example Function with generics and params
+* ```ts
+* createFunction({
+*   name: 'identity',
+*   export: true,
+*   generics: ['T'],
+*   params: 'value: T',
+*   returnType: 'T',
+* })
+* // export function identity<T>(value: T): T { ... }
+* ```
+*/
+function createFunction(props) {
+	return {
+		...props,
+		kind: "Function"
+	};
+}
+/**
+* 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> => { ... }
+* ```
+*/
+function createArrowFunction(props) {
+	return {
+		...props,
+		kind: "ArrowFunction"
+	};
+}
+/**
+* Creates a {@link TextNode} representing a raw string fragment in the source output.
+*
+* Use this instead of bare strings when building `nodes` arrays so that every
+* entry in the array is a typed {@link CodeNode}.
+*
+* @example
+* ```ts
+* createText('return fetch(id)')
+* // { kind: 'Text', value: 'return fetch(id)' }
+* ```
+*/
+function createText(value) {
+	return {
+		value,
+		kind: "Text"
+	};
+}
+/**
+* Creates a {@link BreakNode} representing a line break in the source output.
+*
+* Corresponds to `<br/>` in JSX components. Prints as an empty string which,
+* when joined with `\n` by `printNodes`, produces a blank line.
+*
+* @example
+* ```ts
+* createBreak()
+* // { kind: 'Break' }
+* ```
+*/
+function createBreak() {
+	return { kind: "Break" };
+}
+/**
+* Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
+*
+* Use this to embed JSX markup (including fragments `<>…</>`) directly in generated code.
+*
+* @example
+* ```ts
+* createJsx('<>\n  <a href={href}>Open</a>\n</>')
+* // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
+* ```
+*/
+function createJsx(value) {
+	return {
+		value,
+		kind: "Jsx"
+	};
+}
+//#endregion
+//#region src/printer.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
+*
+* When no `print` override is provided, `printer.print` falls back to `printer.transform` (the node-level dispatcher).
+*
+* @example Basic usage — Zod schema printer
+* ```ts
+* type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
+*
+* 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} })`
+*     },
+*   },
+* }))
+* ```
+*/
+function definePrinter(build) {
+	return createPrinterFactory((node) => node.type)(build);
+}
+/**
+* Generic printer-factory function used by `definePrinter` and `defineFunctionPrinter`.
+**
+* @example
+* ```ts
+* export const defineFunctionPrinter = createPrinterFactory<FunctionNode, FunctionNodeType, FunctionNodeByType>(
+*   (node) => kindToHandlerKey[node.kind],
+* )
+* ```
+*/
+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(" "));
+}
+/**
+* Collects import entries for all `ref` schema nodes in `node`.
+*/
+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;
+	} });
+}
+//#endregion
+//#region src/transformers.ts
+/**
+* Replaces a discriminator property's schema with a string enum of allowed values.
+*
+* If `node` is not an object schema, or if the property does not exist, the input
+* node is returned as-is.
+*
+* @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
+				})
+			});
+		})
+	});
+}
+/**
+* Merges adjacent anonymous object members into a single anonymous object member.
+*
+* @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' }) })] }),
+* ])
+* ```
+*/
+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;
+			}
+		}
+		acc.push(member);
+		return acc;
+	}, []);
+}
+/**
+* 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
+* ```
+*/
+function simplifyUnion(members) {
+	const scalarPrimitives = new Set(members.filter((member) => isScalarPrimitive(member.type)).map((m) => m.type));
+	if (!scalarPrimitives.size) return members;
+	return members.filter((member) => {
+		const enumNode = narrowSchema(member, "enum");
+		if (!enumNode) return true;
+		const primitive = enumNode.primitive;
+		if (!primitive) return true;
+		if ((enumNode.namedEnumValues?.length ?? enumNode.enumValues?.length ?? 0) <= 1) return true;
+		if (scalarPrimitives.has(primitive)) return false;
+		if ((primitive === "integer" || primitive === "number") && (scalarPrimitives.has("integer") || scalarPrimitives.has("number"))) return false;
+		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)
+	};
+	return propNode;
+}
+//#endregion
+export { caseParams, childName, collect, collectImports, collectReferencedSchemaNames, 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 };
 
 //# sourceMappingURL=index.js.map