@kubb/ast 5.0.0-beta.3 → 5.0.0-beta.30

package/dist/index.cjs

@@ -224,6 +224,60 @@ const mediaTypes = {
 	videoMp4: "video/mp4"
 };
 //#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 ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -288,6 +342,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 +509,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 +552,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 +575,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 +627,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 +721,114 @@ 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;
-	}
+	await limit(() => applyVisitor(node, visitor, parent));
 	const children = getChildren(node, recurse);
 	for (const child of children) await _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.
-*
-* Non-`undefined` values returned by visitor callbacks are appended to the result.
+* Lazy depth-first collection pass. Yields every non-null value returned by
+* the visitor callbacks. Use `collect` for the eager array form.
 *
-* @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 +882,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 +1020,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 +1096,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({
@@ -1127,6 +1169,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 +1199,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 +1236,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 +1258,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 +1268,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 +1304,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,9 +1314,9 @@ 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.
@@ -1287,14 +1338,19 @@ 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;
 }
 /**
@@ -1310,10 +1366,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 +1377,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 +1394,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 +1427,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.
@@ -1386,19 +1451,23 @@ function findCircularSchemas(schemas) {
 */
 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 +1478,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 +1519,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,35 +1565,35 @@ 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
 	};
 }
 /**
@@ -1595,19 +1707,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)
 	};
 }
 /**
@@ -2018,22 +2140,27 @@ function createJsx(value) {
 //#endregion
 //#region src/printer.ts
 /**
-* Creates a schema printer factory.
-*
-* This function wraps a builder and makes options optional at call sites.
+* 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.
 *
-* @example Basic usage — Zod schema printer
+* Without a `print` override, `printer.print` falls back to `printer.transform`
+* (the node-level dispatcher).
+*
+* @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 +2169,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 +2199,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 +2236,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 +2293,27 @@ 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;
+}
+function mergeAdjacentObjects(members) {
+	return [...mergeAdjacentObjectsLazy(members)];
 }
 /**
 * Removes enum members that are covered by broader scalar primitives in the same union.
@@ -2212,7 +2345,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,
@@ -2225,12 +2358,14 @@ exports.caseParams = caseParams;
 exports.childName = childName;
 exports.collect = collect;
 exports.collectImports = collectImports;
+exports.collectLazy = collectLazy;
 exports.collectReferencedSchemaNames = collectReferencedSchemaNames;
 exports.collectUsedSchemaNames = collectUsedSchemaNames;
 exports.containsCircularRef = containsCircularRef;
 exports.createArrowFunction = createArrowFunction;
 exports.createBreak = createBreak;
 exports.createConst = createConst;
+exports.createContent = createContent;
 exports.createDiscriminantNode = createDiscriminantNode;
 exports.createExport = createExport;
 exports.createFile = createFile;
@@ -2248,18 +2383,23 @@ exports.createParameterGroup = createParameterGroup;
 exports.createParamsType = createParamsType;
 exports.createPrinterFactory = createPrinterFactory;
 exports.createProperty = createProperty;
+exports.createRequestBody = createRequestBody;
 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;
@@ -2268,6 +2408,7 @@ exports.isSchemaNode = isSchemaNode;
 exports.isStringType = isStringType;
 exports.mediaTypes = mediaTypes;
 exports.mergeAdjacentObjects = mergeAdjacentObjects;
+exports.mergeAdjacentObjectsLazy = mergeAdjacentObjectsLazy;
 exports.narrowSchema = narrowSchema;
 exports.nodeKinds = nodeKinds;
 exports.resolveRefName = resolveRefName;
@@ -2278,6 +2419,7 @@ exports.simplifyUnion = simplifyUnion;
 exports.syncOptionality = syncOptionality;
 exports.syncSchemaRef = syncSchemaRef;
 exports.transform = transform;
+exports.update = update;
 exports.walk = walk;
 
 //# sourceMappingURL=index.cjs.map