@kubb/ast 5.0.0-beta.2 → 5.0.0-beta.21

package/dist/index.js

@@ -265,6 +265,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.
@@ -392,11 +432,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;
@@ -445,12 +485,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
 /**
@@ -516,32 +550,40 @@ function createLimit(concurrency) {
 * // 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;
+function* getChildren(node, recurse) {
+	if (node.kind === "Input") {
+		yield* node.schemas;
+		yield* node.operations;
+		return;
+	}
+	if (node.kind === "Output") return;
+	if (node.kind === "Operation") {
+		yield* node.parameters;
+		if (node.requestBody?.content) {
+			for (const c of node.requestBody.content) if (c.schema) yield c.schema;
 		}
-		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 [];
+		yield* node.responses;
+		return;
+	}
+	if (node.kind === "Schema") {
+		if (!recurse) return;
+		if ("properties" in node && node.properties.length > 0) yield* node.properties;
+		if ("items" in node && node.items) yield* node.items;
+		if ("members" in node && node.members) yield* node.members;
+		if ("additionalProperties" in node && node.additionalProperties && node.additionalProperties !== true) yield node.additionalProperties;
+		return;
+	}
+	if (node.kind === "Property") {
+		yield node.schema;
+		return;
+	}
+	if (node.kind === "Parameter") {
+		yield node.schema;
+		return;
+	}
+	if (node.kind === "Response") {
+		if (node.schema) yield node.schema;
+		return;
 	}
 }
 /**
@@ -590,9 +632,6 @@ async function _walk(node, visitor, recurse, limit, parent) {
 		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);
@@ -600,118 +639,95 @@ async function _walk(node, visitor, recurse, limit, parent) {
 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
+	if (node.kind === "Input") {
+		const input = visitor.input?.(node, { parent }) ?? node;
+		return {
+			...input,
+			schemas: input.schemas.map((s) => transform(s, {
+				...options,
+				parent: input
+			})),
+			operations: input.operations.map((op) => transform(op, {
+				...options,
+				parent: input
+			}))
+		};
+	}
+	if (node.kind === "Output") return visitor.output?.(node, { parent }) ?? node;
+	if (node.kind === "Operation") {
+		const op = visitor.operation?.(node, { parent }) ?? node;
+		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
 				}))
-			};
-		}
-		case "Schema": {
-			let schema = node;
-			const replaced = visitor.schema?.(schema, { parent });
-			if (replaced) schema = replaced;
-			const childOptions = {
+			} : void 0,
+			responses: op.responses.map((r) => transform(r, {
 				...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
-				})
-			});
-		}
-		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;
+				parent: op
+			}))
+		};
+	}
+	if (node.kind === "Schema") {
+		const schema = visitor.schema?.(node, { parent }) ?? node;
+		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) } : {}
+		};
+	}
+	if (node.kind === "Property") {
+		const prop = visitor.property?.(node, { parent }) ?? node;
+		return createProperty({
+			...prop,
+			schema: transform(prop.schema, {
+				...options,
+				parent: prop
+			})
+		});
 	}
+	if (node.kind === "Parameter") {
+		const param = visitor.parameter?.(node, { parent }) ?? node;
+		return createParameter({
+			...param,
+			schema: transform(param.schema, {
+				...options,
+				parent: param
+			})
+		});
+	}
+	if (node.kind === "Response") {
+		const response = visitor.response?.(node, { parent }) ?? node;
+		return {
+			...response,
+			schema: transform(response.schema, {
+				...options,
+				parent: response
+			})
+		};
+	}
+	return node;
 }
 /**
 * Runs a depth-first synchronous collection pass.
 *
-* Non-`undefined` values returned by visitor callbacks are appended to the result.
+* Non-`null` values returned by visitor callbacks are appended to the result.
 *
 * @example
 * ```ts
@@ -728,10 +744,9 @@ function transform(node, options) {
 * const values = collect(root, { depth: 'shallow', root: () => 'root' })
 * ```
 */
-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":
@@ -755,16 +770,15 @@ function collect(node, options) {
 		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, {
+	if (v != null) yield v;
+	for (const child of getChildren(node, recurse)) yield* collectLazy(child, {
 		...options,
 		parent: node
-	})) results.push(item);
-	return results;
+	});
+}
+function collect(node, options) {
+	return Array.from(collectLazy(node, options));
 }
 //#endregion
 //#region src/utils.ts
@@ -818,15 +832,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.
@@ -955,7 +970,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,
@@ -1031,13 +1046,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({
@@ -1157,6 +1172,13 @@ function combineExports(exports) {
 function combineImports(imports, exports, source) {
 	const exportedNames = new Set(exports.flatMap((e) => Array.isArray(e.name) ? e.name : e.name ? [e.name] : []));
 	const isUsed = (importName) => !source || source.includes(importName) || exportedNames.has(importName);
+	const importNameMemo = /* @__PURE__ */ new Map();
+	const canonicalizeName = (n) => {
+		if (typeof n === "string") return n;
+		const key = `${n.propertyName}:${n.name ?? ""}`;
+		if (!importNameMemo.has(key)) importNameMemo.set(key, n);
+		return importNameMemo.get(key);
+	};
 	const result = [];
 	const namedByPath = /* @__PURE__ */ new Map();
 	const seen = /* @__PURE__ */ new Set();
@@ -1170,7 +1192,7 @@ function combineImports(imports, exports, source) {
 		const { path, isTypeOnly } = curr;
 		let { name } = curr;
 		if (Array.isArray(name)) {
-			name = [...new Set(name)].filter((item) => typeof item === "string" ? isUsed(item) : isUsed(item.name ?? item.propertyName));
+			name = [...new Set(name.map(canonicalizeName))].filter((item) => typeof item === "string" ? isUsed(item) : isUsed(item.name ?? item.propertyName));
 			if (!name.length) continue;
 			const key = pathTypeKey(path, isTypeOnly);
 			const existing = namedByPath.get(key);
@@ -1223,7 +1245,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
@@ -1233,9 +1255,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.
@@ -1257,14 +1279,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;
 }
 /**
@@ -1280,10 +1307,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
 * }
@@ -1291,11 +1318,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();
@@ -1307,22 +1335,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;
@@ -1345,6 +1368,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.
@@ -1356,11 +1392,12 @@ 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
@@ -1397,11 +1434,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
@@ -2040,7 +2097,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);
@@ -2077,10 +2134,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;
 	} });
 }
@@ -2134,23 +2191,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.
@@ -2182,7 +2243,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,
@@ -2191,6 +2252,6 @@ function setEnumName(propNode, parentName, propName, enumSuffix) {
 	return propNode;
 }
 //#endregion
-export { caseParams, childName, collect, collectImports, collectReferencedSchemaNames, collectUsedSchemaNames, containsCircularRef, createArrowFunction, createBreak, createConst, createDiscriminantNode, createExport, createFile, createFunction, createFunctionParameter, createFunctionParameters, createImport, createInput, createJsx, createOperation, createOperationParams, createOutput, createParameter, createParameterGroup, createParamsType, createPrinterFactory, createProperty, createResponse, createSchema, createSource, createText, createType, definePrinter, enumPropName, extractRefName, extractStringsFromNodes, findCircularSchemas, findDiscriminator, httpMethods, isInputNode, isOperationNode, isOutputNode, isScalarPrimitive, isSchemaNode, isStringType, mediaTypes, mergeAdjacentObjects, narrowSchema, nodeKinds, resolveRefName, schemaTypes, setDiscriminatorEnum, setEnumName, simplifyUnion, syncOptionality, syncSchemaRef, transform, walk };
+export { caseParams, childName, collect, collectImports, collectLazy, collectReferencedSchemaNames, collectUsedSchemaNames, containsCircularRef, createArrowFunction, createBreak, createConst, createDiscriminantNode, createExport, createFile, createFunction, createFunctionParameter, createFunctionParameters, createImport, createInput, createJsx, createOperation, createOperationParams, createOutput, createParameter, createParameterGroup, createParamsType, createPrinterFactory, createProperty, createResponse, createSchema, createSource, createStreamInput, createText, createType, definePrinter, enumPropName, extractRefName, extractStringsFromNodes, findCircularSchemas, findDiscriminator, httpMethods, isInputNode, isOperationNode, isOutputNode, isScalarPrimitive, isSchemaNode, isStringType, mediaTypes, mergeAdjacentObjects, mergeAdjacentObjectsLazy, narrowSchema, nodeKinds, resolveRefName, schemaTypes, setDiscriminatorEnum, setEnumName, simplifyUnion, syncOptionality, syncSchemaRef, transform, walk };
 
 //# sourceMappingURL=index.js.map