@kubb/ast 5.0.0-beta.4 → 5.0.0-beta.40

package/dist/index.cjs

@@ -29,25 +29,6 @@ const visitorDepths = {
 	shallow: "shallow",
 	deep: "deep"
 };
-const nodeKinds = {
-	input: "Input",
-	output: "Output",
-	operation: "Operation",
-	schema: "Schema",
-	property: "Property",
-	parameter: "Parameter",
-	response: "Response",
-	functionParameter: "FunctionParameter",
-	parameterGroup: "ParameterGroup",
-	functionParameters: "FunctionParameters",
-	type: "Type",
-	file: "File",
-	import: "Import",
-	export: "Export",
-	source: "Source",
-	text: "Text",
-	break: "Break"
-};
 /**
 * Schema type discriminators used by all AST schema nodes.
 *
@@ -196,33 +177,6 @@ const httpMethods = {
 	options: "OPTIONS",
 	trace: "TRACE"
 };
-/**
-* Common MIME types used in request/response content negotiation.
-*
-* Covers JSON, XML, form data, PDFs, images, audio, and video formats.
-* Use these as keys when serializing request/response bodies.
-*/
-const mediaTypes = {
-	applicationJson: "application/json",
-	applicationXml: "application/xml",
-	applicationFormUrlEncoded: "application/x-www-form-urlencoded",
-	applicationOctetStream: "application/octet-stream",
-	applicationPdf: "application/pdf",
-	applicationZip: "application/zip",
-	applicationGraphql: "application/graphql",
-	multipartFormData: "multipart/form-data",
-	textPlain: "text/plain",
-	textHtml: "text/html",
-	textCsv: "text/csv",
-	textXml: "text/xml",
-	imagePng: "image/png",
-	imageJpeg: "image/jpeg",
-	imageGif: "image/gif",
-	imageWebp: "image/webp",
-	imageSvgXml: "image/svg+xml",
-	audioMpeg: "audio/mpeg",
-	videoMp4: "video/mp4"
-};
 //#endregion
 //#region ../../internals/utils/src/casing.ts
 /**
@@ -288,6 +242,46 @@ function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
 //#endregion
+//#region ../../internals/utils/src/promise.ts
+/**
+* Wraps `factory` with a keyed cache backed by the provided store.
+*
+* Pass a `WeakMap` for object keys (results are GC-eligible when the key is
+* collected) or a `Map` for primitive keys. For multi-argument functions,
+* nest two `memoize` calls — the outer keyed by the first argument, the
+* inner (created once per outer miss) keyed by the second.
+*
+* Because the cache is owned by the caller, it can be shared, inspected, or
+* cleared independently of the memoized function.
+*
+* @example Single WeakMap key
+* ```ts
+* const cache = new WeakMap<SchemaNode, Set<string>>()
+* const getRefs = memoize(cache, (node) => collectRefs(node))
+* ```
+*
+* @example Single Map key (primitive)
+* ```ts
+* const cache = new Map<string, Resolver>()
+* const getResolver = memoize(cache, (name) => buildResolver(name))
+* ```
+*
+* @example Two-level (object + primitive)
+* ```ts
+* const outer = new WeakMap<Params[], Map<string, Params[]>>()
+* const fn = memoize(outer, (params) => memoize(new Map(), (key) => transform(params, key)))
+* fn(params)('camelcase')
+* ```
+*/
+function memoize(store, factory) {
+	return (key) => {
+		if (store.has(key)) return store.get(key);
+		const value = factory(key);
+		store.set(key, value);
+		return value;
+	};
+}
+//#endregion
 //#region ../../internals/utils/src/reserved.ts
 /**
 * JavaScript and Java reserved words.
@@ -415,11 +409,11 @@ function trimExtName(text) {
 * @example
 * ```ts
 * const schema = createSchema({ type: 'string' })
-* const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | undefined
+* const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | null
 * ```
 */
 function narrowSchema(node, type) {
-	return node?.type === type ? node : void 0;
+	return node?.type === type ? node : null;
 }
 function isKind(kind) {
 	return (node) => node.kind === kind;
@@ -458,6 +452,19 @@ const isOutputNode = isKind("Output");
 */
 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;
+}
+/**
 * Returns `true` when the input is a `SchemaNode`.
 *
 * @example
@@ -468,12 +475,6 @@ const isOperationNode = isKind("Operation");
 * ```
 */
 const isSchemaNode = isKind("Schema");
-isKind("Property");
-isKind("Parameter");
-isKind("Response");
-isKind("FunctionParameter");
-isKind("ParameterGroup");
-isKind("FunctionParameters");
 //#endregion
 //#region src/refs.ts
 /**
@@ -526,53 +527,92 @@ function createLimit(concurrency) {
 		});
 	};
 }
+const visitorKeysByKind = {
+	Input: ["schemas", "operations"],
+	Operation: [
+		"parameters",
+		"requestBody",
+		"responses"
+	],
+	RequestBody: ["content"],
+	Content: ["schema"],
+	Response: ["content"],
+	Schema: [
+		"properties",
+		"items",
+		"members",
+		"additionalProperties"
+	],
+	Property: ["schema"],
+	Parameter: ["schema"]
+};
+/**
+* Returns `true` when `value` is an AST node (an object carrying a `kind`).
+*/
+function isNode(value) {
+	return typeof value === "object" && value !== null && "kind" in value;
+}
 /**
-* Returns the immediate traversable children of `node`.
+* Returns the immediate traversable children of `node` based on {@link VISITOR_KEYS}.
 *
-* For `Schema` nodes, children (`properties`, `items`, `members`, and non-boolean
-* `additionalProperties`) are only included
-* when `recurse` is `true`; shallow mode skips them.
+* `Schema` children are only included when `recurse` is `true`. Shallow mode skips them.
 *
 * @example
 * ```ts
 * const children = getChildren(operationNode, true)
-* // returns parameters, requestBody schema (if present), and responses
-* ```
-*/
-function getChildren(node, recurse) {
-	switch (node.kind) {
-		case "Input": return [...node.schemas, ...node.operations];
-		case "Output": return [];
-		case "Operation": return [
-			...node.parameters,
-			...node.requestBody?.content?.flatMap((c) => c.schema ? [c.schema] : []) ?? [],
-			...node.responses
-		];
-		case "Schema": {
-			const children = [];
-			if (!recurse) return [];
-			if ("properties" in node && node.properties.length > 0) children.push(...node.properties);
-			if ("items" in node && node.items) children.push(...node.items);
-			if ("members" in node && node.members) children.push(...node.members);
-			if ("additionalProperties" in node && node.additionalProperties && node.additionalProperties !== true) children.push(node.additionalProperties);
-			return children;
-		}
-		case "Property": return [node.schema];
-		case "Parameter": return [node.schema];
-		case "Response": return node.schema ? [node.schema] : [];
-		case "FunctionParameter":
-		case "ParameterGroup":
-		case "FunctionParameters":
-		case "Type": return [];
-		default: return [];
+* // returns parameters, the request body, and responses
+* ```
+*/
+function* getChildren(node, recurse) {
+	if (node.kind === "Schema" && !recurse) return;
+	const keys = visitorKeysByKind[node.kind];
+	if (!keys) return;
+	const record = node;
+	for (const key of keys) {
+		const value = record[key];
+		if (Array.isArray(value)) {
+			for (const item of value) if (isNode(item)) yield item;
+		} else if (isNode(value)) yield value;
 	}
 }
 /**
-* Depth-first traversal for side effects. Visitor return values are ignored.
-* Sibling nodes at each level are visited concurrently up to `options.concurrency`
-* (default: `WALK_CONCURRENCY`).
+* 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.
+*/
+const VISITOR_KEY_BY_KIND = {
+	Input: "input",
+	Output: "output",
+	Operation: "operation",
+	Schema: "schema",
+	Property: "property",
+	Parameter: "parameter",
+	Response: "response"
+};
+/**
+* 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
+* 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 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 });
+}
+/**
+* Async depth-first traversal for side effects. Visitor return values are
+* ignored. Use `transform` when you want to rewrite nodes.
+*
+* 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 Log every operation
 * ```ts
 * await walk(root, {
 *   operation(node) {
@@ -581,213 +621,115 @@ function getChildren(node, recurse) {
 * })
 * ```
 *
-* @example
+* @example Only visit the root node
 * ```ts
-* // Visit only the current node
-* await walk(root, { depth: 'shallow', root: () => {} })
+* await walk(root, { depth: 'shallow', input: () => {} })
 * ```
 */
 async function walk(node, options) {
 	return _walk(node, options, (options.depth ?? visitorDepths.deep) === visitorDepths.deep, createLimit(options.concurrency ?? 30), void 0);
 }
 async function _walk(node, visitor, recurse, limit, parent) {
-	switch (node.kind) {
-		case "Input":
-			await limit(() => visitor.input?.(node, { parent }));
-			break;
-		case "Output":
-			await limit(() => visitor.output?.(node, { parent }));
-			break;
-		case "Operation":
-			await limit(() => visitor.operation?.(node, { parent }));
-			break;
-		case "Schema":
-			await limit(() => visitor.schema?.(node, { parent }));
-			break;
-		case "Property":
-			await limit(() => visitor.property?.(node, { parent }));
-			break;
-		case "Parameter":
-			await limit(() => visitor.parameter?.(node, { parent }));
-			break;
-		case "Response":
-			await limit(() => visitor.response?.(node, { parent }));
-			break;
-		case "FunctionParameter":
-		case "ParameterGroup":
-		case "FunctionParameters": break;
-	}
-	const children = getChildren(node, recurse);
-	for (const child of children) await _walk(child, visitor, recurse, limit, node);
+	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;
-	switch (node.kind) {
-		case "Input": {
-			let input = node;
-			const replaced = visitor.input?.(input, { parent });
-			if (replaced) input = replaced;
-			return {
-				...input,
-				schemas: input.schemas.map((s) => transform(s, {
-					...options,
-					parent: input
-				})),
-				operations: input.operations.map((op) => transform(op, {
-					...options,
-					parent: input
-				}))
-			};
-		}
-		case "Output": {
-			let output = node;
-			const replaced = visitor.output?.(output, { parent });
-			if (replaced) output = replaced;
-			return output;
-		}
-		case "Operation": {
-			let op = node;
-			const replaced = visitor.operation?.(op, { parent });
-			if (replaced) op = replaced;
-			return {
-				...op,
-				parameters: op.parameters.map((p) => transform(p, {
-					...options,
-					parent: op
-				})),
-				requestBody: op.requestBody ? {
-					...op.requestBody,
-					content: op.requestBody.content?.map((c) => ({
-						...c,
-						schema: c.schema ? transform(c.schema, {
-							...options,
-							parent: op
-						}) : void 0
-					}))
-				} : void 0,
-				responses: op.responses.map((r) => transform(r, {
-					...options,
-					parent: op
-				}))
-			};
-		}
-		case "Schema": {
-			let schema = node;
-			const replaced = visitor.schema?.(schema, { parent });
-			if (replaced) schema = replaced;
-			const childOptions = {
-				...options,
-				parent: schema
-			};
-			return {
-				...schema,
-				..."properties" in schema && recurse ? { properties: schema.properties.map((p) => transform(p, childOptions)) } : {},
-				..."items" in schema && recurse ? { items: schema.items?.map((i) => transform(i, childOptions)) } : {},
-				..."members" in schema && recurse ? { members: schema.members?.map((m) => transform(m, childOptions)) } : {},
-				..."additionalProperties" in schema && recurse && schema.additionalProperties && schema.additionalProperties !== true ? { additionalProperties: transform(schema.additionalProperties, childOptions) } : {}
-			};
-		}
-		case "Property": {
-			let prop = node;
-			const replaced = visitor.property?.(prop, { parent });
-			if (replaced) prop = replaced;
-			return createProperty({
-				...prop,
-				schema: transform(prop.schema, {
-					...options,
-					parent: prop
-				})
-			});
-		}
-		case "Parameter": {
-			let param = node;
-			const replaced = visitor.parameter?.(param, { parent });
-			if (replaced) param = replaced;
-			return createParameter({
-				...param,
-				schema: transform(param.schema, {
-					...options,
-					parent: param
-				})
+	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;
+}
+/**
+* Per-kind builders rerun after children are rebuilt. `Property`/`Parameter`
+* resync schema optionality against their `required` flag once the schema may
+* have changed.
+*/
+const nodeFinalizers = {
+	Property: (node) => createProperty(node),
+	Parameter: (node) => createParameter(node)
+};
+/**
+* Immutably rebuilds a node's children using {@link VISITOR_KEYS}, transforming
+* each child node and leaving non-node values (e.g. `additionalProperties: true`) intact.
+* `Schema` children are skipped in shallow mode.
+*/
+function transformChildren(node, 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;
 		}
-		case "Response": {
-			let response = node;
-			const replaced = visitor.response?.(response, { parent });
-			if (replaced) response = replaced;
-			return {
-				...response,
-				schema: transform(response.schema, {
-					...options,
-					parent: response
-				})
-			};
-		}
-		case "FunctionParameter":
-		case "ParameterGroup":
-		case "FunctionParameters":
-		case "Type": return node;
-		default: return node;
 	}
+	return updates ? {
+		...node,
+		...updates
+	} : node;
 }
 /**
-* Runs a depth-first synchronous collection pass.
+* Lazy depth-first collection pass. Yields every non-null value returned by
+* the visitor callbacks. Use `collect` for the eager array form.
 *
-* Non-`undefined` values returned by visitor callbacks are appended to the result.
-*
-* @example
+* @example Collect every operationId
 * ```ts
-* const ids = collect(root, {
+* const ids: string[] = []
+* for (const id of collectLazy<string>(root, {
 *   operation(node) {
 *     return node.operationId
 *   },
-* })
-* ```
-*
-* @example
-* ```ts
-* // Collect from only the current node
-* const values = collect(root, { depth: 'shallow', root: () => 'root' })
+* })) {
+*   ids.push(id)
+* }
 * ```
 */
-function collect(node, options) {
+function* collectLazy(node, options) {
 	const { depth, parent, ...visitor } = options;
 	const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep;
-	const results = [];
-	let v;
-	switch (node.kind) {
-		case "Input":
-			v = visitor.input?.(node, { parent });
-			break;
-		case "Output":
-			v = visitor.output?.(node, { parent });
-			break;
-		case "Operation":
-			v = visitor.operation?.(node, { parent });
-			break;
-		case "Schema":
-			v = visitor.schema?.(node, { parent });
-			break;
-		case "Property":
-			v = visitor.property?.(node, { parent });
-			break;
-		case "Parameter":
-			v = visitor.parameter?.(node, { parent });
-			break;
-		case "Response":
-			v = visitor.response?.(node, { parent });
-			break;
-		case "FunctionParameter":
-		case "ParameterGroup":
-		case "FunctionParameters": break;
-	}
-	if (v !== void 0) results.push(v);
-	for (const child of getChildren(node, recurse)) for (const item of collect(child, {
+	const v = applyVisitor(node, visitor, parent);
+	if (v != null) yield v;
+	for (const child of getChildren(node, recurse)) yield* collectLazy(child, {
 		...options,
 		parent: node
-	})) results.push(item);
-	return results;
+	});
+}
+/**
+* Eager depth-first collection pass. Returns an array of every non-null value
+* the visitor callbacks return.
+*
+* @example Collect every operationId
+* ```ts
+* const ids = collect<string>(root, {
+*   operation(node) {
+*     return node.operationId
+*   },
+* })
+* ```
+*/
+function collect(node, options) {
+	return Array.from(collectLazy(node, options));
 }
 //#endregion
 //#region src/utils.ts
@@ -841,15 +783,16 @@ function isStringType(node) {
 * 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.
 */
+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 params.map((param) => {
-		const transformed = casing === "camelcase" || !isValidVarName(param.name) ? camelCase(param.name) : param.name;
-		return {
-			...param,
-			name: transformed
-		};
-	});
+	return caseParamsMemo(params)(casing);
 }
 /**
 * Creates a single-property object schema used as a discriminator literal.
@@ -978,7 +921,7 @@ function createOperationParams(node, options) {
 		}));
 	} else {
 		if (pathParams.length) if (pathParamsType === "inlineSpread") {
-			const spreadType = resolver?.resolvePathParamsName(node, pathParams[0]) ?? void 0;
+			const spreadType = resolver?.resolvePathParamsName(node, pathParams[0]);
 			params.push(createFunctionParameter({
 				name: pathName,
 				type: spreadType ? wrapType(spreadType) : void 0,
@@ -1054,13 +997,13 @@ function buildGroupParam({ name, node, params, groupType, resolver, wrapType })
 }
 /**
 * Derives a {@link ParamGroupType} from the resolver's group method.
-* Returns `undefined` when the group name equals the individual param name (no real group).
+* Returns `null` when the group name equals the individual param name (no real group).
 */
 function resolveGroupType({ node, params, groupMethod, resolver }) {
-	if (!params.length) return;
+	if (!params.length) return null;
 	const firstParam = params[0];
 	const groupName = groupMethod.call(resolver, node, firstParam);
-	if (groupName === resolver.resolveParamName(node, firstParam)) return;
+	if (groupName === resolver.resolveParamName(node, firstParam)) return null;
 	const allOptional = params.every((p) => !p.required);
 	return {
 		type: createParamsType({
@@ -1104,7 +1047,7 @@ function importKey(path, name, isTypeOnly) {
 }
 /**
 * Computes a multi-level sort key for exports and imports:
-* non-array names first (wildcards/namespace aliases); type-only before value; alphabetical path; unnamed before named.
+* non-array names first (wildcards/namespace aliases). Type-only before value. Alphabetical path. Unnamed before named.
 */
 function sortKey(node) {
 	const isArray = Array.isArray(node.name) ? "1" : "0";
@@ -1127,6 +1070,16 @@ function combineSources(sources) {
 	return [...seen.values()];
 }
 /**
+* Merges `incoming` names into `existing`, preserving order and dropping duplicates.
+*
+* Shared by `combineExports` and `combineImports` for the same-path name-merge case.
+*/
+function mergeNameArrays(existing, incoming) {
+	const merged = new Set(existing);
+	for (const name of incoming) merged.add(name);
+	return [...merged];
+}
+/**
 * Deduplicates and merges `ExportNode` objects by path and type.
 *
 * Named exports with the same path and `isTypeOnly` flag have their names merged into a single export.
@@ -1147,11 +1100,8 @@ function combineExports(exports) {
 			if (!name.length) continue;
 			const key = pathTypeKey(path, isTypeOnly);
 			const existing = namedByPath.get(key);
-			if (existing && Array.isArray(existing.name)) {
-				const merged = new Set(existing.name);
-				for (const n of name) merged.add(n);
-				existing.name = [...merged];
-			} else {
+			if (existing && Array.isArray(existing.name)) existing.name = mergeNameArrays(existing.name, name);
+			else {
 				const newItem = {
 					...curr,
 					name: [...new Set(name)]
@@ -1187,6 +1137,11 @@ function combineImports(imports, exports, source) {
 		if (!importNameMemo.has(key)) importNameMemo.set(key, n);
 		return importNameMemo.get(key);
 	};
+	const pathsWithUsedNamedImport = /* @__PURE__ */ new Set();
+	for (const node of imports) {
+		if (!Array.isArray(node.name)) continue;
+		if (node.name.some((item) => typeof item === "string" ? isUsed(item) : isUsed(item.name ?? item.propertyName))) pathsWithUsedNamedImport.add(node.path);
+	}
 	const result = [];
 	const namedByPath = /* @__PURE__ */ new Map();
 	const seen = /* @__PURE__ */ new Set();
@@ -1204,11 +1159,8 @@ function combineImports(imports, exports, source) {
 			if (!name.length) continue;
 			const key = pathTypeKey(path, isTypeOnly);
 			const existing = namedByPath.get(key);
-			if (existing && Array.isArray(existing.name)) {
-				const merged = new Set(existing.name);
-				for (const n of name) merged.add(n);
-				existing.name = [...merged];
-			} else {
+			if (existing && Array.isArray(existing.name)) existing.name = mergeNameArrays(existing.name, name);
+			else {
 				const newItem = {
 					...curr,
 					name
@@ -1217,7 +1169,7 @@ function combineImports(imports, exports, source) {
 				namedByPath.set(key, newItem);
 			}
 		} else {
-			if (name && !isUsed(name)) continue;
+			if (name && !isUsed(name) && !pathsWithUsedNamedImport.has(path)) continue;
 			const key = importKey(path, name, isTypeOnly);
 			if (!seen.has(key)) {
 				result.push(curr);
@@ -1253,7 +1205,7 @@ function extractStringsFromNodes(nodes) {
 /**
 * Resolves the schema name of a ref node, falling back through `ref` → `name` → nested `schema.name`.
 *
-* Returns `undefined` for non-ref nodes or when no name can be resolved. Use this to get a schema's
+* 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
@@ -1263,14 +1215,14 @@ function extractStringsFromNodes(nodes) {
 * ```
 */
 function resolveRefName(node) {
-	if (!node || node.type !== "ref") return void 0;
-	if (node.ref) return extractRefName(node.ref) ?? node.name ?? node.schema?.name ?? void 0;
-	return node.name ?? node.schema?.name ?? void 0;
+	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.
+* 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
@@ -1287,21 +1239,26 @@ function resolveRefName(node) {
 * }
 * ```
 */
-function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
-	if (!node) return 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) out.add(name);
+			if (name) refs.add(name);
 		}
 	} });
+	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.
+* 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`
@@ -1310,10 +1267,10 @@ function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
 *
 * @example Only generate schemas referenced by included operations
 * ```ts
-* const includedOps = inputNode.operations.filter(op => resolver.resolveOptions(op, { options, include }) !== null)
-* const allowed = collectUsedSchemaNames(includedOps, inputNode.schemas)
+* const includedOps = operations.filter(op => resolver.resolveOptions(op, { options, include }) !== null)
+* const allowed = collectUsedSchemaNames(includedOps, schemas)
 *
-* for (const schema of inputNode.schemas) {
+* for (const schema of schemas) {
 *   if (schema.name && !allowed.has(schema.name)) continue
 *   // … generate schema
 * }
@@ -1321,11 +1278,12 @@ function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
 *
 * @example Check whether a specific schema is needed
 * ```ts
-* const allowed = collectUsedSchemaNames(includedOps, inputNode.schemas)
+* const allowed = collectUsedSchemaNames(includedOps, schemas)
 * allowed.has('OrderStatus') // false when no included operation references OrderStatus
 * ```
 */
-function collectUsedSchemaNames(operations, schemas) {
+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();
@@ -1337,22 +1295,17 @@ function collectUsedSchemaNames(operations, schemas) {
 			if (namedSchema) visitSchema(namedSchema);
 		}
 	}
-	for (const op of operations) for (const schema of collect(op, {
+	for (const op of operations) for (const schema of collectLazy(op, {
 		depth: "shallow",
 		schema: (node) => node
 	})) visitSchema(schema);
 	return result;
 }
-/**
-* Identifies all schemas that participate in circular dependency chains, including direct self-loops.
-*
-* Returns a Set of schema names with circular dependencies. Use this to wrap recursive schema positions
-* in deferred constructs (lazy getter, `z.lazy(() => …)`) to prevent infinite recursion when generated code runs.
-* Refs are followed by name only, keeping the algorithm linear in the schema graph size.
-*
-* @note Call this once on the full schema graph, then use `containsCircularRef()` to check individual schemas.
-*/
-function findCircularSchemas(schemas) {
+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;
@@ -1375,6 +1328,19 @@ function findCircularSchemas(schemas) {
 		}
 	}
 	return circular;
+});
+/**
+* Identifies all schemas that participate in circular dependency chains, including direct self-loops.
+*
+* Returns a Set of schema names with circular dependencies. Use this to wrap recursive schema positions
+* in deferred constructs (lazy getter, `z.lazy(() => …)`) to prevent infinite recursion when generated code runs.
+* Refs are followed by name only, keeping the algorithm linear in the schema graph size.
+*
+* @note Call this once on the full schema graph, then use `containsCircularRef()` to check individual schemas.
+*/
+function findCircularSchemas(schemas) {
+	if (schemas.length === 0) return EMPTY_CIRCULAR_SET;
+	return findCircularSchemasMemo(schemas);
 }
 /**
 * Type guard returning `true` when a schema or anything nested within it contains a ref to a circular schema.
@@ -1382,23 +1348,27 @@ function findCircularSchemas(schemas) {
 * 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.
+* @note Returns `true` for the first matching circular ref found. Use for fast dependency checks.
 */
 function containsCircularRef(node, { circularSchemas, excludeName }) {
 	if (!node || circularSchemas.size === 0) return false;
-	return collect(node, { schema(child) {
-		if (child.type !== "ref") return void 0;
+	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 : void 0;
-	} }).length > 0;
+		return name && name !== excludeName && circularSchemas.has(name) ? true : null;
+	} })) return true;
+	return false;
 }
 //#endregion
 //#region src/factory.ts
 /**
-* Syncs property/parameter schema optionality flags from `required` and `schema.nullable`.
+* 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.
 *
-* - `optional` is set for non-required, non-nullable schemas.
-* - `nullish` is set for non-required, nullable schemas.
+* - Non-required + non-nullable → `optional: true`.
+* - Non-required + nullable → `nullish: true`.
+* - Required → both flags cleared.
 */
 function syncOptionality(schema, required) {
 	const nullable = schema.nullable ?? false;
@@ -1409,6 +1379,29 @@ function syncOptionality(schema, required) {
 	};
 }
 /**
+* 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.
+*
+* @example
+* ```ts
+* update(node, { name: node.name })        // -> same `node` reference
+* update(node, { name: 'renamed' })        // -> new node, `name` replaced
+* ```
+*/
+function update(node, changes) {
+	for (const key in changes) if (changes[key] !== node[key]) return {
+		...node,
+		...changes
+	};
+	return node;
+}
+/**
 * Creates an `InputNode` with stable defaults for `schemas` and `operations`.
 *
 * @example
@@ -1427,11 +1420,31 @@ function createInput(overrides = {}) {
 	return {
 		schemas: [],
 		operations: [],
+		meta: {
+			circularNames: [],
+			enumNames: []
+		},
 		...overrides,
 		kind: "Input"
 	};
 }
 /**
+* Creates an `InputStreamNode` from pre-built `AsyncIterable` sources.
+*
+* @example
+* ```ts
+* const node = createStreamInput(schemasIterable, operationsIterable, { title: 'My API' })
+* ```
+*/
+function createStreamInput(schemas, operations, meta) {
+	return {
+		kind: "Input",
+		schemas,
+		operations,
+		meta
+	};
+}
+/**
 * Creates an `OutputNode` with a stable default for `files`.
 *
 * @example
@@ -1453,40 +1466,40 @@ function createOutput(overrides = {}) {
 	};
 }
 /**
-* Creates an `OperationNode` with default empty arrays for `tags`, `parameters`, and `responses`.
-*
-* @example
-* ```ts
-* const operation = createOperation({
-*   operationId: 'getPetById',
-*   method: 'GET',
-*   path: '/pet/{petId}',
-* })
-* // tags, parameters, and responses are []
-* ```
-*
-* @example
-* ```ts
-* const operation = createOperation({
-*   operationId: 'findPets',
-*   method: 'GET',
-*   path: '/pet/findByStatus',
-*   tags: ['pet'],
-* })
-* ```
+* Creates a `ContentNode` for a single request-body or response content type.
 */
+function createContent(props) {
+	return {
+		...props,
+		kind: "Content"
+	};
+}
+/**
+* Creates a `RequestBodyNode`, normalizing each content entry into a `ContentNode`.
+*/
+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: [],
-		...props,
-		kind: "Operation"
+		...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'`.
+* 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 = {
@@ -1595,19 +1608,29 @@ function createParameter(props) {
 /**
 * 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',
-*   description: 'Success',
-*   schema: createSchema({ type: 'object', properties: [] }),
+*   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 {
-		...props,
-		kind: "Response"
+		...rest,
+		kind: "Response",
+		content: entries?.map(createContent)
 	};
 }
 /**
@@ -1627,7 +1650,7 @@ function createResponse(props) {
 * // → params?: QueryParams
 * ```
 *
-* @example Param with default (implicitly optional; cannot combine with `optional: true`)
+* @example Param with default (implicitly optional. Cannot combine with `optional: true`)
 * ```ts
 * createFunctionParameter({ name: 'config', type: createParamsType({ variant: 'reference', name: 'RequestConfig' }), default: '{}' })
 * // → config: RequestConfig = {}
@@ -1684,7 +1707,7 @@ function createParamsType(props) {
 * // call        → { id, name }
 * ```
 *
-* @example Inline (spread) — children emitted as individual top-level parameters
+* @example Inline (spread), children emitted as individual top-level parameters
 * ```ts
 * createParameterGroup({
 *   properties: [createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false })],
@@ -1786,9 +1809,9 @@ function createSource(props) {
 * 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`
+* - `id` SHA256 hash of the file path
+* - `name` `baseName` without extension
+* - `extname` extension extracted from `baseName`
 *
 * Deduplicates:
 * - `sources` via `combineSources`
@@ -2016,24 +2039,466 @@ function createJsx(value) {
 	};
 }
 //#endregion
-//#region src/printer.ts
+//#region src/signature.ts
+/**
+* The shape-affecting flags shared by every node kind: base primitive, format, and `nullable`.
+* Documentation and usage-slot flags (`optional`/`nullish`/`readOnly`/`writeOnly`) are
+* intentionally excluded, they describe the property slot, not the type.
+*/
+function flagsDescriptor(node) {
+	return `${node.primitive ?? ""};${node.format ?? ""};${node.nullable ? 1 : 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"
+}];
+/**
+* Maps each schema node `type` to the ordered list of shape-contributing fields.
+* Node types absent from this map (scalar types like boolean, null, any, etc.) fall
+* back to `${type}|${flags}` with no additional fields.
+*/
+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(",")}]`;
+		}
+		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)}`;
+	}
+}
+/**
+* Builds the local, shape-only descriptor for a node: its kind, flags, constraints, and its
+* children's signatures. {@link signatureOf} hashes this string. Children contribute their
+* fixed-length signature rather than their own full descriptor, which keeps the result bounded.
+*/
+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("|");
+}
+/**
+* Persistent hash-consing cache: `SchemaNode` → signature digest, keyed by node identity.
+*
+* A `WeakMap` so entries are released once the node is garbage-collected, and so a node hashed
+* during dedupe planning is not re-hashed when the same tree is rewritten during streaming
+* (where `schemaSignature` and `applyDedupe` would otherwise each walk it from scratch). Reuse
+* across calls is sound because a signature depends only on a node's content, and schema nodes
+* are immutable once created, transforms allocate new objects rather than mutating in place.
+*/
+const signatureCache = /* @__PURE__ */ new WeakMap();
+/**
+* Hash-consing: each node's signature is a fixed-length digest of its local shape plus its
+* children's digests (a Merkle hash). Children contribute their 64-char hash instead of their
+* full nested descriptor, so a signature stays bounded regardless of subtree depth, and the
+* digest is identical across calls because it depends only on content, never on traversal
+* order. This keeps the keys built during planning consistent with the ones recomputed later
+* during streaming. {@link signatureCache} memoizes node → digest across every computation.
+*/
+function signatureOf(node) {
+	const cached = signatureCache.get(node);
+	if (cached !== void 0) return cached;
+	const signature = (0, node_crypto.createHash)("sha256").update(describeShape(node)).digest("hex");
+	signatureCache.set(node, signature);
+	return signature;
+}
 /**
-* Creates a schema printer factory.
+* Computes a deterministic, shape-only signature (a fixed-length content hash) for a schema node.
 *
-* This function wraps a builder and makes options optional at call sites.
+* 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. `ref` nodes compare by target name,
+* which also keeps the algorithm terminating on circular shapes.
+*
+* @example Two enums with different descriptions share a signature
+* ```ts
+* schemaSignature(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'], description: 'x' })) ===
+*   schemaSignature(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'] }))
+* ```
+*/
+function schemaSignature(node) {
+	return signatureOf(node);
+}
+//#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, canonicalBySignature, skipRootMatch = false) {
+	if (canonicalBySignature.size === 0) return node;
+	const root = node;
+	return transform(node, { schema(schemaNode) {
+		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
+	};
+}
+/**
+* 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, that name becomes the canonical (so other top-level duplicates
+* and inline copies turn into references to it). Otherwise a new definition is hoisted using
+* `nameFor`. The plan is then applied per node with {@link applyDedupe}.
+*
+* @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}`,
+* })
+* ```
+*/
+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.topLevelName) group.topLevelName = schemaNode.name;
+		} else groups.set(signature, {
+			count: 1,
+			representative: schemaNode,
+			topLevelName: isTopLevel ? schemaNode.name : void 0
+		});
+	}
+	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 pendingHoists = [];
+	for (const [signature, group] of groups) {
+		if (group.count < minOccurrences) continue;
+		if (group.topLevelName) {
+			canonicalBySignature.set(signature, {
+				name: group.topLevelName,
+				ref: refFor(group.topLevelName)
+			});
+			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,
+		hoisted: pendingHoists.map(({ name, representative }) => cleanDefinition(applyDedupe(representative, canonicalBySignature, true), name))
+	};
+}
+//#endregion
+//#region src/dialect.ts
+/**
+* Identity helper that types a {@link SchemaDialect} for an adapter. Like
+* `defineParser`, it adds no runtime behavior, it pins the dialect's type for
+* inference and gives adapter authors a discoverable anchor.
+*
+* @example
+* ```ts
+* export const oasDialect = defineSchemaDialect({
+*   name: 'oas',
+*   isNullable,
+*   isReference,
+*   isDiscriminator,
+*   isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',
+*   resolveRef,
+* })
+* ```
+*/
+function defineSchemaDialect(dialect) {
+	return dialect;
+}
+//#endregion
+//#region src/dispatch.ts
+/**
+* Walks an ordered list of {@link DispatchRule}s and returns the first node produced.
+*
+* This is the shared backbone for spec adapters (OpenAPI today, AsyncAPI and others later).
+* The contract an adapter follows is intentionally minimal:
+*
+*     context → [rule.match → rule.convert] → node
+*
+* An adapter derives a context from a source spec node, then declares an ordered table of
+* rules mapping spec shapes onto Kubb AST nodes. To add support for a new spec, write a new
+* context type and a new rules table, the traversal here is reused unchanged.
+*
+* Order is significant: earlier rules win, so list higher-precedence or more specific shapes
+* first (e.g. composition keywords before plain `type`). A rule whose `match` returns `true`
+* may still `convert` to `null` to defer to later rules. When no rule produces a node this
+* returns `null`, leaving the caller to apply its own fallback.
+*
+* @example
+* ```ts
+* const node = dispatch(schemaRules, schemaContext) ?? createSchema({ type: fallbackType })
+* ```
+*/
+function dispatch(rules, context) {
+	for (const rule of rules) {
+		if (!rule.match(context)) continue;
+		const node = rule.convert(context);
+		if (node !== null && node !== void 0) return node;
+	}
+	return null;
+}
+//#endregion
+//#region src/printer.ts
+/**
+* Defines a schema printer: a function that takes a `SchemaNode` and emits
+* code in your target language. Each plugin that produces code from schemas
+* (TypeScript types, Zod schemas, Faker factories) ships a printer built
+* with this helper.
 *
 * The builder receives resolved options and returns:
-* - `name` — a unique identifier for the printer
-* - `options` — options stored on the returned printer instance
-* - `nodes` — a map of `SchemaType` → handler functions that convert a `SchemaNode` to `TOutput`
-* - `print` _(optional)_ — top-level override exposed as `printer.print`
-*   - Inside this function, use `this.transform(node)` to dispatch to the `nodes` map
-*   - This keeps recursion safe and avoids self-calls
 *
-* When no `print` override is provided, `printer.print` falls back to `printer.transform` (the node-level dispatcher).
+* - `name` unique identifier for the printer.
+* - `options` stored on the returned printer instance.
+* - `nodes` map of `SchemaType` → handler. Handlers return the rendered
+*   output (a string, a TypeScript AST node, ...) for that schema type.
+* - `print` (optional), top-level override exposed as `printer.print`.
+*   Use `this.transform(node)` inside it to dispatch to `nodes` recursively.
+*
+* Without a `print` override, `printer.print` falls back to `printer.transform`
+* (the node-level dispatcher).
 *
-* @example Basic usage — Zod schema printer
+* @example Tiny Zod printer
 * ```ts
+* import { definePrinter, type PrinterFactoryOptions } from '@kubb/ast'
+*
 * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
 *
 * export const zodPrinter = definePrinter<PrinterZod>((options) => ({
@@ -2042,7 +2507,9 @@ function createJsx(value) {
 *   nodes: {
 *     string: () => 'z.string()',
 *     object(node) {
-*       const props = node.properties.map(p => `${p.name}: ${this.transform(p.schema)}`).join(', ')
+*       const props = node.properties
+*         .map((p) => `${p.name}: ${this.transform(p.schema)}`)
+*         .join(', ')
 *       return `z.object({ ${props} })`
 *     },
 *   },
@@ -2070,7 +2537,7 @@ function createPrinterFactory(getKey) {
 				options: resolvedOptions,
 				transform: (node) => {
 					const key = getKey(node);
-					if (key === void 0) return null;
+					if (key === null) return null;
 					const handler = nodes[key];
 					if (!handler) return null;
 					return handler.call(context, node);
@@ -2107,10 +2574,10 @@ function enumPropName(parentName, propName, enumSuffix) {
 function collectImports({ node, nameMapping, resolve }) {
 	return collect(node, { schema(schemaNode) {
 		const schemaRef = narrowSchema(schemaNode, "ref");
-		if (!schemaRef?.ref) return;
+		if (!schemaRef?.ref) return null;
 		const rawName = extractRefName(schemaRef.ref);
 		const result = resolve(nameMapping.get(rawName) ?? rawName);
-		if (!result) return;
+		if (!result) return null;
 		return result;
 	} });
 }
@@ -2164,23 +2631,24 @@ function setDiscriminatorEnum({ node, propertyName, values, enumName }) {
 * ])
 * ```
 */
-function mergeAdjacentObjects(members) {
-	return members.reduce((acc, member) => {
+function* mergeAdjacentObjectsLazy(members) {
+	let acc;
+	for (const member of members) {
 		const objectMember = narrowSchema(member, "object");
-		if (objectMember && !objectMember.name) {
-			const previous = acc.at(-1);
-			const previousObject = previous ? narrowSchema(previous, "object") : void 0;
-			if (previousObject && !previousObject.name) {
-				acc[acc.length - 1] = createSchema({
-					...previousObject,
-					properties: [...previousObject.properties ?? [], ...objectMember.properties ?? []]
+		if (objectMember && !objectMember.name && acc !== void 0) {
+			const accObject = narrowSchema(acc, "object");
+			if (accObject && !accObject.name) {
+				acc = createSchema({
+					...accObject,
+					properties: [...accObject.properties ?? [], ...objectMember.properties ?? []]
 				});
-				return acc;
+				continue;
 			}
 		}
-		acc.push(member);
-		return acc;
-	}, []);
+		if (acc !== void 0) yield acc;
+		acc = member;
+	}
+	if (acc !== void 0) yield acc;
 }
 /**
 * Removes enum members that are covered by broader scalar primitives in the same union.
@@ -2212,7 +2680,7 @@ function setEnumName(propNode, parentName, propName, enumSuffix) {
 	const enumNode = narrowSchema(propNode, "enum");
 	if (enumNode?.primitive === "boolean") return {
 		...propNode,
-		name: void 0
+		name: null
 	};
 	if (enumNode) return {
 		...propNode,
@@ -2221,11 +2689,12 @@ function setEnumName(propNode, parentName, propName, enumSuffix) {
 	return propNode;
 }
 //#endregion
+exports.applyDedupe = applyDedupe;
+exports.buildDedupePlan = buildDedupePlan;
 exports.caseParams = caseParams;
 exports.childName = childName;
 exports.collect = collect;
 exports.collectImports = collectImports;
-exports.collectReferencedSchemaNames = collectReferencedSchemaNames;
 exports.collectUsedSchemaNames = collectUsedSchemaNames;
 exports.containsCircularRef = containsCircularRef;
 exports.createArrowFunction = createArrowFunction;
@@ -2251,26 +2720,27 @@ exports.createProperty = createProperty;
 exports.createResponse = createResponse;
 exports.createSchema = createSchema;
 exports.createSource = createSource;
+exports.createStreamInput = createStreamInput;
 exports.createText = createText;
 exports.createType = createType;
 exports.definePrinter = definePrinter;
+exports.defineSchemaDialect = defineSchemaDialect;
+exports.dispatch = dispatch;
 exports.enumPropName = enumPropName;
 exports.extractRefName = extractRefName;
 exports.extractStringsFromNodes = extractStringsFromNodes;
 exports.findCircularSchemas = findCircularSchemas;
 exports.findDiscriminator = findDiscriminator;
 exports.httpMethods = httpMethods;
+exports.isHttpOperationNode = isHttpOperationNode;
 exports.isInputNode = isInputNode;
 exports.isOperationNode = isOperationNode;
 exports.isOutputNode = isOutputNode;
-exports.isScalarPrimitive = isScalarPrimitive;
 exports.isSchemaNode = isSchemaNode;
 exports.isStringType = isStringType;
-exports.mediaTypes = mediaTypes;
-exports.mergeAdjacentObjects = mergeAdjacentObjects;
+exports.mergeAdjacentObjectsLazy = mergeAdjacentObjectsLazy;
 exports.narrowSchema = narrowSchema;
-exports.nodeKinds = nodeKinds;
-exports.resolveRefName = resolveRefName;
+exports.schemaSignature = schemaSignature;
 exports.schemaTypes = schemaTypes;
 exports.setDiscriminatorEnum = setDiscriminatorEnum;
 exports.setEnumName = setEnumName;
@@ -2278,6 +2748,7 @@ exports.simplifyUnion = simplifyUnion;
 exports.syncOptionality = syncOptionality;
 exports.syncSchemaRef = syncSchemaRef;
 exports.transform = transform;
+exports.update = update;
 exports.walk = walk;
 
 //# sourceMappingURL=index.cjs.map