@kubb/ast 5.0.0-beta.56 → 5.0.0-beta.57

package/dist/index.js

@@ -2,6 +2,131 @@ import "./chunk-C0LytTxp.js";
 import { _ as httpMethods, a as enumPropName, b as visitorDepths, g as camelCase, h as isValidVarName, o as extractRefName, v as isScalarPrimitive, y as schemaTypes } from "./utils-0p8ZO287.js";
 import { hash } from "node:crypto";
 import path from "node:path";
+//#region src/node.ts
+/**
+* Builds a type guard that matches nodes of the given `kind`.
+*/
+function isKind(kind) {
+	return (node) => node.kind === kind;
+}
+/**
+* Updates a schema's `optional` and `nullish` flags from a parent's `required`
+* value and the schema's own `nullable`. Mirrors how OpenAPI parameters and
+* object properties combine "required" and "nullable" into a single AST.
+*
+* - Non-required + non-nullable → `optional: true`.
+* - Non-required + nullable → `nullish: true`.
+* - Required → both flags cleared.
+*/
+function syncOptionality(schema, required) {
+	const nullable = schema.nullable ?? false;
+	return {
+		...schema,
+		optional: !required && !nullable ? true : void 0,
+		nullish: !required && nullable ? true : void 0
+	};
+}
+/**
+* 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.
+*
+* Set `rebuild: true` when the `build` hook derives fields from children. After a
+* transform rewrites those children, the registry reruns `create` so the derived
+* fields stay correct.
+*
+* @example Simple node
+* ```ts
+* const importDef = defineNode<ImportNode>({ kind: 'Import' })
+* const createImport = importDef.create
+* ```
+*
+* @example Node with a build hook that is rerun on transform
+* ```ts
+* const propertyDef = defineNode<PropertyNode, UserPropertyNode>({
+*   kind: 'Property',
+*   build: (props) => ({ ...props, required: props.required ?? false }),
+*   children: ['schema'],
+*   visitorKey: 'property',
+*   rebuild: true,
+* })
+* ```
+*/
+function defineNode(config) {
+	const { kind, defaults, build, children, visitorKey, rebuild } = config;
+	function create(input) {
+		const base = build ? build(input) : input;
+		return {
+			...defaults,
+			...base,
+			kind
+		};
+	}
+	return {
+		kind,
+		create,
+		is: isKind(kind),
+		children,
+		visitorKey,
+		rebuild
+	};
+}
+//#endregion
+//#region src/nodes/schema.ts
+/**
+* Maps schema `type` to its underlying `primitive`.
+* Primitive types map to themselves. Special string formats map to `'string'`.
+* Complex types (`ref`, `enum`, `union`, `intersection`, `tuple`, `blob`) are left unset.
+*/
+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"
+	],
+	visitorKey: "schema"
+});
+function createSchema(props) {
+	return schemaDef.create(props);
+}
+//#endregion
 //#region ../../internals/utils/src/fs.ts
 /**
 * Strips the file extension from a path or file name.
@@ -59,2040 +184,1857 @@ function memoize(store, factory) {
 	};
 }
 //#endregion
-//#region src/guards.ts
+//#region src/signature.ts
 /**
-* Narrows a `SchemaNode` to the variant that matches `type`.
-*
-* @example
-* ```ts
-* const schema = createSchema({ type: 'string' })
-* const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | null
-* ```
+* The flags shared by every node kind that affect its type: `primitive`, `format`, `nullable`.
 */
-function narrowSchema(node, type) {
-	return node?.type === type ? node : null;
-}
-function isKind(kind) {
-	return (node) => node.kind === kind;
+function flagsDescriptor(node) {
+	return `${node.primitive ?? ""};${node.format ?? ""};${node.nullable ? 1 : 0}`;
 }
-/**
-* Returns `true` when the input is an `InputNode`.
-*
-* @example
-* ```ts
-* if (isInputNode(node)) {
-*   console.log(node.schemas.length)
-* }
-* ```
-*/
-const isInputNode = isKind("Input");
-/**
-* Returns `true` when the input is an `OutputNode`.
-*
-* @example
-* ```ts
-* if (isOutputNode(node)) {
-*   console.log(node.files.length)
-* }
-* ```
-*/
-const isOutputNode = isKind("Output");
-/**
-* Returns `true` when the input is an `OperationNode`.
-*
-* @example
-* ```ts
-* if (isOperationNode(node)) {
-*   console.log(node.operationId)
-* }
-* ```
-*/
-const isOperationNode = isKind("Operation");
-/**
-* Narrows an `OperationNode` to an `HttpOperationNode`, guaranteeing `method` and `path`.
-*
-* @example
-* ```ts
-* if (isHttpOperationNode(node)) {
-*   console.log(node.method, node.path)
-* }
-* ```
-*/
-function isHttpOperationNode(node) {
-	return node.protocol === "http" || node.method !== void 0 && node.path !== void 0;
+function refTargetName(node) {
+	if (node.ref) return extractRefName(node.ref);
+	return node.name ?? "";
 }
+const arrayTupleFields = [
+	{
+		kind: "children",
+		key: "items",
+		prefix: "i"
+	},
+	{
+		kind: "child",
+		key: "rest",
+		prefix: "r"
+	},
+	{
+		kind: "scalar",
+		key: "min",
+		prefix: "mn"
+	},
+	{
+		kind: "scalar",
+		key: "max",
+		prefix: "mx"
+	},
+	{
+		kind: "bool",
+		key: "unique",
+		prefix: "u"
+	}
+];
+const numericFields = [
+	{
+		kind: "scalar",
+		key: "min",
+		prefix: "mn"
+	},
+	{
+		kind: "scalar",
+		key: "max",
+		prefix: "mx"
+	},
+	{
+		kind: "scalar",
+		key: "exclusiveMinimum",
+		prefix: "emn"
+	},
+	{
+		kind: "scalar",
+		key: "exclusiveMaximum",
+		prefix: "emx"
+	},
+	{
+		kind: "scalar",
+		key: "multipleOf",
+		prefix: "mo"
+	}
+];
+const rangeFields = [{
+	kind: "scalar",
+	key: "min",
+	prefix: "mn"
+}, {
+	kind: "scalar",
+	key: "max",
+	prefix: "mx"
+}];
 /**
-* Returns `true` when the input is a `SchemaNode`.
-*
-* @example
-* ```ts
-* if (isSchemaNode(node)) {
-*   console.log(node.type)
-* }
-* ```
-*/
-const isSchemaNode = isKind("Schema");
-//#endregion
-//#region src/visitor.ts
-/**
-* Creates a small async concurrency limiter.
-*
-* At most `concurrency` tasks are in flight at once. Extra tasks are queued.
-*
-* @example
-* ```ts
-* const limit = createLimit(2)
-* for (const task of [taskA, taskB, taskC]) {
-*   await limit(() => task())
-* }
-* // only 2 tasks run at the same time
-* ```
+* Maps each node `type` to its ordered shape-contributing fields. Types absent from the map
+* (boolean, null, any, and other scalars) fall back to `${type}|${flags}`.
 */
-function createLimit(concurrency) {
-	let active = 0;
-	const queue = [];
-	function next() {
-		if (active < concurrency && queue.length > 0) {
-			active++;
-			queue.shift()();
+const SHAPE_KEYS = {
+	object: [
+		{ kind: "objectProps" },
+		{ kind: "additionalProps" },
+		{ kind: "patternProps" },
+		{
+			kind: "scalar",
+			key: "minProperties",
+			prefix: "mn"
+		},
+		{
+			kind: "scalar",
+			key: "maxProperties",
+			prefix: "mx"
 		}
-	}
-	return function limit(fn) {
-		return new Promise((resolve, reject) => {
-			queue.push(() => {
-				Promise.resolve(fn()).then(resolve, reject).finally(() => {
-					active--;
-					next();
-				});
-			});
-			next();
-		});
-	};
-}
-const visitorKeysByKind = {
-	Input: ["schemas", "operations"],
-	Operation: [
-		"parameters",
-		"requestBody",
-		"responses"
 	],
-	RequestBody: ["content"],
-	Content: ["schema"],
-	Response: ["content"],
-	Schema: [
-		"properties",
-		"items",
-		"members",
-		"additionalProperties"
+	array: arrayTupleFields,
+	tuple: arrayTupleFields,
+	union: [
+		{
+			kind: "scalar",
+			key: "strategy",
+			prefix: "s"
+		},
+		{
+			kind: "scalar",
+			key: "discriminatorPropertyName",
+			prefix: "d"
+		},
+		{
+			kind: "children",
+			key: "members",
+			prefix: "m"
+		}
+	],
+	intersection: [{
+		kind: "children",
+		key: "members",
+		prefix: "m"
+	}],
+	enum: [{ kind: "enumValues" }],
+	ref: [{ kind: "refTarget" }],
+	string: [
+		{
+			kind: "scalar",
+			key: "min",
+			prefix: "mn"
+		},
+		{
+			kind: "scalar",
+			key: "max",
+			prefix: "mx"
+		},
+		{
+			kind: "scalar",
+			key: "pattern",
+			prefix: "pt"
+		}
+	],
+	number: numericFields,
+	integer: numericFields,
+	bigint: numericFields,
+	url: [
+		{
+			kind: "scalar",
+			key: "path",
+			prefix: "path"
+		},
+		{
+			kind: "scalar",
+			key: "min",
+			prefix: "mn"
+		},
+		{
+			kind: "scalar",
+			key: "max",
+			prefix: "mx"
+		}
 	],
-	Property: ["schema"],
-	Parameter: ["schema"]
+	uuid: rangeFields,
+	email: rangeFields,
+	datetime: [{
+		kind: "bool",
+		key: "offset",
+		prefix: "o"
+	}, {
+		kind: "bool",
+		key: "local",
+		prefix: "l"
+	}],
+	date: [{
+		kind: "scalar",
+		key: "representation",
+		prefix: "rep"
+	}],
+	time: [{
+		kind: "scalar",
+		key: "representation",
+		prefix: "rep"
+	}]
 };
+function serializeShapeField(field, node, record) {
+	switch (field.kind) {
+		case "scalar": return `${field.prefix}:${record[field.key] ?? ""}`;
+		case "bool": return `${field.prefix}:${record[field.key] ? 1 : 0}`;
+		case "child": {
+			const child = record[field.key];
+			return `${field.prefix}:${child ? signatureOf(child) : ""}`;
+		}
+		case "children": {
+			const children = record[field.key] ?? [];
+			return `${field.prefix}[${children.map((c) => signatureOf(c)).join(",")}]`;
+		}
+		case "objectProps": return `p[${(node.properties ?? []).map((prop) => `${prop.name}${prop.required ? "!" : "?"}${signatureOf(prop.schema)}`).join(",")}]`;
+		case "additionalProps": {
+			const obj = node;
+			if (typeof obj.additionalProperties === "boolean") return `ab:${obj.additionalProperties}`;
+			if (obj.additionalProperties) return `as:${signatureOf(obj.additionalProperties)}`;
+			return "";
+		}
+		case "patternProps": {
+			const obj = node;
+			return `pp[${obj.patternProperties ? Object.keys(obj.patternProperties).sort().map((key) => `${key}=${signatureOf(obj.patternProperties[key])}`).join(",") : ""}]`;
+		}
+		case "enumValues": {
+			const en = node;
+			let values = "";
+			if (en.namedEnumValues?.length) values = en.namedEnumValues.map((entry) => `${entry.name}=${entry.primitive}:${String(entry.value)}`).join(",");
+			else if (en.enumValues?.length) values = en.enumValues.map((value) => `${value === null ? "null" : typeof value}:${String(value)}`).join(",");
+			return `v[${values}]`;
+		}
+		case "refTarget": return `->${refTargetName(node)}`;
+	}
+}
 /**
-* Returns `true` when `value` is an AST node (an object carrying a `kind`).
+* Builds the local shape descriptor that {@link signatureOf} hashes: the node's kind, flags,
+* constraints, and its children's signatures.
 */
-function isNode(value) {
-	return typeof value === "object" && value !== null && "kind" in value;
+function describeShape(node) {
+	const flags = flagsDescriptor(node);
+	const fields = SHAPE_KEYS[node.type];
+	if (!fields) return `${node.type}|${flags}`;
+	const record = node;
+	const parts = [`${node.type}|${flags}`];
+	for (const field of fields) parts.push(serializeShapeField(field, node, record));
+	return parts.join("|");
 }
 /**
-* Returns the immediate traversable children of `node` based on {@link VISITOR_KEYS}.
-*
-* `Schema` children are only included when `recurse` is `true`. Shallow mode skips them.
+* Node → digest cache, keyed by identity. A `WeakMap` so entries die with the node, and so a tree
+* hashed during dedupe planning is not walked again when it is rewritten during streaming. Reuse
+* is safe because a signature depends only on content, and nodes are immutable once created.
+*/
+const signatureCache = /* @__PURE__ */ new WeakMap();
+/**
+* Computes a deterministic, shape-only signature (a content hash) for a schema node. Two schemas
+* share a signature when they are structurally identical, ignoring documentation (`name`, `title`,
+* `description`, `example`, `default`, `deprecated`) and usage-slot flags (`optional`, `nullish`,
+* `readOnly`, `writeOnly`). `nullable` is kept because it changes the produced type, and `ref`
+* nodes compare by target name, which also terminates on circular shapes.
 *
-* @example
+* @example Two enums with different descriptions share a signature
 * ```ts
-* const children = getChildren(operationNode, true)
-* // returns parameters, the request body, and responses
+* signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'], description: 'x' })) ===
+*   signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'] }))
 * ```
 */
-function* getChildren(node, recurse) {
-	if (node.kind === "Schema" && !recurse) return;
-	const keys = visitorKeysByKind[node.kind];
-	if (!keys) return;
-	const record = node;
-	for (const key of keys) {
-		const value = record[key];
-		if (Array.isArray(value)) {
-			for (const item of value) if (isNode(item)) yield item;
-		} else if (isNode(value)) yield value;
-	}
+function signatureOf(node) {
+	const cached = signatureCache.get(node);
+	if (cached !== void 0) return cached;
+	const signature = hash("sha256", describeShape(node), "hex");
+	signatureCache.set(node, signature);
+	return signature;
 }
+//#endregion
+//#region src/nodes/code.ts
 /**
-* Maps a node `kind` to the matching visitor callback name. Only the seven
-* traversable node kinds have an entry. Every other kind resolves to
-* `undefined` and is skipped.
+* Definition for the {@link ConstNode}.
 */
-const VISITOR_KEY_BY_KIND = {
-	Input: "input",
-	Output: "output",
-	Operation: "operation",
-	Schema: "schema",
-	Property: "property",
-	Parameter: "parameter",
-	Response: "response"
-};
+const constDef = defineNode({ kind: "Const" });
 /**
-* Invokes the visitor callback that matches `node.kind`, passing the traversal
-* context. Returns the callback's result (a replacement node, a collected
-* value, or `undefined` when no callback is registered for the kind).
+* Creates a `ConstNode` representing a TypeScript `const` declaration.
 *
-* Shared by `walk`, `transform`, and `collectLazy` so node-kind dispatch lives
-* in one place. `TResult` is the caller's expected return: the same node type
-* for `transform`, the collected value type for `collectLazy`, ignored for `walk`.
+* @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 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 });
-}
+const createConst = constDef.create;
 /**
-* Async depth-first traversal for side effects. Visitor return values are
-* ignored. Use `transform` when you want to rewrite nodes.
+* Definition for the {@link TypeNode}.
+*/
+const typeDef = defineNode({ kind: "Type" });
+/**
+* Creates a `TypeNode` representing a TypeScript `type` alias declaration.
 *
-* Sibling nodes at each depth run concurrently up to `options.concurrency`
-* (defaults to `WALK_CONCURRENCY`). Higher values overlap I/O-bound visitor
-* work. Lower values reduce memory pressure.
+* @example
+* ```ts
+* createType({ name: 'Pet', export: true })
+* // export type Pet = ...
+* ```
+*/
+const createType = typeDef.create;
+/**
+* Definition for the {@link FunctionNode}.
+*/
+const functionDef = defineNode({ kind: "Function" });
+/**
+* Creates a `FunctionNode` representing a TypeScript `function` declaration.
 *
-* @example Log every operation
+* @example
 * ```ts
-* await walk(root, {
-*   operation(node) {
-*     console.log(node.operationId)
-*   },
-* })
+* createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
+* // export async function fetchPet(): Promise<Pet> { ... }
 * ```
+*/
+const createFunction = functionDef.create;
+/**
+* Definition for the {@link ArrowFunctionNode}.
+*/
+const arrowFunctionDef = defineNode({ kind: "ArrowFunction" });
+/**
+* Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
 *
-* @example Only visit the root node
+* @example
 * ```ts
-* await walk(root, { depth: 'shallow', input: () => {} })
+* createArrowFunction({ name: 'double', export: true, params: 'n: number', singleLine: true })
+* // export const double = (n: number) => ...
 * ```
 */
-async function walk(node, options) {
-	return _walk(node, options, (options.depth ?? visitorDepths.deep) === visitorDepths.deep, createLimit(options.concurrency ?? 30), void 0);
-}
-async function _walk(node, visitor, recurse, limit, parent) {
-	await limit(() => applyVisitor(node, visitor, parent));
-	const children = Array.from(getChildren(node, recurse));
-	if (children.length === 0) return;
-	await Promise.all(children.map((child) => _walk(child, visitor, recurse, limit, node)));
-}
-function transform(node, options) {
-	const { depth, parent, ...visitor } = options;
-	const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep;
-	const rebuilt = transformChildren(applyVisitor(node, visitor, parent) ?? node, options, recurse);
-	if (rebuilt === node) return node;
-	const finalize = nodeFinalizers[rebuilt.kind];
-	return finalize ? finalize(rebuilt) : rebuilt;
-}
+const createArrowFunction = arrowFunctionDef.create;
 /**
-* Per-kind builders rerun after children are rebuilt. `Property`/`Parameter`
-* resync schema optionality against their `required` flag once the schema may
-* have changed.
+* Definition for the {@link TextNode}.
 */
-const nodeFinalizers = {
-	Property: (node) => createProperty(node),
-	Parameter: (node) => createParameter(node)
-};
+const textDef = defineNode({
+	kind: "Text",
+	build: (value) => ({ value })
+});
 /**
-* Immutably rebuilds a node's children using {@link VISITOR_KEYS}, transforming
-* each child node and leaving non-node values (e.g. `additionalProperties: true`) intact.
-* `Schema` children are skipped in shallow mode.
+* Creates a {@link TextNode} representing a raw string fragment in the source output.
+*
+* @example
+* ```ts
+* createText('return fetch(id)')
+* // { kind: 'Text', value: 'return fetch(id)' }
+* ```
 */
-function transformChildren(node, options, recurse) {
-	if (node.kind === "Schema" && !recurse) return node;
-	const keys = visitorKeysByKind[node.kind];
-	if (!keys) return node;
-	const record = node;
-	const childOptions = {
-		...options,
-		parent: node
-	};
-	let updates;
-	for (const key of keys) {
-		if (!(key in record)) continue;
-		const value = record[key];
-		if (Array.isArray(value)) {
-			let changed = false;
-			const mapped = value.map((item) => {
-				if (!isNode(item)) return item;
-				const next = transform(item, childOptions);
-				if (next !== item) changed = true;
-				return next;
-			});
-			if (changed) (updates ??= {})[key] = mapped;
-		} else if (isNode(value)) {
-			const next = transform(value, childOptions);
-			if (next !== value) (updates ??= {})[key] = next;
-		}
-	}
-	return updates ? {
-		...node,
-		...updates
-	} : node;
-}
+const createText = textDef.create;
 /**
-* Lazy depth-first collection pass. Yields every non-null value returned by
-* the visitor callbacks. Use `collect` for the eager array form.
+* Definition for the {@link BreakNode}.
+*/
+const breakDef = defineNode({
+	kind: "Break",
+	build: () => ({})
+});
+/**
+* Creates a {@link BreakNode} representing a line break in the source output.
 *
-* @example Collect every operationId
+* @example
 * ```ts
-* const ids: string[] = []
-* for (const id of collectLazy<string>(root, {
-*   operation(node) {
-*     return node.operationId
-*   },
-* })) {
-*   ids.push(id)
-* }
+* createBreak()
+* // { kind: 'Break' }
 * ```
 */
-function* collectLazy(node, options) {
-	const { depth, parent, ...visitor } = options;
-	const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep;
-	const v = applyVisitor(node, visitor, parent);
-	if (v != null) yield v;
-	for (const child of getChildren(node, recurse)) yield* collectLazy(child, {
-		...options,
-		parent: node
-	});
+function createBreak() {
+	return breakDef.create();
 }
 /**
-* Eager depth-first collection pass. Returns an array of every non-null value
-* the visitor callbacks return.
+* Definition for the {@link JsxNode}.
+*/
+const jsxDef = defineNode({
+	kind: "Jsx",
+	build: (value) => ({ value })
+});
+/**
+* Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
 *
-* @example Collect every operationId
+* @example
 * ```ts
-* const ids = collect<string>(root, {
-*   operation(node) {
-*     return node.operationId
-*   },
-* })
+* createJsx('<>\n  <a href={href}>Open</a>\n</>')
+* // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
 * ```
 */
-function collect(node, options) {
-	return Array.from(collectLazy(node, options));
-}
+const createJsx = jsxDef.create;
 //#endregion
-//#region src/utils/ast.ts
-const plainStringTypes = new Set([
-	"string",
-	"uuid",
-	"email",
-	"url",
-	"datetime"
-]);
+//#region src/nodes/content.ts
 /**
-* Merges a ref node with its resolved schema, giving usage-site fields precedence.
-*
-* Usage-site fields (`description`, `readOnly`, `nullable`, `deprecated`) on the ref node
-* override the same fields in the resolved `node.schema`. Non-ref nodes are returned unchanged.
+* Definition for the {@link ContentNode}.
+*/
+const contentDef = defineNode({
+	kind: "Content",
+	children: ["schema"]
+});
+/**
+* Creates a `ContentNode` for a single request-body or response content type.
+*/
+const createContent = contentDef.create;
+//#endregion
+//#region src/nodes/file.ts
+/**
+* Definition for the {@link ImportNode}.
+*/
+const importDef = defineNode({ kind: "Import" });
+/**
+* Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
 *
-* @example
+* @example Named import
 * ```ts
-* // Ref with description override
-* const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A cute pet' })
-* const merged = syncSchemaRef(ref)  // merges with resolved Pet schema
+* createImport({ name: ['useState'], path: 'react' })
+* // import { useState } from 'react'
 * ```
 */
-function syncSchemaRef(node) {
-	const ref = narrowSchema(node, "ref");
-	if (!ref) return node;
-	if (!ref.schema) return node;
-	const { kind: _kind, type: _type, name: _name, ref: _ref, schema: _schema, ...overrides } = ref;
-	const definedOverrides = Object.fromEntries(Object.entries(overrides).filter(([, v]) => v !== void 0));
-	return createSchema({
-		...ref.schema,
-		...definedOverrides
-	});
-}
+const createImport = importDef.create;
 /**
-* Type guard that returns `true` when a schema emits as a plain `string` type.
-*
-* Covers `string`, `uuid`, `email`, `url`, and `datetime` types. For `date` and `time`
-* types, returns `true` only when `representation` is `'string'` rather than `'date'`.
+* Definition for the {@link ExportNode}.
 */
-function isStringType(node) {
-	if (plainStringTypes.has(node.type)) return true;
-	const temporal = narrowSchema(node, "date") ?? narrowSchema(node, "time");
-	if (temporal) return temporal.representation !== "date";
-	return false;
-}
+const exportDef = defineNode({ kind: "Export" });
 /**
-* Applies casing rules to parameter names and returns a new parameter array.
+* Creates an `ExportNode` representing a language-agnostic export/public API declaration.
 *
-* Use this before passing parameters to schema builders so output property keys match
-* the desired casing while preserving `OperationNode.parameters` for other consumers.
-* The input array is not mutated. When `casing` is not set, the original array is returned unchanged.
+* @example Named export
+* ```ts
+* createExport({ name: ['Pet'], path: './Pet' })
+* // export { Pet } from './Pet'
+* ```
 */
-const caseParamsMemo = memoize(/* @__PURE__ */ new WeakMap(), (params) => memoize(/* @__PURE__ */ new Map(), (casing) => params.map((param) => {
-	const transformed = casing === "camelcase" || !isValidVarName(param.name) ? camelCase(param.name) : param.name;
-	return {
-		...param,
-		name: transformed
-	};
-})));
-function caseParams(params, casing) {
-	if (!casing) return params;
-	return caseParamsMemo(params)(casing);
-}
+const createExport = exportDef.create;
 /**
-* Creates a single-property object schema used as a discriminator literal.
+* Definition for the {@link SourceNode}.
+*/
+const sourceDef = defineNode({ kind: "Source" });
+/**
+* Creates a `SourceNode` representing a fragment of source code within a file.
 *
 * @example
 * ```ts
-* createDiscriminantNode({ propertyName: 'type', value: 'dog' })
-* // -> { type: 'object', properties: [{ name: 'type', required: true, schema: enum('dog') }] }
+* createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
 * ```
 */
-function createDiscriminantNode({ propertyName, value }) {
-	return createSchema({
-		type: "object",
-		primitive: "object",
-		properties: [createProperty({
-			name: propertyName,
-			schema: createSchema({
-				type: "enum",
-				primitive: "string",
-				enumValues: [value]
-			}),
-			required: true
-		})]
-	});
-}
-function resolveParamsType({ node, param, resolver }) {
-	if (!resolver) return createParamsType({
-		variant: "reference",
-		name: param.schema.primitive ?? "unknown"
-	});
-	const individualName = resolver.resolveParamName(node, param);
-	const groupLocation = param.in === "path" || param.in === "query" || param.in === "header" ? param.in : void 0;
-	const groupResolvers = {
-		path: resolver.resolvePathParamsName,
-		query: resolver.resolveQueryParamsName,
-		header: resolver.resolveHeaderParamsName
-	};
-	const groupName = groupLocation ? groupResolvers[groupLocation].call(resolver, node, param) : void 0;
-	if (groupName && groupName !== individualName) return createParamsType({
-		variant: "member",
-		base: groupName,
-		key: param.name
-	});
-	return createParamsType({
-		variant: "reference",
-		name: individualName
-	});
-}
+const createSource = sourceDef.create;
 /**
-* Converts an `OperationNode` into function parameters for code generation.
-*
-* Centralizes parameter grouping logic for all plugins. Provide a `resolver` for type name resolution
-* and `extraParams` for plugin-specific trailing parameters (e.g., `options` objects).
-* Supports three grouping modes: `object` (single destructured param), `inline` (separate params),
-* and `inlineSpread` (rest parameter). Use `CreateOperationParamsOptions` to fine-tune output.
+* Definition for the {@link FileNode}. The fully resolved builder lives in
+* `createFile`, so this definition only supplies the guard.
 */
-function createOperationParams(node, options) {
-	const { paramsType, pathParamsType, paramsCasing, resolver, pathParamsDefault, extraParams = [], paramNames, typeWrapper } = options;
-	const dataName = paramNames?.data ?? "data";
-	const paramsName = paramNames?.params ?? "params";
-	const headersName = paramNames?.headers ?? "headers";
-	const pathName = paramNames?.path ?? "pathParams";
-	const wrapType = (type) => createParamsType({
-		variant: "reference",
-		name: typeWrapper ? typeWrapper(type) : type
-	});
-	const wrapTypeNode = (type) => type.kind === "ParamsType" && type.variant === "reference" ? wrapType(type.name) : type;
-	const casedParams = caseParams(node.parameters, paramsCasing);
-	const pathParams = casedParams.filter((p) => p.in === "path");
-	const queryParams = casedParams.filter((p) => p.in === "query");
-	const headerParams = casedParams.filter((p) => p.in === "header");
-	const bodyType = node.requestBody?.content?.[0]?.schema ? wrapType(resolver?.resolveDataName(node) ?? "unknown") : void 0;
-	const bodyRequired = node.requestBody?.required ?? false;
-	const queryGroupType = resolver ? resolveGroupType({
-		node,
-		params: queryParams,
-		groupMethod: resolver.resolveQueryParamsName,
-		resolver
-	}) : void 0;
-	const headerGroupType = resolver ? resolveGroupType({
-		node,
-		params: headerParams,
-		groupMethod: resolver.resolveHeaderParamsName,
-		resolver
-	}) : void 0;
-	const params = [];
-	if (paramsType === "object") {
-		const children = [
-			...pathParams.map((p) => {
-				const type = resolveParamsType({
-					node,
-					param: p,
-					resolver
-				});
-				return createFunctionParameter({
-					name: p.name,
-					type: wrapTypeNode(type),
-					optional: !p.required
-				});
-			}),
-			...bodyType ? [createFunctionParameter({
-				name: dataName,
-				type: bodyType,
-				optional: !bodyRequired
-			})] : [],
-			...buildGroupParam({
-				name: paramsName,
-				node,
-				params: queryParams,
-				groupType: queryGroupType,
-				resolver,
-				wrapType
-			}),
-			...buildGroupParam({
-				name: headersName,
-				node,
-				params: headerParams,
-				groupType: headerGroupType,
-				resolver,
-				wrapType
-			})
-		];
-		if (children.length) params.push(createParameterGroup({
-			properties: children,
-			default: children.every((c) => c.optional) ? "{}" : void 0
-		}));
-	} else {
-		if (pathParams.length) if (pathParamsType === "inlineSpread") {
-			const spreadType = resolver?.resolvePathParamsName(node, pathParams[0]);
-			params.push(createFunctionParameter({
-				name: pathName,
-				type: spreadType ? wrapType(spreadType) : void 0,
-				rest: true
-			}));
-		} else {
-			const pathChildren = pathParams.map((p) => {
-				const type = resolveParamsType({
-					node,
-					param: p,
-					resolver
-				});
-				return createFunctionParameter({
-					name: p.name,
-					type: wrapTypeNode(type),
-					optional: !p.required
-				});
-			});
-			params.push(createParameterGroup({
-				properties: pathChildren,
-				inline: pathParamsType === "inline",
-				default: pathParamsDefault ?? (pathChildren.every((c) => c.optional) ? "{}" : void 0)
-			}));
-		}
-		if (bodyType) params.push(createFunctionParameter({
-			name: dataName,
-			type: bodyType,
-			optional: !bodyRequired
-		}));
-		params.push(...buildGroupParam({
-			name: paramsName,
-			node,
-			params: queryParams,
-			groupType: queryGroupType,
-			resolver,
-			wrapType
-		}));
-		params.push(...buildGroupParam({
-			name: headersName,
-			node,
-			params: headerParams,
-			groupType: headerGroupType,
-			resolver,
-			wrapType
-		}));
-	}
-	params.push(...extraParams);
-	return createFunctionParameters({ params });
-}
+const fileDef = defineNode({ kind: "File" });
+//#endregion
+//#region src/nodes/function.ts
 /**
-* Builds a single {@link FunctionParameterNode} for a query or header group.
-* Returns an empty array when there are no params to emit.
+* Definition for the {@link TypeLiteralNode}.
+*/
+const typeLiteralDef = defineNode({ kind: "TypeLiteral" });
+/**
+* Creates a {@link TypeLiteralNode} representing an inline anonymous object type.
 *
-* If a pre-resolved `groupType` is provided it emits `name: GroupType`.
-* Otherwise, it builds an inline struct from the individual params.
+* @example
+* ```ts
+* createTypeLiteral({ members: [{ name: 'petId', type: 'string', optional: false }] })
+* // { petId: string }
+* ```
 */
-function buildGroupParam({ name, node, params, groupType, resolver, wrapType }) {
-	if (groupType) return [createFunctionParameter({
-		name,
-		type: groupType.type.kind === "ParamsType" && groupType.type.variant === "reference" ? wrapType(groupType.type.name) : groupType.type,
-		optional: groupType.optional
-	})];
-	if (params.length) return [createFunctionParameter({
-		name,
-		type: toStructType({
-			node,
-			params,
-			resolver
-		}),
-		optional: params.every((p) => !p.required)
-	})];
-	return [];
-}
+const createTypeLiteral = typeLiteralDef.create;
 /**
-* Derives a {@link ParamGroupType} from the resolver's group method.
-* Returns `null` when the group name equals the individual param name (no real group).
+* Definition for the {@link IndexedAccessTypeNode}.
 */
-function resolveGroupType({ node, params, groupMethod, resolver }) {
-	if (!params.length) return null;
-	const firstParam = params[0];
-	const groupName = groupMethod.call(resolver, node, firstParam);
-	if (groupName === resolver.resolveParamName(node, firstParam)) return null;
-	const allOptional = params.every((p) => !p.required);
-	return {
-		type: createParamsType({
-			variant: "reference",
-			name: groupName
-		}),
-		optional: allOptional
-	};
-}
+const indexedAccessTypeDef = defineNode({ kind: "IndexedAccessType" });
 /**
-* Builds a {@link TypeNode} with `variant: 'struct'` for an inline anonymous type grouping named fields.
+* Creates an {@link IndexedAccessTypeNode} representing a single field accessed from a named type.
 *
-* Used when query or header parameters have no dedicated group type name.
-* Each language printer renders this appropriately (TypeScript: `{ petId: string; name?: string }`).
-*/
-function toStructType({ node, params, resolver }) {
-	return createParamsType({
-		variant: "struct",
-		properties: params.map((p) => ({
-			name: p.name,
-			optional: !p.required,
-			type: resolveParamsType({
-				node,
-				param: p,
-				resolver
-			})
-		}))
-	});
-}
-function sourceKey(source) {
-	return `${source.name ?? extractStringsFromNodes(source.nodes)}:${source.isExportable ?? false}:${source.isTypeOnly ?? false}`;
-}
-function pathTypeKey(path, isTypeOnly) {
-	return `${path}:${isTypeOnly ?? false}`;
-}
-function exportKey(path, name, isTypeOnly, asAlias) {
-	return `${path}:${name ?? ""}:${isTypeOnly ?? false}:${asAlias ?? ""}`;
-}
-function importKey(path, name, isTypeOnly) {
-	return `${path}:${name ?? ""}:${isTypeOnly ?? false}`;
-}
-/**
-* Computes a multi-level sort key for exports and imports:
-* non-array names first (wildcards/namespace aliases). Type-only before value. Alphabetical path. Unnamed before named.
+* @example
+* ```ts
+* createIndexedAccessType({ objectType: 'DeletePetPathParams', indexType: 'petId' })
+* // DeletePetPathParams['petId']
+* ```
 */
-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}`;
-}
+const createIndexedAccessType = indexedAccessTypeDef.create;
 /**
-* Deduplicates and merges `SourceNode` objects by `name + isExportable + isTypeOnly`.
-*
-* Unnamed sources are deduplicated by object reference. Returns a deduplicated array in original order.
+* Definition for the {@link ObjectBindingPatternNode}.
 */
-function combineSources(sources) {
-	const seen = /* @__PURE__ */ new Map();
-	for (const source of sources) {
-		const key = sourceKey(source);
-		if (!seen.has(key)) seen.set(key, source);
-	}
-	return [...seen.values()];
-}
+const objectBindingPatternDef = defineNode({ kind: "ObjectBindingPattern" });
 /**
-* Merges `incoming` names into `existing`, preserving order and dropping duplicates.
+* Creates an {@link ObjectBindingPatternNode} for a destructured parameter binding.
 *
-* Shared by `combineExports` and `combineImports` for the same-path name-merge case.
+* @example
+* ```ts
+* createObjectBindingPattern({ elements: [{ name: 'id' }, { name: 'name' }] })
+* // { id, name }
+* ```
 */
-function mergeNameArrays(existing, incoming) {
-	const merged = new Set(existing);
-	for (const name of incoming) merged.add(name);
-	return [...merged];
-}
+const createObjectBindingPattern = objectBindingPatternDef.create;
 /**
-* 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.
+* Definition for the {@link FunctionParameterNode}. `optional` defaults to `false`.
+* Passing `properties` builds a destructured group: an {@link ObjectBindingPatternNode} name
+* paired with a {@link TypeLiteralNode} type.
 */
-function combineExports(exports) {
-	const result = [];
-	const namedByPath = /* @__PURE__ */ new Map();
-	const seen = /* @__PURE__ */ new Set();
-	const keyed = exports.map((node) => ({
-		node,
-		key: sortKey(node)
-	}));
-	keyed.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
-	for (const { node: curr } of keyed) {
-		const { name, path, isTypeOnly, asAlias } = curr;
-		if (Array.isArray(name)) {
-			if (!name.length) continue;
-			const key = pathTypeKey(path, isTypeOnly);
-			const existing = namedByPath.get(key);
-			if (existing && Array.isArray(existing.name)) existing.name = mergeNameArrays(existing.name, name);
-			else {
-				const newItem = {
-					...curr,
-					name: [...new Set(name)]
-				};
-				result.push(newItem);
-				namedByPath.set(key, newItem);
-			}
-		} else {
-			const key = exportKey(path, name, isTypeOnly, asAlias);
-			if (!seen.has(key)) {
-				result.push(curr);
-				seen.add(key);
-			}
-		}
+const functionParameterDef = defineNode({
+	kind: "FunctionParameter",
+	build: (input) => {
+		if ("properties" in input) return {
+			name: createObjectBindingPattern({ elements: input.properties.map((p) => ({ name: p.name })) }),
+			type: createTypeLiteral({ members: input.properties.map((p) => ({
+				name: p.name,
+				type: p.type,
+				optional: p.optional ?? false
+			})) }),
+			optional: input.optional ?? false,
+			...input.default !== void 0 ? { default: input.default } : {}
+		};
+		return {
+			optional: false,
+			...input
+		};
 	}
-	return result;
-}
+});
 /**
-* Deduplicates and merges `ImportNode` objects, filtering out unused imports.
+* Creates a `FunctionParameterNode`. `optional` defaults to `false`.
 *
-* 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.
+* @example Optional param
+* ```ts
+* createFunctionParameter({ name: 'params', type: 'QueryParams', optional: true })
+* // → params?: QueryParams
+* ```
 *
-* @note Use this when combining imports from multiple files to avoid duplicate declarations.
+* @example Destructured group
+* ```ts
+* createFunctionParameter({ properties: [{ name: 'id', type: 'string' }, { name: 'name', type: 'string', optional: true }], default: '{}' })
+* // → { id, name }: { id: string; name?: string } = {}
+* ```
 */
-function combineImports(imports, exports, source) {
-	const exportedNames = new Set(exports.flatMap((e) => Array.isArray(e.name) ? e.name : e.name ? [e.name] : []));
-	const isUsed = (importName) => !source || source.includes(importName) || exportedNames.has(importName);
-	const 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)) continue;
-		if (node.name.some((item) => typeof item === "string" ? isUsed(item) : isUsed(item.name ?? item.propertyName))) pathsWithUsedNamedImport.add(node.path);
-	}
-	const result = [];
-	const namedByPath = /* @__PURE__ */ new Map();
-	const seen = /* @__PURE__ */ new Set();
-	const keyed = imports.map((node) => ({
-		node,
-		key: sortKey(node)
-	}));
-	keyed.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
-	for (const { node: curr } of keyed) {
-		if (curr.path === curr.root) continue;
-		const { path, isTypeOnly } = curr;
-		let { name } = curr;
-		if (Array.isArray(name)) {
-			name = [...new Set(name.map(canonicalizeName))].filter((item) => typeof item === "string" ? isUsed(item) : isUsed(item.name ?? item.propertyName));
-			if (!name.length) continue;
-			const key = pathTypeKey(path, isTypeOnly);
-			const existing = namedByPath.get(key);
-			if (existing && Array.isArray(existing.name)) existing.name = mergeNameArrays(existing.name, name);
-			else {
-				const newItem = {
-					...curr,
-					name
-				};
-				result.push(newItem);
-				namedByPath.set(key, newItem);
-			}
-		} else {
-			if (name && !isUsed(name) && !pathsWithUsedNamedImport.has(path)) continue;
-			const key = importKey(path, name, isTypeOnly);
-			if (!seen.has(key)) {
-				result.push(curr);
-				seen.add(key);
-			}
-		}
-	}
-	return result;
-}
+const createFunctionParameter = functionParameterDef.create;
 /**
-* Extracts all string content from a `CodeNode` tree recursively.
-*
-* Collects text node values, identifier references in string fields (`params`, `generics`, `returnType`, `type`),
-* and nested node content. Used internally to build the full source string for import filtering.
+* Definition for the {@link FunctionParametersNode}.
 */
-function extractStringsFromNodes(nodes) {
-	if (!nodes?.length) return "";
-	return nodes.map((node) => {
-		if (typeof node === "string") return node;
-		if (node.kind === "Text") return node.value;
-		if (node.kind === "Break") return "";
-		if (node.kind === "Jsx") return node.value;
-		const parts = [];
-		if ("params" in node && node.params) parts.push(node.params);
-		if ("generics" in node && node.generics) parts.push(Array.isArray(node.generics) ? node.generics.join(", ") : node.generics);
-		if ("returnType" in node && node.returnType) parts.push(node.returnType);
-		if ("type" in node && typeof node.type === "string") parts.push(node.type);
-		const nested = extractStringsFromNodes(node.nodes);
-		if (nested) parts.push(nested);
-		return parts.join("\n");
-	}).filter(Boolean).join("\n");
-}
+const functionParametersDef = defineNode({
+	kind: "FunctionParameters",
+	defaults: { params: [] }
+});
 /**
-* Resolves the schema name of a ref node, falling back through `ref` → `name` → nested `schema.name`.
-*
-* Returns `null` for non-ref nodes or when no name can be resolved. Use this to get a schema's
-* identifier for type definitions or error messages.
+* Creates a `FunctionParametersNode` from an ordered list of parameters.
 *
 * @example
 * ```ts
-* resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Pet' })
-* // => 'Pet'
+* const empty = createFunctionParameters()
+* // { kind: 'FunctionParameters', params: [] }
 * ```
 */
-function resolveRefName(node) {
-	if (!node || node.type !== "ref") return null;
-	if (node.ref) return extractRefName(node.ref) ?? node.name ?? node.schema?.name ?? null;
-	return node.name ?? node.schema?.name ?? null;
+function createFunctionParameters(props = {}) {
+	return functionParametersDef.create(props);
 }
+//#endregion
+//#region src/nodes/input.ts
 /**
-* Collects every named schema referenced (transitively) from a node via ref edges.
-*
-* Refs are followed by name only, the resolved `node.schema` is not traversed inline.
-* Use this to determine schema dependencies, build reference graphs, or detect what schemas need to be emitted.
-*
-* @example Collect refs from a single schema
-* ```ts
-* const names = collectReferencedSchemaNames(petSchema)
-* // → Set { 'Category', 'Tag' }
-* ```
-*
-* @example Accumulate refs from multiple schemas into one set
-* ```ts
-* const out = new Set<string>()
-* for (const schema of schemas) {
-*   collectReferencedSchemaNames(schema, out)
-* }
-* ```
+* Definition for the {@link InputNode}.
 */
-const collectSchemaRefs = memoize(/* @__PURE__ */ new WeakMap(), (node) => {
-	const refs = /* @__PURE__ */ new Set();
-	collect(node, { schema(child) {
-		if (child.type === "ref") {
-			const name = resolveRefName(child);
-			if (name) refs.add(name);
+const inputDef = defineNode({
+	kind: "Input",
+	defaults: {
+		schemas: [],
+		operations: [],
+		meta: {
+			circularNames: [],
+			enumNames: []
 		}
-	} });
-	return refs;
+	},
+	children: ["schemas", "operations"],
+	visitorKey: "input"
 });
-function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
-	if (!node) return out;
-	for (const name of collectSchemaRefs(node)) out.add(name);
-	return out;
-}
 /**
-* Collects the names of all top-level schemas transitively used by a set of operations.
-*
-* An operation uses a schema when any of its parameters, request body content, or responses
-* reference it, directly or indirectly through other named schemas.
-* The walk is iterative and safe against reference cycles.
-*
-* Use this together with `include` filters to determine which schemas from `components/schemas`
-* are reachable from the allowed operations, so that schemas used only by excluded operations
-* are not generated.
+* Creates an `InputNode` with stable defaults for `schemas` and `operations`.
 *
-* @example Only generate schemas referenced by included operations
+* @example
 * ```ts
-* const includedOps = operations.filter(op => resolver.resolveOptions(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 input = createInput()
+* // { kind: 'Input', schemas: [], operations: [] }
 * ```
+*/
+function createInput(overrides = {}) {
+	return inputDef.create(overrides);
+}
+/**
+* Creates a streaming `InputNode<true>` from pre-built `AsyncIterable` sources.
 *
-* @example Check whether a specific schema is needed
+* @example
 * ```ts
-* const allowed = collectUsedSchemaNames(includedOps, schemas)
-* allowed.has('OrderStatus') // false when no included operation references OrderStatus
+* const node = createStreamInput(schemasIterable, operationsIterable, { title: 'My API' })
 * ```
 */
-const collectUsedSchemaNamesMemo = memoize(/* @__PURE__ */ new WeakMap(), (ops) => memoize(/* @__PURE__ */ new WeakMap(), (schemas) => computeUsedSchemaNames(ops, schemas)));
-function computeUsedSchemaNames(operations, schemas) {
-	const schemaMap = /* @__PURE__ */ new Map();
-	for (const schema of schemas) if (schema.name) schemaMap.set(schema.name, schema);
-	const result = /* @__PURE__ */ new Set();
-	function visitSchema(schema) {
-		const directRefs = collectReferencedSchemaNames(schema);
-		for (const name of directRefs) if (!result.has(name)) {
-			result.add(name);
-			const namedSchema = schemaMap.get(name);
-			if (namedSchema) visitSchema(namedSchema);
-		}
-	}
-	for (const op of operations) for (const schema of collectLazy(op, {
-		depth: "shallow",
-		schema: (node) => node
-	})) visitSchema(schema);
-	return result;
-}
-function collectUsedSchemaNames(operations, schemas) {
-	return collectUsedSchemaNamesMemo(operations)(schemas);
+function createStreamInput(schemas, operations, meta) {
+	return {
+		kind: "Input",
+		schemas,
+		operations,
+		meta
+	};
 }
-const EMPTY_CIRCULAR_SET = /* @__PURE__ */ new Set();
-const findCircularSchemasMemo = memoize(/* @__PURE__ */ new WeakMap(), (schemas) => {
-	const graph = /* @__PURE__ */ new Map();
-	for (const schema of schemas) {
-		if (!schema.name) continue;
-		graph.set(schema.name, collectReferencedSchemaNames(schema));
-	}
-	const circular = /* @__PURE__ */ new Set();
-	for (const start of graph.keys()) {
-		const visited = /* @__PURE__ */ new Set();
-		const stack = [...graph.get(start) ?? []];
-		while (stack.length > 0) {
-			const node = stack.pop();
-			if (node === start) {
-				circular.add(start);
-				break;
-			}
-			if (visited.has(node)) continue;
-			visited.add(node);
-			const next = graph.get(node);
-			if (next) for (const r of next) stack.push(r);
-		}
-	}
-	return circular;
-});
+//#endregion
+//#region src/nodes/requestBody.ts
 /**
-* Identifies all schemas that participate in circular dependency chains, including direct self-loops.
-*
-* Returns a Set of schema names with circular dependencies. Use this to wrap recursive schema positions
-* in deferred constructs (lazy getter, `z.lazy(() => …)`) to prevent infinite recursion when generated code runs.
-* Refs are followed by name only, keeping the algorithm linear in the schema graph size.
-*
-* @note Call this once on the full schema graph, then use `containsCircularRef()` to check individual schemas.
+* Definition for the {@link RequestBodyNode}, normalizing each content entry into a `ContentNode`.
 */
-function findCircularSchemas(schemas) {
-	if (schemas.length === 0) return EMPTY_CIRCULAR_SET;
-	return findCircularSchemasMemo(schemas);
-}
+const requestBodyDef = defineNode({
+	kind: "RequestBody",
+	build: (props) => ({
+		...props,
+		content: props.content?.map(createContent)
+	}),
+	children: ["content"]
+});
 /**
-* Type guard returning `true` when a schema or anything nested within it contains a ref to a circular schema.
-*
-* Use `excludeName` to ignore refs to specific schemas (useful when self-references are handled separately).
-* Commonly used with `findCircularSchemas()` to detect where lazy wrappers are needed in code generation.
-*
-* @note Returns `true` for the first matching circular ref found. Use for fast dependency checks.
+* Creates a `RequestBodyNode`, normalizing each content entry into a `ContentNode`.
 */
-function containsCircularRef(node, { circularSchemas, excludeName }) {
-	if (!node || circularSchemas.size === 0) return false;
-	for (const _ of collectLazy(node, { schema(child) {
-		if (child.type !== "ref") return null;
-		const name = resolveRefName(child);
-		return name && name !== excludeName && circularSchemas.has(name) ? true : null;
-	} })) return true;
-	return false;
+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/factory.ts
+//#region src/nodes/output.ts
 /**
-* Updates a schema's `optional` and `nullish` flags from a parent's `required`
-* value and the schema's own `nullable`. Mirrors how OpenAPI parameters and
-* object properties combine "required" and "nullable" into a single AST.
-*
-* - Non-required + non-nullable → `optional: true`.
-* - Non-required + nullable → `nullish: true`.
-* - Required → both flags cleared.
+* Definition for the {@link OutputNode}.
 */
-function syncOptionality(schema, required) {
-	const nullable = schema.nullable ?? false;
-	return {
-		...schema,
-		optional: !required && !nullable ? true : void 0,
-		nullish: !required && nullable ? true : void 0
-	};
-}
+const outputDef = defineNode({
+	kind: "Output",
+	defaults: { files: [] },
+	visitorKey: "output"
+});
 /**
-* Identity-preserving node update: returns `node` unchanged when every field in
-* `changes` already equals (by reference) the current value, otherwise a new node
-* with the changes applied.
-*
-* Mirrors the TypeScript compiler's `factory.updateX` contract, pair it with the
-* structural sharing in {@link transform} so a no-op rewrite doesn't allocate and
-* downstream passes can detect "nothing changed" by identity. Comparison is
-* shallow: a structurally-equal but newly-allocated array/object counts as a change.
+* Creates an `OutputNode` with a stable default for `files`.
 *
 * @example
 * ```ts
-* update(node, { name: node.name })        // -> same `node` reference
-* update(node, { name: 'renamed' })        // -> new node, `name` replaced
+* const output = createOutput()
+* // { kind: 'Output', files: [] }
 * ```
 */
-function update(node, changes) {
-	for (const key in changes) if (changes[key] !== node[key]) return {
-		...node,
-		...changes
-	};
-	return node;
+function createOutput(overrides = {}) {
+	return outputDef.create(overrides);
 }
+//#endregion
+//#region src/nodes/parameter.ts
+/**
+* Definition for the {@link ParameterNode}. `required` defaults to `false` and the
+* schema's `optional`/`nullish` flags are kept in sync with it.
+*/
+const parameterDef = defineNode({
+	kind: "Parameter",
+	build: (props) => {
+		const required = props.required ?? false;
+		return {
+			...props,
+			required,
+			schema: syncOptionality(props.schema, required)
+		};
+	},
+	children: ["schema"],
+	visitorKey: "parameter",
+	rebuild: true
+});
 /**
-* Creates an `InputNode` with stable defaults for `schemas` and `operations`.
+* Creates a `ParameterNode`.
 *
 * @example
 * ```ts
-* const input = createInput()
-* // { kind: 'Input', schemas: [], operations: [] }
+* const param = createParameter({
+*   name: 'petId',
+*   in: 'path',
+*   required: true,
+*   schema: createSchema({ type: 'string' }),
+* })
 * ```
+*/
+const createParameter = parameterDef.create;
+//#endregion
+//#region src/nodes/property.ts
+/**
+* Definition for the {@link PropertyNode}. `required` defaults to `false` and the
+* schema's `optional`/`nullish` flags are kept in sync with it.
+*/
+const propertyDef = defineNode({
+	kind: "Property",
+	build: (props) => {
+		const required = props.required ?? false;
+		return {
+			...props,
+			required,
+			schema: syncOptionality(props.schema, required)
+		};
+	},
+	children: ["schema"],
+	visitorKey: "property",
+	rebuild: true
+});
+/**
+* Creates a `PropertyNode`.
 *
 * @example
 * ```ts
-* const input = createInput({ schemas: [petSchema] })
-* // keeps default operations: []
+* const property = createProperty({
+*   name: 'status',
+*   required: true,
+*   schema: createSchema({ type: 'string', nullable: true }),
+* })
+* // required=true, no optional/nullish
 * ```
 */
-function createInput(overrides = {}) {
-	return {
-		schemas: [],
-		operations: [],
-		meta: {
-			circularNames: [],
-			enumNames: []
-		},
-		...overrides,
-		kind: "Input"
-	};
-}
+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 ? [{
+			contentType: mediaType ?? "application/json",
+			schema,
+			keysToOmit: keysToOmit ?? null
+		}] : void 0);
+		return {
+			...rest,
+			content: entries?.map(createContent)
+		};
+	},
+	children: ["content"],
+	visitorKey: "response"
+});
 /**
-* Creates a streaming `InputNode<true>` from pre-built `AsyncIterable` sources.
+* Creates a `ResponseNode`.
 *
 * @example
 * ```ts
-* const node = createStreamInput(schemasIterable, operationsIterable, { title: 'My API' })
+* const response = createResponse({
+*   statusCode: '200',
+*   content: [{ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) }],
+* })
 * ```
 */
-function createStreamInput(schemas, operations, meta) {
-	return {
-		kind: "Input",
-		schemas,
-		operations,
-		meta
-	};
-}
+const createResponse = responseDef.create;
+//#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 below derive from it.
+*/
+const nodeDefs = [
+	inputDef,
+	outputDef,
+	operationDef,
+	requestBodyDef,
+	contentDef,
+	responseDef,
+	schemaDef,
+	propertyDef,
+	parameterDef,
+	functionParameterDef,
+	functionParametersDef,
+	typeLiteralDef,
+	indexedAccessTypeDef,
+	objectBindingPatternDef,
+	constDef,
+	typeDef,
+	functionDef,
+	arrowFunctionDef,
+	textDef,
+	breakDef,
+	jsxDef,
+	importDef,
+	exportDef,
+	sourceDef,
+	fileDef
+];
 /**
-* Creates an `OutputNode` with a stable default for `files`.
+* 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]] : []));
+/**
+* Per-kind builders rerun after children are rebuilt. Derived from each
+* definition's `rebuild` flag.
+*/
+const nodeRebuilders = Object.fromEntries(nodeDefs.flatMap((def) => def.rebuild ? [[def.kind, def.create]] : []));
+//#endregion
+//#region src/visitor.ts
+/**
+* Creates a small async concurrency limiter.
 *
-* @example
-* ```ts
-* const output = createOutput()
-* // { kind: 'Output', files: [] }
-* ```
+* At most `concurrency` tasks are in flight at once. Extra tasks are queued.
 *
 * @example
 * ```ts
-* const output = createOutput({ files: [petFile] })
+* const limit = createLimit(2)
+* for (const task of [taskA, taskB, taskC]) {
+*   await limit(() => task())
+* }
+* // only 2 tasks run at the same time
 * ```
 */
-function createOutput(overrides = {}) {
-	return {
-		files: [],
-		...overrides,
-		kind: "Output"
+function createLimit(concurrency) {
+	let active = 0;
+	const queue = [];
+	function next() {
+		if (active < concurrency && queue.length > 0) {
+			active++;
+			queue.shift()();
+		}
+	}
+	return function limit(fn) {
+		return new Promise((resolve, reject) => {
+			queue.push(() => {
+				Promise.resolve(fn()).then(resolve, reject).finally(() => {
+					active--;
+					next();
+				});
+			});
+			next();
+		});
 	};
 }
+const visitorKeysByKind = VISITOR_KEYS;
 /**
-* Creates a `ContentNode` for a single request-body or response content type.
+* Returns `true` when `value` is an AST node (an object carrying a `kind`).
 */
-function createContent(props) {
-	return {
-		...props,
-		kind: "Content"
-	};
+function isNode(value) {
+	return typeof value === "object" && value !== null && "kind" in value;
 }
 /**
-* Creates a `RequestBodyNode`, normalizing each content entry into a `ContentNode`.
+* Returns the immediate traversable children of `node` based on {@link VISITOR_KEYS}.
+*
+* `Schema` children are only included when `recurse` is `true`. Shallow mode skips them.
+*
+* @example
+* ```ts
+* const children = getChildren(operationNode, true)
+* // returns parameters, the request body, and responses
+* ```
 */
-function createRequestBody(props) {
-	return {
-		...props,
-		kind: "RequestBody",
-		content: props.content?.map(createContent)
-	};
-}
-function createOperation(props) {
-	const { requestBody, ...rest } = props;
-	const isHttp = rest.method !== void 0 && rest.path !== void 0;
-	return {
-		tags: [],
-		parameters: [],
-		responses: [],
-		...rest,
-		...isHttp ? { protocol: "http" } : {},
-		kind: "Operation",
-		requestBody: requestBody ? createRequestBody(requestBody) : void 0
-	};
-}
-/**
-* Maps schema `type` to its underlying `primitive`.
-* Primitive types map to themselves. Special string formats map to `'string'`.
-* Complex types (`ref`, `enum`, `union`, `intersection`, `tuple`, `blob`) are left unset.
-*/
-const TYPE_TO_PRIMITIVE = {
-	string: "string",
-	number: "number",
-	integer: "integer",
-	bigint: "bigint",
-	boolean: "boolean",
-	null: "null",
-	any: "any",
-	unknown: "unknown",
-	void: "void",
-	never: "never",
-	object: "object",
-	array: "array",
-	date: "date",
-	uuid: "string",
-	email: "string",
-	url: "string",
-	datetime: "string",
-	time: "string"
-};
-function createSchema(props) {
-	const inferredPrimitive = TYPE_TO_PRIMITIVE[props.type];
-	if (props["type"] === "object") return {
-		properties: [],
-		primitive: "object",
-		...props,
-		kind: "Schema"
-	};
-	return {
-		primitive: inferredPrimitive,
-		...props,
-		kind: "Schema"
-	};
+function* getChildren(node, recurse) {
+	if (node.kind === "Schema" && !recurse) return;
+	const keys = visitorKeysByKind[node.kind];
+	if (!keys) return;
+	const record = node;
+	for (const key of keys) {
+		const value = record[key];
+		if (Array.isArray(value)) {
+			for (const item of value) if (isNode(item)) yield item;
+		} else if (isNode(value)) yield value;
+	}
 }
 /**
-* Creates a `PropertyNode`.
-*
-* `required` defaults to `false`.
-* `schema.optional` and `schema.nullish` are derived from `required` and `schema.nullable`.
-*
-* @example
-* ```ts
-* const property = createProperty({
-*   name: 'status',
-*   schema: createSchema({ type: 'string' }),
-* })
-* // required=false, schema.optional=true
-* ```
+* Invokes the visitor callback that matches `node.kind`, passing the traversal
+* context. Returns the callback's result (a replacement node, a collected
+* value, or `undefined` when no callback is registered for the kind).
 *
-* @example
-* ```ts
-* const property = createProperty({
-*   name: 'status',
-*   required: true,
-*   schema: createSchema({ type: 'string', nullable: true }),
-* })
-* // required=true, no optional/nullish
-* ```
+* Shared by `walk`, `transform`, and `collectLazy` so node-kind dispatch lives
+* in one place. `TResult` is the caller's expected return: the same node type
+* for `transform`, the collected value type for `collectLazy`, ignored for `walk`.
 */
-function createProperty(props) {
-	const required = props.required ?? false;
-	return {
-		...props,
-		kind: "Property",
-		required,
-		schema: syncOptionality(props.schema, required)
-	};
+function applyVisitor(node, visitor, parent) {
+	const key = VISITOR_KEY_BY_KIND[node.kind];
+	if (!key) return void 0;
+	const fn = visitor[key];
+	return fn?.(node, { parent });
 }
 /**
-* Creates a `ParameterNode`.
+* Async depth-first traversal for side effects. Visitor return values are
+* ignored. Use `transform` when you want to rewrite nodes.
 *
-* `required` defaults to `false`.
-* Nested schema flags are set from `required` and `schema.nullable`.
+* Sibling nodes at each depth run concurrently up to `options.concurrency`
+* (defaults to `WALK_CONCURRENCY`). Higher values overlap I/O-bound visitor
+* work. Lower values reduce memory pressure.
 *
-* @example
+* @example Log every operation
 * ```ts
-* const param = createParameter({
-*   name: 'petId',
-*   in: 'path',
-*   required: true,
-*   schema: createSchema({ type: 'string' }),
+* await walk(root, {
+*   operation(node) {
+*     console.log(node.operationId)
+*   },
 * })
 * ```
 *
-* @example
+* @example Only visit the root node
 * ```ts
-* const param = createParameter({
-*   name: 'status',
-*   in: 'query',
-*   schema: createSchema({ type: 'string', nullable: true }),
-* })
-* // required=false, schema.nullish=true
+* await walk(root, { depth: 'shallow', input: () => {} })
 * ```
 */
-function createParameter(props) {
-	const required = props.required ?? false;
-	return {
-		...props,
-		kind: "Parameter",
-		required,
-		schema: syncOptionality(props.schema, required)
-	};
+async function walk(node, options) {
+	return _walk(node, options, (options.depth ?? visitorDepths.deep) === visitorDepths.deep, createLimit(options.concurrency ?? 30), void 0);
 }
-/**
-* Creates a `ResponseNode`.
-*
-* Response body schemas live inside `content`. For convenience a single legacy `schema`
-* (with optional `mediaType`/`keysToOmit`) is normalized into one `content` entry, so the same
-* schema is never stored both at the node root and inside `content`.
-*
-* @example
-* ```ts
-* const response = createResponse({
-*   statusCode: '200',
-*   content: [{ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) }],
-* })
-* ```
-*/
-function createResponse(props) {
-	const { schema, mediaType, keysToOmit, content, ...rest } = props;
-	const entries = content ?? (schema ? [{
-		contentType: mediaType ?? "application/json",
-		schema,
-		keysToOmit: keysToOmit ?? null
-	}] : void 0);
-	return {
-		...rest,
-		kind: "Response",
-		content: entries?.map(createContent)
-	};
+async function _walk(node, visitor, recurse, limit, parent) {
+	await limit(() => applyVisitor(node, visitor, parent));
+	const children = Array.from(getChildren(node, recurse));
+	if (children.length === 0) return;
+	await Promise.all(children.map((child) => _walk(child, visitor, recurse, limit, node)));
 }
-/**
-* Creates a `FunctionParameterNode`.
-*
-* `optional` defaults to `false`.
-*
-* @example Required typed param
-* ```ts
-* createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }) })
-* // → petId: string
-* ```
-*
-* @example Optional param
-* ```ts
-* createFunctionParameter({ name: 'params', type: createParamsType({ variant: 'reference', name: 'QueryParams' }), optional: true })
-* // → params?: QueryParams
-* ```
-*
-* @example Param with default (implicitly optional. Cannot combine with `optional: true`)
-* ```ts
-* createFunctionParameter({ name: 'config', type: createParamsType({ variant: 'reference', name: 'RequestConfig' }), default: '{}' })
-* // → config: RequestConfig = {}
-* ```
-*/
-function createFunctionParameter(props) {
-	return {
-		optional: false,
-		...props,
-		kind: "FunctionParameter"
-	};
+function transform(node, options) {
+	const { depth, parent, ...visitor } = options;
+	const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep;
+	const rebuilt = transformChildren(applyVisitor(node, visitor, parent) ?? node, options, recurse);
+	if (rebuilt === node) return node;
+	const rebuild = nodeRebuilders[rebuilt.kind];
+	return rebuild ? rebuild(rebuilt) : rebuilt;
 }
 /**
-* Creates a {@link TypeNode} representing a language-agnostic structured type expression.
-*
-* Use `variant: 'struct'` for inline anonymous types and `variant: 'member'` for a single
-* named field accessed from a group type. Each language's printer renders the variant
-* into its own syntax (TypeScript, Python, C#, Kotlin, …).
-*
-* @example Reference type (TypeScript: `QueryParams`)
-* ```ts
-* createParamsType({ variant: 'reference', name: 'QueryParams' })
-* ```
-*
-* @example Struct type (TypeScript: `{ petId: string }`)
-* ```ts
-* createParamsType({ variant: 'struct', properties: [{ name: 'petId', optional: false, type: createParamsType({ variant: 'reference', name: 'string' }) }] })
-* ```
-*
-* @example Member type (TypeScript: `DeletePetPathParams['petId']`)
-* ```ts
-* createParamsType({ variant: 'member', base: 'DeletePetPathParams', key: 'petId' })
-* ```
+* Immutably rebuilds a node's children using {@link VISITOR_KEYS}, transforming
+* each child node and leaving non-node values (e.g. `additionalProperties: true`) intact.
+* `Schema` children are skipped in shallow mode.
 */
-function createParamsType(props) {
-	return {
-		...props,
-		kind: "ParamsType"
+function transformChildren(node, options, recurse) {
+	if (node.kind === "Schema" && !recurse) return node;
+	const keys = visitorKeysByKind[node.kind];
+	if (!keys) return node;
+	const record = node;
+	const childOptions = {
+		...options,
+		parent: node
 	};
+	let updates;
+	for (const key of keys) {
+		if (!(key in record)) continue;
+		const value = record[key];
+		if (Array.isArray(value)) {
+			let changed = false;
+			const mapped = value.map((item) => {
+				if (!isNode(item)) return item;
+				const next = transform(item, childOptions);
+				if (next !== item) changed = true;
+				return next;
+			});
+			if (changed) (updates ??= {})[key] = mapped;
+		} else if (isNode(value)) {
+			const next = transform(value, childOptions);
+			if (next !== value) (updates ??= {})[key] = next;
+		}
+	}
+	return updates ? {
+		...node,
+		...updates
+	} : node;
 }
 /**
-* Creates a `ParameterGroupNode` representing a group of related parameters treated as a unit.
-*
-* @example Grouped param (TypeScript declaration)
-* ```ts
-* createParameterGroup({
-*   properties: [
-*     createFunctionParameter({ name: 'id', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false }),
-*     createFunctionParameter({ name: 'name', type: createParamsType({ variant: 'reference', name: 'string' }), optional: true }),
-*   ],
-*   default: '{}',
-* })
-* // declaration → { id, name? }: { id: string; name?: string } = {}
-* // call        → { id, name }
-* ```
+* Lazy depth-first collection pass. Yields every non-null value returned by
+* the visitor callbacks. Use `collect` for the eager array form.
 *
-* @example Inline (spread), children emitted as individual top-level parameters
+* @example Collect every operationId
 * ```ts
-* createParameterGroup({
-*   properties: [createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false })],
-*   inline: true,
-* })
-* // declaration → petId: string
-* // call        → petId
+* const ids: string[] = []
+* for (const id of collectLazy<string>(root, {
+*   operation(node) {
+*     return node.operationId
+*   },
+* })) {
+*   ids.push(id)
+* }
 * ```
 */
-function createParameterGroup(props) {
-	return {
-		...props,
-		kind: "ParameterGroup"
-	};
+function* collectLazy(node, options) {
+	const { depth, parent, ...visitor } = options;
+	const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep;
+	const v = applyVisitor(node, visitor, parent);
+	if (v != null) yield v;
+	for (const child of getChildren(node, recurse)) yield* collectLazy(child, {
+		...options,
+		parent: node
+	});
 }
 /**
-* Creates a `FunctionParametersNode` from an ordered list of parameters.
+* Eager depth-first collection pass. Returns an array of every non-null value
+* the visitor callbacks return.
 *
-* @example
+* @example Collect every operationId
 * ```ts
-* createFunctionParameters({
-*   params: [
-*     createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false }),
-*     createFunctionParameter({ name: 'config', type: createParamsType({ variant: 'reference', name: 'RequestConfig' }), optional: false, default: '{}' }),
-*   ],
+* const ids = collect<string>(root, {
+*   operation(node) {
+*     return node.operationId
+*   },
 * })
 * ```
-*
-* @example
-* ```ts
-* const empty = createFunctionParameters()
-* // { kind: 'FunctionParameters', params: [] }
-* ```
 */
-function createFunctionParameters(props = {}) {
-	return {
-		params: [],
-		...props,
-		kind: "FunctionParameters"
-	};
+function collect(node, options) {
+	return Array.from(collectLazy(node, options));
 }
+//#endregion
+//#region src/dedupe.ts
 /**
-* Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
-*
-* @example Named import
-* ```ts
-* createImport({ name: ['useState'], path: 'react' })
-* // import { useState } from 'react'
-* ```
-*
-* @example Type-only import
-* ```ts
-* createImport({ name: ['FC'], path: 'react', isTypeOnly: true })
-* // import type { FC } from 'react'
-* ```
+* Builds the shared `ref` replacement for a duplicate occurrence, carrying the
+* usage-slot and documentation fields that are not part of the canonical type.
 */
-function createImport(props) {
-	return {
-		...props,
-		kind: "Import"
-	};
-}
+function createRefNode(node, canonical) {
+	return createSchema({
+		type: "ref",
+		name: canonical.name,
+		ref: canonical.ref,
+		optional: node.optional,
+		nullish: node.nullish,
+		readOnly: node.readOnly,
+		writeOnly: node.writeOnly,
+		deprecated: node.deprecated,
+		description: node.description,
+		default: node.default,
+		example: node.example
+	});
+}
+function applyDedupe(node, plan, skipRootMatch = false) {
+	const { canonicalBySignature, aliasNames } = plan;
+	if (canonicalBySignature.size === 0 && aliasNames.size === 0) return node;
+	const root = node;
+	return transform(node, { schema(schemaNode) {
+		if (schemaNode.type === "ref") {
+			const target = schemaNode.ref ? extractRefName(schemaNode.ref) : schemaNode.name;
+			const canonical = target ? aliasNames.get(target) : void 0;
+			return canonical ? {
+				...schemaNode,
+				name: canonical.name,
+				ref: canonical.ref
+			} : void 0;
+		}
+		const signature = signatureOf(schemaNode);
+		if (skipRootMatch && schemaNode === root) return void 0;
+		const canonical = canonicalBySignature.get(signature);
+		if (!canonical) return void 0;
+		return createRefNode(schemaNode, canonical);
+	} });
+}
 /**
-* Creates an `ExportNode` representing a language-agnostic export/public API declaration.
-*
-* @example Named export
-* ```ts
-* createExport({ name: ['Pet'], path: './Pet' })
-* // export { Pet } from './Pet'
-* ```
-*
-* @example Wildcard export
-* ```ts
-* createExport({ path: './utils' })
-* // export * from './utils'
-* ```
+* Strips usage-slot flags from a hoisted definition and applies its canonical name.
+* A standalone definition is never optional, so `optional`/`nullish` are cleared.
 */
-function createExport(props) {
+function cleanDefinition(node, name) {
 	return {
-		...props,
-		kind: "Export"
+		...node,
+		name,
+		optional: void 0,
+		nullish: void 0
 	};
 }
 /**
-* Creates a `SourceNode` representing a fragment of source code within a file.
+* Scans a forest of schema and operation nodes and produces a {@link DedupePlan}.
+*
+* A shape that occurs at least `minOccurrences` times is deduplicated: if any occurrence
+* is a named top-level schema, the first one becomes the canonical (so other top-level
+* duplicates and inline copies turn into references to it). Every other top-level name with
+* the same content is recorded in `aliasNames`, so refs to it can be repointed at the
+* canonical. Otherwise a new definition is hoisted using `nameFor`. The plan is then applied
+* per node with {@link applyDedupe}.
 *
 * @example
 * ```ts
-* createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
+* const plan = buildDedupePlan([...schemaNodes, ...operationNodes], {
+*   isCandidate: (node) => node.type === 'enum' || node.type === 'object',
+*   nameFor: (node) => node.name ?? null,
+*   refFor: (name) => `#/components/schemas/${name}`,
+* })
 * ```
 */
-function createSource(props) {
+function buildDedupePlan(roots, options) {
+	const { isCandidate, nameFor, refFor, minOccurrences = 2 } = options;
+	const topLevelNodes = /* @__PURE__ */ new Set();
+	const groups = /* @__PURE__ */ new Map();
+	function record(schemaNode) {
+		const signature = signatureOf(schemaNode);
+		if (!isCandidate(schemaNode)) return;
+		const isTopLevel = topLevelNodes.has(schemaNode) && !!schemaNode.name;
+		const group = groups.get(signature);
+		if (group) {
+			group.count++;
+			if (isTopLevel) group.topLevelNames.push(schemaNode.name);
+		} else groups.set(signature, {
+			count: 1,
+			representative: schemaNode,
+			topLevelNames: isTopLevel ? [schemaNode.name] : []
+		});
+	}
+	for (const root of roots) {
+		if (root.kind === "Schema") topLevelNodes.add(root);
+		for (const schemaNode of collectLazy(root, { schema: (node) => node })) record(schemaNode);
+	}
+	const canonicalBySignature = /* @__PURE__ */ new Map();
+	const aliasNames = /* @__PURE__ */ new Map();
+	const pendingHoists = [];
+	for (const [signature, group] of groups) {
+		if (group.count < minOccurrences) continue;
+		const [firstName, ...duplicateNames] = group.topLevelNames;
+		if (firstName) {
+			const canonical = {
+				name: firstName,
+				ref: refFor(firstName)
+			};
+			canonicalBySignature.set(signature, canonical);
+			for (const duplicate of duplicateNames) aliasNames.set(duplicate, canonical);
+			continue;
+		}
+		const name = nameFor(group.representative, signature);
+		if (!name) continue;
+		canonicalBySignature.set(signature, {
+			name,
+			ref: refFor(name)
+		});
+		pendingHoists.push({
+			name,
+			representative: group.representative
+		});
+	}
 	return {
-		...props,
-		kind: "Source"
+		canonicalBySignature,
+		aliasNames,
+		hoisted: pendingHoists.map(({ name, representative }) => cleanDefinition(applyDedupe(representative, {
+			canonicalBySignature,
+			aliasNames
+		}, true), name))
 	};
 }
+//#endregion
+//#region src/dialect.ts
 /**
-* 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.
+* Types a {@link SchemaDialect} for an adapter. Adds no runtime behavior and only pins the
+* dialect's type for inference.
 *
 * @example
 * ```ts
-* const file = createFile({
-*   baseName: 'petStore.ts',
-*   path: 'src/models/petStore.ts',
-*   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')] })],
-*   imports: [createImport({ name: ['z'], path: 'zod' })],
-*   exports: [createExport({ name: ['Pet'], path: './petStore' })],
+* export const oasDialect = defineSchemaDialect({
+*   name: 'oas',
+*   isNullable,
+*   isReference,
+*   isDiscriminator,
+*   isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',
+*   resolveRef,
 * })
-* // file.id      = SHA256 hash of 'src/models/petStore.ts'
-* // file.name    = 'petStore'
-* // file.extname = '.ts'
 * ```
 */
-function createFile(input) {
-	const extname = path.extname(input.baseName) || (input.baseName.startsWith(".") ? input.baseName : "");
-	if (!extname) throw new Error(`No extname found for ${input.baseName}`);
-	const source = (input.sources ?? []).flatMap((item) => item.nodes ?? []).map((node) => extractStringsFromNodes([node])).filter(Boolean).join("\n\n");
-	const resolvedExports = input.exports?.length ? combineExports(input.exports) : [];
-	const combinedImports = input.imports?.length ? combineImports(input.imports, resolvedExports, source || void 0) : [];
-	const localNames = new Set((input.sources ?? []).map((item) => item.name).filter((name) => Boolean(name)));
-	const nameOf = (item) => typeof item === "string" ? item : item.name ?? item.propertyName;
-	const resolvedImports = combinedImports.filter((imp) => imp.path !== input.path).flatMap((imp) => {
-		if (!Array.isArray(imp.name)) return typeof imp.name === "string" && localNames.has(imp.name) ? [] : [imp];
-		const kept = imp.name.filter((item) => !localNames.has(nameOf(item)));
-		if (!kept.length) return [];
-		return [kept.length === imp.name.length ? imp : {
-			...imp,
-			name: kept
-		}];
-	});
-	const resolvedSources = input.sources?.length ? combineSources(input.sources) : [];
-	return {
-		kind: "File",
-		...input,
-		id: hash("sha256", input.path, "hex"),
-		name: trimExtName(input.baseName),
-		extname,
-		imports: resolvedImports,
-		exports: resolvedExports,
-		sources: resolvedSources,
-		meta: input.meta ?? {}
-	};
+function defineSchemaDialect(dialect) {
+	return dialect;
 }
+//#endregion
+//#region src/guards.ts
 /**
-* Creates a `ConstNode` representing a TypeScript `const` declaration.
-*
-* Mirrors the `Const` component from `@kubb/renderer-jsx`.
-* The component's `children` are represented as `nodes`.
-*
-* @example Simple constant
-* ```ts
-* createConst({ name: 'pet' })
-* // const pet = ...
-* ```
-*
-* @example Exported constant with type and `as const`
-* ```ts
-* createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
-* // export const pets: Pet[] = ... as const
-* ```
+* Narrows a `SchemaNode` to the variant that matches `type`.
 *
-* @example With JSDoc and child nodes
+* @example
 * ```ts
-* createConst({
-*   name: 'config',
-*   export: true,
-*   JSDoc: { comments: ['@description App configuration'] },
-*   nodes: [],
-* })
+* const schema = createSchema({ type: 'string' })
+* const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | null
 * ```
 */
-function createConst(props) {
-	return {
-		...props,
-		kind: "Const"
-	};
+function narrowSchema(node, type) {
+	return node?.type === type ? node : null;
 }
 /**
-* Creates a `TypeNode` representing a TypeScript `type` alias declaration.
-*
-* Mirrors the `Type` component from `@kubb/renderer-jsx`.
-* The component's `children` are represented as `nodes`.
-*
-* @example Simple type alias
-* ```ts
-* createType({ name: 'Pet' })
-* // type Pet = ...
-* ```
+* Narrows an `OperationNode` to an `HttpOperationNode`, guaranteeing `method` and `path`.
 *
-* @example Exported type with JSDoc
+* @example
 * ```ts
-* createType({
-*   name: 'PetStatus',
-*   export: true,
-*   JSDoc: { comments: ['@description Status of a pet'] },
-* })
-* // export type PetStatus = ...
+* if (isHttpOperationNode(node)) {
+*   console.log(node.method, node.path)
+* }
 * ```
 */
-function createType(props) {
-	return {
-		...props,
-		kind: "Type"
-	};
+function isHttpOperationNode(node) {
+	return node.protocol === "http" || node.method !== void 0 && node.path !== void 0;
 }
+//#endregion
+//#region src/utils/ast.ts
+const plainStringTypes = new Set([
+	"string",
+	"uuid",
+	"email",
+	"url",
+	"datetime"
+]);
 /**
-* Creates a `FunctionNode` representing a TypeScript `function` declaration.
-*
-* Mirrors the `Function` component from `@kubb/renderer-jsx`.
-* The component's `children` are represented as `nodes`.
-*
-* @example Simple function
-* ```ts
-* createFunction({ name: 'getPet' })
-* // function getPet() { ... }
-* ```
+* Merges a ref node with its resolved schema, giving usage-site fields precedence.
 *
-* @example Exported async function with return type
-* ```ts
-* createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
-* // export async function fetchPet(): Promise<Pet> { ... }
-* ```
+* Usage-site fields (`description`, `readOnly`, `nullable`, `deprecated`) on the ref node
+* override the same fields in the resolved `node.schema`. Non-ref nodes are returned unchanged.
 *
-* @example Function with generics and params
+* @example
 * ```ts
-* createFunction({
-*   name: 'identity',
-*   export: true,
-*   generics: ['T'],
-*   params: 'value: T',
-*   returnType: 'T',
-* })
-* // export function identity<T>(value: T): T { ... }
+* // Ref with description override
+* const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A cute pet' })
+* const merged = syncSchemaRef(ref)  // merges with resolved Pet schema
 * ```
 */
-function createFunction(props) {
-	return {
-		...props,
-		kind: "Function"
-	};
+function syncSchemaRef(node) {
+	const ref = narrowSchema(node, "ref");
+	if (!ref) return node;
+	if (!ref.schema) return node;
+	const { kind: _kind, type: _type, name: _name, ref: _ref, schema: _schema, ...overrides } = ref;
+	const definedOverrides = Object.fromEntries(Object.entries(overrides).filter(([, v]) => v !== void 0));
+	return createSchema({
+		...ref.schema,
+		...definedOverrides
+	});
 }
 /**
-* Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
-*
-* Mirrors the `Function.Arrow` component from `@kubb/renderer-jsx`.
-* The component's `children` are represented as `nodes`.
-*
-* @example Simple arrow function
-* ```ts
-* createArrowFunction({ name: 'getPet' })
-* // const getPet = () => { ... }
-* ```
+* Type guard that returns `true` when a schema emits as a plain `string` type.
 *
-* @example Single-line exported arrow function
-* ```ts
-* createArrowFunction({ name: 'double', export: true, params: 'n: number', singleLine: true })
-* // export const double = (n: number) => ...
-* ```
+* Covers `string`, `uuid`, `email`, `url`, and `datetime` types. For `date` and `time`
+* types, returns `true` only when `representation` is `'string'` rather than `'date'`.
+*/
+function isStringType(node) {
+	if (plainStringTypes.has(node.type)) return true;
+	const temporal = narrowSchema(node, "date") ?? narrowSchema(node, "time");
+	if (temporal) return temporal.representation !== "date";
+	return false;
+}
+/**
+* Applies casing rules to parameter names and returns a new parameter array.
 *
-* @example Async arrow function with generics
-* ```ts
-* createArrowFunction({
-*   name: 'fetchPet',
-*   export: true,
-*   async: true,
-*   generics: ['T'],
-*   params: 'id: string',
-*   returnType: 'T',
-* })
-* // export const fetchPet = async <T>(id: string): Promise<T> => { ... }
-* ```
+* Use this before passing parameters to schema builders so output property keys match
+* the desired casing while preserving `OperationNode.parameters` for other consumers.
+* The input array is not mutated. When `casing` is not set, the original array is returned unchanged.
 */
-function createArrowFunction(props) {
+const caseParamsMemo = memoize(/* @__PURE__ */ new WeakMap(), (params) => memoize(/* @__PURE__ */ new Map(), (casing) => params.map((param) => {
+	const transformed = casing === "camelcase" || !isValidVarName(param.name) ? camelCase(param.name) : param.name;
 	return {
-		...props,
-		kind: "ArrowFunction"
+		...param,
+		name: transformed
 	};
+})));
+function caseParams(params, casing) {
+	if (!casing) return params;
+	return caseParamsMemo(params)(casing);
 }
 /**
-* Creates a {@link TextNode} representing a raw string fragment in the source output.
-*
-* Use this instead of bare strings when building `nodes` arrays so that every
-* entry in the array is a typed {@link CodeNode}.
+* Creates a single-property object schema used as a discriminator literal.
 *
 * @example
 * ```ts
-* createText('return fetch(id)')
-* // { kind: 'Text', value: 'return fetch(id)' }
+* createDiscriminantNode({ propertyName: 'type', value: 'dog' })
+* // -> { type: 'object', properties: [{ name: 'type', required: true, schema: enum('dog') }] }
 * ```
 */
-function createText(value) {
-	return {
-		value,
-		kind: "Text"
+function createDiscriminantNode({ propertyName, value }) {
+	return createSchema({
+		type: "object",
+		primitive: "object",
+		properties: [createProperty({
+			name: propertyName,
+			schema: createSchema({
+				type: "enum",
+				primitive: "string",
+				enumValues: [value]
+			}),
+			required: true
+		})]
+	});
+}
+/**
+* Resolves the {@link TypeExpression} for an individual parameter.
+*
+* Without a resolver, falls back to the schema primitive (a plain type-name string).
+* When the parameter belongs to a named group, emits an {@link IndexedAccessTypeNode}
+* (`GroupParams['petId']`); otherwise the resolved individual name as a plain string.
+*/
+function resolveParamType({ node, param, resolver }) {
+	if (!resolver) return param.schema.primitive ?? "unknown";
+	const individualName = resolver.resolveParamName(node, param);
+	const groupLocation = param.in === "path" || param.in === "query" || param.in === "header" ? param.in : void 0;
+	const groupResolvers = {
+		path: resolver.resolvePathParamsName,
+		query: resolver.resolveQueryParamsName,
+		header: resolver.resolveHeaderParamsName
 	};
+	const groupName = groupLocation ? groupResolvers[groupLocation].call(resolver, node, param) : void 0;
+	if (groupName && groupName !== individualName) return createIndexedAccessType({
+		objectType: groupName,
+		indexType: param.name
+	});
+	return individualName;
 }
 /**
-* Creates a {@link BreakNode} representing a line break in the source output.
+* Converts an `OperationNode` into function parameters for code generation.
 *
-* Corresponds to `<br/>` in JSX components. Prints as an empty string which,
-* when joined with `\n` by `printNodes`, produces a blank line.
+* Centralizes parameter grouping logic for all plugins. `paramsType` chooses between one
+* destructured object parameter (`object`) and separate top-level parameters (`inline`), while
+* `pathParamsType` controls how path params render in inline mode. Provide a `resolver` for type
+* name resolution and `extraParams` for plugin-specific trailing parameters such as an `options` object.
+*/
+function createOperationParams(node, options) {
+	const { paramsType, pathParamsType, paramsCasing, resolver, pathParamsDefault, extraParams = [], paramNames, typeWrapper } = options;
+	const dataName = paramNames?.data ?? "data";
+	const paramsName = paramNames?.params ?? "params";
+	const headersName = paramNames?.headers ?? "headers";
+	const pathName = paramNames?.path ?? "pathParams";
+	const wrapType = (type) => typeWrapper ? typeWrapper(type) : type;
+	const wrapTypeExpression = (type) => typeof type === "string" ? wrapType(type) : type;
+	const casedParams = caseParams(node.parameters, paramsCasing);
+	const pathParams = casedParams.filter((p) => p.in === "path");
+	const queryParams = casedParams.filter((p) => p.in === "query");
+	const headerParams = casedParams.filter((p) => p.in === "header");
+	const toProperty = (param) => ({
+		name: param.name,
+		type: wrapTypeExpression(resolveParamType({
+			node,
+			param,
+			resolver
+		})),
+		optional: !param.required
+	});
+	const emptyObjectDefault = (props) => props.every((p) => p.optional) ? "{}" : void 0;
+	const bodyType = node.requestBody?.content?.[0]?.schema ? wrapType(resolver?.resolveDataName(node) ?? "unknown") : void 0;
+	const bodyProperty = bodyType ? [{
+		name: dataName,
+		type: bodyType,
+		optional: !(node.requestBody?.required ?? false)
+	}] : [];
+	const trailingGroups = [{
+		name: paramsName,
+		node,
+		params: queryParams,
+		groupType: resolveGroupType({
+			node,
+			params: queryParams,
+			group: "query",
+			resolver
+		}),
+		resolver,
+		wrapType
+	}, {
+		name: headersName,
+		node,
+		params: headerParams,
+		groupType: resolveGroupType({
+			node,
+			params: headerParams,
+			group: "header",
+			resolver
+		}),
+		resolver,
+		wrapType
+	}];
+	const params = [];
+	if (paramsType === "object") {
+		const children = [
+			...pathParams.map(toProperty),
+			...bodyProperty,
+			...trailingGroups.flatMap(buildGroupProperty)
+		];
+		if (children.length) params.push(createFunctionParameter({
+			properties: children,
+			default: emptyObjectDefault(children)
+		}));
+	} else {
+		if (pathParamsType === "inlineSpread" && pathParams.length) {
+			const spreadType = resolver?.resolvePathParamsName(node, pathParams[0]);
+			params.push(createFunctionParameter({
+				name: pathName,
+				type: spreadType ? wrapType(spreadType) : void 0,
+				rest: true
+			}));
+		} else if (pathParamsType === "inline") params.push(...pathParams.map((p) => createFunctionParameter(toProperty(p))));
+		else if (pathParams.length) {
+			const pathChildren = pathParams.map(toProperty);
+			params.push(createFunctionParameter({
+				properties: pathChildren,
+				default: pathParamsDefault ?? emptyObjectDefault(pathChildren)
+			}));
+		}
+		params.push(...bodyProperty.map((p) => createFunctionParameter(p)));
+		params.push(...trailingGroups.flatMap(buildGroupParam));
+	}
+	params.push(...extraParams);
+	return createFunctionParameters({ params });
+}
+/**
+* Builds the property descriptor for a query or header group.
+* Returns an empty array when there are no params to emit.
 *
-* @example
-* ```ts
-* createBreak()
-* // { kind: 'Break' }
-* ```
+* A pre-resolved `groupType` emits `name: GroupType`. Otherwise it builds an inline
+* {@link TypeLiteralNode} from the individual params.
 */
-function createBreak() {
-	return { kind: "Break" };
+function buildGroupProperty({ name, node, params, groupType, resolver, wrapType }) {
+	if (groupType) return [{
+		name,
+		type: typeof groupType.type === "string" ? wrapType(groupType.type) : groupType.type,
+		optional: groupType.optional
+	}];
+	if (params.length) return [{
+		name,
+		type: buildTypeLiteral({
+			node,
+			params,
+			resolver
+		}),
+		optional: params.every((p) => !p.required)
+	}];
+	return [];
 }
 /**
-* Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
+* Builds a single {@link FunctionParameterNode} for a query or header group.
+* Returns an empty array when there are no params to emit.
 *
-* Use this to embed JSX markup (including fragments `<>…</>`) directly in generated code.
+* A pre-resolved `groupType` emits `name: GroupType`. Otherwise it builds an inline
+* {@link TypeLiteralNode} from the individual params.
+*/
+function buildGroupParam(args) {
+	return buildGroupProperty(args).map((p) => createFunctionParameter(p));
+}
+/**
+* Derives a {@link ParamGroupType} for a query or header group from the resolver.
 *
-* @example
-* ```ts
-* createJsx('<>\n  <a href={href}>Open</a>\n</>')
-* // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
-* ```
+* Returns `null` when there is no resolver, no params, or the group name equals the
+* individual param name (so there is no real group to emit).
 */
-function createJsx(value) {
+function resolveGroupType({ node, params, group, resolver }) {
+	if (!resolver || !params.length) return null;
+	const firstParam = params[0];
+	const groupName = (group === "query" ? resolver.resolveQueryParamsName : resolver.resolveHeaderParamsName).call(resolver, node, firstParam);
+	if (groupName === resolver.resolveParamName(node, firstParam)) return null;
 	return {
-		value,
-		kind: "Jsx"
+		type: groupName,
+		optional: params.every((p) => !p.required)
 	};
 }
-//#endregion
-//#region src/signature.ts
 /**
-* The flags shared by every node kind that affect its type: `primitive`, `format`, `nullable`.
+* Builds a {@link TypeLiteralNode} for an inline anonymous type grouping named fields.
+*
+* Used when query or header parameters have no dedicated group type name.
+* Each language printer renders this appropriately (TypeScript: `{ petId: string; name?: string }`).
 */
-function flagsDescriptor(node) {
-	return `${node.primitive ?? ""};${node.format ?? ""};${node.nullable ? 1 : 0}`;
+function buildTypeLiteral({ node, params, resolver }) {
+	return createTypeLiteral({ members: params.map((p) => ({
+		name: p.name,
+		type: resolveParamType({
+			node,
+			param: p,
+			resolver
+		}),
+		optional: !p.required
+	})) });
 }
-function refTargetName(node) {
-	if (node.ref) return extractRefName(node.ref);
-	return node.name ?? "";
+function sourceKey(source) {
+	return `${source.name ?? extractStringsFromNodes(source.nodes)}:${source.isExportable ?? false}:${source.isTypeOnly ?? false}`;
+}
+function pathTypeKey(path, isTypeOnly) {
+	return `${path}:${isTypeOnly ?? false}`;
+}
+function exportKey(path, name, isTypeOnly, asAlias) {
+	return `${path}:${name ?? ""}:${isTypeOnly ?? false}:${asAlias ?? ""}`;
+}
+function importKey(path, name, isTypeOnly) {
+	return `${path}:${name ?? ""}:${isTypeOnly ?? false}`;
 }
-const arrayTupleFields = [
-	{
-		kind: "children",
-		key: "items",
-		prefix: "i"
-	},
-	{
-		kind: "child",
-		key: "rest",
-		prefix: "r"
-	},
-	{
-		kind: "scalar",
-		key: "min",
-		prefix: "mn"
-	},
-	{
-		kind: "scalar",
-		key: "max",
-		prefix: "mx"
-	},
-	{
-		kind: "bool",
-		key: "unique",
-		prefix: "u"
-	}
-];
-const numericFields = [
-	{
-		kind: "scalar",
-		key: "min",
-		prefix: "mn"
-	},
-	{
-		kind: "scalar",
-		key: "max",
-		prefix: "mx"
-	},
-	{
-		kind: "scalar",
-		key: "exclusiveMinimum",
-		prefix: "emn"
-	},
-	{
-		kind: "scalar",
-		key: "exclusiveMaximum",
-		prefix: "emx"
-	},
-	{
-		kind: "scalar",
-		key: "multipleOf",
-		prefix: "mo"
-	}
-];
-const rangeFields = [{
-	kind: "scalar",
-	key: "min",
-	prefix: "mn"
-}, {
-	kind: "scalar",
-	key: "max",
-	prefix: "mx"
-}];
 /**
-* Maps each node `type` to its ordered shape-contributing fields. Types absent from the map
-* (boolean, null, any, and other scalars) fall back to `${type}|${flags}`.
+* 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.
 */
-const SHAPE_KEYS = {
-	object: [
-		{ kind: "objectProps" },
-		{ kind: "additionalProps" },
-		{ kind: "patternProps" },
-		{
-			kind: "scalar",
-			key: "minProperties",
-			prefix: "mn"
-		},
-		{
-			kind: "scalar",
-			key: "maxProperties",
-			prefix: "mx"
-		}
-	],
-	array: arrayTupleFields,
-	tuple: arrayTupleFields,
-	union: [
-		{
-			kind: "scalar",
-			key: "strategy",
-			prefix: "s"
-		},
-		{
-			kind: "scalar",
-			key: "discriminatorPropertyName",
-			prefix: "d"
-		},
-		{
-			kind: "children",
-			key: "members",
-			prefix: "m"
-		}
-	],
-	intersection: [{
-		kind: "children",
-		key: "members",
-		prefix: "m"
-	}],
-	enum: [{ kind: "enumValues" }],
-	ref: [{ kind: "refTarget" }],
-	string: [
-		{
-			kind: "scalar",
-			key: "min",
-			prefix: "mn"
-		},
-		{
-			kind: "scalar",
-			key: "max",
-			prefix: "mx"
-		},
-		{
-			kind: "scalar",
-			key: "pattern",
-			prefix: "pt"
-		}
-	],
-	number: numericFields,
-	integer: numericFields,
-	bigint: numericFields,
-	url: [
-		{
-			kind: "scalar",
-			key: "path",
-			prefix: "path"
-		},
-		{
-			kind: "scalar",
-			key: "min",
-			prefix: "mn"
-		},
-		{
-			kind: "scalar",
-			key: "max",
-			prefix: "mx"
-		}
-	],
-	uuid: rangeFields,
-	email: rangeFields,
-	datetime: [{
-		kind: "bool",
-		key: "offset",
-		prefix: "o"
-	}, {
-		kind: "bool",
-		key: "local",
-		prefix: "l"
-	}],
-	date: [{
-		kind: "scalar",
-		key: "representation",
-		prefix: "rep"
-	}],
-	time: [{
-		kind: "scalar",
-		key: "representation",
-		prefix: "rep"
-	}]
-};
-function serializeShapeField(field, node, record) {
-	switch (field.kind) {
-		case "scalar": return `${field.prefix}:${record[field.key] ?? ""}`;
-		case "bool": return `${field.prefix}:${record[field.key] ? 1 : 0}`;
-		case "child": {
-			const child = record[field.key];
-			return `${field.prefix}:${child ? signatureOf(child) : ""}`;
-		}
-		case "children": {
-			const children = record[field.key] ?? [];
-			return `${field.prefix}[${children.map((c) => signatureOf(c)).join(",")}]`;
+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}`;
+}
+/**
+* Deduplicates and merges `SourceNode` objects by `name + isExportable + isTypeOnly`.
+*
+* Unnamed sources are deduplicated by object reference. Returns a deduplicated array in original order.
+*/
+function combineSources(sources) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		const key = sourceKey(source);
+		if (!seen.has(key)) seen.set(key, source);
+	}
+	return [...seen.values()];
+}
+/**
+* Merges `incoming` names into `existing`, preserving order and dropping duplicates.
+*
+* Shared by `combineExports` and `combineImports` for the same-path name-merge case.
+*/
+function mergeNameArrays(existing, incoming) {
+	const merged = new Set(existing);
+	for (const name of incoming) merged.add(name);
+	return [...merged];
+}
+/**
+* Deduplicates and merges `ExportNode` objects by path and type.
+*
+* Named exports with the same path and `isTypeOnly` flag have their names merged into a single export.
+* Non-array exports are deduplicated by exact identity. Returns a sorted, deduplicated array.
+*/
+function combineExports(exports) {
+	const result = [];
+	const namedByPath = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	const keyed = exports.map((node) => ({
+		node,
+		key: sortKey(node)
+	}));
+	keyed.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+	for (const { node: curr } of keyed) {
+		const { name, path, isTypeOnly, asAlias } = curr;
+		if (Array.isArray(name)) {
+			if (!name.length) continue;
+			const key = pathTypeKey(path, isTypeOnly);
+			const existing = namedByPath.get(key);
+			if (existing && Array.isArray(existing.name)) existing.name = mergeNameArrays(existing.name, name);
+			else {
+				const newItem = {
+					...curr,
+					name: [...new Set(name)]
+				};
+				result.push(newItem);
+				namedByPath.set(key, newItem);
+			}
+		} else {
+			const key = exportKey(path, name, isTypeOnly, asAlias);
+			if (!seen.has(key)) {
+				result.push(curr);
+				seen.add(key);
+			}
 		}
-		case "objectProps": return `p[${(node.properties ?? []).map((prop) => `${prop.name}${prop.required ? "!" : "?"}${signatureOf(prop.schema)}`).join(",")}]`;
-		case "additionalProps": {
-			const obj = node;
-			if (typeof obj.additionalProperties === "boolean") return `ab:${obj.additionalProperties}`;
-			if (obj.additionalProperties) return `as:${signatureOf(obj.additionalProperties)}`;
-			return "";
+	}
+	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.
+*
+* @note Use this when combining imports from multiple files to avoid duplicate declarations.
+*/
+function combineImports(imports, exports, source) {
+	const exportedNames = new Set(exports.flatMap((e) => Array.isArray(e.name) ? e.name : e.name ? [e.name] : []));
+	const isUsed = (importName) => !source || 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)) continue;
+		if (node.name.some((item) => typeof item === "string" ? isUsed(item) : isUsed(item.name ?? item.propertyName))) pathsWithUsedNamedImport.add(node.path);
+	}
+	const result = [];
+	const namedByPath = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	const keyed = imports.map((node) => ({
+		node,
+		key: sortKey(node)
+	}));
+	keyed.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+	for (const { node: curr } of keyed) {
+		if (curr.path === curr.root) continue;
+		const { path, isTypeOnly } = curr;
+		let { name } = curr;
+		if (Array.isArray(name)) {
+			name = [...new Set(name.map(canonicalizeName))].filter((item) => typeof item === "string" ? isUsed(item) : isUsed(item.name ?? item.propertyName));
+			if (!name.length) continue;
+			const key = pathTypeKey(path, isTypeOnly);
+			const existing = namedByPath.get(key);
+			if (existing && Array.isArray(existing.name)) existing.name = mergeNameArrays(existing.name, name);
+			else {
+				const newItem = {
+					...curr,
+					name
+				};
+				result.push(newItem);
+				namedByPath.set(key, newItem);
+			}
+		} else {
+			if (name && !isUsed(name) && !pathsWithUsedNamedImport.has(path)) continue;
+			const key = importKey(path, name, isTypeOnly);
+			if (!seen.has(key)) {
+				result.push(curr);
+				seen.add(key);
+			}
 		}
-		case "patternProps": {
-			const obj = node;
-			return `pp[${obj.patternProperties ? Object.keys(obj.patternProperties).sort().map((key) => `${key}=${signatureOf(obj.patternProperties[key])}`).join(",") : ""}]`;
+	}
+	return result;
+}
+/**
+* Extracts all string content from a `CodeNode` tree recursively.
+*
+* Collects text node values, identifier references in string fields (`params`, `generics`, `returnType`, `type`),
+* and nested node content. Used internally to build the full source string for import filtering.
+*/
+function extractStringsFromNodes(nodes) {
+	if (!nodes?.length) return "";
+	return nodes.map((node) => {
+		if (typeof node === "string") return node;
+		if (node.kind === "Text") return node.value;
+		if (node.kind === "Break") return "";
+		if (node.kind === "Jsx") return node.value;
+		const parts = [];
+		if ("params" in node && node.params) parts.push(node.params);
+		if ("generics" in node && node.generics) parts.push(Array.isArray(node.generics) ? node.generics.join(", ") : node.generics);
+		if ("returnType" in node && node.returnType) parts.push(node.returnType);
+		if ("type" in node && typeof node.type === "string") parts.push(node.type);
+		const nested = extractStringsFromNodes(node.nodes);
+		if (nested) parts.push(nested);
+		return parts.join("\n");
+	}).filter(Boolean).join("\n");
+}
+/**
+* Resolves the schema name of a ref node, falling back through `ref` → `name` → nested `schema.name`.
+*
+* Returns `null` for non-ref nodes or when no name can be resolved. Use this to get a schema's
+* identifier for type definitions or error messages.
+*
+* @example
+* ```ts
+* resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Pet' })
+* // => 'Pet'
+* ```
+*/
+function resolveRefName(node) {
+	if (!node || node.type !== "ref") return null;
+	if (node.ref) return extractRefName(node.ref) ?? node.name ?? node.schema?.name ?? null;
+	return node.name ?? node.schema?.name ?? null;
+}
+/**
+* Collects every named schema referenced (transitively) from a node via ref edges.
+*
+* Refs are followed by name only, the resolved `node.schema` is not traversed inline.
+* Use this to determine schema dependencies, build reference graphs, or detect what schemas need to be emitted.
+*
+* @example Collect refs from a single schema
+* ```ts
+* const names = collectReferencedSchemaNames(petSchema)
+* // → Set { 'Category', 'Tag' }
+* ```
+*
+* @example Accumulate refs from multiple schemas into one set
+* ```ts
+* const out = new Set<string>()
+* for (const schema of schemas) {
+*   collectReferencedSchemaNames(schema, out)
+* }
+* ```
+*/
+const collectSchemaRefs = memoize(/* @__PURE__ */ new WeakMap(), (node) => {
+	const refs = /* @__PURE__ */ new Set();
+	collect(node, { schema(child) {
+		if (child.type === "ref") {
+			const name = resolveRefName(child);
+			if (name) refs.add(name);
 		}
-		case "enumValues": {
-			const en = node;
-			let values = "";
-			if (en.namedEnumValues?.length) values = en.namedEnumValues.map((entry) => `${entry.name}=${entry.primitive}:${String(entry.value)}`).join(",");
-			else if (en.enumValues?.length) values = en.enumValues.map((value) => `${value === null ? "null" : typeof value}:${String(value)}`).join(",");
-			return `v[${values}]`;
+	} });
+	return refs;
+});
+function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
+	if (!node) return out;
+	for (const name of collectSchemaRefs(node)) out.add(name);
+	return out;
+}
+/**
+* Collects the names of all top-level schemas transitively used by a set of operations.
+*
+* An operation uses a schema when any of its parameters, request body content, or responses
+* reference it, directly or indirectly through other named schemas.
+* The walk is iterative and safe against reference cycles.
+*
+* Use this together with `include` filters to determine which schemas from `components/schemas`
+* are reachable from the allowed operations, so that schemas used only by excluded operations
+* are not generated.
+*
+* @example Only generate schemas referenced by included operations
+* ```ts
+* const includedOps = operations.filter(op => resolver.resolveOptions(op, { options, include }) !== null)
+* const allowed = collectUsedSchemaNames(includedOps, schemas)
+*
+* for (const schema of schemas) {
+*   if (schema.name && !allowed.has(schema.name)) continue
+*   // … generate schema
+* }
+* ```
+*
+* @example Check whether a specific schema is needed
+* ```ts
+* const allowed = collectUsedSchemaNames(includedOps, schemas)
+* allowed.has('OrderStatus') // false when no included operation references OrderStatus
+* ```
+*/
+const collectUsedSchemaNamesMemo = memoize(/* @__PURE__ */ new WeakMap(), (ops) => memoize(/* @__PURE__ */ new WeakMap(), (schemas) => computeUsedSchemaNames(ops, schemas)));
+function computeUsedSchemaNames(operations, schemas) {
+	const schemaMap = /* @__PURE__ */ new Map();
+	for (const schema of schemas) if (schema.name) schemaMap.set(schema.name, schema);
+	const result = /* @__PURE__ */ new Set();
+	function visitSchema(schema) {
+		const directRefs = collectReferencedSchemaNames(schema);
+		for (const name of directRefs) if (!result.has(name)) {
+			result.add(name);
+			const namedSchema = schemaMap.get(name);
+			if (namedSchema) visitSchema(namedSchema);
 		}
-		case "refTarget": return `->${refTargetName(node)}`;
 	}
+	for (const op of operations) for (const schema of collectLazy(op, {
+		depth: "shallow",
+		schema: (node) => node
+	})) visitSchema(schema);
+	return result;
 }
+function collectUsedSchemaNames(operations, schemas) {
+	return collectUsedSchemaNamesMemo(operations)(schemas);
+}
+const EMPTY_CIRCULAR_SET = /* @__PURE__ */ new Set();
+const findCircularSchemasMemo = memoize(/* @__PURE__ */ new WeakMap(), (schemas) => {
+	const graph = /* @__PURE__ */ new Map();
+	for (const schema of schemas) {
+		if (!schema.name) continue;
+		graph.set(schema.name, collectReferencedSchemaNames(schema));
+	}
+	const circular = /* @__PURE__ */ new Set();
+	for (const start of graph.keys()) {
+		const visited = /* @__PURE__ */ new Set();
+		const stack = [...graph.get(start) ?? []];
+		while (stack.length > 0) {
+			const node = stack.pop();
+			if (node === start) {
+				circular.add(start);
+				break;
+			}
+			if (visited.has(node)) continue;
+			visited.add(node);
+			const next = graph.get(node);
+			if (next) for (const r of next) stack.push(r);
+		}
+	}
+	return circular;
+});
 /**
-* Builds the local shape descriptor that {@link signatureOf} hashes: the node's kind, flags,
-* constraints, and its children's signatures.
+* Identifies all schemas that participate in circular dependency chains, including direct self-loops.
+*
+* Returns a Set of schema names with circular dependencies. Use this to wrap recursive schema positions
+* in deferred constructs (lazy getter, `z.lazy(() => …)`) to prevent infinite recursion when generated code runs.
+* Refs are followed by name only, keeping the algorithm linear in the schema graph size.
+*
+* @note Call this once on the full schema graph, then use `containsCircularRef()` to check individual schemas.
 */
-function describeShape(node) {
-	const flags = flagsDescriptor(node);
-	const fields = SHAPE_KEYS[node.type];
-	if (!fields) return `${node.type}|${flags}`;
-	const record = node;
-	const parts = [`${node.type}|${flags}`];
-	for (const field of fields) parts.push(serializeShapeField(field, node, record));
-	return parts.join("|");
+function findCircularSchemas(schemas) {
+	if (schemas.length === 0) return EMPTY_CIRCULAR_SET;
+	return findCircularSchemasMemo(schemas);
 }
 /**
-* Node → digest cache, keyed by identity. A `WeakMap` so entries die with the node, and so a tree
-* hashed during dedupe planning is not walked again when it is rewritten during streaming. Reuse
-* is safe because a signature depends only on content, and nodes are immutable once created.
-*/
-const signatureCache = /* @__PURE__ */ new WeakMap();
-/**
-* Computes a deterministic, shape-only signature (a content hash) for a schema node. Two schemas
-* share a signature when they are structurally identical, ignoring documentation (`name`, `title`,
-* `description`, `example`, `default`, `deprecated`) and usage-slot flags (`optional`, `nullish`,
-* `readOnly`, `writeOnly`). `nullable` is kept because it changes the produced type, and `ref`
-* nodes compare by target name, which also terminates on circular shapes.
+* Type guard returning `true` when a schema or anything nested within it contains a ref to a circular schema.
 *
-* @example Two enums with different descriptions share a signature
-* ```ts
-* signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'], description: 'x' })) ===
-*   signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'] }))
-* ```
+* Use `excludeName` to ignore refs to specific schemas (useful when self-references are handled separately).
+* Commonly used with `findCircularSchemas()` to detect where lazy wrappers are needed in code generation.
+*
+* @note Returns `true` for the first matching circular ref found. Use for fast dependency checks.
 */
-function signatureOf(node) {
-	const cached = signatureCache.get(node);
-	if (cached !== void 0) return cached;
-	const signature = hash("sha256", describeShape(node), "hex");
-	signatureCache.set(node, signature);
-	return signature;
+function containsCircularRef(node, { circularSchemas, excludeName }) {
+	if (!node || circularSchemas.size === 0) return false;
+	for (const _ of collectLazy(node, { schema(child) {
+		if (child.type !== "ref") return null;
+		const name = resolveRefName(child);
+		return name && name !== excludeName && circularSchemas.has(name) ? true : null;
+	} })) return true;
+	return false;
 }
 //#endregion
-//#region src/dedupe.ts
-/**
-* Builds the shared `ref` replacement for a duplicate occurrence, carrying the
-* usage-slot and documentation fields that are not part of the canonical type.
-*/
-function createRefNode(node, canonical) {
-	return createSchema({
-		type: "ref",
-		name: canonical.name,
-		ref: canonical.ref,
-		optional: node.optional,
-		nullish: node.nullish,
-		readOnly: node.readOnly,
-		writeOnly: node.writeOnly,
-		deprecated: node.deprecated,
-		description: node.description,
-		default: node.default,
-		example: node.example
-	});
-}
-function applyDedupe(node, plan, skipRootMatch = false) {
-	const { canonicalBySignature, aliasNames } = plan;
-	if (canonicalBySignature.size === 0 && aliasNames.size === 0) return node;
-	const root = node;
-	return transform(node, { schema(schemaNode) {
-		if (schemaNode.type === "ref") {
-			const target = schemaNode.ref ? extractRefName(schemaNode.ref) : schemaNode.name;
-			const canonical = target ? aliasNames.get(target) : void 0;
-			return canonical ? {
-				...schemaNode,
-				name: canonical.name,
-				ref: canonical.ref
-			} : void 0;
-		}
-		const signature = signatureOf(schemaNode);
-		if (skipRootMatch && schemaNode === root) return void 0;
-		const canonical = canonicalBySignature.get(signature);
-		if (!canonical) return void 0;
-		return createRefNode(schemaNode, canonical);
-	} });
-}
-/**
-* Strips usage-slot flags from a hoisted definition and applies its canonical name.
-* A standalone definition is never optional, so `optional`/`nullish` are cleared.
-*/
-function cleanDefinition(node, name) {
-	return {
-		...node,
-		name,
-		optional: void 0,
-		nullish: void 0
-	};
-}
+//#region src/factory.ts
 /**
-* Scans a forest of schema and operation nodes and produces a {@link DedupePlan}.
+* Identity-preserving node update: returns `node` unchanged when every field in
+* `changes` already equals (by reference) the current value, otherwise a new node
+* with the changes applied.
 *
-* A shape that occurs at least `minOccurrences` times is deduplicated: if any occurrence
-* is a named top-level schema, the first one becomes the canonical (so other top-level
-* duplicates and inline copies turn into references to it). Every other top-level name with
-* the same content is recorded in `aliasNames`, so refs to it can be repointed at the
-* canonical. Otherwise a new definition is hoisted using `nameFor`. The plan is then applied
-* per node with {@link applyDedupe}.
+* Mirrors the TypeScript compiler's `factory.updateX` contract, pair it with the
+* structural sharing in {@link transform} so a no-op rewrite doesn't allocate and
+* downstream passes can detect "nothing changed" by identity. Comparison is
+* shallow: a structurally-equal but newly-allocated array/object counts as a change.
 *
 * @example
 * ```ts
-* const plan = buildDedupePlan([...schemaNodes, ...operationNodes], {
-*   isCandidate: (node) => node.type === 'enum' || node.type === 'object',
-*   nameFor: (node) => node.name ?? null,
-*   refFor: (name) => `#/components/schemas/${name}`,
-* })
+* update(node, { name: node.name })        // -> same `node` reference
+* update(node, { name: 'renamed' })        // -> new node, `name` replaced
 * ```
 */
-function buildDedupePlan(roots, options) {
-	const { isCandidate, nameFor, refFor, minOccurrences = 2 } = options;
-	const topLevelNodes = /* @__PURE__ */ new Set();
-	const groups = /* @__PURE__ */ new Map();
-	function record(schemaNode) {
-		const signature = signatureOf(schemaNode);
-		if (!isCandidate(schemaNode)) return;
-		const isTopLevel = topLevelNodes.has(schemaNode) && !!schemaNode.name;
-		const group = groups.get(signature);
-		if (group) {
-			group.count++;
-			if (isTopLevel) group.topLevelNames.push(schemaNode.name);
-		} else groups.set(signature, {
-			count: 1,
-			representative: schemaNode,
-			topLevelNames: isTopLevel ? [schemaNode.name] : []
-		});
-	}
-	for (const root of roots) {
-		if (root.kind === "Schema") topLevelNodes.add(root);
-		for (const schemaNode of collectLazy(root, { schema: (node) => node })) record(schemaNode);
-	}
-	const canonicalBySignature = /* @__PURE__ */ new Map();
-	const aliasNames = /* @__PURE__ */ new Map();
-	const pendingHoists = [];
-	for (const [signature, group] of groups) {
-		if (group.count < minOccurrences) continue;
-		const [firstName, ...duplicateNames] = group.topLevelNames;
-		if (firstName) {
-			const canonical = {
-				name: firstName,
-				ref: refFor(firstName)
-			};
-			canonicalBySignature.set(signature, canonical);
-			for (const duplicate of duplicateNames) aliasNames.set(duplicate, canonical);
-			continue;
-		}
-		const name = nameFor(group.representative, signature);
-		if (!name) continue;
-		canonicalBySignature.set(signature, {
-			name,
-			ref: refFor(name)
-		});
-		pendingHoists.push({
-			name,
-			representative: group.representative
-		});
-	}
-	return {
-		canonicalBySignature,
-		aliasNames,
-		hoisted: pendingHoists.map(({ name, representative }) => cleanDefinition(applyDedupe(representative, {
-			canonicalBySignature,
-			aliasNames
-		}, true), name))
+function update(node, changes) {
+	for (const key in changes) if (changes[key] !== node[key]) return {
+		...node,
+		...changes
 	};
+	return node;
 }
-//#endregion
-//#region src/dialect.ts
 /**
-* Types a {@link SchemaDialect} for an adapter. Adds no runtime behavior and only pins the
-* dialect's type for inference.
+* Creates a fully resolved `FileNode` from a file input descriptor.
+*
+* Computes:
+* - `id` SHA256 hash of the file path
+* - `name` `baseName` without extension
+* - `extname` extension extracted from `baseName`
+*
+* Deduplicates:
+* - `sources` via `combineSources`
+* - `exports` via `combineExports`
+* - `imports` via `combineImports` (also filters unused imports)
+*
+* @throws {Error} when `baseName` has no extension.
 *
 * @example
 * ```ts
-* export const oasDialect = defineSchemaDialect({
-*   name: 'oas',
-*   isNullable,
-*   isReference,
-*   isDiscriminator,
-*   isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',
-*   resolveRef,
+* const file = createFile({
+*   baseName: 'petStore.ts',
+*   path: 'src/models/petStore.ts',
+*   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')] })],
+*   imports: [createImport({ name: ['z'], path: 'zod' })],
+*   exports: [createExport({ name: ['Pet'], path: './petStore' })],
 * })
+* // file.id      = SHA256 hash of 'src/models/petStore.ts'
+* // file.name    = 'petStore'
+* // file.extname = '.ts'
 * ```
 */
-function defineSchemaDialect(dialect) {
-	return dialect;
+function createFile(input) {
+	const extname = path.extname(input.baseName) || (input.baseName.startsWith(".") ? input.baseName : "");
+	if (!extname) throw new Error(`No extname found for ${input.baseName}`);
+	const source = (input.sources ?? []).flatMap((item) => item.nodes ?? []).map((node) => extractStringsFromNodes([node])).filter(Boolean).join("\n\n");
+	const resolvedExports = input.exports?.length ? combineExports(input.exports) : [];
+	const combinedImports = input.imports?.length ? combineImports(input.imports, resolvedExports, source || void 0) : [];
+	const localNames = new Set((input.sources ?? []).map((item) => item.name).filter((name) => Boolean(name)));
+	const nameOf = (item) => typeof item === "string" ? item : item.name ?? item.propertyName;
+	const resolvedImports = combinedImports.filter((imp) => imp.path !== input.path).flatMap((imp) => {
+		if (!Array.isArray(imp.name)) return typeof imp.name === "string" && localNames.has(imp.name) ? [] : [imp];
+		const kept = imp.name.filter((item) => !localNames.has(nameOf(item)));
+		if (!kept.length) return [];
+		return [kept.length === imp.name.length ? imp : {
+			...imp,
+			name: kept
+		}];
+	});
+	const resolvedSources = input.sources?.length ? combineSources(input.sources) : [];
+	return {
+		kind: "File",
+		...input,
+		id: hash("sha256", input.path, "hex"),
+		name: trimExtName(input.baseName),
+		extname,
+		imports: resolvedImports,
+		exports: resolvedExports,
+		sources: resolvedSources,
+		meta: input.meta ?? {}
+	};
 }
 //#endregion
 //#region src/printer.ts
@@ -2279,6 +2221,6 @@ function setEnumName(propNode, parentName, propName, enumSuffix) {
 	return propNode;
 }
 //#endregion
-export { applyDedupe, buildDedupePlan, caseParams, collect, collectUsedSchemaNames, containsCircularRef, createArrowFunction, createBreak, createConst, createDiscriminantNode, createExport, createFile, createFunction, createFunctionParameter, createFunctionParameters, createImport, createInput, createJsx, createOperation, createOperationParams, createOutput, createParameter, createParameterGroup, createParamsType, createPrinterFactory, createProperty, createResponse, createSchema, createSource, createStreamInput, createText, createType, definePrinter, defineSchemaDialect, extractStringsFromNodes, findCircularSchemas, httpMethods, isHttpOperationNode, isInputNode, isOperationNode, isOutputNode, isSchemaNode, isStringType, mergeAdjacentObjectsLazy, narrowSchema, schemaTypes, setDiscriminatorEnum, setEnumName, signatureOf, simplifyUnion, syncOptionality, syncSchemaRef, transform, update, walk };
+export { applyDedupe, arrowFunctionDef, breakDef, buildDedupePlan, caseParams, collect, collectUsedSchemaNames, constDef, containsCircularRef, contentDef, createArrowFunction, createBreak, createConst, createDiscriminantNode, createExport, createFile, createFunction, createFunctionParameter, createFunctionParameters, createImport, createIndexedAccessType, createInput, createJsx, createObjectBindingPattern, createOperation, createOperationParams, createOutput, createParameter, createPrinterFactory, createProperty, createResponse, createSchema, createSource, createStreamInput, createText, createType, createTypeLiteral, defineNode, definePrinter, defineSchemaDialect, exportDef, extractStringsFromNodes, fileDef, findCircularSchemas, functionDef, functionParameterDef, functionParametersDef, httpMethods, importDef, indexedAccessTypeDef, inputDef, isHttpOperationNode, isStringType, jsxDef, mergeAdjacentObjectsLazy, narrowSchema, objectBindingPatternDef, operationDef, outputDef, parameterDef, propertyDef, requestBodyDef, responseDef, schemaDef, schemaTypes, setDiscriminatorEnum, setEnumName, signatureOf, simplifyUnion, sourceDef, syncOptionality, syncSchemaRef, textDef, transform, typeDef, typeLiteralDef, update, walk };
 
 //# sourceMappingURL=index.js.map