@kubb/ast 5.8.4 → 5.9.1

package/dist/index.cjs

@@ -30,9 +30,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-let node_crypto = require("node:crypto");
 let node_path = require("node:path");
 node_path = __toESM(node_path, 1);
+let node_crypto = require("node:crypto");
 //#region src/constants.ts
 const visitorDepths = {
 	shallow: "shallow",
@@ -177,11 +177,32 @@ function isHttpOperationNode(node) {
 	return node.protocol === "http" || node.method !== void 0 && node.path !== void 0;
 }
 //#endregion
-//#region src/defineNode.ts
+//#region src/visitor.ts
 /**
-* Visitor callback names, one per traversable node kind, in traversal order.
-* Kept in sync with the keys of `Visitor` in `visitor.ts`.
+* Child node fields per node kind, in traversal order (Babel's `VISITOR_KEYS`).
 */
+const VISITOR_KEYS = {
+	Input: ["schemas", "operations"],
+	Operation: [
+		"parameters",
+		"requestBody",
+		"responses"
+	],
+	RequestBody: ["content"],
+	Content: ["schema"],
+	Response: ["content"],
+	Schema: [
+		"properties",
+		"items",
+		"members",
+		"additionalProperties",
+		"patternProperties",
+		"rest"
+	],
+	Property: ["schema"],
+	Parameter: ["schema"]
+};
+/** Visitor callback names in traversal order, the keys of {@link Visitor}. */
 const visitorKeys = [
 	"input",
 	"output",
@@ -192,176 +213,395 @@ const visitorKeys = [
 	"response"
 ];
 /**
-* Builds a type guard that matches nodes of the given `kind`.
+* Maps a node kind to the matching visitor callback name.
 */
-function isKind(kind) {
-	return (node) => node?.kind === kind;
-}
+const VISITOR_KEY_BY_KIND = {
+	Input: "input",
+	Output: "output",
+	Operation: "operation",
+	Schema: "schema",
+	Property: "property",
+	Parameter: "parameter",
+	Response: "response"
+};
+const visitorKeysByKind = VISITOR_KEYS;
 /**
-* Defines a node once and derives its `create` builder, `is` guard, and traversal
-* metadata. `create` merges `defaults`, the `build` hook (or the raw input), and the
-* `kind`, so node construction lives in one place without scattered `as` casts.
-*
-* @example Simple node
-* ```ts
-* const importDef = defineNode<ImportNode>({ kind: 'Import' })
-* const createImport = importDef.create
-* ```
-*
-* @example Node with a build hook
-* ```ts
-* const propertyDef = defineNode<PropertyNode, UserPropertyNode>({
-*   kind: 'Property',
-*   build: (props) => ({ ...props, required: props.required ?? false }),
-*   children: ['schema'],
-*   visitorKey: 'property',
-* })
-* ```
+* Returns `true` when `value` is an AST node (an object carrying a `kind`).
 */
-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
-	};
+function isNode(value) {
+	return typeof value === "object" && value !== null && typeof value.kind === "string";
 }
-//#endregion
-//#region src/nodes/code.ts
-/**
-* Definition for the {@link ConstNode}.
-*/
-const constDef = defineNode({ kind: "Const" });
-/**
-* Definition for the {@link TypeNode}.
-*/
-const typeDef = defineNode({ kind: "Type" });
-/**
-* Definition for the {@link FunctionNode}.
-*/
-const functionDef = defineNode({ kind: "Function" });
-/**
-* Definition for the {@link ArrowFunctionNode}.
-*/
-const arrowFunctionDef = defineNode({ kind: "ArrowFunction" });
-/**
-* Definition for the {@link TextNode}.
-*/
-const textDef = defineNode({
-	kind: "Text",
-	build: (value) => ({ value })
-});
 /**
-* Definition for the {@link BreakNode}.
+* Returns `true` for a plain object that maps names to nodes, such as `patternProperties`.
 */
-const breakDef = defineNode({
-	kind: "Break",
-	build: () => ({})
-});
+function isNodeRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 /**
-* Definition for the {@link JsxNode}.
+* Returns the child fields of `node` to walk, from {@link VISITOR_KEYS}, or `undefined` when there
+* is nothing to walk. `Schema` children are only walked when `recurse` is `true`.
 */
-const jsxDef = defineNode({
-	kind: "Jsx",
-	build: (value) => ({ value })
-});
+function childKeys(node, recurse) {
+	if (node.kind === "Schema" && !recurse) return void 0;
+	return visitorKeysByKind[node.kind];
+}
 /**
-* Creates a `ConstNode` representing a TypeScript `const` declaration.
+* Returns the immediate traversable children of `node`.
 *
-* @example Exported constant with type and `as const`
+* @example
 * ```ts
-* createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
-* // export const pets: Pet[] = ... as const
+* const children = getChildren(operationNode, true)
+* // returns parameters, the request body, and responses
 * ```
 */
-const createConst = constDef.create;
+function* getChildren(node, recurse) {
+	const keys = childKeys(node, recurse);
+	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;
+			continue;
+		}
+		if (isNode(value)) {
+			yield value;
+			continue;
+		}
+		if (isNodeRecord(value)) {
+			for (const item of Object.values(value)) if (isNode(item)) yield item;
+		}
+	}
+}
 /**
-* Creates a `TypeNode` representing a TypeScript `type` alias declaration.
+* 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
-* createType({ name: 'Pet', export: true })
-* // export type Pet = ...
-* ```
+* Shared by `transform` and `collect` 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 `collect`.
 */
-const createType = typeDef.create;
+function applyVisitor(node, visitor, parent) {
+	const key = VISITOR_KEY_BY_KIND[node.kind];
+	if (!key) return void 0;
+	const fn = visitor[key];
+	return fn?.(node, { parent });
+}
 /**
-* Creates a `FunctionNode` representing a TypeScript `function` declaration.
+* Synchronous depth-first transform. Each visitor callback can return a
+* replacement node. Returning `undefined` keeps the original.
 *
-* @example
+* The original tree is never mutated, a new tree is returned. Pass
+* `depth: 'shallow'` to skip recursion into children.
+*
+* @example Prefix every operationId
 * ```ts
-* createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
-* // export async function fetchPet(): Promise<Pet> { ... }
+* const next = transform(root, {
+*   operation(node) {
+*     return { ...node, operationId: `prefixed_${node.operationId}` }
+*   },
+* })
 * ```
-*/
-const createFunction = functionDef.create;
-/**
-* Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
 *
-* @example
+* @example Replace only the root node
 * ```ts
-* createArrowFunction({ name: 'double', export: true, params: 'n: number', singleLine: true })
-* // export const double = (n: number) => ...
+* const next = transform(root, {
+*   depth: 'shallow',
+*   input: (node) => ({ ...node, meta: { ...node.meta, title: 'Rewritten' } }),
+* })
 * ```
 */
-const createArrowFunction = arrowFunctionDef.create;
+function transform(node, options) {
+	const { depth, parent, ...visitor } = options;
+	return transformNode(node, visitor, (depth ?? visitorDepths.deep) === visitorDepths.deep, parent);
+}
 /**
-* Creates a {@link TextNode} representing a raw string fragment in the source output.
+* 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, transforming each child node and leaving non-node values
+* (e.g. `additionalProperties: true`) intact.
+*/
+function transformChildren(node, visitor, recurse) {
+	const keys = childKeys(node, recurse);
+	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;
+			continue;
+		}
+		if (isNode(value)) {
+			const next = transformNode(value, visitor, recurse, node);
+			if (next !== value) (updates ??= {})[key] = next;
+			continue;
+		}
+		if (isNodeRecord(value)) {
+			let mapped;
+			for (const [name, item] of Object.entries(value)) {
+				const next = isNode(item) ? transformNode(item, visitor, recurse, node) : item;
+				if (next !== item) (mapped ??= { ...value })[name] = next;
+			}
+			if (mapped) (updates ??= {})[key] = mapped;
+		}
+	}
+	if (!updates) return node;
+	return {
+		...node,
+		...updates
+	};
+}
+/**
+* Lazy depth-first collection pass. Yields every non-null value returned by
+* the visitor callbacks. Use `collectSync` for the eager array form.
 *
-* @example
+* @example Collect every operationId
 * ```ts
-* createText('return fetch(id)')
-* // { kind: 'Text', value: 'return fetch(id)' }
+* const ids: string[] = []
+* for (const id of collect<string>(root, {
+*   operation(node) {
+*     return node.operationId
+*   },
+* })) {
+*   ids.push(id)
+* }
 * ```
 */
-const createText = textDef.create;
+function* collect(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);
+}
 /**
-* Creates a {@link BreakNode} representing a line break in the source output.
+* Eager depth-first collection pass. Gathers every non-null value the visitor
+* callbacks return into an array.
 *
-* @example
+* @example Collect every operationId
 * ```ts
-* createBreak()
-* // { kind: 'Break' }
+* const ids = collectSync<string>(root, {
+*   operation(node) {
+*     return node.operationId
+*   },
+* })
 * ```
 */
-function createBreak() {
-	return breakDef.create();
+function collectSync(node, options) {
+	return Array.from(collect(node, options));
 }
+//#endregion
+//#region src/defineMacro.ts
 /**
-* Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
+* 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 `defineExtension`.
+* Adds no runtime behavior.
 *
 * @example
 * ```ts
-* createJsx('<>\n  <a href={href}>Open</a>\n</>')
-* // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
+* const macroUntagged = defineMacro({
+*   name: 'untagged',
+*   operation(node) {
+*     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }
+*   },
+* })
 * ```
 */
-const createJsx = jsxDef.create;
-//#endregion
-//#region src/nodes/content.ts
+function defineMacro(macro) {
+	return macro;
+}
 /**
-* Definition for the {@link ContentNode}.
+* 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).
 */
-const contentDef = defineNode({
-	kind: "Content",
-	children: ["schema"]
-});
+function chain({ macros, key, node, context }) {
+	let current = node;
+	for (const macro of macros) {
+		const callback = macro[key];
+		if (!callback) continue;
+		if (macro.match && !macro.match(current)) continue;
+		const next = callback(current, context);
+		if (next != null) current = next;
+	}
+	return current === node ? void 0 : current;
+}
 /**
-* Creates a `ContentNode` for a single request-body or response content type.
+* 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
+* ```ts
+* 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
+* ```ts
+* const next = applyMacros(root, [macroIntegerToString])
+* ```
+*
+* @example Apply to the root node only
+* ```ts
+* const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })
+* ```
+*/
+function applyMacros(root, macros, options) {
+	if (macros.length === 0) return root;
+	return transform(root, {
+		...composeMacros(macros),
+		...options
+	});
+}
+//#endregion
+//#region src/optionality.ts
+/**
+* Generic JSON Schema optionality: a non-required field is optional, and a
+* non-required nullable field is nullish.
+*/
+function optionality(schema, required) {
+	const nullable = schema.nullable ?? false;
+	return {
+		...schema,
+		optional: !required && !nullable ? true : void 0,
+		nullish: !required && nullable ? true : void 0
+	};
+}
+/**
+* Defaults `required` to `false` and derives the schema's `optional`/`nullish` flags from it.
+* Shared build step of `createProperty` and `createParameter`.
+*/
+function withRequired(props) {
+	const required = props.required ?? false;
+	return {
+		...props,
+		required,
+		schema: optionality(props.schema, required)
+	};
+}
+//#endregion
+//#region src/createPrinter.ts
+/**
+* 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.
+*
+* The builder receives resolved options and returns:
+*
+* - `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.
+*
+* Without a `print` override, `printer.print` falls back to `printer.transform`
+* (the node-level dispatcher).
+*
+* @example Tiny Zod printer
+* ```ts
+* import { createPrinter, type PrinterFactoryOptions } from '@kubb/ast'
+*
+* type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
+*
+* export const zodPrinter = createPrinter<PrinterZod>((options) => ({
+*   name: 'zod',
+*   options: { strict: options.strict ?? true },
+*   nodes: {
+*     string: () => 'z.string()',
+*     object(node) {
+*       const props = node.properties
+*         .map((p) => `${p.name}: ${this.transform(p.schema)}`)
+*         .join(', ')
+*       return `z.object({ ${props} })`
+*     },
+*   },
+* }))
+* ```
 */
-const createContent = contentDef.create;
+function createPrinter(build) {
+	return (options) => {
+		const { name, options: resolvedOptions, nodes, overrides, print: printOverride } = build(options ?? {});
+		const merged = overrides ? {
+			...nodes,
+			...overrides
+		} : nodes;
+		const collectedImports = [];
+		const dispatch = (table) => (node) => {
+			const handler = table[node.type];
+			if (!handler) return null;
+			return handler.call(context, node);
+		};
+		const context = {
+			options: resolvedOptions,
+			import: (node) => {
+				collectedImports.push(node);
+			},
+			transform: dispatch(merged),
+			base: dispatch(nodes)
+		};
+		return {
+			name,
+			options: resolvedOptions,
+			transform: context.transform,
+			print: printOverride ? printOverride.bind(context) : context.transform,
+			drainImports: () => collectedImports.splice(0)
+		};
+	};
+}
 //#endregion
 //#region src/utils/extractStringsFromNodes.ts
 /**
@@ -395,1278 +635,909 @@ function extractStringsFromNodes(nodes) {
 	return collected.join("\n");
 }
 //#endregion
-//#region src/utils/combineFileMembers.ts
-const IDENTIFIER_RUN = /[\w$]+/g;
-/**
-* How many imports a file needs before indexing the source beats scanning it once per name.
-*/
-const INDEX_ABOVE_IMPORTS = 128;
-/**
-* Returns the local binding an import name item introduces: the alias when there is one, else the
-* imported name.
-*/
-function importLocalName(item) {
-	return typeof item === "string" ? item : item.name ?? item.propertyName;
-}
+//#region src/utils/refs.ts
 /**
-* 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.
+* Resolves the emitted name of the schema a ref node points at. Prefers `targetName` (set when
+* the referenced schema was renamed, e.g. to break a collision), then the last segment of `ref`,
+* then `name`, then the nested `schema.name`.
+*
+* Returns `null` for non-ref nodes or when no name resolves.
+*
+* @example
+* `resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Pet' }) // 'Pet'`
+*
+* @example Collision-renamed target
+* `resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Order', targetName: 'OrderSchema' }) // 'OrderSchema'`
 */
-function sortKey(node) {
-	const isArray = Array.isArray(node.name) ? "1" : "0";
-	const typeOnly = node.isTypeOnly ? "0" : "1";
-	const hasName = node.name != null ? "1" : "0";
-	const name = Array.isArray(node.name) ? node.name.toSorted().join("\0") : node.name ?? "";
-	return `${isArray}:${typeOnly}:${node.path}:${hasName}:${name}`;
+function resolveRefName(node) {
+	if (!node || node.type !== "ref") return null;
+	if (node.targetName) return node.targetName;
+	if (node.ref) return node.ref.split("/").at(-1) ?? node.ref;
+	return node.name ?? node.schema?.name ?? null;
 }
 /**
-* Sorts members by {@link sortKey}. Keys are computed once per node, not per comparison.
+* Merges a ref node with its resolved schema, giving the fields set at the usage site precedence.
+*
+* Every field on the ref except `kind`, `type`, `name`, `ref`, and `schema` overrides the same field
+* of the resolved `schema` (for example `description`, `nullable`, `readOnly`, `deprecated`). Fields
+* left `undefined` on the ref do not shadow the resolved schema. A ref without a resolved `schema`
+* is returned as is.
+*
+* @example
+* ```ts
+* const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A pet', schema: petSchema })
+* mergeRefWithSchema(ref) // petSchema's fields with description 'A pet'
+* ```
 */
-function sortMembers(nodes) {
-	return nodes.map((node) => ({
-		node,
-		key: sortKey(node)
-	})).sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0).map(({ node }) => node);
+function mergeRefWithSchema(node) {
+	if (!node.schema) return node;
+	const { kind: _kind, type: _type, name: _name, ref: _ref, schema: _schema, ...overrides } = node;
+	const definedOverrides = Object.fromEntries(Object.entries(overrides).filter(([, value]) => value !== void 0));
+	return {
+		...node.schema,
+		...definedOverrides
+	};
 }
 /**
-* Returns a collector for array-named members. A member whose path and `isTypeOnly` were already
-* seen folds its names into that entry, otherwise it joins `result` as a new entry.
+* Returns `true` when a schema is a bare ref without modifiers, metadata, or omit keys.
+*
+* Modifiers inherited from the resolved schema are included in the check because a ref emits the
+* referenced schema variable with those modifiers already applied.
 */
-function mergeByPath(result) {
-	const byPath = /* @__PURE__ */ new Map();
-	return ({ node, names }) => {
-		const key = `${node.path}:${node.isTypeOnly ?? false}`;
-		const existing = byPath.get(key);
-		if (existing && Array.isArray(existing.name)) {
-			existing.name = [.../* @__PURE__ */ new Set([...existing.name, ...names])];
-			return;
-		}
-		const item = {
-			...node,
-			name: names
-		};
-		result.push(item);
-		byPath.set(key, item);
-	};
+function isBareRef(node, keysToOmit) {
+	if (!node || node.type !== "ref") return false;
+	const meta = mergeRefWithSchema(node);
+	return !meta.nullable && !meta.optional && !meta.nullish && meta.default === void 0 && !meta.description && !meta.examples?.length && !keysToOmit?.length;
 }
+//#endregion
+//#region ../../internals/utils/src/promise.ts
 /**
-* 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();
-	for (const source of sources) {
-		const key = `${source.name ?? extractStringsFromNodes(source.nodes)}:${source.isExportable ?? false}:${source.isTypeOnly ?? false}`;
-		if (!seen.has(key)) seen.set(key, source);
-	}
-	return [...seen.values()];
-}
-/**
-* Deduplicates and merges `ExportNode` objects by path and type.
-*
-* Named exports with the same path and `isTypeOnly` flag have their names merged into a single export.
-* Non-array exports are deduplicated by exact identity. Returns a sorted, deduplicated array.
-*/
-function combineExports(exports) {
-	const result = [];
-	const merge = mergeByPath(result);
-	const seen = /* @__PURE__ */ new Set();
-	for (const curr of sortMembers(exports)) {
-		const { name, path, isTypeOnly, asAlias } = curr;
-		if (Array.isArray(name)) {
-			if (name.length) merge({
-				node: curr,
-				names: [...new Set(name)]
-			});
-			continue;
-		}
-		const key = `${path}:${name ?? ""}:${isTypeOnly ?? false}:${asAlias ?? ""}`;
-		if (!seen.has(key)) {
-			result.push(curr);
-			seen.add(key);
-		}
-	}
-	return result;
-}
-/**
-* Deduplicates and merges `ImportNode` objects, filtering out unused imports.
-*
-* 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.
-*/
-function combineImports(imports, exports, source) {
-	const exportedNames = new Set(exports.flatMap((e) => Array.isArray(e.name) ? e.name : e.name ? [e.name] : []));
-	const identifiers = source && imports.length > INDEX_ABOVE_IMPORTS ? new Set(source.match(IDENTIFIER_RUN)) : null;
-	const isUsed = (importName) => !source || identifiers?.has(importName) || source.includes(importName) || exportedNames.has(importName);
-	const importNameMemo = /* @__PURE__ */ new Map();
-	const canonicalizeName = (n) => {
-		if (typeof n === "string") return n;
-		const key = `${n.propertyName}:${n.name ?? ""}`;
-		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) && node.name.some((item) => isUsed(importLocalName(item)))) pathsWithUsedNamedImport.add(node.path);
-	const result = [];
-	const merge = mergeByPath(result);
-	const seen = /* @__PURE__ */ new Set();
-	for (const curr of sortMembers(imports)) {
-		if (curr.path === curr.root) continue;
-		const { name, path, isTypeOnly } = curr;
-		if (Array.isArray(name)) {
-			const names = [...new Set(name.map(canonicalizeName))].filter((item) => isUsed(importLocalName(item)));
-			if (names.length) merge({
-				node: curr,
-				names
-			});
-			continue;
-		}
-		if (!isUsed(name) && !pathsWithUsedNamedImport.has(path)) continue;
-		const key = `${path}:${name}:${isTypeOnly ?? false}`;
-		if (!seen.has(key)) {
-			result.push(curr);
-			seen.add(key);
-		}
-	}
-	return result;
-}
-//#endregion
-//#region src/nodes/file.ts
-/**
-* Definition for the {@link ImportNode}.
-*/
-const importDef = defineNode({ kind: "Import" });
-/**
-* 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.
+* Wraps `factory` with a keyed cache backed by the provided store.
 *
-* @example Named import
-* ```ts
-* createImport({ name: ['useState'], path: 'react' })
-* // import { useState } from 'react'
-* ```
-*/
-const createImport = importDef.create;
-/**
-* Creates an `ExportNode` representing a language-agnostic export/public API declaration.
+* 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 Named export
-* ```ts
-* 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.
+* Because the cache is owned by the caller, it can be shared, inspected, or
+* cleared independently of the memoized function.
 *
-* @example
+* @example Single WeakMap key
 * ```ts
-* createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
+* const cache = new WeakMap<SchemaNode, Set<string>>()
+* const getRefs = memoize(cache, (node) => collectRefs(node))
 * ```
-*/
-const createSource = sourceDef.create;
-/**
-* 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
+* @example Single Map key (primitive)
 * ```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 cache = new Map<string, Resolver>()
+* const getResolver = memoize(cache, (name) => buildResolver(name))
 * ```
 *
-* @example Copy a real file into the output
+* @example Two-level (object + primitive)
 * ```ts
-* const file = createFile({
-*   baseName: 'client.ts',
-*   path: 'src/gen/client.ts',
-*   copy: '/abs/path/to/templates/client.ts',
-* })
+* const outer = new WeakMap<Params[], Map<string, Params[]>>()
+* const fn = memoize(outer, (params) => memoize(new Map(), (key) => transform(params, key)))
+* fn(params)('camelcase')
 * ```
 */
-function createFile(input) {
-	const extname = node_path.default.extname(input.baseName);
-	if (!extname) throw new Error(`No extname found for ${input.baseName}`);
-	const resolvedExports = input.exports?.length ? combineExports(input.exports) : [];
-	const resolvedImports = (() => {
-		if (!input.imports?.length) return [];
-		const sourceParts = [];
-		const localNames = /* @__PURE__ */ new Set();
-		for (const item of input.sources ?? []) {
-			const extracted = item.nodes && extractStringsFromNodes(item.nodes);
-			if (extracted) sourceParts.push(extracted);
-			if (item.name) localNames.add(item.name);
-		}
-		const source = sourceParts.join("\n") || void 0;
-		return combineImports(input.imports, resolvedExports, source).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(importLocalName(item)));
-			if (!kept.length) return [];
-			return [kept.length === imp.name.length ? imp : {
-				...imp,
-				name: kept
-			}];
-		});
-	})();
-	const resolvedSources = input.sources?.length ? combineSources(input.sources) : [];
-	return {
-		kind: "File",
-		...input,
-		id: (0, node_crypto.hash)("sha256", input.path, "hex"),
-		name: node_path.default.basename(input.baseName, extname),
-		extname,
-		imports: resolvedImports,
-		exports: resolvedExports,
-		sources: resolvedSources,
-		meta: input.meta ?? {}
+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/nodes/input.ts
-/**
-* Definition for the {@link InputNode}.
-*/
-const inputDef = defineNode({
-	kind: "Input",
-	build: (props) => ({
-		schemas: [],
-		operations: [],
-		meta: {
-			circularNames: [],
-			enumNames: []
-		},
-		...props
-	}),
-	children: ["schemas", "operations"],
-	visitorKey: "input"
-});
+//#region src/utils/schemaGraph.ts
 /**
-* Creates an `InputNode`, defaulting `schemas`/`operations` to empty arrays and `meta` per
-* {@link inputDef}.
+* Collects the names of every schema a node's subtree references, resolved with `resolveRefName`.
+* Each ref contributes its name only, so the schema it points to is never traversed. The walk is
+* memoized by node identity, which lets `findCircularSchemas` and `containsCircularRef` share one
+* scan per schema.
 *
 * @example
 * ```ts
-* const input = createInput()
-* // { kind: 'Input', schemas: [], operations: [] }
+* collectSchemaRefs(petSchema)
+* // Set { 'Category', 'Tag' }
 * ```
 */
-function createInput(overrides = {}) {
-	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"
+const collectSchemaRefs = memoize(/* @__PURE__ */ new WeakMap(), (node) => {
+	const refs = /* @__PURE__ */ new Set();
+	collectSync(node, { schema(child) {
+		if (child.type === "ref") {
+			const name = resolveRefName(child);
+			if (name) refs.add(name);
+		}
+	} });
+	return refs;
 });
 /**
-* Creates an `OutputNode` with a stable default for `files`.
+* Collects the de-duplicated target names of every pointer-carrying ref in a node's subtree, in
+* first-occurrence order. The walk is memoized by node identity, so the subtree is scanned once and
+* `resolver.imports` reads the same result across the ts, zod, and faker plugins instead of
+* re-scanning the same schema per plugin.
 *
-* @example
-* ```ts
-* const output = createOutput()
-* // { kind: 'Output', files: [] }
-* ```
-*/
-function createOutput(overrides = {}) {
-	return outputDef.create(overrides);
-}
-//#endregion
-//#region src/optionality.ts
-/**
-* Generic JSON Schema optionality: a non-required field is optional, and a
-* non-required nullable field is nullish.
-*/
-function optionality(schema, required) {
-	const nullable = schema.nullable ?? false;
-	return {
-		...schema,
-		optional: !required && !nullable ? true : void 0,
-		nullish: !required && nullable ? true : void 0
-	};
-}
-/**
-* Defaults `required` to `false` and derives the schema's `optional`/`nullish` flags from it.
-* Shared build step of `createProperty` and `createParameter`.
-*/
-function withRequired(props) {
-	const required = props.required ?? false;
-	return {
-		...props,
-		required,
-		schema: optionality(props.schema, required)
-	};
-}
-//#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 withRequired}.
-*/
-const parameterDef = defineNode({
-	kind: "Parameter",
-	build: withRequired,
-	children: ["schema"],
-	visitorKey: "parameter"
-});
-/**
-* Creates a `ParameterNode`.
+* Only refs that carry a `$ref` pointer count, so a synthesized ref pointing at a sibling in the
+* same file (a union member created by name) is left out. That leaves exactly the set
+* `resolver.imports` emits.
 *
 * @example
 * ```ts
-* const param = createParameter({
-*   name: 'petId',
-*   in: 'path',
-*   required: true,
-*   schema: createSchema({ type: 'string' }),
-* })
+* collectImportedRefNames(petSchema)
+* // ['Category', 'Tag']
 * ```
 */
-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 withRequired}.
-*/
-const propertyDef = defineNode({
-	kind: "Property",
-	build: withRequired,
-	children: ["schema"],
-	visitorKey: "property"
+const collectImportedRefNames = memoize(/* @__PURE__ */ new WeakMap(), (node) => {
+	const seen = /* @__PURE__ */ new Set();
+	const names = [];
+	collectSync(node, { schema(child) {
+		if (child.type !== "ref" || !child.ref) return;
+		const name = resolveRefName(child);
+		if (name && !seen.has(name)) {
+			seen.add(name);
+			names.push(name);
+		}
+	} });
+	return names;
 });
 /**
-* Creates a `PropertyNode`.
+* Collects the names of all top-level schemas transitively used by a set of operations.
 *
-* @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`.
+* 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
-* const response = createResponse({
-*   statusCode: '200',
-*   content: [createContent({ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) })],
-* })
+* 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
+* }
 * ```
 */
-const createResponse = responseDef.create;
-//#endregion
-//#region src/nodes/schema.ts
-/**
-* Maps schema `type` to its underlying `primitive`.
-* Primitive types map to themselves and special string formats map to `'string'`.
-* Any type not listed here (such as `ref`, `enum`, `union`, `intersection`, `tuple`, `ipv4`, `ipv6`, `blob`) has no `primitive`.
-*/
-const TYPE_TO_PRIMITIVE = {
-	string: "string",
-	number: "number",
-	integer: "integer",
-	bigint: "bigint",
-	boolean: "boolean",
-	null: "null",
-	any: "any",
-	unknown: "unknown",
-	void: "void",
-	never: "never",
-	object: "object",
-	array: "array",
-	date: "date",
-	uuid: "string",
-	email: "string",
-	url: "string",
-	datetime: "string",
-	time: "string"
-};
-/**
-* Definition for the {@link SchemaNode}. Object schemas default `properties` to an
-* empty array, and `primitive` is inferred from `type` when not explicitly provided.
-*/
-const schemaDef = defineNode({
-	kind: "Schema",
-	build: (props) => {
-		if (props.type === "object") return {
-			properties: [],
-			primitive: "object",
-			...props
-		};
-		return {
-			primitive: TYPE_TO_PRIMITIVE[props.type],
-			...props
-		};
-	},
-	children: [
-		"properties",
-		"items",
-		"members",
-		"additionalProperties",
-		"patternProperties",
-		"rest"
-	],
-	visitorKey: "schema"
-});
-function createSchema(props) {
-	return schemaDef.create(props);
-}
-//#endregion
-//#region src/registry.ts
-/**
-* Every node definition. Adding a node means adding its `defineNode` to one
-* `nodes/*.ts` file and listing it here. The visitor tables in `visitor.ts` derive from it.
-*/
-const nodeDefs = [
-	inputDef,
-	outputDef,
-	operationDef,
-	requestBodyDef,
-	contentDef,
-	responseDef,
-	schemaDef,
-	propertyDef,
-	parameterDef,
-	constDef,
-	typeDef,
-	functionDef,
-	arrowFunctionDef,
-	textDef,
-	breakDef,
-	jsxDef,
-	importDef,
-	exportDef,
-	sourceDef,
-	fileDef
-];
-//#endregion
-//#region src/visitor.ts
-/**
-* Child node fields per node kind, in traversal order (Babel's `VISITOR_KEYS`).
-* Derived from each definition's `children`.
-*/
-const VISITOR_KEYS = Object.fromEntries(nodeDefs.flatMap((def) => def.children ? [[def.kind, def.children]] : []));
-/**
-* Maps a node kind to the matching visitor callback name. Derived from each
-* definition's `visitorKey`.
-*/
-const VISITOR_KEY_BY_KIND = Object.fromEntries(nodeDefs.flatMap((def) => def.visitorKey ? [[def.kind, def.visitorKey]] : []));
-const visitorKeysByKind = VISITOR_KEYS;
-/**
-* Returns `true` when `value` is an AST node (an object carrying a `kind`).
-*/
-function isNode(value) {
-	return typeof value === "object" && value !== null && typeof value.kind === "string";
-}
-/**
-* Returns `true` for a plain object that maps names to nodes, such as `patternProperties`.
-*/
-function isNodeRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/**
-* Returns the child fields of `node` to walk, from {@link VISITOR_KEYS}, or `undefined` when there
-* is nothing to walk. `Schema` children are only walked when `recurse` is `true`.
-*/
-function childKeys(node, recurse) {
-	if (node.kind === "Schema" && !recurse) return void 0;
-	return visitorKeysByKind[node.kind];
+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) {
+		for (const name of collectSchemaRefs(schema)) 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;
 }
 /**
-* Returns the immediate traversable children of `node`.
+* Finds every schema that takes part in a circular dependency chain in a schema dependency graph
+* that maps each schema name to the names it references directly.
 *
-* @example
-* ```ts
-* const children = getChildren(operationNode, true)
-* // returns parameters, the request body, and responses
-* ```
-*/
-function* getChildren(node, recurse) {
-	const keys = childKeys(node, recurse);
-	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;
-			continue;
-		}
-		if (isNode(value)) {
-			yield value;
-			continue;
-		}
-		if (isNodeRecord(value)) {
-			for (const item of Object.values(value)) if (isNode(item)) yield item;
+* Use this when the graph was already collected during another pass (e.g. the adapter's convert
+* walk), so the schema nodes are not swept a second time. `findCircularSchemas` builds the graph
+* from schema nodes and delegates here.
+*
+* @example
+* ```ts
+* const graph = new Map([
+*   ['Pet', new Set(['Category'])],
+*   ['Category', new Set(['Pet'])],
+* ])
+* findCircularSchemasFromGraph(graph) // Set { 'Pet', 'Category' }
+* ```
+*/
+function findCircularSchemasFromGraph(graph) {
+	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;
 }
 /**
-* 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.
+* Finds every schema that takes part in a circular dependency chain, including direct self-loops.
 *
-* Shared by `transform` and `collect` 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 `collect`.
+* 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.
+*
+* @note Call this once on the full graph, then check individual schemas with `containsCircularRef()`.
 */
-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 findCircularSchemas(schemas) {
+	const graph = /* @__PURE__ */ new Map();
+	for (const schema of schemas) if (schema.name) graph.set(schema.name, collectSchemaRefs(schema));
+	return findCircularSchemasFromGraph(graph);
 }
+//#endregion
+//#region src/utils/schemaProperties.ts
 /**
-* Synchronous depth-first transform. Each visitor callback can return a
-* replacement node. Returning `undefined` keeps the original.
+* Finds every matching property exposed by an object, resolved reference, or intersection.
 *
-* The original tree is never mutated, a new tree is returned. Pass
-* `depth: 'shallow'` to skip recursion into children.
+* References are followed through their parsed `schema`. Circular references terminate without
+* revisiting a node. Unions are not traversed because a property on one branch does not describe
+* every branch.
 *
-* @example Prefix every operationId
+* @example Faker discriminator narrowing
 * ```ts
-* const next = transform(root, {
-*   operation(node) {
-*     return { ...node, operationId: `prefixed_${node.operationId}` }
-*   },
-* })
+* const values = resolveSchemaProperties({ node: member, propertyName: union.discriminatorPropertyName }).flatMap(({ schema }) =>
+*   getSchemaLiteralValues(schema),
+* )
+* const typeName = `Extract<Pet, { type: ${values.map(JSON.stringify).join(' | ')} }>`
 * ```
 *
-* @example Replace only the root node
+* @example Zod discriminated unions
 * ```ts
-* const next = transform(root, {
-*   depth: 'shallow',
-*   input: (node) => ({ ...node, meta: { ...node.meta, title: 'Rewritten' } }),
-* })
+* const canDiscriminate = union.members?.every(
+*   (member) => resolveSchemaProperties({ node: member, propertyName: 'type' }).length > 0,
+* )
+* const expression = canDiscriminate ? `z.discriminatedUnion('type', members)` : `z.union(members)`
+* ```
+*
+* @example TypeScript property lookup
+* ```ts
+* const properties = resolveSchemaProperties({ node: schema, propertyName: 'status' })
+* const statusSchemas = properties.map((property) => print(property.schema))
 * ```
 */
-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, transforming each child node and leaving non-node values
-* (e.g. `additionalProperties: true`) intact.
-*/
-function transformChildren(node, visitor, recurse) {
-	const keys = childKeys(node, recurse);
-	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;
-			continue;
-		}
-		if (isNode(value)) {
-			const next = transformNode(value, visitor, recurse, node);
-			if (next !== value) (updates ??= {})[key] = next;
-			continue;
+function resolveSchemaProperties({ node, propertyName }) {
+	const properties = [];
+	const visited = /* @__PURE__ */ new WeakSet();
+	function visit(current) {
+		if (!current || visited.has(current)) return;
+		visited.add(current);
+		if (current.type === "object") {
+			const property = current.properties.find((candidate) => candidate.name === propertyName);
+			if (property) properties.push(property);
+			return;
 		}
-		if (isNodeRecord(value)) {
-			let mapped;
-			for (const [name, item] of Object.entries(value)) {
-				const next = isNode(item) ? transformNode(item, visitor, recurse, node) : item;
-				if (next !== item) (mapped ??= { ...value })[name] = next;
-			}
-			if (mapped) (updates ??= {})[key] = mapped;
+		if (current.type === "ref") {
+			visit(current.schema);
+			return;
 		}
+		if (current.type === "intersection") for (const member of current.members ?? []) visit(member);
 	}
-	if (!updates) return node;
-	return {
-		...node,
-		...updates
-	};
+	visit(node);
+	return properties;
 }
 /**
-* Lazy depth-first collection pass. Yields every non-null value returned by
-* the visitor callbacks. Use `collectSync` for the eager array form.
+* Reads the unique literal values represented by an enum, resolved reference, or union.
 *
-* @example Collect every operationId
+* Named enum values take precedence over simple enum values, matching how renderers consume
+* `EnumSchemaNode`.
+*
+* @example
 * ```ts
-* const ids: string[] = []
-* for (const id of collect<string>(root, {
-*   operation(node) {
-*     return node.operationId
-*   },
-* })) {
-*   ids.push(id)
-* }
+* const values = getSchemaLiteralValues(enumNode)
+* // ['cat', 'dog']
 * ```
 */
-function* collect(node, options) {
-	const { depth, parent, ...visitor } = options;
-	yield* collectNode(node, visitor, (depth ?? visitorDepths.deep) === visitorDepths.deep, parent);
+function getSchemaLiteralValues(node) {
+	const values = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new WeakSet();
+	function visit(current) {
+		if (!current || visited.has(current)) return;
+		visited.add(current);
+		if (current.type === "enum") {
+			const enumValues = current.namedEnumValues?.map(({ value }) => value) ?? current.enumValues ?? [];
+			for (const value of enumValues) values.add(value);
+			return;
+		}
+		if (current.type === "ref") {
+			visit(current.schema);
+			return;
+		}
+		if (current.type === "union") for (const member of current.members ?? []) visit(member);
+	}
+	visit(node);
+	return [...values];
 }
-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);
+function collectPropertyNames(node, visited = /* @__PURE__ */ new WeakSet()) {
+	if (visited.has(node)) return /* @__PURE__ */ new Set();
+	visited.add(node);
+	if (node.type === "object") return new Set(node.properties.map((property) => property.name));
+	if (node.type === "ref") return node.schema ? collectPropertyNames(node.schema, visited) : /* @__PURE__ */ new Set();
+	if (node.type === "intersection") {
+		const names = /* @__PURE__ */ new Set();
+		for (const member of node.members ?? []) for (const name of collectPropertyNames(member, visited)) names.add(name);
+		return names;
+	}
+	return /* @__PURE__ */ new Set();
 }
 /**
-* Eager depth-first collection pass. Gathers every non-null value the visitor
-* callbacks return into an array.
-*
-* @example Collect every operationId
-* ```ts
-* const ids = collectSync<string>(root, {
-*   operation(node) {
-*     return node.operationId
-*   },
-* })
-* ```
+* Infers an implicit discriminator: a property every member exposes with a distinct single
+* literal value, the same shape a declared OpenAPI `discriminator` already narrows on.
 */
-function collectSync(node, options) {
-	return Array.from(collect(node, options));
+function inferDiscriminatorPropertyName(members) {
+	if (members.length < 2) return void 0;
+	let candidates;
+	for (const member of members) {
+		const names = collectPropertyNames(member);
+		candidates = candidates ? new Set([...candidates].filter((name) => names.has(name))) : names;
+	}
+	for (const name of candidates ?? []) {
+		const values = members.map((member) => {
+			const literals = new Set(resolveSchemaProperties({
+				node: member,
+				propertyName: name
+			}).flatMap((property) => getSchemaLiteralValues(property.schema)));
+			return literals.size === 1 ? [...literals][0] : void 0;
+		});
+		if (values.every((value) => value !== void 0) && new Set(values).size === members.length) return name;
+	}
 }
 //#endregion
-//#region src/defineMacro.ts
+//#region src/nodes/code.ts
 /**
-* Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain
-* list keeps its authored order.
-*/
-function enforceWeight(enforce) {
-	if (enforce === "pre") return 0;
-	if (enforce === "post") return 2;
-	return 1;
+* Creates a `ConstNode` representing a TypeScript `const` declaration.
+*
+* @example Exported constant with type and `as const`
+* ```ts
+* createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
+* // export const pets: Pet[] = ... as const
+* ```
+*/
+function createConst(input) {
+	return {
+		...input,
+		kind: "Const"
+	};
 }
 /**
-* Types a macro for inference and a single construction site, mirroring `defineExtension`.
-* Adds no runtime behavior.
+* Creates a `TypeNode` representing a TypeScript `type` alias declaration.
 *
 * @example
 * ```ts
-* const macroUntagged = defineMacro({
-*   name: 'untagged',
-*   operation(node) {
-*     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }
-*   },
-* })
+* createType({ name: 'Pet', export: true })
+* // export type Pet = ...
 * ```
 */
-function defineMacro(macro) {
-	return macro;
+function createType(input) {
+	return {
+		...input,
+		kind: "Type"
+	};
 }
 /**
-* 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).
+* Creates a `FunctionNode` representing a TypeScript `function` declaration.
+*
+* @example
+* ```ts
+* createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
+* // export async function fetchPet(): Promise<Pet> { ... }
+* ```
 */
-function chain({ macros, key, node, context }) {
-	let current = node;
-	for (const macro of macros) {
-		const callback = macro[key];
-		if (!callback) continue;
-		if (macro.match && !macro.match(current)) continue;
-		const next = callback(current, context);
-		if (next != null) current = next;
-	}
-	return current === node ? void 0 : current;
+function createFunction(input) {
+	return {
+		...input,
+		kind: "Function"
+	};
 }
 /**
-* 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.
+* Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
 *
 * @example
 * ```ts
-* const visitor = composeMacros([macroSimplifyUnion, macroDiscriminatorEnum])
-* const next = transform(root, visitor)
+* createArrowFunction({ name: 'double', export: true, params: 'n: number', singleLine: true })
+* // export const double = (n: number) => ...
 * ```
 */
-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;
+function createArrowFunction(input) {
+	return {
+		...input,
+		kind: "ArrowFunction"
+	};
 }
 /**
-* 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.
+* Creates a {@link TextNode} representing a raw string fragment in the source output.
 *
 * @example
 * ```ts
-* const next = applyMacros(root, [macroIntegerToString])
+* createText('return fetch(id)')
+* // { kind: 'Text', value: 'return fetch(id)' }
 * ```
+*/
+function createText(value) {
+	return {
+		kind: "Text",
+		value
+	};
+}
+/**
+* Creates a {@link BreakNode} representing a line break in the source output.
 *
-* @example Apply to the root node only
+* @example
 * ```ts
-* const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })
+* createBreak()
+* // { kind: 'Break' }
 * ```
 */
-function applyMacros(root, macros, options) {
-	if (macros.length === 0) return root;
-	return transform(root, {
-		...composeMacros(macros),
-		...options
-	});
+function createBreak() {
+	return { kind: "Break" };
 }
-//#endregion
-//#region src/createPrinter.ts
 /**
-* 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.
-*
-* The builder receives resolved options and returns:
-*
-* - `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.
-*
-* Without a `print` override, `printer.print` falls back to `printer.transform`
-* (the node-level dispatcher).
+* Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
 *
-* @example Tiny Zod printer
+* @example
 * ```ts
-* import { createPrinter, type PrinterFactoryOptions } from '@kubb/ast'
-*
-* type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
-*
-* export const zodPrinter = createPrinter<PrinterZod>((options) => ({
-*   name: 'zod',
-*   options: { strict: options.strict ?? true },
-*   nodes: {
-*     string: () => 'z.string()',
-*     object(node) {
-*       const props = node.properties
-*         .map((p) => `${p.name}: ${this.transform(p.schema)}`)
-*         .join(', ')
-*       return `z.object({ ${props} })`
-*     },
-*   },
-* }))
+* createJsx('<>\n  <a href={href}>Open</a>\n</>')
+* // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
 * ```
 */
-function createPrinter(build) {
-	return (options) => {
-		const { name, options: resolvedOptions, nodes, overrides, print: printOverride } = build(options ?? {});
-		const merged = overrides ? {
-			...nodes,
-			...overrides
-		} : nodes;
-		const collectedImports = [];
-		const dispatch = (table) => (node) => {
-			const handler = table[node.type];
-			if (!handler) return null;
-			return handler.call(context, node);
-		};
-		const context = {
-			options: resolvedOptions,
-			import: (node) => {
-				collectedImports.push(node);
-			},
-			transform: dispatch(merged),
-			base: dispatch(nodes)
-		};
-		return {
-			name,
-			options: resolvedOptions,
-			transform: context.transform,
-			print: printOverride ? printOverride.bind(context) : context.transform,
-			drainImports: () => collectedImports.splice(0)
-		};
+function createJsx(value) {
+	return {
+		kind: "Jsx",
+		value
 	};
 }
 //#endregion
-//#region src/utils/refs.ts
+//#region src/nodes/content.ts
 /**
-* Resolves the emitted name of the schema a ref node points at. Prefers `targetName` (set when
-* the referenced schema was renamed, e.g. to break a collision), then the last segment of `ref`,
-* then `name`, then the nested `schema.name`.
-*
-* Returns `null` for non-ref nodes or when no name resolves.
-*
-* @example
-* `resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Pet' }) // 'Pet'`
-*
-* @example Collision-renamed target
-* `resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Order', targetName: 'OrderSchema' }) // 'OrderSchema'`
+* Creates a `ContentNode` for a single request-body or response content type.
 */
-function resolveRefName(node) {
-	if (!node || node.type !== "ref") return null;
-	if (node.targetName) return node.targetName;
-	if (node.ref) return node.ref.split("/").at(-1) ?? node.ref;
-	return node.name ?? node.schema?.name ?? null;
+function createContent(input) {
+	return {
+		...input,
+		kind: "Content"
+	};
+}
+//#endregion
+//#region src/utils/combineFileMembers.ts
+const IDENTIFIER_RUN = /[\w$]+/g;
+/**
+* How many imports a file needs before indexing the source beats scanning it once per name.
+*/
+const INDEX_ABOVE_IMPORTS = 128;
+/**
+* Returns the local binding an import name item introduces: the alias when there is one, else the
+* imported name.
+*/
+function importLocalName(item) {
+	return typeof item === "string" ? item : item.name ?? item.propertyName;
+}
+/**
+* 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.toSorted().join("\0") : node.name ?? "";
+	return `${isArray}:${typeOnly}:${node.path}:${hasName}:${name}`;
+}
+/**
+* Sorts members by {@link sortKey}. Keys are computed once per node, not per comparison.
+*/
+function sortMembers(nodes) {
+	return nodes.map((node) => ({
+		node,
+		key: sortKey(node)
+	})).sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0).map(({ node }) => node);
+}
+/**
+* Returns a collector for array-named members. A member whose path and `isTypeOnly` were already
+* seen folds its names into that entry, otherwise it joins `result` as a new entry.
+*/
+function mergeByPath(result) {
+	const byPath = /* @__PURE__ */ new Map();
+	return ({ node, names }) => {
+		const key = `${node.path}:${node.isTypeOnly ?? false}`;
+		const existing = byPath.get(key);
+		if (existing && Array.isArray(existing.name)) {
+			existing.name = [.../* @__PURE__ */ new Set([...existing.name, ...names])];
+			return;
+		}
+		const item = {
+			...node,
+			name: names
+		};
+		result.push(item);
+		byPath.set(key, item);
+	};
+}
+/**
+* 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();
+	for (const source of sources) {
+		const key = `${source.name ?? extractStringsFromNodes(source.nodes)}:${source.isExportable ?? false}:${source.isTypeOnly ?? false}`;
+		if (!seen.has(key)) seen.set(key, source);
+	}
+	return [...seen.values()];
 }
 /**
-* Merges a ref node with its resolved schema, giving the fields set at the usage site precedence.
-*
-* Every field on the ref except `kind`, `type`, `name`, `ref`, and `schema` overrides the same field
-* of the resolved `schema` (for example `description`, `nullable`, `readOnly`, `deprecated`). Fields
-* left `undefined` on the ref do not shadow the resolved schema. A ref without a resolved `schema`
-* is returned as is.
+* Deduplicates and merges `ExportNode` objects by path and type.
 *
-* @example
-* ```ts
-* const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A pet', schema: petSchema })
-* mergeRefWithSchema(ref) // petSchema's fields with description 'A pet'
-* ```
+* Named exports with the same path and `isTypeOnly` flag have their names merged into a single export.
+* Non-array exports are deduplicated by exact identity. Returns a sorted, deduplicated array.
 */
-function mergeRefWithSchema(node) {
-	if (!node.schema) return node;
-	const { kind: _kind, type: _type, name: _name, ref: _ref, schema: _schema, ...overrides } = node;
-	const definedOverrides = Object.fromEntries(Object.entries(overrides).filter(([, value]) => value !== void 0));
-	return {
-		...node.schema,
-		...definedOverrides
-	};
+function combineExports(exports) {
+	const result = [];
+	const merge = mergeByPath(result);
+	const seen = /* @__PURE__ */ new Set();
+	for (const curr of sortMembers(exports)) {
+		const { name, path, isTypeOnly, asAlias } = curr;
+		if (Array.isArray(name)) {
+			if (name.length) merge({
+				node: curr,
+				names: [...new Set(name)]
+			});
+			continue;
+		}
+		const key = `${path}:${name ?? ""}:${isTypeOnly ?? false}:${asAlias ?? ""}`;
+		if (!seen.has(key)) {
+			result.push(curr);
+			seen.add(key);
+		}
+	}
+	return result;
 }
 /**
-* Returns `true` when a schema is a bare ref without modifiers, metadata, or omit keys.
+* Deduplicates and merges `ImportNode` objects, filtering out unused imports.
 *
-* Modifiers inherited from the resolved schema are included in the check because a ref emits the
-* referenced schema variable with those modifiers already applied.
+* 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.
 */
-function isBareRef(node, keysToOmit) {
-	if (!node || node.type !== "ref") return false;
-	const meta = mergeRefWithSchema(node);
-	return !meta.nullable && !meta.optional && !meta.nullish && meta.default === void 0 && !meta.description && !meta.examples?.length && !keysToOmit?.length;
+function combineImports(imports, exports, source) {
+	const exportedNames = new Set(exports.flatMap((e) => Array.isArray(e.name) ? e.name : e.name ? [e.name] : []));
+	const identifiers = source && imports.length > INDEX_ABOVE_IMPORTS ? new Set(source.match(IDENTIFIER_RUN)) : null;
+	const isUsed = (importName) => !source || identifiers?.has(importName) || source.includes(importName) || exportedNames.has(importName);
+	const importNameMemo = /* @__PURE__ */ new Map();
+	const canonicalizeName = (n) => {
+		if (typeof n === "string") return n;
+		const key = `${n.propertyName}:${n.name ?? ""}`;
+		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) && node.name.some((item) => isUsed(importLocalName(item)))) pathsWithUsedNamedImport.add(node.path);
+	const result = [];
+	const merge = mergeByPath(result);
+	const seen = /* @__PURE__ */ new Set();
+	for (const curr of sortMembers(imports)) {
+		if (curr.path === curr.root) continue;
+		const { name, path, isTypeOnly } = curr;
+		if (Array.isArray(name)) {
+			const names = [...new Set(name.map(canonicalizeName))].filter((item) => isUsed(importLocalName(item)));
+			if (names.length) merge({
+				node: curr,
+				names
+			});
+			continue;
+		}
+		if (!isUsed(name) && !pathsWithUsedNamedImport.has(path)) continue;
+		const key = `${path}:${name}:${isTypeOnly ?? false}`;
+		if (!seen.has(key)) {
+			result.push(curr);
+			seen.add(key);
+		}
+	}
+	return result;
 }
 //#endregion
-//#region ../../internals/utils/src/promise.ts
+//#region src/nodes/file.ts
 /**
-* Wraps `factory` with a keyed cache backed by the provided store.
-*
-* Pass a `WeakMap` for object keys (results are GC-eligible when the key is
-* collected) or a `Map` for primitive keys. For multi-argument functions,
-* nest two `memoize` calls — the outer keyed by the first argument, the
-* inner (created once per outer miss) keyed by the second.
-*
-* Because the cache is owned by the caller, it can be shared, inspected, or
-* cleared independently of the memoized function.
-*
-* @example Single WeakMap key
-* ```ts
-* const cache = new WeakMap<SchemaNode, Set<string>>()
-* const getRefs = memoize(cache, (node) => collectRefs(node))
-* ```
-*
-* @example Single Map key (primitive)
-* ```ts
-* const cache = new Map<string, Resolver>()
-* const getResolver = memoize(cache, (name) => buildResolver(name))
-* ```
+* Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
 *
-* @example Two-level (object + primitive)
+* @example Named import
 * ```ts
-* const outer = new WeakMap<Params[], Map<string, Params[]>>()
-* const fn = memoize(outer, (params) => memoize(new Map(), (key) => transform(params, key)))
-* fn(params)('camelcase')
+* createImport({ name: ['useState'], path: 'react' })
+* // import { useState } from 'react'
 * ```
 */
-function memoize(store, factory) {
-	return (key) => {
-		if (store.has(key)) return store.get(key);
-		const value = factory(key);
-		store.set(key, value);
-		return value;
+function createImport(input) {
+	return {
+		...input,
+		kind: "Import"
 	};
 }
-//#endregion
-//#region src/utils/schemaGraph.ts
 /**
-* Collects the names of every schema a node's subtree references, resolved with `resolveRefName`.
-* Each ref contributes its name only, so the schema it points to is never traversed. The walk is
-* memoized by node identity, which lets `findCircularSchemas` and `containsCircularRef` share one
-* scan per schema.
+* Creates an `ExportNode` representing a language-agnostic export/public API declaration.
 *
-* @example
+* @example Named export
 * ```ts
-* collectSchemaRefs(petSchema)
-* // Set { 'Category', 'Tag' }
+* createExport({ name: ['Pet'], path: './Pet' })
+* // export { Pet } from './Pet'
 * ```
 */
-const collectSchemaRefs = memoize(/* @__PURE__ */ new WeakMap(), (node) => {
-	const refs = /* @__PURE__ */ new Set();
-	collectSync(node, { schema(child) {
-		if (child.type === "ref") {
-			const name = resolveRefName(child);
-			if (name) refs.add(name);
-		}
-	} });
-	return refs;
-});
+function createExport(input) {
+	return {
+		...input,
+		kind: "Export"
+	};
+}
 /**
-* Collects the de-duplicated target names of every pointer-carrying ref in a node's subtree, in
-* first-occurrence order. The walk is memoized by node identity, so the subtree is scanned once and
-* `resolver.imports` reads the same result across the ts, zod, and faker plugins instead of
-* re-scanning the same schema per plugin.
-*
-* Only refs that carry a `$ref` pointer count, so a synthesized ref pointing at a sibling in the
-* same file (a union member created by name) is left out. That leaves exactly the set
-* `resolver.imports` emits.
+* Creates a `SourceNode` representing a fragment of source code within a file.
 *
 * @example
 * ```ts
-* collectImportedRefNames(petSchema)
-* // ['Category', 'Tag']
+* createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
 * ```
 */
-const collectImportedRefNames = memoize(/* @__PURE__ */ new WeakMap(), (node) => {
-	const seen = /* @__PURE__ */ new Set();
-	const names = [];
-	collectSync(node, { schema(child) {
-		if (child.type !== "ref" || !child.ref) return;
-		const name = resolveRefName(child);
-		if (name && !seen.has(name)) {
-			seen.add(name);
-			names.push(name);
-		}
-	} });
-	return names;
-});
+function createSource(input) {
+	return {
+		...input,
+		kind: "Source"
+	};
+}
 /**
-* 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 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.
+* Computes:
+* - `id` SHA256 hash of the file path
+* - `name` `baseName` without extension
+* - `extname` extension extracted from `baseName`
 *
-* Pair it with `include` filters so schemas reachable only from excluded operations stay ungenerated.
+* Deduplicates:
+* - `sources` via `combineSources`
+* - `exports` via `combineExports`
+* - `imports` via `combineImports` (also filters unused imports)
 *
-* @example Only generate schemas referenced by included operations
+* @throws {Error} when `baseName` has no extension.
+*
+* @example
 * ```ts
-* const includedOps = operations.filter((op) => resolver.default.options(op, { options, include }) !== null)
-* const allowed = collectUsedSchemaNames(includedOps, schemas)
+* 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'
+* ```
 *
-* for (const schema of schemas) {
-*   if (schema.name && !allowed.has(schema.name)) continue
-*   // generate schema
-* }
+* @example Copy a real file into the output
+* ```ts
+* 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) {
-		for (const name of collectSchemaRefs(schema)) if (!result.has(name)) {
-			result.add(name);
-			const namedSchema = schemaMap.get(name);
-			if (namedSchema) visitSchema(namedSchema);
+function createFile(input) {
+	const extname = node_path.default.extname(input.baseName);
+	if (!extname) throw new Error(`No extname found for ${input.baseName}`);
+	const resolvedExports = input.exports?.length ? combineExports(input.exports) : [];
+	const resolvedImports = (() => {
+		if (!input.imports?.length) return [];
+		const sourceParts = [];
+		const localNames = /* @__PURE__ */ new Set();
+		for (const item of input.sources ?? []) {
+			const extracted = item.nodes && extractStringsFromNodes(item.nodes);
+			if (extracted) sourceParts.push(extracted);
+			if (item.name) localNames.add(item.name);
 		}
-	}
-	for (const op of operations) for (const schema of collect(op, {
-		depth: "shallow",
-		schema: (node) => node
-	})) visitSchema(schema);
-	return result;
+		const source = sourceParts.join("\n") || void 0;
+		return combineImports(input.imports, resolvedExports, source).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(importLocalName(item)));
+			if (!kept.length) return [];
+			return [kept.length === imp.name.length ? imp : {
+				...imp,
+				name: kept
+			}];
+		});
+	})();
+	const resolvedSources = input.sources?.length ? combineSources(input.sources) : [];
+	return {
+		...input,
+		kind: "File",
+		id: (0, node_crypto.hash)("sha256", input.path, "hex"),
+		name: node_path.default.basename(input.baseName, extname),
+		extname,
+		imports: resolvedImports,
+		exports: resolvedExports,
+		sources: resolvedSources,
+		meta: input.meta ?? {}
+	};
 }
+//#endregion
+//#region src/nodes/input.ts
 /**
-* Finds every schema that takes part in a circular dependency chain in a schema dependency graph
-* that maps each schema name to the names it references directly.
-*
-* Use this when the graph was already collected during another pass (e.g. the adapter's convert
-* walk), so the schema nodes are not swept a second time. `findCircularSchemas` builds the graph
-* from schema nodes and delegates here.
+* Creates an `InputNode`, defaulting `schemas`/`operations` to empty arrays and `meta` to empty
+* name lists. Every call allocates fresh defaults so no two inputs share them.
 *
 * @example
 * ```ts
-* const graph = new Map([
-*   ['Pet', new Set(['Category'])],
-*   ['Category', new Set(['Pet'])],
-* ])
-* findCircularSchemasFromGraph(graph) // Set { 'Pet', 'Category' }
+* const input = createInput()
+* // { kind: 'Input', schemas: [], operations: [] }
 * ```
 */
-function findCircularSchemasFromGraph(graph) {
-	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;
+function createInput(overrides = {}) {
+	return {
+		schemas: [],
+		operations: [],
+		meta: {
+			circularNames: [],
+			enumNames: []
+		},
+		...overrides,
+		kind: "Input"
+	};
 }
+//#endregion
+//#region src/nodes/requestBody.ts
 /**
-* Finds every schema that takes part in a circular dependency chain, including direct self-loops.
-*
-* 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.
-*
-* @note Call this once on the full graph, then check individual schemas with `containsCircularRef()`.
+* Creates a `RequestBodyNode`.
 */
-function findCircularSchemas(schemas) {
-	const graph = /* @__PURE__ */ new Map();
-	for (const schema of schemas) if (schema.name) graph.set(schema.name, collectSchemaRefs(schema));
-	return findCircularSchemasFromGraph(graph);
+function createRequestBody(input) {
+	return {
+		...input,
+		kind: "RequestBody"
+	};
 }
 //#endregion
-//#region src/utils/schemaProperties.ts
+//#region src/nodes/operation.ts
+function createOperation(props) {
+	const { requestBody, ...rest } = props;
+	const isHttp = rest.method !== void 0 && rest.path !== void 0;
+	return {
+		tags: [],
+		parameters: [],
+		responses: [],
+		...rest,
+		kind: "Operation",
+		...isHttp ? { protocol: "http" } : {},
+		requestBody: requestBody ? createRequestBody(requestBody) : void 0
+	};
+}
+//#endregion
+//#region src/nodes/output.ts
 /**
-* Finds every matching property exposed by an object, resolved reference, or intersection.
-*
-* References are followed through their parsed `schema`. Circular references terminate without
-* revisiting a node. Unions are not traversed because a property on one branch does not describe
-* every branch.
+* Creates an `OutputNode` with a stable default for `files`.
 *
-* @example Faker discriminator narrowing
+* @example
 * ```ts
-* const values = resolveSchemaProperties({ node: member, propertyName: union.discriminatorPropertyName }).flatMap(({ schema }) =>
-*   getSchemaLiteralValues(schema),
-* )
-* const typeName = `Extract<Pet, { type: ${values.map(JSON.stringify).join(' | ')} }>`
+* const output = createOutput()
+* // { kind: 'Output', files: [] }
 * ```
+*/
+function createOutput(overrides = {}) {
+	return {
+		files: [],
+		...overrides,
+		kind: "Output"
+	};
+}
+//#endregion
+//#region src/nodes/parameter.ts
+/**
+* Creates a `ParameterNode`. `required` defaults to `false`, and the schema's
+* `optional`/`nullish` flags are derived from it through {@link withRequired}.
 *
-* @example Zod discriminated unions
+* @example
 * ```ts
-* const canDiscriminate = union.members?.every(
-*   (member) => resolveSchemaProperties({ node: member, propertyName: 'type' }).length > 0,
-* )
-* const expression = canDiscriminate ? `z.discriminatedUnion('type', members)` : `z.union(members)`
+* const param = createParameter({
+*   name: 'petId',
+*   in: 'path',
+*   required: true,
+*   schema: createSchema({ type: 'string' }),
+* })
 * ```
+*/
+function createParameter(input) {
+	return {
+		...withRequired(input),
+		kind: "Parameter"
+	};
+}
+//#endregion
+//#region src/nodes/property.ts
+/**
+* Creates a `PropertyNode`. `required` defaults to `false`, and the schema's
+* `optional`/`nullish` flags are derived from it through {@link withRequired}.
 *
-* @example TypeScript property lookup
+* @example
 * ```ts
-* const properties = resolveSchemaProperties({ node: schema, propertyName: 'status' })
-* const statusSchemas = properties.map((property) => print(property.schema))
+* const property = createProperty({
+*   name: 'status',
+*   required: true,
+*   schema: createSchema({ type: 'string', nullable: true }),
+* })
+* // required=true, no optional/nullish
 * ```
 */
-function resolveSchemaProperties({ node, propertyName }) {
-	const properties = [];
-	const visited = /* @__PURE__ */ new WeakSet();
-	function visit(current) {
-		if (!current || visited.has(current)) return;
-		visited.add(current);
-		if (current.type === "object") {
-			const property = current.properties.find((candidate) => candidate.name === propertyName);
-			if (property) properties.push(property);
-			return;
-		}
-		if (current.type === "ref") {
-			visit(current.schema);
-			return;
-		}
-		if (current.type === "intersection") for (const member of current.members ?? []) visit(member);
-	}
-	visit(node);
-	return properties;
+function createProperty(input) {
+	return {
+		...withRequired(input),
+		kind: "Property"
+	};
 }
+//#endregion
+//#region src/nodes/response.ts
 /**
-* Reads the unique literal values represented by an enum, resolved reference, or union.
-*
-* Named enum values take precedence over simple enum values, matching how renderers consume
-* `EnumSchemaNode`.
+* Creates a `ResponseNode`. A single legacy `schema` (with optional `mediaType`/`keysToOmit`)
+* is normalized into one `content` entry.
 *
 * @example
 * ```ts
-* const values = getSchemaLiteralValues(enumNode)
-* // ['cat', 'dog']
+* const response = createResponse({
+*   statusCode: '200',
+*   content: [createContent({ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) })],
+* })
 * ```
 */
-function getSchemaLiteralValues(node) {
-	const values = /* @__PURE__ */ new Set();
-	const visited = /* @__PURE__ */ new WeakSet();
-	function visit(current) {
-		if (!current || visited.has(current)) return;
-		visited.add(current);
-		if (current.type === "enum") {
-			const enumValues = current.namedEnumValues?.map(({ value }) => value) ?? current.enumValues ?? [];
-			for (const value of enumValues) values.add(value);
-			return;
-		}
-		if (current.type === "ref") {
-			visit(current.schema);
-			return;
-		}
-		if (current.type === "union") for (const member of current.members ?? []) visit(member);
-	}
-	visit(node);
-	return [...values];
-}
-function collectPropertyNames(node, visited = /* @__PURE__ */ new WeakSet()) {
-	if (visited.has(node)) return /* @__PURE__ */ new Set();
-	visited.add(node);
-	if (node.type === "object") return new Set(node.properties.map((property) => property.name));
-	if (node.type === "ref") return node.schema ? collectPropertyNames(node.schema, visited) : /* @__PURE__ */ new Set();
-	if (node.type === "intersection") {
-		const names = /* @__PURE__ */ new Set();
-		for (const member of node.members ?? []) for (const name of collectPropertyNames(member, visited)) names.add(name);
-		return names;
-	}
-	return /* @__PURE__ */ new Set();
+function createResponse(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,
+		kind: "Response"
+	};
 }
+//#endregion
+//#region src/nodes/schema.ts
 /**
-* Infers an implicit discriminator: a property every member exposes with a distinct single
-* literal value, the same shape a declared OpenAPI `discriminator` already narrows on.
+* Maps schema `type` to its underlying `primitive`.
+* Primitive types map to themselves and special string formats map to `'string'`.
+* Any type not listed here (such as `ref`, `enum`, `union`, `intersection`, `tuple`, `ipv4`, `ipv6`, `blob`) has no `primitive`.
 */
-function inferDiscriminatorPropertyName(members) {
-	if (members.length < 2) return void 0;
-	let candidates;
-	for (const member of members) {
-		const names = collectPropertyNames(member);
-		candidates = candidates ? new Set([...candidates].filter((name) => names.has(name))) : names;
-	}
-	for (const name of candidates ?? []) {
-		const values = members.map((member) => {
-			const literals = new Set(resolveSchemaProperties({
-				node: member,
-				propertyName: name
-			}).flatMap((property) => getSchemaLiteralValues(property.schema)));
-			return literals.size === 1 ? [...literals][0] : void 0;
-		});
-		if (values.every((value) => value !== void 0) && new Set(values).size === members.length) return name;
-	}
+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) {
+	if (props.type === "object") return {
+		properties: [],
+		primitive: "object",
+		...props,
+		kind: "Schema"
+	};
+	return {
+		primitive: TYPE_TO_PRIMITIVE[props.type],
+		...props,
+		kind: "Schema"
+	};
 }
 //#endregion
 //#region src/factory.ts
@@ -1717,77 +1588,50 @@ function update(node, changes) {
 	return node;
 }
 //#endregion
-//#region src/exports.ts
-var exports_exports = /* @__PURE__ */ __exportAll({
+//#region src/index.ts
+var src_exports = /* @__PURE__ */ __exportAll({
 	applyMacros: () => applyMacros,
-	arrowFunctionDef: () => arrowFunctionDef,
-	breakDef: () => breakDef,
+	ast: () => src_exports,
 	collect: () => collect,
 	collectImportedRefNames: () => collectImportedRefNames,
 	collectSchemaRefs: () => collectSchemaRefs,
 	collectSync: () => collectSync,
 	collectUsedSchemaNames: () => collectUsedSchemaNames,
 	composeMacros: () => composeMacros,
-	constDef: () => constDef,
-	contentDef: () => contentDef,
 	createPrinter: () => createPrinter,
 	defineMacro: () => defineMacro,
-	defineNode: () => defineNode,
-	exportDef: () => exportDef,
 	extractStringsFromNodes: () => extractStringsFromNodes,
 	factory: () => factory_exports,
-	fileDef: () => fileDef,
 	findCircularSchemas: () => findCircularSchemas,
 	findCircularSchemasFromGraph: () => findCircularSchemasFromGraph,
-	functionDef: () => functionDef,
 	getSchemaLiteralValues: () => getSchemaLiteralValues,
-	importDef: () => importDef,
 	inferDiscriminatorPropertyName: () => inferDiscriminatorPropertyName,
-	inputDef: () => inputDef,
 	isBareRef: () => isBareRef,
 	isHttpOperationNode: () => isHttpOperationNode,
-	jsxDef: () => jsxDef,
 	mergeRefWithSchema: () => mergeRefWithSchema,
 	narrowSchema: () => narrowSchema,
-	nodeDefs: () => nodeDefs,
-	operationDef: () => operationDef,
 	optionality: () => optionality,
-	outputDef: () => outputDef,
-	parameterDef: () => parameterDef,
-	propertyDef: () => propertyDef,
-	requestBodyDef: () => requestBodyDef,
 	resolveRefName: () => resolveRefName,
 	resolveSchemaProperties: () => resolveSchemaProperties,
-	responseDef: () => responseDef,
-	schemaDef: () => schemaDef,
 	schemaTypes: () => schemaTypes,
-	sourceDef: () => sourceDef,
-	textDef: () => textDef,
-	transform: () => transform,
-	typeDef: () => typeDef
+	transform: () => transform
 });
 //#endregion
 exports.applyMacros = applyMacros;
-exports.arrowFunctionDef = arrowFunctionDef;
 Object.defineProperty(exports, "ast", {
 	enumerable: true,
 	get: function() {
-		return exports_exports;
+		return src_exports;
 	}
 });
-exports.breakDef = breakDef;
 exports.collect = collect;
 exports.collectImportedRefNames = collectImportedRefNames;
 exports.collectSchemaRefs = collectSchemaRefs;
 exports.collectSync = collectSync;
 exports.collectUsedSchemaNames = collectUsedSchemaNames;
 exports.composeMacros = composeMacros;
-exports.constDef = constDef;
-exports.contentDef = contentDef;
 exports.createPrinter = createPrinter;
 exports.defineMacro = defineMacro;
-exports.defineNode = defineNode;
-exports.exportDef = exportDef;
 exports.extractStringsFromNodes = extractStringsFromNodes;
 Object.defineProperty(exports, "factory", {
 	enumerable: true,
@@ -1795,34 +1639,18 @@ Object.defineProperty(exports, "factory", {
 		return factory_exports;
 	}
 });
-exports.fileDef = fileDef;
 exports.findCircularSchemas = findCircularSchemas;
 exports.findCircularSchemasFromGraph = findCircularSchemasFromGraph;
-exports.functionDef = functionDef;
 exports.getSchemaLiteralValues = getSchemaLiteralValues;
-exports.importDef = importDef;
 exports.inferDiscriminatorPropertyName = inferDiscriminatorPropertyName;
-exports.inputDef = inputDef;
 exports.isBareRef = isBareRef;
 exports.isHttpOperationNode = isHttpOperationNode;
-exports.jsxDef = jsxDef;
 exports.mergeRefWithSchema = mergeRefWithSchema;
 exports.narrowSchema = narrowSchema;
-exports.nodeDefs = nodeDefs;
-exports.operationDef = operationDef;
 exports.optionality = optionality;
-exports.outputDef = outputDef;
-exports.parameterDef = parameterDef;
-exports.propertyDef = propertyDef;
-exports.requestBodyDef = requestBodyDef;
 exports.resolveRefName = resolveRefName;
 exports.resolveSchemaProperties = resolveSchemaProperties;
-exports.responseDef = responseDef;
-exports.schemaDef = schemaDef;
 exports.schemaTypes = schemaTypes;
-exports.sourceDef = sourceDef;
-exports.textDef = textDef;
 exports.transform = transform;
-exports.typeDef = typeDef;
 
 //# sourceMappingURL=index.cjs.map