@kubb/ast 5.8.4 → 5.9.1

package/dist/index.js

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-CNktS9qV.js";
-import { hash } from "node:crypto";
 import path from "node:path";
+import { hash } from "node:crypto";
 //#region src/constants.ts
 const visitorDepths = {
 	shallow: "shallow",
@@ -145,11 +145,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",
@@ -160,176 +181,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
 /**
@@ -363,1278 +603,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 = path.extname(input.baseName);
-	if (!extname) throw new Error(`No extname found for ${input.baseName}`);
-	const resolvedExports = input.exports?.length ? combineExports(input.exports) : [];
-	const resolvedImports = (() => {
-		if (!input.imports?.length) return [];
-		const sourceParts = [];
-		const localNames = /* @__PURE__ */ new Set();
-		for (const item of input.sources ?? []) {
-			const extracted = item.nodes && extractStringsFromNodes(item.nodes);
-			if (extracted) sourceParts.push(extracted);
-			if (item.name) localNames.add(item.name);
-		}
-		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: hash("sha256", input.path, "hex"),
-		name: path.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 = path.extname(input.baseName);
+	if (!extname) throw new Error(`No extname found for ${input.baseName}`);
+	const resolvedExports = input.exports?.length ? combineExports(input.exports) : [];
+	const resolvedImports = (() => {
+		if (!input.imports?.length) return [];
+		const sourceParts = [];
+		const localNames = /* @__PURE__ */ new Set();
+		for (const item of input.sources ?? []) {
+			const extracted = item.nodes && extractStringsFromNodes(item.nodes);
+			if (extracted) sourceParts.push(extracted);
+			if (item.name) localNames.add(item.name);
 		}
-	}
-	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: hash("sha256", input.path, "hex"),
+		name: path.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
@@ -1685,56 +1556,35 @@ 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
-export { applyMacros, arrowFunctionDef, exports_exports as ast, breakDef, collect, collectImportedRefNames, collectSchemaRefs, collectSync, collectUsedSchemaNames, composeMacros, constDef, contentDef, createPrinter, defineMacro, defineNode, exportDef, extractStringsFromNodes, factory_exports as factory, fileDef, findCircularSchemas, findCircularSchemasFromGraph, functionDef, getSchemaLiteralValues, importDef, inferDiscriminatorPropertyName, inputDef, isBareRef, isHttpOperationNode, jsxDef, mergeRefWithSchema, narrowSchema, nodeDefs, operationDef, optionality, outputDef, parameterDef, propertyDef, requestBodyDef, resolveRefName, resolveSchemaProperties, responseDef, schemaDef, schemaTypes, sourceDef, textDef, transform, typeDef };
+export { applyMacros, src_exports as ast, collect, collectImportedRefNames, collectSchemaRefs, collectSync, collectUsedSchemaNames, composeMacros, createPrinter, defineMacro, extractStringsFromNodes, factory_exports as factory, findCircularSchemas, findCircularSchemasFromGraph, getSchemaLiteralValues, inferDiscriminatorPropertyName, isBareRef, isHttpOperationNode, mergeRefWithSchema, narrowSchema, optionality, resolveRefName, resolveSchemaProperties, schemaTypes, transform };
 
 //# sourceMappingURL=index.js.map