@kubb/plugin-zod 5.0.0-beta.3 → 5.0.0-beta.30

package/dist/index.js

@@ -1,6 +1,6 @@
-import "./chunk--u3MIqq1.js";
+import { t as __name } from "./chunk--u3MIqq1.js";
 import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
-import { Const, File, Type, jsxRenderer } from "@kubb/renderer-jsx";
+import { Const, File, Type, jsxRendererSync } from "@kubb/renderer-jsx";
 import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
 //#region ../../internals/utils/src/casing.ts
 /**
@@ -126,6 +126,129 @@ function toRegExpString(text, func = "RegExp") {
 	return `new ${func}(${JSON.stringify(source)}${flags ? `, ${JSON.stringify(flags)}` : ""})`;
 }
 //#endregion
+//#region ../../internals/utils/src/reserved.ts
+/**
+* JavaScript and Java reserved words.
+* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+*/
+const reservedWords = new Set([
+	"abstract",
+	"arguments",
+	"boolean",
+	"break",
+	"byte",
+	"case",
+	"catch",
+	"char",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"double",
+	"else",
+	"enum",
+	"eval",
+	"export",
+	"extends",
+	"false",
+	"final",
+	"finally",
+	"float",
+	"for",
+	"function",
+	"goto",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"int",
+	"interface",
+	"let",
+	"long",
+	"native",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"short",
+	"static",
+	"super",
+	"switch",
+	"synchronized",
+	"this",
+	"throw",
+	"throws",
+	"transient",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"volatile",
+	"while",
+	"with",
+	"yield",
+	"Array",
+	"Date",
+	"hasOwnProperty",
+	"Infinity",
+	"isFinite",
+	"isNaN",
+	"isPrototypeOf",
+	"length",
+	"Math",
+	"name",
+	"NaN",
+	"Number",
+	"Object",
+	"prototype",
+	"String",
+	"toString",
+	"undefined",
+	"valueOf"
+]);
+/**
+* Returns `true` when `name` is a syntactically valid JavaScript variable name.
+*
+* @example
+* ```ts
+* isValidVarName('status')  // true
+* isValidVarName('class')   // false (reserved word)
+* isValidVarName('42foo')   // false (starts with digit)
+* ```
+*/
+function isValidVarName(name) {
+	if (!name || reservedWords.has(name)) return false;
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+/**
+* Returns `name` when it's a syntactically valid JavaScript variable name,
+* otherwise prefixes it with `_` so the result is a valid identifier.
+*
+* Useful for sanitizing OpenAPI schema names or operation IDs that start with
+* a digit (e.g. `409`, `504AccountCancel`) before using them as exported
+* variable, type, or function names.
+*
+* @example
+* ```ts
+* ensureValidVarName('409')             // '_409'
+* ensureValidVarName('504AccountCancel') // '_504AccountCancel'
+* ensureValidVarName('Pet')              // 'Pet'
+* ensureValidVarName('class')            // '_class'
+* ```
+*/
+function ensureValidVarName(name) {
+	if (!name || isValidVarName(name)) return name;
+	return `_${name}`;
+}
+//#endregion
 //#region src/components/Operations.tsx
 function Operations({ name, operations }) {
 	const operationsJSON = operations.reduce((prev, acc) => {
@@ -261,11 +384,11 @@ function buildSchemaNames(node, { params, resolver }) {
 	}
 	responses["default"] = resolver.resolveResponseName(node);
 	return {
-		request: node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0,
+		request: node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null,
 		parameters: {
-			path: pathParam ? resolver.resolvePathParamsName(node, pathParam) : void 0,
-			query: queryParam ? resolver.resolveQueryParamsName(node, queryParam) : void 0,
-			header: headerParam ? resolver.resolveHeaderParamsName(node, headerParam) : void 0
+			path: pathParam ? resolver.resolvePathParamsName(node, pathParam) : null,
+			query: queryParam ? resolver.resolveQueryParamsName(node, queryParam) : null,
+			header: headerParam ? resolver.resolveHeaderParamsName(node, headerParam) : null
 		},
 		responses,
 		errors
@@ -339,30 +462,44 @@ function lengthChecksMini({ min, max, pattern }) {
 * to a schema value string using the chainable Zod v4 API.
 */
 function applyModifiers({ value, nullable, optional, nullish, defaultValue, description }) {
-	let result = value;
-	if (nullish || nullable && optional) result = `${result}.nullish()`;
-	else if (optional) result = `${result}.optional()`;
-	else if (nullable) result = `${result}.nullable()`;
-	if (defaultValue !== void 0) result = `${result}.default(${formatDefault(defaultValue)})`;
-	if (description) result = `${result}.describe(${stringify(description)})`;
-	return result;
+	const withModifier = (() => {
+		if (nullish || nullable && optional) return `${value}.nullish()`;
+		if (optional) return `${value}.optional()`;
+		if (nullable) return `${value}.nullable()`;
+		return value;
+	})();
+	const withDefault = defaultValue !== void 0 ? `${withModifier}.default(${formatDefault(defaultValue)})` : withModifier;
+	return description ? `${withDefault}.describe(${stringify(description)})` : withDefault;
 }
 /**
 * Apply nullable / optional / nullish modifiers using the functional `zod/mini` API
 * (`z.nullable()`, `z.optional()`, `z.nullish()`).
 */
 function applyMiniModifiers({ value, nullable, optional, nullish, defaultValue }) {
-	let result = value;
-	if (nullish) result = `z.nullish(${result})`;
-	else {
-		if (nullable) result = `z.nullable(${result})`;
-		if (optional) result = `z.optional(${result})`;
-	}
-	if (defaultValue !== void 0) result = `z._default(${result}, ${formatDefault(defaultValue)})`;
-	return result;
+	const withModifier = (() => {
+		if (nullish) return `z.nullish(${value})`;
+		const withNullable = nullable ? `z.nullable(${value})` : value;
+		return optional ? `z.optional(${withNullable})` : withNullable;
+	})();
+	return defaultValue !== void 0 ? `z._default(${withModifier}, ${formatDefault(defaultValue)})` : withModifier;
 }
 //#endregion
 //#region src/printers/printerZod.ts
+function strictOneOfMember$1(member, node) {
+	if (node.type === "object" && node.additionalProperties === void 0) return `${member}.strict()`;
+	if (node.type === "ref") {
+		if (member.startsWith("z.lazy(")) return member;
+		const schema = ast.syncSchemaRef(node);
+		if (schema.type === "object" && (schema.additionalProperties === void 0 || schema.additionalProperties === false)) return `${member}.strict()`;
+	}
+	return member;
+}
+__name(strictOneOfMember$1, "strictOneOfMember");
+function getMemberConstraint(member) {
+	if (member.primitive === "string") return lengthConstraints(ast.narrowSchema(member, "string") ?? {}) || void 0;
+	if (member.primitive === "number" || member.primitive === "integer") return numberConstraints(ast.narrowSchema(member, "number") ?? ast.narrowSchema(member, "integer") ?? {}) || void 0;
+	if (member.primitive === "array") return lengthConstraints(ast.narrowSchema(member, "array") ?? {}) || void 0;
+}
 /**
 * Zod v4 printer built with `definePrinter`.
 *
@@ -435,29 +572,29 @@ const printerZod = ast.definePrinter((options) => {
 				return `z.enum([${nonNullValues.map(formatLiteral).join(", ")}])`;
 			},
 			ref(node) {
-				if (!node.name) return void 0;
+				if (!node.name) return null;
 				const refName = node.ref ? ast.extractRefName(node.ref) ?? node.name : node.name;
 				const resolvedName = node.ref ? this.options.resolver?.default(refName, "function") ?? refName : node.name;
 				if (node.ref && this.options.cyclicSchemas?.has(refName)) return `z.lazy(() => ${resolvedName})`;
 				return resolvedName;
 			},
 			object(node) {
-				let result = `z.object({\n    ${node.properties.map((prop) => {
+				const objectBase = `z.object({\n    ${node.properties.map((prop) => {
 					const { name: propName, schema } = prop;
 					const meta = ast.syncSchemaRef(schema);
 					const isNullable = meta.nullable;
 					const isOptional = schema.optional;
 					const isNullish = schema.nullish;
 					const hasSelfRef = this.options.cyclicSchemas != null && ast.containsCircularRef(schema, { circularSchemas: this.options.cyclicSchemas });
+					const savedCyclicSchemas = this.options.cyclicSchemas;
 					if (hasSelfRef) this.options.cyclicSchemas = void 0;
 					const baseOutput = this.transform(schema) ?? this.transform(ast.createSchema({ type: "unknown" }));
-					if (hasSelfRef) this.options.cyclicSchemas = options.cyclicSchemas;
+					if (hasSelfRef) this.options.cyclicSchemas = savedCyclicSchemas;
 					const wrappedOutput = this.options.wrapOutput ? this.options.wrapOutput({
 						output: baseOutput,
 						schema
 					}) || baseOutput : baseOutput;
-					let descriptionToApply = meta.description;
-					if (schema.type !== "ref" && meta.type === "ref") descriptionToApply = void 0;
+					const descriptionToApply = schema.type !== "ref" && meta.type === "ref" ? void 0 : meta.description;
 					const value = applyModifiers({
 						value: wrappedOutput,
 						nullable: isNullable,
@@ -469,24 +606,29 @@ const printerZod = ast.definePrinter((options) => {
 					if (hasSelfRef) return `get "${propName}"() { return ${value} }`;
 					return `"${propName}": ${value}`;
 				}).join(",\n    ")}\n    })`;
-				if (node.additionalProperties && node.additionalProperties !== true) {
-					const catchallType = this.transform(node.additionalProperties);
-					if (catchallType) result += `.catchall(${catchallType})`;
-				} else if (node.additionalProperties === true) result += `.catchall(${this.transform(ast.createSchema({ type: "unknown" }))})`;
-				else if (node.additionalProperties === false) result += ".strict()";
-				return result;
+				return (() => {
+					if (node.additionalProperties && node.additionalProperties !== true) {
+						const catchallType = this.transform(node.additionalProperties);
+						return catchallType ? `${objectBase}.catchall(${catchallType})` : objectBase;
+					}
+					if (node.additionalProperties === true) return `${objectBase}.catchall(${this.transform(ast.createSchema({ type: "unknown" }))})`;
+					if (node.additionalProperties === false) return `${objectBase}.strict()`;
+					return objectBase;
+				})();
 			},
 			array(node) {
-				let result = `z.array(${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ") || this.transform(ast.createSchema({ type: "unknown" }))})${lengthConstraints(node)}`;
-				if (node.unique) result += `.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })`;
-				return result;
+				const base = `z.array(${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ") || this.transform(ast.createSchema({ type: "unknown" }))})${lengthConstraints(node)}`;
+				return node.unique ? `${base}.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })` : base;
 			},
 			tuple(node) {
 				return `z.tuple([${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ")}])`;
 			},
 			union(node) {
 				const nodeMembers = node.members ?? [];
-				const members = nodeMembers.map((m) => this.transform(m)).filter(Boolean);
+				const members = nodeMembers.map((memberNode) => {
+					const member = this.transform(memberNode);
+					return member && node.strategy === "one" ? strictOneOfMember$1(member, memberNode) : member;
+				}).filter(Boolean);
 				if (members.length === 0) return "";
 				if (members.length === 1) return members[0];
 				if (node.discriminatorPropertyName && !nodeMembers.some((m) => m.type === "intersection")) return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, [${members.join(", ")}])`;
@@ -497,47 +639,29 @@ const printerZod = ast.definePrinter((options) => {
 				if (members.length === 0) return "";
 				const [first, ...rest] = members;
 				if (!first) return "";
-				let base = this.transform(first);
-				if (!base) return "";
-				for (const member of rest) {
-					if (member.primitive === "string") {
-						const c = lengthConstraints(ast.narrowSchema(member, "string") ?? {});
-						if (c) {
-							base += c;
-							continue;
-						}
-					} else if (member.primitive === "number" || member.primitive === "integer") {
-						const c = numberConstraints(ast.narrowSchema(member, "number") ?? ast.narrowSchema(member, "integer") ?? {});
-						if (c) {
-							base += c;
-							continue;
-						}
-					} else if (member.primitive === "array") {
-						const c = lengthConstraints(ast.narrowSchema(member, "array") ?? {});
-						if (c) {
-							base += c;
-							continue;
-						}
-					}
+				const firstBase = this.transform(first);
+				if (!firstBase) return "";
+				return rest.reduce((acc, member) => {
+					const constraint = getMemberConstraint(member);
+					if (constraint) return acc + constraint;
 					const transformed = this.transform(member);
-					if (transformed) base = `${base}.and(${transformed})`;
-				}
-				return base;
+					return transformed ? `${acc}.and(${transformed})` : acc;
+				}, firstBase);
 			},
 			...options.nodes
 		},
 		print(node) {
 			const { keysToOmit } = this.options;
-			let base = this.transform(node);
-			if (!base) return null;
+			const transformed = this.transform(node);
+			if (!transformed) return null;
 			const meta = ast.syncSchemaRef(node);
-			if (keysToOmit?.length && meta.primitive === "object" && !(meta.type === "union" && meta.discriminatorPropertyName)) {
-				const lazyMatch = base.match(/^z\.lazy\(\(\)\s*=>\s*(.+)\)$/);
-				if (lazyMatch) base = `z.lazy(() => ${lazyMatch[1]}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} }))`;
-				else base = `${base}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} })`;
-			}
 			return applyModifiers({
-				value: base,
+				value: (() => {
+					if (!keysToOmit?.length || meta.primitive !== "object" || meta.type === "union" && meta.discriminatorPropertyName) return transformed;
+					const lazyMatch = transformed.match(/^z\.lazy\(\(\)\s*=>\s*(.+)\)$/);
+					if (lazyMatch) return `z.lazy(() => ${lazyMatch[1]}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} }))`;
+					return `${transformed}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} })`;
+				})(),
 				nullable: meta.nullable,
 				optional: meta.optional,
 				nullish: meta.nullish,
@@ -549,6 +673,15 @@ const printerZod = ast.definePrinter((options) => {
 });
 //#endregion
 //#region src/printers/printerZodMini.ts
+function strictOneOfMember(member, node) {
+	if (node.type === "object" && (node.additionalProperties === void 0 || node.additionalProperties === false)) return member.replace(/^z\.object\(/, "z.strictObject(");
+	return member;
+}
+function getMemberConstraintMini(member) {
+	if (member.primitive === "string") return lengthChecksMini(ast.narrowSchema(member, "string") ?? {}) || void 0;
+	if (member.primitive === "number" || member.primitive === "integer") return numberChecksMini(ast.narrowSchema(member, "number") ?? ast.narrowSchema(member, "integer") ?? {}) || void 0;
+	if (member.primitive === "array") return lengthChecksMini(ast.narrowSchema(member, "array") ?? {}) || void 0;
+}
 /**
 * Zod v4 **Mini** printer built with `definePrinter`.
 *
@@ -617,7 +750,7 @@ const printerZodMini = ast.definePrinter((options) => {
 				return `z.enum([${nonNullValues.map(formatLiteral).join(", ")}])`;
 			},
 			ref(node) {
-				if (!node.name) return void 0;
+				if (!node.name) return null;
 				const refName = node.ref ? ast.extractRefName(node.ref) ?? node.name : node.name;
 				const resolvedName = node.ref ? this.options.resolver?.default(refName, "function") ?? refName : node.name;
 				if (node.ref && this.options.cyclicSchemas?.has(refName)) return `z.lazy(() => ${resolvedName})`;
@@ -631,9 +764,10 @@ const printerZodMini = ast.definePrinter((options) => {
 					const isOptional = schema.optional;
 					const isNullish = schema.nullish;
 					const hasSelfRef = this.options.cyclicSchemas != null && ast.containsCircularRef(schema, { circularSchemas: this.options.cyclicSchemas });
+					const savedCyclicSchemas = this.options.cyclicSchemas;
 					if (hasSelfRef) this.options.cyclicSchemas = void 0;
 					const baseOutput = this.transform(schema) ?? this.transform(ast.createSchema({ type: "unknown" }));
-					if (hasSelfRef) this.options.cyclicSchemas = options.cyclicSchemas;
+					if (hasSelfRef) this.options.cyclicSchemas = savedCyclicSchemas;
 					const value = applyMiniModifiers({
 						value: this.options.wrapOutput ? this.options.wrapOutput({
 							output: baseOutput,
@@ -649,16 +783,18 @@ const printerZodMini = ast.definePrinter((options) => {
 				}).join(",\n    ")}\n    })`;
 			},
 			array(node) {
-				let result = `z.array(${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ") || this.transform(ast.createSchema({ type: "unknown" }))})${lengthChecksMini(node)}`;
-				if (node.unique) result += `.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })`;
-				return result;
+				const base = `z.array(${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ") || this.transform(ast.createSchema({ type: "unknown" }))})${lengthChecksMini(node)}`;
+				return node.unique ? `${base}.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })` : base;
 			},
 			tuple(node) {
 				return `z.tuple([${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ")}])`;
 			},
 			union(node) {
 				const nodeMembers = node.members ?? [];
-				const members = nodeMembers.map((m) => this.transform(m)).filter(Boolean);
+				const members = nodeMembers.map((memberNode) => {
+					const member = this.transform(memberNode);
+					return member && node.strategy === "one" ? strictOneOfMember(member, memberNode) : member;
+				}).filter(Boolean);
 				if (members.length === 0) return "";
 				if (members.length === 1) return members[0];
 				if (node.discriminatorPropertyName && !nodeMembers.some((m) => m.type === "intersection")) return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, [${members.join(", ")}])`;
@@ -669,47 +805,29 @@ const printerZodMini = ast.definePrinter((options) => {
 				if (members.length === 0) return "";
 				const [first, ...rest] = members;
 				if (!first) return "";
-				let base = this.transform(first);
-				if (!base) return "";
-				for (const member of rest) {
-					if (member.primitive === "string") {
-						const c = lengthChecksMini(ast.narrowSchema(member, "string") ?? {});
-						if (c) {
-							base += c;
-							continue;
-						}
-					} else if (member.primitive === "number" || member.primitive === "integer") {
-						const c = numberChecksMini(ast.narrowSchema(member, "number") ?? ast.narrowSchema(member, "integer") ?? {});
-						if (c) {
-							base += c;
-							continue;
-						}
-					} else if (member.primitive === "array") {
-						const c = lengthChecksMini(ast.narrowSchema(member, "array") ?? {});
-						if (c) {
-							base += c;
-							continue;
-						}
-					}
+				const firstBase = this.transform(first);
+				if (!firstBase) return "";
+				return rest.reduce((acc, member) => {
+					const constraint = getMemberConstraintMini(member);
+					if (constraint) return acc + constraint;
 					const transformed = this.transform(member);
-					if (transformed) base = `z.intersection(${base}, ${transformed})`;
-				}
-				return base;
+					return transformed ? `z.intersection(${acc}, ${transformed})` : acc;
+				}, firstBase);
 			},
 			...options.nodes
 		},
 		print(node) {
 			const { keysToOmit } = this.options;
-			let base = this.transform(node);
-			if (!base) return null;
+			const transformed = this.transform(node);
+			if (!transformed) return null;
 			const meta = ast.syncSchemaRef(node);
-			if (keysToOmit?.length && meta.primitive === "object" && !(meta.type === "union" && meta.discriminatorPropertyName)) {
-				const lazyMatch = base.match(/^z\.lazy\(\(\)\s*=>\s*(.+)\)$/);
-				if (lazyMatch) base = `z.lazy(() => ${lazyMatch[1]}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} }))`;
-				else base = `${base}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} })`;
-			}
 			return applyMiniModifiers({
-				value: base,
+				value: (() => {
+					if (!keysToOmit?.length || meta.primitive !== "object" || meta.type === "union" && meta.discriminatorPropertyName) return transformed;
+					const lazyMatch = transformed.match(/^z\.lazy\(\(\)\s*=>\s*(.+)\)$/);
+					if (lazyMatch) return `z.lazy(() => ${lazyMatch[1]}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} }))`;
+					return `${transformed}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} })`;
+				})(),
 				nullable: meta.nullable,
 				optional: meta.optional,
 				nullish: meta.nullish,
@@ -720,9 +838,17 @@ const printerZodMini = ast.definePrinter((options) => {
 });
 //#endregion
 //#region src/generators/zodGenerator.tsx
+const zodPrinterCache = /* @__PURE__ */ new WeakMap();
+const zodMiniPrinterCache = /* @__PURE__ */ new WeakMap();
+/**
+* Built-in generator for `@kubb/plugin-zod`. Emits one Zod schema per
+* schema in the spec plus per-operation request/response/parameter schemas.
+* When `mini: true`, schemas use the Zod Mini functional API instead of
+* chainable methods.
+*/
 const zodGenerator = defineGenerator({
 	name: "zod",
-	renderer: jsxRenderer,
+	renderer: jsxRendererSync,
 	schema(node, ctx) {
 		const { adapter, config, resolver, root } = ctx;
 		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, printer } = ctx.options;
@@ -738,7 +864,7 @@ const zodGenerator = defineGenerator({
 			}, {
 				root,
 				output,
-				group
+				group: group ?? void 0
 			}).path
 		}));
 		const meta = {
@@ -749,37 +875,67 @@ const zodGenerator = defineGenerator({
 			}, {
 				root,
 				output,
-				group
+				group: group ?? void 0
 			})
 		};
-		const inferTypeName = inferred ? resolver.resolveSchemaTypeName(node.name) : void 0;
-		const cyclicSchemas = adapter.inputNode ? ast.findCircularSchemas(adapter.inputNode.schemas) : void 0;
-		const schemaPrinter = mini ? printerZodMini({
-			guidType,
-			wrapOutput,
-			resolver,
-			cyclicSchemas,
-			nodes: printer?.nodes
-		}) : printerZod({
-			coercion,
-			guidType,
-			dateType,
-			wrapOutput,
-			resolver,
-			cyclicSchemas,
-			nodes: printer?.nodes
-		});
+		const inferTypeName = inferred ? resolver.resolveSchemaTypeName(node.name) : null;
+		const cyclicSchemas = new Set(ctx.meta.circularNames);
+		const schemaPrinter = mini ? getCachedMiniPrinter() : getCachedStdPrinter();
+		function getCachedStdPrinter() {
+			const cached = zodPrinterCache.get(resolver);
+			if (cached && cached.coercion === coercion && cached.guidType === guidType && cached.dateType === dateType) return cached.printer;
+			const p = printerZod({
+				coercion,
+				guidType,
+				dateType,
+				wrapOutput,
+				resolver,
+				cyclicSchemas,
+				nodes: printer?.nodes
+			});
+			zodPrinterCache.set(resolver, {
+				printer: p,
+				coercion,
+				guidType,
+				dateType
+			});
+			return p;
+		}
+		function getCachedMiniPrinter() {
+			const cached = zodMiniPrinterCache.get(resolver);
+			if (cached && cached.guidType === guidType) return cached.printer;
+			const p = printerZodMini({
+				guidType,
+				wrapOutput,
+				resolver,
+				cyclicSchemas,
+				nodes: printer?.nodes
+			});
+			zodMiniPrinterCache.set(resolver, {
+				printer: p,
+				guidType
+			});
+			return p;
+		}
 		return /* @__PURE__ */ jsxs(File, {
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
-			banner: resolver.resolveBanner(adapter.inputNode, {
+			banner: resolver.resolveBanner(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
-			footer: resolver.resolveFooter(adapter.inputNode, {
+			footer: resolver.resolveFooter(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
 			children: [
 				/* @__PURE__ */ jsx(File.Import, {
@@ -816,12 +972,12 @@ const zodGenerator = defineGenerator({
 		}, {
 			root,
 			output,
-			group
+			group: group ?? void 0
 		}) };
-		const cyclicSchemas = adapter.inputNode ? ast.findCircularSchemas(adapter.inputNode.schemas) : void 0;
+		const cyclicSchemas = new Set(ctx.meta.circularNames);
 		function renderSchemaEntry({ schema, name, keysToOmit }) {
 			if (!schema) return null;
-			const inferTypeName = inferred ? resolver.resolveTypeName(name) : void 0;
+			const inferTypeName = inferred ? resolver.resolveTypeName(name) : null;
 			const imports = adapter.getImports(schema, (schemaName) => ({
 				name: resolver.resolveSchemaName(schemaName),
 				path: resolver.resolveFile({
@@ -830,17 +986,25 @@ const zodGenerator = defineGenerator({
 				}, {
 					root,
 					output,
-					group
+					group: group ?? void 0
 				}).path
 			}));
-			const schemaPrinter = mini ? printerZodMini({
+			const cachedStd = zodPrinterCache.get(resolver);
+			const cachedMini = zodMiniPrinterCache.get(resolver);
+			const schemaPrinter = mini ? keysToOmit?.length ? printerZodMini({
 				guidType,
 				wrapOutput,
 				resolver,
 				keysToOmit,
 				cyclicSchemas,
 				nodes: printer?.nodes
-			}) : printerZod({
+			}) : cachedMini?.guidType === guidType ? cachedMini.printer : printerZodMini({
+				guidType,
+				wrapOutput,
+				resolver,
+				cyclicSchemas,
+				nodes: printer?.nodes
+			}) : keysToOmit?.length ? printerZod({
 				coercion,
 				guidType,
 				dateType,
@@ -849,6 +1013,14 @@ const zodGenerator = defineGenerator({
 				keysToOmit,
 				cyclicSchemas,
 				nodes: printer?.nodes
+			}) : cachedStd?.coercion === coercion && cachedStd?.guidType === guidType && cachedStd?.dateType === dateType ? cachedStd.printer : printerZod({
+				coercion,
+				guidType,
+				dateType,
+				wrapOutput,
+				resolver,
+				cyclicSchemas,
+				nodes: printer?.nodes
 			});
 			return /* @__PURE__ */ jsxs(Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
 				root: meta.file.path,
@@ -870,14 +1042,14 @@ const zodGenerator = defineGenerator({
 			name: resolver.resolveParamName(node, param)
 		}));
 		const responseSchemas = node.responses.map((res) => renderSchemaEntry({
-			schema: res.schema,
+			schema: res.content?.[0]?.schema ?? null,
 			name: resolver.resolveResponseStatusName(node, res.statusCode),
-			keysToOmit: res.keysToOmit
+			keysToOmit: res.content?.[0]?.keysToOmit
 		}));
-		const responsesWithSchema = node.responses.filter((res) => res.schema);
+		const responsesWithSchema = node.responses.filter((res) => res.content?.[0]?.schema);
 		const responseUnionSchema = responsesWithSchema.length > 0 ? (() => {
 			const responseUnionName = resolver.resolveResponseName(node);
-			if (new Set(responsesWithSchema.flatMap((res) => res.schema ? adapter.getImports(res.schema, (schemaName) => ({
+			if (new Set(responsesWithSchema.flatMap((res) => res.content?.[0]?.schema ? adapter.getImports(res.content[0].schema, (schemaName) => ({
 				name: resolver.resolveSchemaName(schemaName),
 				path: ""
 			})).flatMap((imp) => Array.isArray(imp.name) ? imp.name : [imp.name]) : [])).has(responseUnionName)) return null;
@@ -905,13 +1077,21 @@ const zodGenerator = defineGenerator({
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
-			banner: resolver.resolveBanner(adapter.inputNode, {
+			banner: resolver.resolveBanner(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
-			footer: resolver.resolveFooter(adapter.inputNode, {
+			footer: resolver.resolveFooter(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
 			children: [
 				/* @__PURE__ */ jsx(File.Import, {
@@ -927,7 +1107,7 @@ const zodGenerator = defineGenerator({
 		});
 	},
 	operations(nodes, ctx) {
-		const { adapter, config, resolver, root } = ctx;
+		const { config, resolver, root } = ctx;
 		const { output, importPath, group, operations, paramsCasing } = ctx.options;
 		if (!operations) return;
 		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
@@ -937,7 +1117,7 @@ const zodGenerator = defineGenerator({
 		}, {
 			root,
 			output,
-			group
+			group: group ?? void 0
 		}) };
 		const transformedOperations = nodes.map((node) => {
 			return {
@@ -962,7 +1142,7 @@ const zodGenerator = defineGenerator({
 			}, {
 				root,
 				output,
-				group
+				group: group ?? void 0
 			});
 			return names.map((name) => /* @__PURE__ */ jsx(File.Import, {
 				name: [name],
@@ -974,13 +1154,21 @@ const zodGenerator = defineGenerator({
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
-			banner: resolver.resolveBanner(adapter.inputNode, {
+			banner: resolver.resolveBanner(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
-			footer: resolver.resolveFooter(adapter.inputNode, {
+			footer: resolver.resolveFooter(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
 			children: [
 				/* @__PURE__ */ jsx(File.Import, {
@@ -1001,77 +1189,96 @@ const zodGenerator = defineGenerator({
 //#endregion
 //#region src/resolvers/resolverZod.ts
 /**
-* Naming convention resolver for Zod plugin.
+* Default resolver used by `@kubb/plugin-zod`. Decides the names and file
+* paths for every generated Zod schema. Schemas use camelCase with a
+* `Schema` suffix (`listPetsSchema`); their inferred types use PascalCase.
 *
-* Provides default naming helpers using camelCase with a `Schema` suffix for schemas.
+* @example Resolve schema and type names
+* ```ts
+* import { resolverZod } from '@kubb/plugin-zod'
 *
-* @example
-* `resolverZod.default('list pets', 'function')  // → 'listPetsSchema'`
+* resolverZod.default('list pets', 'function') // 'listPetsSchema'
+* resolverZod.resolveSchemaTypeName('pet')     // 'PetSchema'
+* ```
 */
-const resolverZod = defineResolver((ctx) => {
+const resolverZod = defineResolver(() => {
 	return {
 		name: "default",
 		pluginName: "plugin-zod",
 		default(name, type) {
-			return camelCase(name, {
+			const resolved = camelCase(name, {
 				isFile: type === "file",
 				suffix: type ? "schema" : void 0
 			});
+			return type === "file" ? resolved : ensureValidVarName(resolved);
 		},
 		resolveSchemaName(name) {
-			return camelCase(name, { suffix: "schema" });
+			return ensureValidVarName(camelCase(name, { suffix: "schema" }));
 		},
 		resolveSchemaTypeName(name) {
-			return pascalCase(name, { suffix: "schema" });
+			return ensureValidVarName(pascalCase(name, { suffix: "schema" }));
 		},
 		resolveTypeName(name) {
-			return pascalCase(name);
+			return ensureValidVarName(pascalCase(name));
 		},
 		resolvePathName(name, type) {
-			return ctx.default(name, type);
+			return this.default(name, type);
 		},
 		resolveParamName(node, param) {
-			return ctx.resolveSchemaName(`${node.operationId} ${param.in} ${param.name}`);
+			return this.resolveSchemaName(`${node.operationId} ${param.in} ${param.name}`);
 		},
 		resolveResponseStatusName(node, statusCode) {
-			return ctx.resolveSchemaName(`${node.operationId} Status ${statusCode}`);
+			return this.resolveSchemaName(`${node.operationId} Status ${statusCode}`);
 		},
 		resolveDataName(node) {
-			return ctx.resolveSchemaName(`${node.operationId} Data`);
+			return this.resolveSchemaName(`${node.operationId} Data`);
 		},
 		resolveResponsesName(node) {
-			return ctx.resolveSchemaName(`${node.operationId} Responses`);
+			return this.resolveSchemaName(`${node.operationId} Responses`);
 		},
 		resolveResponseName(node) {
-			return ctx.resolveSchemaName(`${node.operationId} Response`);
+			return this.resolveSchemaName(`${node.operationId} Response`);
 		},
 		resolvePathParamsName(node, param) {
-			return ctx.resolveParamName(node, param);
+			return this.resolveParamName(node, param);
 		},
 		resolveQueryParamsName(node, param) {
-			return ctx.resolveParamName(node, param);
+			return this.resolveParamName(node, param);
 		},
 		resolveHeaderParamsName(node, param) {
-			return ctx.resolveParamName(node, param);
+			return this.resolveParamName(node, param);
 		}
 	};
 });
 //#endregion
 //#region src/plugin.ts
 /**
-* Canonical plugin name for `@kubb/plugin-zod`, used in driver lookups and warnings.
+* Canonical plugin name for `@kubb/plugin-zod`. Used for driver lookups and
+* cross-plugin dependency references.
 */
 const pluginZodName = "plugin-zod";
 /**
-* Generates Zod validation schemas from an OpenAPI specification.
-* Walks schemas and operations, delegates to generators, and writes barrel files
-* based on the configured `barrelType`.
+* Generates Zod v4 schemas from an OpenAPI spec. Use them to validate API
+* responses at runtime, build form schemas, or feed back into router libraries
+* that consume Zod (tRPC, Hono, Elysia). Pair with `@kubb/plugin-client` and
+* set the client's `parser: 'zod'` to validate every response automatically.
 *
-* @example Zod schema generator
+* @example
 * ```ts
-* import pluginZod from '@kubb/plugin-zod'
+* import { defineConfig } from 'kubb'
+* import { pluginTs } from '@kubb/plugin-ts'
+* import { pluginZod } from '@kubb/plugin-zod'
+*
 * export default defineConfig({
-*   plugins: [pluginZod({ output: { path: 'zod' } })]
+*   input: { path: './petStore.yaml' },
+*   output: { path: './src/gen' },
+*   plugins: [
+*     pluginTs(),
+*     pluginZod({
+*       output: { path: './zod' },
+*       typed: true,
+*     }),
+*   ],
 * })
 * ```
 */
@@ -1086,7 +1293,7 @@ const pluginZod = definePlugin((options) => {
 			if (group.type === "path") return `${ctx.group.split("/")[1]}`;
 			return `${camelCase(ctx.group)}Controller`;
 		}
-	} : void 0;
+	} : null;
 	return {
 		name: pluginZodName,
 		options,