@kubb/plugin-zod 5.7.2 → 5.7.4

package/dist/index.js

@@ -1,8 +1,7 @@
-import { Diagnostics, Resolver, addGenerator, ast, containsCircularRef, createResolver, defineExtension, defineGenerator, extractRefName, setMacros, setResolver, syncSchemaRef } from "kubb/kit";
+import { Diagnostics, Resolver, addGenerator, ast, camelCase, containsCircularRef, createResolver, defineExtension, defineGenerator, extractRefName, pascalCase, setMacros, setResolver, syncSchemaRef } from "kubb/kit";
 import { Const, File, Function, Type, jsxRenderer } from "kubb/jsx";
 import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
-//#endregion
-//#region ../../internals/shared/src/operation.ts
+// ../../internals/shared/src/operation.ts
 /**
 * Maps a content type to the PascalCase suffix used to name per-content-type variants
 * (e.g. `application/json` → `Json`, `application/xml` → `Xml`, `multipart/form-data` → `FormData`).
@@ -85,7 +84,10 @@ function getOperationParameters(node) {
 * shape from the same inputs. `primitive: 'object'` is a no-op for the TS printer and tells the Zod
 * printer to emit `z.object(…)` rather than a record.
 */
-function buildOptionsSchema(node, resolver) {
+function hasRequestContentTypeChoice(node) {
+	return (node.requestBody?.content ?? []).filter((entry) => entry.schema).length > 1;
+}
+function buildOptionsSchema(node, resolver, { pairContentTypes = false } = {}) {
 	const { path, query, header } = getOperationParameters(node);
 	const hasBody = Boolean(node.requestBody?.content?.[0]?.schema);
 	const createNever = () => ast.factory.createSchema({
@@ -110,29 +112,57 @@ function buildOptionsSchema(node, resolver) {
 			resolve: resolver.param.headers
 		}
 	];
-	return ast.factory.createSchema({
+	const createOptions = (body, extra = []) => ast.factory.createSchema({
 		type: "object",
 		primitive: "object",
 		deprecated: node.deprecated,
-		properties: [ast.factory.createProperty({
-			name: "body",
-			required: hasBody,
-			schema: hasBody ? ast.factory.createSchema({
-				type: "ref",
-				name: resolver.response.body(node)
-			}) : createNever()
-		}), ...groups.map(({ name, params, resolve }) => {
-			const required = params.some((param) => param.required);
-			return ast.factory.createProperty({
-				name,
-				required,
-				schema: params.length > 0 ? ast.factory.createSchema({
-					type: "ref",
-					name: resolve.call(resolver.param, node, params[0]),
-					optional: !required
-				}) : createNever()
-			});
-		})]
+		properties: [
+			ast.factory.createProperty({
+				name: "body",
+				required: hasBody,
+				schema: body
+			}),
+			...groups.map(({ name, params, resolve }) => {
+				const required = params.some((param) => param.required);
+				return ast.factory.createProperty({
+					name,
+					required,
+					schema: params.length > 0 ? ast.factory.createSchema({
+						type: "ref",
+						name: resolve.call(resolver.param, node, params[0]),
+						optional: !required
+					}) : createNever()
+				});
+			}),
+			...extra
+		]
+	});
+	const variants = pairContentTypes && hasRequestContentTypeChoice(node) ? resolveContentTypeVariants(node.requestBody?.content ?? [], resolver.response.body(node)) : [];
+	if (variants.length < 2) return createOptions(hasBody ? ast.factory.createSchema({
+		type: "ref",
+		name: resolver.response.body(node)
+	}) : createNever());
+	return ast.factory.createSchema({
+		type: "union",
+		members: variants.map((variant, index) => createOptions(ast.factory.createSchema({
+			type: "ref",
+			name: variant.name
+		}), [ast.factory.createProperty({
+			name: "contentType",
+			required: index > 0,
+			schema: ast.factory.createSchema({
+				type: "object",
+				primitive: "object",
+				properties: [ast.factory.createProperty({
+					name: "request",
+					required: true,
+					schema: ast.factory.createSchema({
+						type: "enum",
+						enumValues: [variant.contentType]
+					})
+				})]
+			})
+		})]))
 	});
 }
 /**
@@ -202,8 +232,7 @@ function isSuccessStatusCode(statusCode) {
 function getSuccessResponses(responses) {
 	return responses.filter((response) => isSuccessStatusCode(response.statusCode));
 }
-//#endregion
-//#region ../../internals/shared/src/adapter.ts
+// ../../internals/shared/src/adapter.ts
 /**
 * Narrows the generic `Adapter` from a generator context to the OpenAPI adapter,
 * so OAS-only options (`dateType`, `enums`) and the parsed `document` are typed.
@@ -226,58 +255,7 @@ function getOasAdapter(adapter) {
 	});
 	return adapter;
 }
-//#endregion
-//#region ../../internals/utils/src/casing.ts
-/**
-* Shared implementation for camelCase and PascalCase conversion.
-* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
-* and capitalizes each word according to `pascal`.
-*
-* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
-*/
-function convert(text, pascal) {
-	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
-		if (word.length > 1 && word === word.toUpperCase()) return word;
-		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
-	}).join("").replace(/[^a-zA-Z0-9]/g, "");
-}
-const cache = /* @__PURE__ */ new Map();
-const cacheLimit = 1e4;
-function toCamelOrPascal(text, pascal) {
-	const key = `${pascal ? "P" : "c"}${text}`;
-	const cached = cache.get(key);
-	if (cached !== void 0) return cached;
-	const result = convert(text, pascal);
-	if (cache.size >= cacheLimit) cache.clear();
-	cache.set(key, result);
-	return result;
-}
-/**
-* Converts `text` to camelCase.
-*
-* @example Word boundaries
-* `camelCase('hello-world') // 'helloWorld'`
-*
-* @example With a prefix
-* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
-*/
-function camelCase(text, { prefix = "", suffix = "" } = {}) {
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
-}
-/**
-* Converts `text` to PascalCase.
-*
-* @example Word boundaries
-* `pascalCase('hello-world') // 'HelloWorld'`
-*
-* @example With a suffix
-* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
-*/
-function pascalCase(text, { prefix = "", suffix = "" } = {}) {
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
-}
-//#endregion
-//#region ../../internals/utils/src/reserved.ts
+// ../../internals/utils/src/reserved.ts
 /**
 * JavaScript and Java reserved words.
 * @link https://github.com/jonschlinkert/reserved/blob/master/index.js
@@ -285,6 +263,7 @@ function pascalCase(text, { prefix = "", suffix = "" } = {}) {
 const reservedWords = /* @__PURE__ */ new Set([
 	"abstract",
 	"arguments",
+	"await",
 	"boolean",
 	"break",
 	"byte",
@@ -415,8 +394,7 @@ function ensureValidVarName(name) {
 function isIdentifier(name) {
 	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
-//#endregion
-//#region ../../internals/utils/src/strings.ts
+// ../../internals/utils/src/strings.ts
 /**
 * Wraps a value in single quotes for emitting a single-quoted JavaScript string literal, escaping
 * any backslash or single quote in the content.
@@ -465,6 +443,34 @@ function stringify(value) {
 	if (value === void 0 || value === null) return "''";
 	return `'${JSON.stringify(trimQuotes(value.toString())).slice(1, -1).replace(/\\"/g, "\"").replace(/'/g, "\\'")}'`;
 }
+const NEEDS_UNICODE = /(?<!\\)(?:\\\\)*\\[pPu]\{|[\u{10000}-\u{10FFFF}]/u;
+const KEPT_ESCAPE = /[A-Za-z0-9^$\\.*+?()[\]{}|/]/;
+/**
+* Drops the backslash from escapes that the `u` flag rejects: an escaped punctuation character that is
+* not a syntax character, and `\-` outside a class. Both match the same character without the backslash.
+*/
+function dropIdentityEscapes(pattern) {
+	let inClass = false;
+	return pattern.replace(/\\(.)|[[\]]/gs, (match, escaped) => {
+		if (escaped === void 0) {
+			inClass = match === "[";
+			return match;
+		}
+		return KEPT_ESCAPE.test(escaped) || escaped === "-" && inClass ? match : escaped;
+	});
+}
+/**
+* Builds the `RegExp` for a pattern, adding the `u` flag when it uses `\p{...}`, `\P{...}` or `\u{...}`, or
+* holds a character outside the BMP. A pattern that is not valid under `u` keeps the flags it came with.
+*/
+function toRegExp(pattern, flags) {
+	if (flags?.includes("u") || !NEEDS_UNICODE.test(pattern)) return new RegExp(pattern, flags);
+	try {
+		return new RegExp(dropIdentityEscapes(pattern), `${flags ?? ""}u`);
+	} catch {
+		return new RegExp(pattern, flags);
+	}
+}
 /**
 * Converts a pattern string into a `new RegExp(...)` constructor call or a regex literal string.
 * Inline flags expressed as a `^(?im)` prefix are extracted and applied to the resulting expression.
@@ -481,13 +487,11 @@ function toRegExpString(text, func = "RegExp") {
 	const match = raw.match(/^\^(\(\?([igmsuy]+)\))/i);
 	const replacementTarget = match?.[1] ?? "";
 	const matchedFlags = match?.[2];
-	const cleaned = raw.replace(/^\\?\//, "").replace(/\\?\/$/, "").replace(replacementTarget, "");
-	const { source, flags } = new RegExp(cleaned, matchedFlags);
+	const { source, flags } = toRegExp(raw.replace(/^\\?\//, "").replace(/\\?\/$/, "").replace(replacementTarget, ""), matchedFlags);
 	if (func === null) return `/${source}/${flags}`;
 	return `new ${func}(${JSON.stringify(source)}${flags ? `, ${JSON.stringify(flags)}` : ""})`;
 }
-//#endregion
-//#region ../../internals/utils/src/codegen.ts
+// ../../internals/utils/src/codegen.ts
 const INDENT = "  ";
 /**
 * Indents every non-empty line of `text` by one indent level, leaving blank lines empty.
@@ -556,8 +560,7 @@ function buildList(items, brackets = ["[", "]"]) {
 function lazyGetter({ name, body }) {
 	return `get ${objectKey(name)}() { return ${body} }`;
 }
-//#endregion
-//#region ../../internals/utils/src/fs.ts
+// ../../internals/utils/src/fs.ts
 /**
 * Builds a nested file path from a dotted name. Splits on dots that precede a letter
 * (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases
@@ -581,17 +584,24 @@ function toFilePath(name, caseLast = camelCase) {
 	const parts = name.split(/\.(?=[a-zA-Z])/);
 	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
 }
-//#endregion
-//#region ../../internals/shared/src/resolver.ts
+// ../../internals/shared/src/resolver.ts
 /**
-* Resolves a single operation parameter name with the
-* `<operationId> <in> <name>` template.
+* Builds the allocation key for a declaration an operation owns. `scope` names which declaration
+* it is, so two of them never share an allocation even when a custom resolver gives both the same
+* name. Leave `scope` empty for the operation's own declaration.
 *
 * @example
-* `operationParamName.call(resolver, node, param) // → 'DeletePetPathPetId'`
+* ```ts
+* resolver.resolveName({ key: operationKey(node, 'response', 'status', 404), name })
+* ```
 */
-function operationParamName(node, param) {
-	return this.name(`${node.operationId} ${param.in} ${param.name}`);
+function operationKey(node, ...scope) {
+	return [
+		"operation",
+		node.method,
+		node.path,
+		...scope.map(String)
+	];
 }
 /**
 * Builds the shared `param` namespace. Spread the result into `createResolver`
@@ -604,15 +614,33 @@ function operationParamName(node, param) {
 */
 function createOperationParamResolver() {
 	return {
-		name: operationParamName,
+		name(node, param) {
+			const name = this.name(`${node.operationId} ${param.in} ${param.name}`);
+			return this.resolveName({
+				key: operationKey(node, "param", "name", param.in, param.name),
+				name
+			});
+		},
 		path(node) {
-			return this.name(`${node.operationId} Path`);
+			const name = this.name(`${node.operationId} Path`);
+			return this.resolveName({
+				key: operationKey(node, "param", "path"),
+				name
+			});
 		},
 		query(node) {
-			return this.name(`${node.operationId} Query`);
+			const name = this.name(`${node.operationId} Query`);
+			return this.resolveName({
+				key: operationKey(node, "param", "query"),
+				name
+			});
 		},
 		headers(node) {
-			return this.name(`${node.operationId} Headers`);
+			const name = this.name(`${node.operationId} Headers`);
+			return this.resolveName({
+				key: operationKey(node, "param", "headers"),
+				name
+			});
 		}
 	};
 }
@@ -629,16 +657,32 @@ function createOperationParamResolver() {
 function createOperationResponseResolver() {
 	return {
 		status(node, statusCode) {
-			return this.name(`${node.operationId} Status ${statusCode}`);
+			const name = this.name(`${node.operationId} Status ${statusCode}`);
+			return this.resolveName({
+				key: operationKey(node, "response", "status", statusCode),
+				name
+			});
 		},
 		body(node) {
-			return this.name(`${node.operationId} Body`);
+			const name = this.name(`${node.operationId} Body`);
+			return this.resolveName({
+				key: operationKey(node, "response", "body"),
+				name
+			});
 		},
 		responses(node) {
-			return this.name(`${node.operationId} Responses`);
+			const name = this.name(`${node.operationId} Responses`);
+			return this.resolveName({
+				key: operationKey(node, "response", "responses"),
+				name
+			});
 		},
 		response(node) {
-			return this.name(`${node.operationId} Response`);
+			const name = this.name(`${node.operationId} Response`);
+			return this.resolveName({
+				key: operationKey(node, "response", "response"),
+				name
+			});
 		}
 	};
 }
@@ -653,11 +697,10 @@ function createOperationResponseResolver() {
 */
 function createCasedFile(caseLast) {
 	return { baseName({ name, extname }) {
-		return `${toFilePath(name, caseLast)}${extname}`;
+		return this.memo(`file:${name}\0${extname}`, () => `${toFilePath(name, caseLast)}${extname}`);
 	} };
 }
-//#endregion
-//#region ../../internals/shared/src/group.ts
+// ../../internals/shared/src/group.ts
 /**
 * Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
 * shared default naming so every plugin groups output consistently:
@@ -687,8 +730,7 @@ function createGroupConfig(group) {
 		name: group.name ? group.name : defaultName
 	};
 }
-//#endregion
-//#region ../../internals/shared/src/schemaTraversal.ts
+// ../../internals/shared/src/schemaTraversal.ts
 /**
 * Maps each property of an object schema to its transformed output. Pairs every result with the
 * original property so the printer keeps full control over modifiers, getters, and key syntax.
@@ -726,8 +768,7 @@ function mapSchemaItems(node, transform) {
 		output: transform(schema)
 	}));
 }
-//#endregion
-//#region src/components/Zod.tsx
+// src/components/Zod.tsx
 function Zod({ name, node, printer, inferTypeName, inferKind = "infer", typeGuards, isName, assertName, mini, cyclic, compile }) {
 	const output = printer.print(node);
 	const printerImports = printer.drainImports();
@@ -799,8 +840,7 @@ function Zod({ name, node, printer, inferTypeName, inferKind = "infer", typeGuar
 		})
 	] });
 }
-//#endregion
-//#region src/utils.ts
+// src/utils.ts
 /**
 * Returns `true` when the given coercion option enables coercion for the specified type.
 */
@@ -829,11 +869,12 @@ function isClosedKeySchema(node) {
 }
 /**
 * Whether the node is a plain inline object whose shape can be lifted into an `.extend({ … })`
-* argument. A catchall, `patternProperties`, or a nullable/optional wrapper cannot, so those stay
+* argument. Property counts, a catchall, `patternProperties`, or a nullable/optional wrapper cannot, so those stay
 * on `.and(…)`.
 */
 function isPlainInlineObject(node) {
 	if (node.type !== "object") return false;
+	if (node.minProperties !== void 0 || node.maxProperties !== void 0) return false;
 	if (node.nullable || node.optional || node.nullish) return false;
 	const hasAdditionalProperties = node.additionalProperties !== void 0;
 	const hasPatternProperties = Boolean(node.patternProperties);
@@ -844,11 +885,12 @@ function isPlainInlineObject(node) {
 * `z.discriminatedUnion` option. Covers object nodes, `$ref`s that resolve to (or are still
 * unresolved) objects, single-member unions of an object, and object-composable `allOf`.
 *
-* `cyclicSchemas` bounds the recursion: a ref into a cycle renders as `z.lazy(…)`, not an object.
+* Property counts render as a pipe. A ref into `cyclicSchemas` renders as `z.lazy(…)`.
 */
 function isObjectSchemaNode(node, cyclicSchemas) {
 	if (node.nullable || node.optional || node.nullish) return false;
 	if (node.type === "object") {
+		if (node.minProperties !== void 0 || node.maxProperties !== void 0) return false;
 		const hasProperties = Boolean(node.properties?.length);
 		const hasTypedAdditionalProperties = Boolean(node.additionalProperties && node.additionalProperties !== true);
 		const hasPatternProperties = Boolean(node.patternProperties);
@@ -876,6 +918,49 @@ function isObjectComposableIntersection(node, cyclicSchemas) {
 	const [first, ...rest] = node.members ?? [];
 	return !!first && isObjectSchemaNode(first, cyclicSchemas) && rest.every(isPlainInlineObject);
 }
+function preserveRequiredProperties(members) {
+	const hasRequiredProperty = ({ node, propertyName, seen = /* @__PURE__ */ new Set() }) => {
+		if (seen.has(node)) return false;
+		seen.add(node);
+		const resolved = syncSchemaRef(node);
+		const composition = ast.narrowSchema(resolved, ast.schemaTypes.intersection) ?? ast.narrowSchema(resolved, ast.schemaTypes.union);
+		if (composition) {
+			if (composition.type === ast.schemaTypes.union && composition.members?.length !== 1) return false;
+			return composition.members?.some((child) => hasRequiredProperty({
+				node: child,
+				propertyName,
+				seen
+			})) ?? false;
+		}
+		return ast.resolveSchemaProperties({
+			node: resolved,
+			propertyName
+		}).some((property) => property.required !== false && !property.schema.optional && !property.schema.nullish);
+	};
+	return members.map((member, index) => {
+		const object = ast.narrowSchema(member, ast.schemaTypes.object);
+		if (!object || index === 0) return member;
+		return {
+			...object,
+			properties: object.properties.map((property) => {
+				if (!members.slice(0, index).some((base) => hasRequiredProperty({
+					node: base,
+					propertyName: property.name
+				}))) return property;
+				return {
+					...property,
+					required: true,
+					schema: {
+						...property.schema,
+						optional: false,
+						nullish: false,
+						nullable: property.schema.nullable || property.schema.nullish
+					}
+				};
+			})
+		};
+	});
+}
 /**
 * Format a default value as a code-level literal.
 * Arrays and objects keep their contents as a JSON literal, primitives become their string
@@ -922,11 +1007,20 @@ function defaultLiteral(node, value) {
 */
 function buildEnum(values) {
 	if (values.every((v) => typeof v === "string")) return `z.enum([${values.map((v) => formatDefault(v)).join(", ")}])`;
-	const literals = values.map((v) => `z.literal(${formatDefault(v)})`);
+	const literals = values.map((value) => buildLiteral(value));
 	if (literals.length === 1) return literals[0];
 	return `z.union([${literals.join(", ")}])`;
 }
 /**
+* Preserves the structure of JSON const values in both Zod APIs.
+*/
+function buildLiteral(value) {
+	if (value === null) return "z.null()";
+	if (Array.isArray(value)) return `z.tuple([${value.map((item) => buildLiteral(item)).join(", ")}])`;
+	if (typeof value === "object") return `z.strictObject({${Object.entries(value).map(([name, item]) => `${JSON.stringify(name)}: ${buildLiteral(item)}`).join(", ")}})`;
+	return `z.literal(${formatDefault(value)})`;
+}
+/**
 * Digit pattern for a `type: 'string'` schema that carries an integer `format`, the way ProtoJSON
 * encodes 64-bit integers. Returns `undefined` for every other format, and a `pattern` from the
 * spec takes precedence over this fallback.
@@ -1009,6 +1103,17 @@ function lengthChecksMini({ min, max, pattern, regexType }) {
 	return checks.length ? `.check(${checks.join(", ")})` : "";
 }
 /**
+* Checks property counts before object parsing strips unknown keys or inserts defaults.
+*/
+function objectConstraints({ value, node }) {
+	if (node.type !== "object") return value;
+	const checks = [];
+	const skip = "typeof value !== \"object\" || value === null || Array.isArray(value)";
+	if (node.minProperties !== void 0) checks.push(`z.refine(value => ${skip} || Object.keys(value).length >= ${node.minProperties}, { message: "Object must have at least ${node.minProperties} properties" })`);
+	if (node.maxProperties !== void 0) checks.push(`z.refine(value => ${skip} || Object.keys(value).length <= ${node.maxProperties}, { message: "Object must have at most ${node.maxProperties} properties" })`);
+	return checks.length ? `z.pipe(z.unknown().check(${checks.join(", ")}), ${value})` : value;
+}
+/**
 * Apply nullable / optional / nullish modifiers, an optional `.describe()` call, and an
 * optional `.meta({ examples })` call to a schema value string using the chainable Zod v4 API.
 */
@@ -1098,7 +1203,7 @@ function getMemberConstraint({ member, regexType, lengths, numbers }) {
 /**
 * Builds the `{ key: value, … }` shape shared by the `z.object(...)` and `.extend(...)` renderings.
 */
-function buildObjectShape(ctx, node, modify) {
+function buildObjectShape(ctx, node, renderProperty) {
 	const objectNode = ast.narrowSchema(node, "object");
 	if (!objectNode) return "{}";
 	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && containsCircularRef(schema, { circularSchemas: ctx.options.cyclicSchemas });
@@ -1109,18 +1214,16 @@ function buildObjectShape(ctx, node, modify) {
 		const baseOutput = ctx.transform(schema) ?? ctx.transform(ast.factory.createSchema({ type: "unknown" }));
 		if (hasSelfRef) ctx.options.cyclicSchemas = savedCyclicSchemas;
 		return baseOutput;
-	}).map(({ name: propName, property, output: baseOutput }) => {
+	}).map(({ name, property, output: value }) => {
 		const { schema } = property;
-		const value = modify({
-			value: baseOutput,
+		return renderProperty({
+			name,
+			value,
 			schema,
 			required: property.required,
-			meta: syncSchemaRef(schema)
+			meta: syncSchemaRef(schema),
+			cyclic: isCyclic(schema)
 		});
-		return isCyclic(schema) ? lazyGetter({
-			name: propName,
-			body: value
-		}) : `${objectKey(propName)}: ${value}`;
 	}));
 }
 /**
@@ -1135,22 +1238,28 @@ function printWithOmit(ctx, node, modify, mini = false) {
 		if (!keysToOmit?.length || meta.primitive !== "object" || meta.type === "union" && meta.discriminatorPropertyName) return transformed;
 		const unwrap = omitUnwrapChain(node, mini ? "._zod.def.innerType" : ".unwrap()");
 		const mask = `{ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} }`;
-		const omit = (target) => mini ? `z.omit(${target}${unwrap}, ${mask})` : `${target}${unwrap}.omit(${mask})`;
+		const omit = (target) => {
+			const inner = `${target}${unwrap}`;
+			const hasObjectConstraints = meta.type === "object" && (meta.minProperties !== void 0 || meta.maxProperties !== void 0);
+			const pipe = mini ? `${inner}._zod.def` : inner;
+			const object = hasObjectConstraints ? `${pipe}.out` : inner;
+			const omitted = mini ? `z.omit(${object}, ${mask})` : `${object}.omit(${mask})`;
+			return hasObjectConstraints ? `z.pipe(${pipe}.in, ${omitted})` : omitted;
+		};
 		const lazyMatch = transformed.match(/^z\.lazy\(\(\)\s*=>\s*(.+)\)$/);
 		if (lazyMatch) return `z.lazy(() => ${omit(lazyMatch[1])})`;
 		return omit(transformed);
 	})(), meta);
 }
-//#endregion
-//#region src/printers/printerZod.ts
+// src/printers/printerZod.ts
 function strictOneOfMember(member, node, cyclicSchemas) {
-	if (node.type === "ref") {
+	if (node.type === ast.schemaTypes.ref) {
 		if (member.startsWith("z.lazy(")) return member;
 		const refName = ast.resolveRefName(node);
 		if (refName && cyclicSchemas?.has(refName)) return member;
 		const schema = syncSchemaRef(node);
 		if (schema.nullable || schema.optional || node.nullable || node.optional) return member;
-		if (schema.type === "object" && (schema.additionalProperties === void 0 || schema.additionalProperties === false)) return `${member}.strict()`;
+		if (schema.type === ast.schemaTypes.object && (schema.additionalProperties === void 0 || schema.additionalProperties === false)) return `${member}.strict()`;
 	}
 	return member;
 }
@@ -1158,28 +1267,70 @@ function strictOneOfMember(member, node, cyclicSchemas) {
 * Builds the `{ key: value, … }` shape for an object node with the chainable modifiers.
 */
 function buildZodObjectShape(ctx, node) {
-	return buildObjectShape(ctx, node, ({ value, schema, required, meta }) => applyModifiers({
-		value,
-		schema,
-		nullable: meta.nullable,
-		optional: schema.optional || required === false,
-		nullish: schema.nullish,
-		defaultValue: meta.default,
-		description: schema.type !== "ref" && meta.type === "ref" ? void 0 : meta.description,
-		examples: meta.examples
-	}));
+	return buildObjectShape(ctx, node, ({ name, value, schema, required, meta, cyclic }) => {
+		const body = applyModifiers({
+			value,
+			schema,
+			nullable: meta.nullable,
+			optional: schema.optional || required === false,
+			nullish: schema.nullish,
+			defaultValue: meta.default,
+			description: schema.type !== ast.schemaTypes.ref && meta.type === ast.schemaTypes.ref ? void 0 : meta.description,
+			examples: meta.examples
+		});
+		if (!cyclic) return `${objectKey(name)}: ${body}`;
+		const returnType = recursiveGetterType({
+			ctx,
+			schema,
+			required
+		});
+		return returnType ? `get ${objectKey(name)}(): ${returnType} { return ${body} }` : lazyGetter({
+			name,
+			body
+		});
+	});
+}
+/**
+* Breaks getter inference cycles without widening recursive refs and arrays to `z.ZodType`.
+*/
+function recursiveGetterType({ ctx, schema, required }) {
+	function baseType(schema) {
+		if (ctx.options.nodes?.[schema.type]) return void 0;
+		if (schema.type === ast.schemaTypes.ref) {
+			const saved = ctx.options.cyclicSchemas;
+			ctx.options.cyclicSchemas = void 0;
+			const name = ctx.transform(schema);
+			ctx.options.cyclicSchemas = saved;
+			return name ? `typeof ${name}` : void 0;
+		}
+		if (schema.type === ast.schemaTypes.array && schema.items?.length === 1) {
+			const item = baseType(schema.items[0]);
+			return item ? `z.ZodArray<${item}>` : void 0;
+		}
+	}
+	const base = baseType(schema);
+	if (!base) return void 0;
+	const meta = syncSchemaRef(schema);
+	const optional = schema.optional || required === false;
+	const wrapped = (() => {
+		if (schema.nullish || meta.nullable && optional) return `z.ZodOptional<z.ZodNullable<${base}>>`;
+		if (optional) return `z.ZodOptional<${base}>`;
+		if (meta.nullable) return `z.ZodNullable<${base}>`;
+		return base;
+	})();
+	return meta.default !== void 0 && defaultLiteral(schema, meta.default) !== null ? `z.ZodDefault<${wrapped}>` : wrapped;
 }
 /**
 * Types the direction probe skips. They delegate to their children rather than reading
 * `direction` themselves, so {@link containsDirectionalNode} walks into the children instead.
 */
 const CONTAINER_TYPES = /* @__PURE__ */ new Set([
-	"object",
-	"array",
-	"tuple",
-	"union",
-	"intersection",
-	"ref"
+	ast.schemaTypes.object,
+	ast.schemaTypes.array,
+	ast.schemaTypes.tuple,
+	ast.schemaTypes.union,
+	ast.schemaTypes.intersection,
+	ast.schemaTypes.ref
 ]);
 /**
 * Runs the node's effective handler (a `printer.nodes` override, else the built-in) once per
@@ -1211,7 +1362,7 @@ function variesByDirection({ node, printerOptions }) {
 */
 function containsDirectionalNode({ node, printerOptions, seen = /* @__PURE__ */ new Set() }) {
 	if (!node) return false;
-	if (node.type === "ref") {
+	if (node.type === ast.schemaTypes.ref) {
 		if (!node.ref) return false;
 		const refName = extractRefName(node.ref);
 		if (refName) {
@@ -1219,7 +1370,7 @@ function containsDirectionalNode({ node, printerOptions, seen = /* @__PURE__ */
 			seen.add(refName);
 		}
 		const resolved = syncSchemaRef(node);
-		if (resolved.type === "ref") return false;
+		if (resolved.type === ast.schemaTypes.ref) return false;
 		return containsDirectionalNode({
 			node: resolved,
 			printerOptions,
@@ -1235,7 +1386,7 @@ function containsDirectionalNode({ node, printerOptions, seen = /* @__PURE__ */
 	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);
-	const propertyNames = node.type === "object" ? node.propertyNames : void 0;
+	const propertyNames = node.type === ast.schemaTypes.object ? node.propertyNames : void 0;
 	if (propertyNames) children.push(propertyNames);
 	return children.some((child) => containsDirectionalNode({
 		node: child,
@@ -1247,7 +1398,7 @@ function containsDirectionalNode({ node, printerOptions, seen = /* @__PURE__ */
 * Names of the `$ref` schemas the generator should route to their input (encode) variant.
 */
 function collectDirectionalRefNames({ node, printerOptions }) {
-	return ast.collectSync(node, { schema: (n) => n.type === "ref" && n.ref && containsDirectionalNode({
+	return ast.collectSync(node, { schema: (n) => n.type === ast.schemaTypes.ref && n.ref && containsDirectionalNode({
 		node: n,
 		printerOptions
 	}) ? ast.resolveRefName(n) ?? void 0 : void 0 });
@@ -1339,7 +1490,7 @@ const scalarNodes = {
 	enum(node) {
 		const nonNullValues = (node.namedEnumValues?.map((v) => v.value) ?? node.enumValues ?? []).filter((v) => v !== null);
 		if (node.namedEnumValues?.length) {
-			const literals = nonNullValues.map((v) => `z.literal(${formatDefault(v)})`);
+			const literals = nonNullValues.map((v) => buildLiteral(v));
 			if (literals.length === 1) return literals[0];
 			return `z.union([${literals.join(", ")}])`;
 		}
@@ -1360,6 +1511,7 @@ const scalarNodes = {
 */
 const printerZod = ast.createPrinter((options) => {
 	const cyclicSchemaNames = options.cyclicSchemas;
+	const unionsWithSiblings = /* @__PURE__ */ new WeakSet();
 	return {
 		name: "zod",
 		options,
@@ -1385,37 +1537,40 @@ const printerZod = ast.createPrinter((options) => {
 				const isStrict = node.additionalProperties === false && patterns.length === 0;
 				const isLoose = node.additionalProperties === true;
 				const objectBase = `${isStrict ? "z.strictObject" : isLoose ? "z.looseObject" : "z.object"}(${buildZodObjectShape(this, node)})`;
-				return (() => {
-					const recordFn = isClosedKeySchema(propertyNamesNode) ? "z.partialRecord" : "z.record";
-					if (node.additionalProperties && node.additionalProperties !== true) {
-						const catchallType = this.transform(node.additionalProperties);
-						if (entries.length === 0) return catchallType ? `${recordFn}(${propertyNamesKeySchema || "z.string()"}, ${catchallType})` : objectBase;
-						return catchallType ? `${objectBase}.catchall(${catchallType})` : objectBase;
-					}
-					if (entries.length === 0 && patterns.length === 0 && propertyNamesKeySchema && !isStrict) {
-						const unknownType = this.transform(ast.factory.createSchema({ type: "unknown" }));
-						return `${recordFn}(${propertyNamesKeySchema}, ${unknownType})`;
-					}
-					if (node.additionalProperties === true) return objectBase;
-					if (isStrict) return objectBase;
-					if (patterns.length > 0) {
-						const values = patterns.map(([, valueSchema]) => {
-							const valueType = this.transform(valueSchema) ?? this.transform(ast.factory.createSchema({ type: "unknown" }));
-							return valueSchema.nullable ? `${valueType}.nullable()` : valueType;
-						});
-						const distinct = [...new Set(values)];
-						const value = distinct.length === 1 ? distinct[0] : `z.union([${distinct.join(", ")}])`;
-						if (entries.length > 0) return `${objectBase}.catchall(${value})`;
-						return `z.record(${patternKeySchema({
-							patterns: patterns.map(([pattern]) => pattern),
-							regexType: this.options.regexType
-						})}, ${value})`;
-					}
-					return objectBase;
-				})();
+				return objectConstraints({
+					value: (() => {
+						const recordFn = isClosedKeySchema(propertyNamesNode) ? "z.partialRecord" : "z.record";
+						if (node.additionalProperties && node.additionalProperties !== true) {
+							const catchallType = this.transform(node.additionalProperties);
+							if (entries.length === 0) return catchallType ? `${recordFn}(${propertyNamesKeySchema || "z.string()"}, ${catchallType})` : objectBase;
+							return catchallType ? `${objectBase}.catchall(${catchallType})` : objectBase;
+						}
+						if (entries.length === 0 && patterns.length === 0 && propertyNamesKeySchema && !isStrict) {
+							const unknownType = this.transform(ast.factory.createSchema({ type: ast.schemaTypes.unknown }));
+							return `${recordFn}(${propertyNamesKeySchema}, ${unknownType})`;
+						}
+						if (node.additionalProperties === true) return objectBase;
+						if (isStrict) return objectBase;
+						if (patterns.length > 0) {
+							const values = patterns.map(([, valueSchema]) => {
+								const valueType = this.transform(valueSchema) ?? this.transform(ast.factory.createSchema({ type: ast.schemaTypes.unknown }));
+								return valueSchema.nullable ? `${valueType}.nullable()` : valueType;
+							});
+							const distinct = [...new Set(values)];
+							const value = distinct.length === 1 ? distinct[0] : `z.union([${distinct.join(", ")}])`;
+							if (entries.length > 0) return `${objectBase}.catchall(${value})`;
+							return `z.record(${patternKeySchema({
+								patterns: patterns.map(([pattern]) => pattern),
+								regexType: this.options.regexType
+							})}, ${value})`;
+						}
+						return objectBase;
+					})(),
+					node
+				});
 			},
 			array(node) {
-				const base = `z.array(${mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean).join(", ") || this.transform(ast.factory.createSchema({ type: "unknown" }))})${lengthConstraints({
+				const base = `z.array(${mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean).join(", ") || this.transform(ast.factory.createSchema({ type: ast.schemaTypes.unknown }))})${lengthConstraints({
 					...node,
 					regexType: this.options.regexType
 				})}`;
@@ -1428,7 +1583,7 @@ const printerZod = ast.createPrinter((options) => {
 				const nodeMembers = node.members ?? [];
 				const isDiscriminated = !!node.discriminatorPropertyName && nodeMembers.every((m) => isObjectSchemaNode(m, cyclicSchemaNames));
 				const isXor = node.strategy === "one" && !isDiscriminated && this.options.oneOfType === "xor";
-				const isStrict = node.strategy === "one" && !isXor;
+				const isStrict = node.strategy === "one" && !isXor && !unionsWithSiblings.has(node);
 				const members = mapSchemaMembers(node, (memberNode) => this.transform(isStrict ? strictOneOfNode(memberNode) : memberNode)).map(({ schema, output }) => output && isStrict ? strictOneOfMember(output, schema, cyclicSchemaNames) : output).filter(Boolean);
 				if (members.length === 0) return "";
 				if (members.length === 1) return members[0];
@@ -1439,11 +1594,21 @@ const printerZod = ast.createPrinter((options) => {
 			intersection(node) {
 				const members = node.members ?? [];
 				if (members.length === 0) return "";
+				const hasSiblingProperties = members.some((member) => member.type === ast.schemaTypes.object && member.properties.length > 0);
+				const transform = (member) => {
+					if (!hasSiblingProperties) return this.transform(member);
+					unionsWithSiblings.add(member);
+					try {
+						return this.transform(member);
+					} finally {
+						unionsWithSiblings.delete(member);
+					}
+				};
 				const [first, ...rest] = members;
 				if (!first) return "";
-				const firstBase = this.transform(first);
+				const firstBase = transform(first);
 				if (!firstBase) return "";
-				if (rest.length > 0 && isObjectComposableIntersection(node, cyclicSchemaNames)) return rest.reduce((acc, member) => `${acc}.extend(${buildZodObjectShape(this, member)})`, firstBase);
+				if (rest.length > 0 && isObjectComposableIntersection(node, cyclicSchemaNames)) return preserveRequiredProperties(members).slice(1).reduce((acc, member) => `${acc}.extend(${buildZodObjectShape(this, member)})`, firstBase);
 				return rest.reduce((acc, member) => {
 					const constraint = getMemberConstraint({
 						member,
@@ -1452,7 +1617,7 @@ const printerZod = ast.createPrinter((options) => {
 						numbers: numberConstraints
 					});
 					if (constraint) return acc + constraint;
-					const transformed = this.transform(member);
+					const transformed = transform(member);
 					return transformed ? `${acc}.and(${transformed})` : acc;
 				}, firstBase);
 			}
@@ -1472,20 +1637,25 @@ const printerZod = ast.createPrinter((options) => {
 		}
 	};
 });
-//#endregion
-//#region src/printers/printerZodMini.ts
+// src/printers/printerZodMini.ts
 /**
 * Builds the `{ key: value, … }` shape for an object node with the functional `zod/mini` modifiers.
 */
 function buildZodMiniObjectShape(ctx, node) {
-	return buildObjectShape(ctx, node, ({ value, schema, required, meta }) => applyMiniModifiers({
-		value,
-		schema,
-		nullable: meta.nullable,
-		optional: schema.optional || required === false,
-		nullish: schema.nullish,
-		defaultValue: meta.default
-	}));
+	return buildObjectShape(ctx, node, ({ name, value, schema, required, meta, cyclic }) => {
+		const body = applyMiniModifiers({
+			value,
+			schema,
+			nullable: meta.nullable,
+			optional: schema.optional || required === false,
+			nullish: schema.nullish,
+			defaultValue: meta.default
+		});
+		return cyclic ? lazyGetter({
+			name,
+			body
+		}) : `${objectKey(name)}: ${body}`;
+	});
 }
 /**
 * Zod v4 Mini printer built with `definePrinter`.
@@ -1501,6 +1671,7 @@ function buildZodMiniObjectShape(ctx, node) {
 */
 const printerZodMini = ast.createPrinter((options) => {
 	const cyclicSchemaNames = options.cyclicSchemas;
+	const unionsWithSiblings = /* @__PURE__ */ new WeakSet();
 	return {
 		name: "zod-mini",
 		options,
@@ -1573,7 +1744,7 @@ const printerZodMini = ast.createPrinter((options) => {
 			enum(node) {
 				const nonNullValues = (node.namedEnumValues?.map((v) => v.value) ?? node.enumValues ?? []).filter((v) => v !== null);
 				if (node.namedEnumValues?.length) {
-					const literals = nonNullValues.map((v) => `z.literal(${formatDefault(v)})`);
+					const literals = nonNullValues.map((v) => buildLiteral(v));
 					if (literals.length === 1) return literals[0];
 					return `z.union([${literals.join(", ")}])`;
 				}
@@ -1595,32 +1766,40 @@ const printerZodMini = ast.createPrinter((options) => {
 				const isStrict = node.additionalProperties === false && patterns.length === 0;
 				const isLoose = node.additionalProperties === true;
 				const objectBase = `${isStrict ? "z.strictObject" : isLoose ? "z.looseObject" : "z.object"}(${buildZodMiniObjectShape(this, node)})`;
-				const recordFn = isClosedKeySchema(propertyNamesNode) ? "z.partialRecord" : "z.record";
-				if (node.additionalProperties && node.additionalProperties !== true) {
-					const catchallType = this.transform(node.additionalProperties);
-					if (entries.length === 0) return catchallType ? `${recordFn}(${propertyNamesKeySchema || "z.string()"}, ${catchallType})` : objectBase;
-					return catchallType ? `z.catchall(${objectBase}, ${catchallType})` : objectBase;
-				}
-				if (entries.length === 0 && patterns.length === 0 && propertyNamesKeySchema && !isStrict) return `${recordFn}(${propertyNamesKeySchema}, ${this.transform(ast.factory.createSchema({ type: "unknown" }))})`;
-				if (node.additionalProperties === true) return objectBase;
-				if (isStrict) return objectBase;
-				if (patterns.length > 0) {
-					const values = patterns.map(([, valueSchema]) => {
-						const valueType = this.transform(valueSchema) ?? this.transform(ast.factory.createSchema({ type: "unknown" }));
-						return valueSchema.nullable ? `z.nullable(${valueType})` : valueType;
-					});
-					const distinct = [...new Set(values)];
-					const value = distinct.length === 1 ? distinct[0] : `z.union([${distinct.join(", ")}])`;
-					if (entries.length > 0) return `z.catchall(${objectBase}, ${value})`;
-					return `z.record(${patternKeySchemaMini({
-						patterns: patterns.map(([pattern]) => pattern),
-						regexType: this.options.regexType
-					})}, ${value})`;
-				}
-				return objectBase;
+				return objectConstraints({
+					value: (() => {
+						const recordFn = isClosedKeySchema(propertyNamesNode) ? "z.partialRecord" : "z.record";
+						if (node.additionalProperties && node.additionalProperties !== true) {
+							const catchallType = this.transform(node.additionalProperties);
+							if (entries.length === 0) return catchallType ? `${recordFn}(${propertyNamesKeySchema || "z.string()"}, ${catchallType})` : objectBase;
+							return catchallType ? `z.catchall(${objectBase}, ${catchallType})` : objectBase;
+						}
+						if (entries.length === 0 && patterns.length === 0 && propertyNamesKeySchema && !isStrict) {
+							const unknownType = this.transform(ast.factory.createSchema({ type: ast.schemaTypes.unknown }));
+							return `${recordFn}(${propertyNamesKeySchema}, ${unknownType})`;
+						}
+						if (node.additionalProperties === true) return objectBase;
+						if (isStrict) return objectBase;
+						if (patterns.length > 0) {
+							const values = patterns.map(([, valueSchema]) => {
+								const valueType = this.transform(valueSchema) ?? this.transform(ast.factory.createSchema({ type: ast.schemaTypes.unknown }));
+								return valueSchema.nullable ? `z.nullable(${valueType})` : valueType;
+							});
+							const distinct = [...new Set(values)];
+							const value = distinct.length === 1 ? distinct[0] : `z.union([${distinct.join(", ")}])`;
+							if (entries.length > 0) return `z.catchall(${objectBase}, ${value})`;
+							return `z.record(${patternKeySchemaMini({
+								patterns: patterns.map(([pattern]) => pattern),
+								regexType: this.options.regexType
+							})}, ${value})`;
+						}
+						return objectBase;
+					})(),
+					node
+				});
 			},
 			array(node) {
-				const base = `z.array(${mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean).join(", ") || this.transform(ast.factory.createSchema({ type: "unknown" }))})${lengthChecksMini({
+				const base = `z.array(${mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean).join(", ") || this.transform(ast.factory.createSchema({ type: ast.schemaTypes.unknown }))})${lengthChecksMini({
 					...node,
 					regexType: this.options.regexType
 				})}`;
@@ -1633,7 +1812,7 @@ const printerZodMini = ast.createPrinter((options) => {
 				const nodeMembers = node.members ?? [];
 				const isDiscriminated = !!node.discriminatorPropertyName && nodeMembers.every((m) => isObjectSchemaNode(m, cyclicSchemaNames));
 				const isXor = node.strategy === "one" && !isDiscriminated && this.options.oneOfType === "xor";
-				const isStrict = node.strategy === "one" && !isXor;
+				const isStrict = node.strategy === "one" && !isXor && !unionsWithSiblings.has(node);
 				const members = mapSchemaMembers(node, (memberNode) => this.transform(isStrict ? strictOneOfNode(memberNode) : memberNode)).map(({ output }) => output).filter(Boolean);
 				if (members.length === 0) return "";
 				if (members.length === 1) return members[0];
@@ -1644,11 +1823,21 @@ const printerZodMini = ast.createPrinter((options) => {
 			intersection(node) {
 				const members = node.members ?? [];
 				if (members.length === 0) return "";
+				const hasSiblingProperties = members.some((member) => member.type === ast.schemaTypes.object && member.properties.length > 0);
+				const transform = (member) => {
+					if (!hasSiblingProperties) return this.transform(member);
+					unionsWithSiblings.add(member);
+					try {
+						return this.transform(member);
+					} finally {
+						unionsWithSiblings.delete(member);
+					}
+				};
 				const [first, ...rest] = members;
 				if (!first) return "";
-				const firstBase = this.transform(first);
+				const firstBase = transform(first);
 				if (!firstBase) return "";
-				if (rest.length > 0 && isObjectComposableIntersection(node, cyclicSchemaNames)) return rest.reduce((acc, member) => `z.extend(${acc}, ${buildZodMiniObjectShape(this, member)})`, firstBase);
+				if (rest.length > 0 && isObjectComposableIntersection(node, cyclicSchemaNames)) return preserveRequiredProperties(members).slice(1).reduce((acc, member) => `z.extend(${acc}, ${buildZodMiniObjectShape(this, member)})`, firstBase);
 				return rest.reduce((acc, member) => {
 					const constraint = getMemberConstraint({
 						member,
@@ -1657,7 +1846,7 @@ const printerZodMini = ast.createPrinter((options) => {
 						numbers: numberChecksMini
 					});
 					if (constraint) return acc + constraint;
-					const transformed = this.transform(member);
+					const transformed = transform(member);
 					return transformed ? `z.intersection(${acc}, ${transformed})` : acc;
 				}, firstBase);
 			}
@@ -1675,8 +1864,7 @@ const printerZodMini = ast.createPrinter((options) => {
 		}
 	};
 });
-//#endregion
-//#region src/generators/zodGenerator.tsx
+// src/generators/zodGenerator.tsx
 /**
 * The helper an inferred alias is printed with. `'codec'` reads a request (encode) schema from its
 * input and a response (decode) schema from its output; `true` keeps `z.infer` for both.
@@ -2137,17 +2325,14 @@ const zodGenerator = defineGenerator({
 		});
 	}
 });
-//#endregion
-//#region kubb-extension.json
+// kubb-extension.json
 var compatibility = {
-	"kubb": ">=5.8.3",
+	"kubb": ">=5.14.6",
 	"node": ">=22.22"
 };
-//#endregion
-//#region package.json
-var version = "5.7.2";
-//#endregion
-//#region src/resolvers/resolverZod.ts
+// package.json
+var version = "5.7.4";
+// src/resolvers/resolverZod.ts
 /**
 * Default resolver used by `@kubb/plugin-zod`. Decides the names and file
 * paths for every generated Zod schema. Schemas use camelCase with a
@@ -2166,15 +2351,15 @@ var version = "5.7.2";
 const resolverZod = createResolver({
 	pluginName: "plugin-zod",
 	name(name) {
-		return ensureValidVarName(camelCase(name, { suffix: "schema" }));
+		return this.memo(`name:${name}`, () => ensureValidVarName(camelCase(name, { suffix: "schema" })));
 	},
 	file: createCasedFile((part) => camelCase(part, { suffix: "schema" })),
 	schema: {
 		typeName(name) {
-			return ensureValidVarName(pascalCase(name, { suffix: "schema type" }));
+			return this.memo(`typeName:${name}`, () => ensureValidVarName(pascalCase(name, { suffix: "schema type" })));
 		},
 		type(name) {
-			return ensureValidVarName(pascalCase(name, { suffix: "type" }));
+			return this.memo(`type:${name}`, () => ensureValidVarName(pascalCase(name, { suffix: "type" })));
 		},
 		inputName(name) {
 			return this.name(`${name} input`);
@@ -2193,15 +2378,22 @@ const resolverZod = createResolver({
 	response: {
 		...createOperationResponseResolver(),
 		error(node) {
-			return this.name(`${node.operationId} Error`);
+			const name = this.name(`${node.operationId} Error`);
+			return this.resolveName({
+				key: operationKey(node, "response", "error"),
+				name
+			});
 		},
 		options(node) {
-			return this.schema.type(this.name(`${node.operationId} Options`));
+			const name = this.schema.type(this.name(`${node.operationId} Options`));
+			return this.resolveName({
+				key: operationKey(node, "response", "options"),
+				name
+			});
 		}
 	}
 });
-//#endregion
-//#region src/plugin.ts
+// src/plugin.ts
 /**
 * Canonical plugin name for `@kubb/plugin-zod`. Used for driver lookups and
 * cross-plugin dependency references.
@@ -2267,7 +2459,6 @@ const pluginZod = defineExtension({
 		};
 	}
 });
-//#endregion
 export { pluginZod as default, pluginZod, pluginZodName, printerZod, printerZodMini, resolverZod, zodGenerator };
 
 //# sourceMappingURL=index.js.map