@kubb/plugin-zod 5.0.0-beta.10 → 5.0.0-beta.100

package/dist/index.js

@@ -1,7 +1,169 @@
-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 { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
+import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
+import { Resolver, ast, containsCircularRef, createResolver, defineGenerator, definePlugin, extractRefName, syncSchemaRef } from "kubb/kit";
+import { Const, File, Type, jsxRenderer } from "kubb/jsx";
+import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
+//#region ../../internals/shared/src/params.ts
+/**
+* Drops parameters that share the same name, keeping the first.
+*
+* A malformed spec can declare the same parameter name twice within one `in` location. Both would
+* resolve to the same output property, so emitting both would yield an object type with a duplicate
+* member, which TypeScript rejects. This is a defensive guard against that case, not a casing guard:
+* parameter names flow through unchanged, so no two distinct names ever collide here anymore.
+*/
+function dedupeParams(params) {
+	const seen = /* @__PURE__ */ new Set();
+	return params.filter((param) => {
+		if (seen.has(param.name)) return false;
+		seen.add(param.name);
+		return true;
+	});
+}
+//#endregion
+//#region ../../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`).
+*/
+function getContentTypeSuffix(contentType) {
+	const baseType = contentType.split(";")[0].trim();
+	if (baseType === "application/json") return "Json";
+	if (baseType === "multipart/form-data") return "FormData";
+	if (baseType === "application/x-www-form-urlencoded") return "FormUrlEncoded";
+	const parts = (baseType.split("/").pop() ?? baseType).split(/[^a-zA-Z0-9]+/).filter(Boolean);
+	if (parts.length === 0) return "Unknown";
+	return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+/**
+* Appends a content-type suffix to a base name, keeping a trailing `Data` segment last
+* (e.g. `AddPetData` + `Json` → `AddPetJsonData`, `AddPetStatus200` + `Xml` → `AddPetStatus200Xml`).
+*/
+function getPerContentTypeName(baseName, suffix) {
+	if (baseName.endsWith("Data")) return suffix.endsWith("Data") ? baseName.slice(0, -4) + suffix : `${baseName.slice(0, -4)}${suffix}Data`;
+	return baseName + suffix;
+}
+/**
+* Resolves per-content-type variant names for a set of content entries, deduplicating suffix
+* collisions with a numeric counter. Entries without a schema are skipped. The returned `suffix` is
+* the final (possibly counter-augmented) value, so callers can derive parallel names in another
+* namespace (e.g. plugin-faker deriving the matching plugin-ts type name).
+*/
+function resolveContentTypeVariants(entries, baseName) {
+	const usedNames = /* @__PURE__ */ new Set();
+	return entries.filter((entry) => entry.schema).map((entry) => {
+		const baseSuffix = getContentTypeSuffix(entry.contentType);
+		let suffix = baseSuffix;
+		let name = getPerContentTypeName(baseName, suffix);
+		let counter = 2;
+		while (usedNames.has(name)) {
+			suffix = `${baseSuffix}${counter++}`;
+			name = getPerContentTypeName(baseName, suffix);
+		}
+		usedNames.add(name);
+		return {
+			name,
+			suffix,
+			schema: entry.schema,
+			keysToOmit: entry.keysToOmit,
+			contentType: entry.contentType
+		};
+	});
+}
+function getOperationParameters(node) {
+	return {
+		path: dedupeParams(node.parameters.filter((param) => param.in === "path")),
+		query: dedupeParams(node.parameters.filter((param) => param.in === "query")),
+		header: dedupeParams(node.parameters.filter((param) => param.in === "header")),
+		cookie: dedupeParams(node.parameters.filter((param) => param.in === "cookie"))
+	};
+}
+/**
+* Builds the combined `{ body, path, query, headers }` options object schema for an operation,
+* referencing the already-resolved body and grouped param names. Shared by `@kubb/plugin-ts`'s
+* `Options` type and `@kubb/plugin-zod`'s inferred options schema, so both printers emit the same
+* 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) {
+	const { path, query, header } = getOperationParameters(node);
+	const hasBody = Boolean(node.requestBody?.content?.[0]?.schema);
+	const createNever = () => ast.factory.createSchema({
+		type: "never",
+		primitive: void 0,
+		optional: true
+	});
+	const groups = [
+		{
+			name: "path",
+			params: path,
+			resolve: resolver.param.path
+		},
+		{
+			name: "query",
+			params: query,
+			resolve: resolver.param.query
+		},
+		{
+			name: "headers",
+			params: header,
+			resolve: resolver.param.headers
+		}
+	];
+	return 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()
+			});
+		})]
+	});
+}
+function getStatusCodeNumber(statusCode) {
+	const code = Number(statusCode);
+	return Number.isNaN(code) ? null : code;
+}
+function isSuccessStatusCode(statusCode) {
+	const code = getStatusCodeNumber(statusCode);
+	return code !== null && code >= 200 && code < 300;
+}
+function getSuccessResponses(responses) {
+	return responses.filter((response) => isSuccessStatusCode(response.statusCode));
+}
+//#endregion
+//#region ../../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.
+*
+* Throws when a non-OAS adapter is configured, turning a silently wrong cast into a
+* clear, actionable error at the point of use.
+*
+* @example
+* ```ts
+* const { dateType } = getOasAdapter(ctx.adapter).options
+* ```
+*/
+function getOasAdapter(adapter) {
+	if (adapter.name !== "oas") throw new Error(`Expected the OpenAPI adapter (adapterOas), but received "${adapter.name}". Configure \`adapter: adapterOas()\` in your Kubb config.`);
+	return adapter;
+}
+//#endregion
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -13,61 +175,197 @@ import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
 function toCamelOrPascal(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;
-		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
-		return word.charAt(0).toUpperCase() + word.slice(1);
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
 	}).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 /**
-* Splits `text` on `.` and applies `transformPart` to each segment.
-* The last segment receives `isLast = true`, all earlier segments receive `false`.
-* Segments are joined with `/` to form a file path.
+* Converts `text` to camelCase.
+*
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
 *
-* Only splits on dots followed by a letter so that version numbers
-* embedded in operationIds (e.g. `v2025.0`) are kept intact.
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
 */
-function applyToFileParts(text, transformPart) {
-	const parts = text.split(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
 }
 /**
-* Converts `text` to camelCase.
-* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
+* 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
+/**
+* JavaScript and Java reserved words.
+* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+*/
+const reservedWords = /* @__PURE__ */ 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
-* camelCase('hello-world')                   // 'helloWorld'
-* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
-*/
-function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
-		prefix,
-		suffix
-	} : {}));
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+* ```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 isIdentifier(name);
 }
 /**
-* Converts `text` to PascalCase.
-* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
+* 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
-* pascalCase('hello-world')                  // 'HelloWorld'
-* pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'
-*/
-function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => isLast ? pascalCase(part, {
-		prefix,
-		suffix
-	}) : camelCase(part));
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
+* ```ts
+* ensureValidVarName('409')             // '_409'
+* ensureValidVarName('504AccountCancel') // '_504AccountCancel'
+* ensureValidVarName('Pet')              // 'Pet'
+* ensureValidVarName('class')            // '_class'
+* ```
+*/
+function ensureValidVarName(name) {
+	if (!name || isValidVarName(name)) return name;
+	return `_${name}`;
+}
+/**
+* Returns `true` when `name` is syntactically a valid identifier, ignoring reserved words.
+*
+* Reserved words and globals (`class`, `name`, `Date`, …) are valid as bare object-literal keys
+* even though they are not valid variable names, so use this (not {@link isValidVarName}) when
+* deciding whether an object key needs quoting.
+*
+* @example
+* ```ts
+* isIdentifier('name')   // true
+* isIdentifier('x-total')// false
+* ```
+*/
+function isIdentifier(name) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
 //#endregion
-//#region ../../internals/utils/src/string.ts
+//#region ../../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.
+*
+* @example
+* ```ts
+* singleQuote('foo')      // "'foo'"
+* singleQuote("o'clock")  // "'o\\'clock'"
+* ```
+*/
+function singleQuote(value) {
+	if (value === void 0 || value === null) return "''";
+	return `'${String(value).replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
 /**
 * Strips a single matching pair of `"..."`, `'...'`, or `` `...` `` from both ends of `text`.
 * Returns the string unchanged when no balanced quote pair is found.
 *
 * @example
+* ```ts
 * trimQuotes('"hello"') // 'hello'
 * trimQuotes('hello')   // 'hello'
+* ```
 */
 function trimQuotes(text) {
 	if (text.length >= 2) {
@@ -77,43 +375,32 @@ function trimQuotes(text) {
 	}
 	return text;
 }
-//#endregion
-//#region ../../internals/utils/src/object.ts
 /**
-* Serializes a primitive value to a JSON string literal, stripping any surrounding quote characters first.
+* Serializes a primitive to a single-quoted string literal, stripping any surrounding quotes first.
 *
-* @example
-* stringify('hello')   // '"hello"'
-* stringify('"hello"') // '"hello"'
-*/
-function stringify(value) {
-	if (value === void 0 || value === null) return "\"\"";
-	return JSON.stringify(trimQuotes(value.toString()));
-}
-/**
-* Converts a plain object into a multiline key-value string suitable for embedding in generated code.
-* Nested objects are recursively stringified with indentation.
+* Escaping runs through `JSON.stringify`, then the result switches to single quotes so the generated
+* code matches the repo style without a formatter.
 *
 * @example
-* stringifyObject({ foo: 'bar', nested: { a: 1 } })
-* // 'foo: bar,\nnested: {\n        a: 1\n      }'
+* ```ts
+* stringify('hello')   // "'hello'"
+* stringify('"hello"') // "'hello'"
+* ```
 */
-function stringifyObject(value) {
-	return Object.entries(value).map(([key, val]) => {
-		if (val !== null && typeof val === "object") return `${key}: {\n        ${stringifyObject(val)}\n      }`;
-		return `${key}: ${val}`;
-	}).filter(Boolean).join(",\n");
+function stringify(value) {
+	if (value === void 0 || value === null) return "''";
+	return `'${JSON.stringify(trimQuotes(value.toString())).slice(1, -1).replace(/\\"/g, "\"").replace(/'/g, "\\'")}'`;
 }
-//#endregion
-//#region ../../internals/utils/src/regexp.ts
 /**
 * Converts a pattern string into a `new RegExp(...)` constructor call or a regex literal string.
-* Inline flags expressed as `^(?im)` prefixes are extracted and applied to the resulting expression.
+* Inline flags expressed as a `^(?im)` prefix are extracted and applied to the resulting expression.
 * Pass `null` as the second argument to emit a `/pattern/flags` literal instead.
 *
 * @example
-* toRegExpString('^(?im)foo')       // → 'new RegExp("foo", "im")'
-* toRegExpString('^(?im)foo', null) // → '/foo/im'
+* ```ts
+* toRegExpString('^(?im)foo')       // 'new RegExp("^foo", "im")'
+* toRegExpString('^(?im)foo', null) // '/^foo/im'
+* ```
 */
 function toRegExpString(text, func = "RegExp") {
 	const raw = trimQuotes(text);
@@ -126,83 +413,265 @@ function toRegExpString(text, func = "RegExp") {
 	return `new ${func}(${JSON.stringify(source)}${flags ? `, ${JSON.stringify(flags)}` : ""})`;
 }
 //#endregion
-//#region src/components/Operations.tsx
-function Operations({ name, operations }) {
-	const operationsJSON = operations.reduce((prev, acc) => {
-		prev[`"${acc.node.operationId}"`] = acc.data;
-		return prev;
-	}, {});
-	const pathsJSON = operations.reduce((prev, acc) => {
-		prev[`"${acc.node.path}"`] = {
-			...prev[`"${acc.node.path}"`] ?? {},
-			[acc.node.method]: `operations["${acc.node.operationId}"]`
-		};
-		return prev;
-	}, {});
-	return /* @__PURE__ */ jsxs(Fragment, { children: [
-		/* @__PURE__ */ jsx(File.Source, {
-			name: "OperationSchema",
-			isExportable: true,
-			isIndexable: true,
-			children: /* @__PURE__ */ jsx(Type, {
-				name: "OperationSchema",
-				export: true,
-				children: `{
-  readonly request: z.ZodTypeAny | undefined;
-  readonly parameters: {
-        readonly path: z.ZodTypeAny | undefined;
-        readonly query: z.ZodTypeAny | undefined;
-        readonly header: z.ZodTypeAny | undefined;
-  };
-  readonly responses: {
-        readonly [status: number]: z.ZodTypeAny;
-        readonly default: z.ZodTypeAny;
-  };
-  readonly errors: {
-        readonly [status: number]: z.ZodTypeAny;
-  };
-}`
-			})
-		}),
-		/* @__PURE__ */ jsx(File.Source, {
-			name: "OperationsMap",
-			isExportable: true,
-			isIndexable: true,
-			children: /* @__PURE__ */ jsx(Type, {
-				name: "OperationsMap",
-				export: true,
-				children: "Record<string, OperationSchema>"
-			})
-		}),
-		/* @__PURE__ */ jsx(File.Source, {
-			name,
-			isExportable: true,
-			isIndexable: true,
-			children: /* @__PURE__ */ jsx(Const, {
-				export: true,
-				name,
-				asConst: true,
-				children: `{${stringifyObject(operationsJSON)}}`
-			})
-		}),
-		/* @__PURE__ */ jsx(File.Source, {
-			name: "paths",
-			isExportable: true,
-			isIndexable: true,
-			children: /* @__PURE__ */ jsx(Const, {
-				export: true,
-				name: "paths",
-				asConst: true,
-				children: `{${stringifyObject(pathsJSON)}}`
-			})
-		})
-	] });
+//#region ../../internals/utils/src/codegen.ts
+const INDENT = "  ";
+/**
+* Indents every non-empty line of `text` by one indent level, leaving blank lines empty.
+*/
+function indentLines(text) {
+	if (!text) return "";
+	return text.split("\n").map((line) => line.trim() ? `${INDENT}${line}` : "").join("\n");
+}
+/**
+* Renders an object key, quoting it with single quotes only when it is not a valid identifier.
+* Reserved words and globals (`name`, `class`, …) are valid bare keys and stay unquoted.
+*
+* @example
+* ```ts
+* objectKey('name')    // 'name'
+* objectKey('x-total') // "'x-total'"
+* ```
+*/
+function objectKey(name) {
+	return isIdentifier(name) ? name : singleQuote(name);
+}
+/**
+* Assembles a multi-line object literal from already-rendered `entries`, indenting each entry one
+* level and closing the brace at column zero. Entries that are themselves multi-line objects indent
+* cumulatively. Each entry ends with a trailing comma to match the formatter's multi-line style.
+*
+* @example
+* ```ts
+* buildObject(['id: z.number()', 'name: z.string()'])
+* // '{\n  id: z.number(),\n  name: z.string(),\n}'
+* ```
+*/
+function buildObject(entries) {
+	if (entries.length === 0) return "{}";
+	return `{\n${entries.map((entry) => `${indentLines(entry)},`).join("\n")}\n}`;
+}
+/**
+* Assembles a bracketed list (array by default) from already-rendered `items`. Keeps everything on
+* one line when no item spans multiple lines, and otherwise puts each item on its own line, indented
+* one level with a trailing comma and the closing bracket at column zero. Used for member lists such
+* as `z.union([…])` and `z.array([…])`.
+*
+* @example
+* ```ts
+* buildList(['z.string()', 'z.number()'])
+* // '[z.string(), z.number()]'
+* ```
+*/
+function buildList(items, brackets = ["[", "]"]) {
+	const [open, close] = brackets;
+	if (items.length === 0) return `${open}${close}`;
+	if (!items.some((item) => item.includes("\n"))) return `${open}${items.join(", ")}${close}`;
+	return `${open}\n${items.map((item) => `${indentLines(item)},`).join("\n")}\n${close}`;
+}
+/**
+* Emits a lazy getter for a circular-ref property position, `get name() { return body }`. The key
+* is quoted only when it is not a valid identifier. Used by the string printers to defer evaluation
+* of a recursive schema until first access.
+*
+* @example
+* ```ts
+* lazyGetter({ name: 'parent', body: 'z.lazy(() => Pet)' })
+* // "get parent() { return z.lazy(() => Pet) }"
+* ```
+*/
+function lazyGetter({ name, body }) {
+	return `get ${objectKey(name)}() { return ${body} }`;
+}
+//#endregion
+//#region ../../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
+* every earlier segment, applies `caseLast` to the final segment, and joins with `/`.
+*
+* Empty segments are dropped before joining. They arise when the name starts with a dot
+* followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to
+* an empty string). Without this a leading `/` would form, which `path.resolve` reads as an
+* absolute path, letting generated files escape the configured output directory.
+*
+* @example Nested path from a dotted name
+* `toFilePath('pet.petId') // 'pet/petId'`
+*
+* @example PascalCase the final segment
+* `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`
+*
+* @example Suffix applied to the final segment only
+* `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
+*/
+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
+/**
+* Resolves a single operation parameter name with the
+* `<operationId> <in> <name>` template.
+*
+* @example
+* `operationParamName.call(resolver, node, param) // → 'DeletePetPathPetId'`
+*/
+function operationParamName(node, param) {
+	return this.name(`${node.operationId} ${param.in} ${param.name}`);
+}
+/**
+* Builds the shared `param` namespace. Spread the result into `createResolver`
+* and override individual methods next to it when a plugin deviates.
+*
+* @example
+* ```ts
+* createResolver<PluginTs>({ param: createOperationParamResolver(), ... })
+* ```
+*/
+function createOperationParamResolver() {
+	return {
+		name: operationParamName,
+		path(node) {
+			return this.name(`${node.operationId} Path`);
+		},
+		query(node) {
+			return this.name(`${node.operationId} Query`);
+		},
+		headers(node) {
+			return this.name(`${node.operationId} Headers`);
+		}
+	};
+}
+/**
+* Builds the shared `response` namespace. Spread the result into
+* `createResolver` and add plugin-specific methods (`options`, `error`) next
+* to it.
+*
+* @example
+* ```ts
+* createResolver<PluginTs>({ response: { ...createOperationResponseResolver(), options(node) {...} }, ... })
+* ```
+*/
+function createOperationResponseResolver() {
+	return {
+		status(node, statusCode) {
+			return this.name(`${node.operationId} Status ${statusCode}`);
+		},
+		body(node) {
+			return this.name(`${node.operationId} Body`);
+		},
+		responses(node) {
+			return this.name(`${node.operationId} Responses`);
+		},
+		response(node) {
+			return this.name(`${node.operationId} Response`);
+		}
+	};
+}
+/**
+* Builds a resolver `file` override whose base name runs every path segment
+* through `toFilePath`, casing the final segment with `caseLast`.
+*
+* @example
+* ```ts
+* createResolver<PluginTs>({ file: createCasedFile(pascalCase), ... })
+* ```
+*/
+function createCasedFile(caseLast) {
+	return { baseName({ name, extname }) {
+		return `${toFilePath(name, caseLast)}${extname}`;
+	} };
+}
+//#endregion
+//#region ../../internals/shared/src/refs.ts
+/**
+* Collects the resolved target name of every pointer-carrying ref in a schema tree, in
+* first-occurrence order. Use this for name-only checks (e.g. redeclaration detection) where
+* `resolver.imports` would resolve file paths that are then discarded.
+*/
+function collectRefNames(schema) {
+	return ast.collectSync(schema, { schema: (node) => {
+		const refNode = ast.narrowSchema(node, "ref");
+		if (!refNode?.ref) return null;
+		return ast.resolveRefName(refNode);
+	} });
+}
+//#endregion
+//#region ../../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:
+*
+* - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).
+* - other groups use the camelCased group (`pet store` → `petStore`).
+*
+* A user-provided `group.name` always wins over the default namer, so callers stay in
+* control of their output folders. Returns `null` when grouping is disabled, matching the
+* per-plugin convention.
+*
+* @param group - The user-supplied group option, or `undefined` to disable grouping.
+*
+* @example
+* ```ts
+* createGroupConfig(group) // shared across every plugin
+* ```
+*/
+function createGroupConfig(group) {
+	if (!group) return null;
+	const defaultName = (ctx) => {
+		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+		return camelCase(ctx.group);
+	};
+	return {
+		...group,
+		name: group.name ? group.name : defaultName
+	};
+}
+//#endregion
+//#region ../../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.
+*
+* @example
+* ```ts
+* const entries = mapSchemaProperties(node, (schema) => this.transform(schema))
+* // entries: [{ name: 'id', property, output: 'z.number()' }, ...]
+* ```
+*/
+function mapSchemaProperties(node, transform) {
+	return node.properties.map((property) => ({
+		name: property.name,
+		property,
+		output: transform(property.schema)
+	}));
+}
+/**
+* Maps each member of a union or intersection schema to its transformed output, pairing every
+* result with the original member.
+*/
+function mapSchemaMembers(node, transform) {
+	return (node.members ?? []).map((schema) => ({
+		schema,
+		output: transform(schema)
+	}));
+}
+/**
+* Maps each item of an array or tuple schema to its transformed output, pairing every result with
+* the original item.
+*/
+function mapSchemaItems(node, transform) {
+	return (node.items ?? []).map((schema) => ({
+		schema,
+		output: transform(schema)
+	}));
 }
 //#endregion
 //#region src/components/Zod.tsx
-function Zod({ name, node, printer, inferTypeName }) {
+function Zod({ name, node, printer, inferTypeName, cyclic }) {
 	const output = printer.print(node);
 	if (!output) return;
+	const needsAnnotation = cyclic && node.type !== "object";
 	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Source, {
 		name,
 		isExportable: true,
@@ -210,6 +679,7 @@ function Zod({ name, node, printer, inferTypeName }) {
 		children: /* @__PURE__ */ jsx(Const, {
 			export: true,
 			name,
+			type: needsAnnotation ? "z.ZodType" : void 0,
 			children: output
 		})
 	}), inferTypeName && /* @__PURE__ */ jsx(File.Source, {
@@ -230,7 +700,7 @@ function Zod({ name, node, printer, inferTypeName }) {
 * Import paths that use a namespace import (`import * as z from '...'`).
 * All other import paths use a named import (`import { z } from '...'`).
 */
-const ZOD_NAMESPACE_IMPORTS = new Set(["zod", "zod/mini"]);
+const ZOD_NAMESPACE_IMPORTS = /* @__PURE__ */ new Set(["zod", "zod/mini"]);
 //#endregion
 //#region src/utils.ts
 /**
@@ -242,34 +712,106 @@ function shouldCoerce(coercion, type) {
 	return !!coercion[type];
 }
 /**
-* Collects all resolved schema names for an operation's parameters and responses
-* into a single lookup object, useful for building imports and type references.
-*/
-function buildSchemaNames(node, { params, resolver }) {
-	const pathParam = params.find((p) => p.in === "path");
-	const queryParam = params.find((p) => p.in === "query");
-	const headerParam = params.find((p) => p.in === "header");
-	const responses = {};
-	const errors = {};
-	for (const res of node.responses) {
-		const name = resolver.resolveResponseStatusName(node, res.statusCode);
-		const statusNum = Number(res.statusCode);
-		if (!Number.isNaN(statusNum)) {
-			responses[statusNum] = name;
-			if (statusNum >= 400) errors[statusNum] = name;
+* Registered codecs, checked in order.
+*/
+const codecs = [{
+	matches(node) {
+		return node.type === "date" && node.representation === "date";
+	},
+	decode(node) {
+		return node.format === "date" ? "z.iso.date().transform((value) => new Date(value))" : "z.iso.datetime().transform((value) => new Date(value))";
+	},
+	encode(node) {
+		return node.format === "date" ? "z.date().transform((value) => value.toISOString().slice(0, 10))" : "z.date().transform((value) => value.toISOString())";
+	}
+}];
+/**
+* Returns the codec for this node, or `undefined` when the node needs no
+* encode/decode (its wire and runtime types match).
+*/
+function getCodec(node) {
+	if (!node) return void 0;
+	return codecs.find((codec) => codec.matches(node));
+}
+/**
+* Returns `true` when the node itself is encoded/decoded by a codec.
+*/
+function hasCodec(node) {
+	return getCodec(node) !== void 0;
+}
+/**
+* Returns `true` when the schema transitively contains a codec node —
+* a value whose runtime type differs from its wire type (see {@link hasCodec}),
+* so it must be decoded (response) or encoded (request) at the validation boundary.
+* `$ref`s are followed via their resolved schema; a `seen` set guards cycles.
+*/
+function containsCodec(node, seen = /* @__PURE__ */ new Set()) {
+	if (!node) return false;
+	if (hasCodec(node)) return true;
+	if (node.type === "ref") {
+		if (!node.ref) return false;
+		const refName = extractRefName(node.ref);
+		if (refName) {
+			if (seen.has(refName)) return false;
+			seen.add(refName);
 		}
+		const resolved = syncSchemaRef(node);
+		if (resolved.type === "ref") return false;
+		return containsCodec(resolved, seen);
 	}
-	responses["default"] = resolver.resolveResponseName(node);
-	return {
-		request: node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0,
-		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
-		},
-		responses,
-		errors
-	};
+	const children = [];
+	if ("properties" in node && node.properties) children.push(...node.properties.map((prop) => prop.schema));
+	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.some((child) => containsCodec(child, seen));
+}
+/**
+* Collects the names of `$ref` schemas that transitively contain a codec, so the generator can route
+* them to their input (encode) variant.
+*/
+function collectCodecRefNames(node) {
+	return ast.collectSync(node, { schema: (n) => n.type === "ref" && n.ref && containsCodec(n) ? ast.resolveRefName(n) ?? void 0 : void 0 });
+}
+/**
+* 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
+* on `.and(…)`.
+*/
+function isPlainInlineObject(node) {
+	return node.type === "object" && !node.nullable && !node.optional && !node.nullish && node.additionalProperties === void 0 && !node.patternProperties;
+}
+/**
+* Whether a node renders as a bare Zod object — one that accepts `.extend(…)` and can be a
+* `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.
+*/
+function isObjectSchemaNode(node, cyclicSchemas) {
+	if (node.nullable || node.optional || node.nullish) return false;
+	if (node.type === "object") return true;
+	if (node.type === "ref") {
+		const refName = ast.resolveRefName(node);
+		if (refName && cyclicSchemas?.has(refName)) return false;
+		const resolved = syncSchemaRef(node);
+		return resolved.type === "ref" || isObjectSchemaNode(resolved, cyclicSchemas);
+	}
+	if (node.type === "union") {
+		const members = node.members ?? [];
+		return members.length === 1 && isObjectSchemaNode(members[0], cyclicSchemas);
+	}
+	return isObjectComposableIntersection(node, cyclicSchemas);
+}
+/**
+* Whether an `allOf` is a pure object composition — an object base plus inline object members whose
+* shapes merge with `.extend(…)`. These stay a Zod object instead of a `ZodIntersection`, which
+* `z.discriminatedUnion` rejects.
+*/
+function isObjectComposableIntersection(node, cyclicSchemas) {
+	if (node.type !== "intersection") return false;
+	const [first, ...rest] = node.members ?? [];
+	return !!first && isObjectSchemaNode(first, cyclicSchemas) && rest.every(isPlainInlineObject);
 }
 /**
 * Format a default value as a code-level literal.
@@ -281,6 +823,33 @@ function formatDefault(value) {
 	return String(value ?? "");
 }
 /**
+* Format a default for `.default(...)` so the literal matches the generated schema's type.
+*
+* An OpenAPI `default` does not always agree with the schema it sits on: a `bigint` field
+* (`format: int64`) carries a `number` default, and a spec may put `default: {}` on an `array`.
+* Emitting those verbatim produces a Zod schema that does not typecheck, so coerce the bigint case
+* to a `BigInt(...)` literal and emit an array literal for arrays (dropping a non-array default).
+* Returns `null` when no `.default(...)` should be emitted. Keys off the schema node's type.
+*/
+function defaultLiteral(node, value) {
+	if (value === null) return null;
+	if (node && ast.narrowSchema(node, "bigint")) {
+		if (typeof value === "bigint") return `BigInt(${value})`;
+		if (typeof value === "number" && Number.isInteger(value)) return `BigInt(${value})`;
+		return null;
+	}
+	if (node && ast.narrowSchema(node, "array")) return Array.isArray(value) ? JSON.stringify(value) : null;
+	const enumNode = node ? ast.narrowSchema(node, "enum") : void 0;
+	if (enumNode) {
+		const values = enumNode.namedEnumValues?.map((member) => member.value) ?? enumNode.enumValues ?? [];
+		if (values.length) {
+			const match = values.find((member) => member === value || String(member) === String(value));
+			return match != null ? formatLiteral(match) : null;
+		}
+	}
+	return formatDefault(value);
+}
+/**
 * Format a primitive enum/literal value.
 * Strings are quoted; numbers and booleans are emitted raw.
 */
@@ -289,6 +858,47 @@ function formatLiteral(v) {
 	return String(v);
 }
 /**
+* Build the Zod schema for a set of literal enum values.
+* `z.enum()` only accepts string members in Zod v4, so a numeric, boolean, or
+* mixed set is emitted as a single `z.literal(…)` or a `z.union([z.literal(…), …])`.
+* An all-string set keeps the more compact `z.enum([…])`.
+*/
+function buildEnum(values) {
+	if (values.every((v) => typeof v === "string")) return `z.enum([${values.map(formatLiteral).join(", ")}])`;
+	const literals = values.map((v) => `z.literal(${formatLiteral(v)})`);
+	if (literals.length === 1) return literals[0];
+	return `z.union([${literals.join(", ")}])`;
+}
+/**
+* Map a `regexType` to the `func` argument of `toRegExpString`: `'constructor'` emits
+* `new RegExp(...)`, while `'literal'` (the default) emits a regex literal.
+*/
+function regexFunc(regexType) {
+	return regexType === "constructor" ? "RegExp" : null;
+}
+/**
+* Builds a Zod record key schema that enforces the `patternProperties` regexes a plain
+* `.catchall()` would drop. Several patterns combine into one alternation (`(^a)|(^b)`).
+*/
+function patternKeySchema({ patterns, regexType }) {
+	return `z.string().regex(${patternKeySource({
+		patterns,
+		regexType
+	})})`;
+}
+/**
+* `zod/mini` variant of {@link patternKeySchema}, wrapping the regex in `.check(z.regex(...))`.
+*/
+function patternKeySchemaMini({ patterns, regexType }) {
+	return `z.string().check(z.regex(${patternKeySource({
+		patterns,
+		regexType
+	})}))`;
+}
+function patternKeySource({ patterns, regexType }) {
+	return toRegExpString(patterns.length === 1 ? patterns[0] : patterns.map((pattern) => `(${pattern})`).join("|"), regexFunc(regexType));
+}
+/**
 * Build `.min()` / `.max()` / `.gt()` / `.lt()` constraint chains for numbers
 * using the standard chainable Zod v4 API.
 */
@@ -305,11 +915,11 @@ function numberConstraints({ min, max, exclusiveMinimum, exclusiveMaximum, multi
 * Build `.min()` / `.max()` / `.regex()` chains for strings/arrays
 * using the standard chainable Zod v4 API.
 */
-function lengthConstraints({ min, max, pattern }) {
+function lengthConstraints({ min, max, pattern, regexType }) {
 	return [
 		min !== void 0 ? `.min(${min})` : "",
 		max !== void 0 ? `.max(${max})` : "",
-		pattern !== void 0 ? `.regex(${toRegExpString(pattern, null)})` : ""
+		pattern !== void 0 ? `.regex(${toRegExpString(pattern, regexFunc(regexType))})` : ""
 	].join("");
 }
 /**
@@ -327,52 +937,140 @@ function numberChecksMini({ min, max, exclusiveMinimum, exclusiveMaximum, multip
 /**
 * Build `.check(z.minLength(), z.maxLength(), z.regex())` for `zod/mini` length constraints.
 */
-function lengthChecksMini({ min, max, pattern }) {
+function lengthChecksMini({ min, max, pattern, regexType }) {
 	const checks = [];
 	if (min !== void 0) checks.push(`z.minLength(${min})`);
 	if (max !== void 0) checks.push(`z.maxLength(${max})`);
-	if (pattern !== void 0) checks.push(`z.regex(${toRegExpString(pattern, null)})`);
+	if (pattern !== void 0) checks.push(`z.regex(${toRegExpString(pattern, regexFunc(regexType))})`);
 	return checks.length ? `.check(${checks.join(", ")})` : "";
 }
 /**
-* Apply nullable / optional / nullish modifiers and an optional `.describe()` call
-* to a schema value string using the chainable Zod v4 API.
+* 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.
 */
-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;
+function applyModifiers({ value, schema, nullable, optional, nullish, defaultValue, description, examples }) {
+	const withModifier = (() => {
+		if (nullish || nullable && optional) return `${value}.nullish()`;
+		if (optional) return `${value}.optional()`;
+		if (nullable) return `${value}.nullable()`;
+		return value;
+	})();
+	const literal = defaultValue !== void 0 ? defaultLiteral(schema, defaultValue) : null;
+	const withDefault = literal !== null ? `${withModifier}.default(${literal})` : withModifier;
+	const withDescription = description ? `${withDefault}.describe(${stringify(description)})` : withDefault;
+	return examples?.length ? `${withDescription}.meta({ examples: [${examples.map(formatDefault).join(", ")}] })` : withDescription;
+}
+function modifierDepth(schema) {
+	if (schema.nullish || schema.nullable && schema.optional) return 2;
+	if (schema.nullable || schema.optional) return 1;
+	return 0;
+}
+/**
+* Build the `.unwrap()` chain to insert before `.omit()` when the schema is a `$ref`.
+*
+* A `$ref` resolves to a named schema variable that already carries its own `.nullable()` /
+* `.optional()` / `.nullish()` / `.default()` wrappers. `.omit()` lives on the inner `ZodObject`,
+* not on those `ZodNullable` / `ZodOptional` / `ZodDefault` wrappers, so the omit has to unwrap
+* down to the object first. This mirrors plugin-ts emitting `Omit<NonNullable<T>, …>`. Inline
+* objects need no unwrap because the printer adds their modifiers after `.omit()`.
+*/
+function omitUnwrapChain(node) {
+	const ref = ast.narrowSchema(node, "ref");
+	if (!ref) return "";
+	const target = ref.schema ?? ref;
+	const depth = modifierDepth(target) + (target.default !== void 0 ? 1 : 0);
+	return ".unwrap()".repeat(depth);
 }
 /**
 * 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;
+function applyMiniModifiers({ value, schema, nullable, optional, nullish, defaultValue }) {
+	const withModifier = (() => {
+		if (nullish) return `z.nullish(${value})`;
+		const withNullable = nullable ? `z.nullable(${value})` : value;
+		return optional ? `z.optional(${withNullable})` : withNullable;
+	})();
+	const literal = defaultValue !== void 0 ? defaultLiteral(schema, defaultValue) : null;
+	return literal !== null ? `z._default(${withModifier}, ${literal})` : withModifier;
+}
+/**
+* Builds an `object` schema node grouping the given parameter nodes.
+* The `primitive: 'object'` marker ensures the Zod printer emits `z.object(…)` rather than a record.
+*/
+function buildGroupedParamsSchema({ params, optional }) {
+	return ast.factory.createSchema({
+		type: "object",
+		optional,
+		primitive: "object",
+		properties: params.map((param) => ast.factory.createProperty({
+			name: param.name,
+			required: param.required,
+			schema: param.schema
+		}))
+	});
 }
 //#endregion
 //#region src/printers/printerZod.ts
-function strictOneOfMember$1(member, node) {
+function strictOneOfMember$1(member, node, cyclicSchemas) {
 	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);
+		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()`;
 	}
 	return member;
 }
 __name(strictOneOfMember$1, "strictOneOfMember");
+function getMemberConstraint({ member, regexType }) {
+	if (member.primitive === "string") return lengthConstraints({
+		...ast.narrowSchema(member, "string") ?? {},
+		regexType
+	}) || 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") ?? {},
+		regexType
+	}) || void 0;
+}
+/**
+* Builds the `{ key: value, … }` shape for an object node, shared by the `z.object(...)` and
+* `.extend(...)` renderings so they stay in lockstep.
+*/
+function buildZodObjectShape(ctx, node) {
+	const objectNode = ast.narrowSchema(node, "object");
+	if (!objectNode) return "{}";
+	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && containsCircularRef(schema, { circularSchemas: ctx.options.cyclicSchemas });
+	return buildObject(mapSchemaProperties(objectNode, (schema) => {
+		const hasSelfRef = isCyclic(schema);
+		const savedCyclicSchemas = ctx.options.cyclicSchemas;
+		if (hasSelfRef) ctx.options.cyclicSchemas = void 0;
+		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 }) => {
+		const { schema } = property;
+		const meta = syncSchemaRef(schema);
+		const descriptionToApply = schema.type !== "ref" && meta.type === "ref" ? void 0 : meta.description;
+		const value = applyModifiers({
+			value: baseOutput,
+			schema,
+			nullable: meta.nullable,
+			optional: schema.optional || property.required === false,
+			nullish: schema.nullish,
+			defaultValue: meta.default,
+			description: descriptionToApply,
+			examples: meta.examples
+		});
+		return isCyclic(schema) ? lazyGetter({
+			name: propName,
+			body: value
+		}) : `${objectKey(propName)}: ${value}`;
+	}));
+}
 /**
 * Zod v4 printer built with `definePrinter`.
 *
@@ -385,7 +1083,8 @@ __name(strictOneOfMember$1, "strictOneOfMember");
 * const code = printer.print(stringNode) // "z.string()"
 * ```
 */
-const printerZod = ast.definePrinter((options) => {
+const printerZod = ast.createPrinter((options) => {
+	const cyclicSchemaNames = options.cyclicSchemas;
 	return {
 		name: "zod",
 		options,
@@ -397,7 +1096,10 @@ const printerZod = ast.definePrinter((options) => {
 			boolean: () => "z.boolean()",
 			null: () => "z.null()",
 			string(node) {
-				return `${shouldCoerce(this.options.coercion, "strings") ? "z.coerce.string()" : "z.string()"}${lengthConstraints(node)}`;
+				return `${shouldCoerce(this.options.coercion, "strings") ? "z.coerce.string()" : "z.string()"}${lengthConstraints({
+					...node,
+					regexType: this.options.regexType
+				})}`;
 			},
 			number(node) {
 				return `${shouldCoerce(this.options.coercion, "numbers") ? "z.coerce.number()" : "z.number()"}${numberConstraints(node)}`;
@@ -409,8 +1111,12 @@ const printerZod = ast.definePrinter((options) => {
 				return shouldCoerce(this.options.coercion, "numbers") ? "z.coerce.bigint()" : "z.bigint()";
 			},
 			date(node) {
-				if (node.representation === "string") return "z.iso.date()";
-				return shouldCoerce(this.options.coercion, "dates") ? "z.coerce.date()" : "z.date()";
+				const codec = getCodec(node);
+				if (codec) {
+					if (this.options.direction === "input") return codec.encode(node);
+					return shouldCoerce(this.options.coercion, "dates") ? "z.coerce.date()" : codec.decode(node);
+				}
+				return "z.iso.date()";
 			},
 			datetime(node) {
 				const offset = node.offset || this.options.dateType === "stringOffset";
@@ -424,13 +1130,22 @@ const printerZod = ast.definePrinter((options) => {
 				return shouldCoerce(this.options.coercion, "dates") ? "z.coerce.date()" : "z.date()";
 			},
 			uuid(node) {
-				return `${this.options.guidType === "guid" ? "z.guid()" : "z.uuid()"}${lengthConstraints(node)}`;
+				return `${this.options.guidType === "guid" ? "z.guid()" : "z.uuid()"}${lengthConstraints({
+					...node,
+					regexType: this.options.regexType
+				})}`;
 			},
 			email(node) {
-				return `z.email()${lengthConstraints(node)}`;
+				return `z.email()${lengthConstraints({
+					...node,
+					regexType: this.options.regexType
+				})}`;
 			},
 			url(node) {
-				return `z.url()${lengthConstraints(node)}`;
+				return `z.url()${lengthConstraints({
+					...node,
+					regexType: this.options.regexType
+				})}`;
 			},
 			ipv4: () => "z.ipv4()",
 			ipv6: () => "z.ipv6()",
@@ -442,120 +1157,104 @@ const printerZod = ast.definePrinter((options) => {
 					if (literals.length === 1) return literals[0];
 					return `z.union([${literals.join(", ")}])`;
 				}
-				return `z.enum([${nonNullValues.map(formatLiteral).join(", ")}])`;
+				return buildEnum(nonNullValues);
 			},
 			ref(node) {
-				if (!node.name) return void 0;
-				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.name) return null;
+				const refName = ast.resolveRefName(node);
+				if (!refName) return null;
+				const useInputVariant = node.ref != null && this.options.direction === "input" && containsCodec(node);
+				const resolvedName = node.ref ? useInputVariant ? this.options.resolver?.schema.inputName(refName) ?? refName : this.options.resolver?.name(refName) ?? 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 { 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 });
-					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;
-					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 value = applyModifiers({
-						value: wrappedOutput,
-						nullable: isNullable,
-						optional: isOptional,
-						nullish: isNullish,
-						defaultValue: meta.default,
-						description: descriptionToApply
-					});
-					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;
+				const entries = node.properties ?? [];
+				const objectBase = `z.object(${buildZodObjectShape(this, node)})`;
+				return (() => {
+					const patterns = node.patternProperties ? Object.entries(node.patternProperties) : [];
+					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.factory.createSchema({ type: "unknown" }))})`;
+					if (node.additionalProperties === false && patterns.length === 0) return `${objectBase}.strict()`;
+					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;
+				})();
 			},
 			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(${mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean).join(", ") || this.transform(ast.factory.createSchema({ type: "unknown" }))})${lengthConstraints({
+					...node,
+					regexType: this.options.regexType
+				})}`;
+				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(", ")}])`;
+				return `z.tuple(${buildList(mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean))})`;
 			},
 			union(node) {
 				const nodeMembers = node.members ?? [];
-				const members = nodeMembers.map((memberNode) => {
-					const member = this.transform(memberNode);
-					return member && node.strategy === "one" ? strictOneOfMember$1(member, memberNode) : member;
-				}).filter(Boolean);
+				const members = mapSchemaMembers(node, (memberNode) => this.transform(memberNode)).map(({ schema, output }) => output && node.strategy === "one" ? strictOneOfMember$1(output, schema, cyclicSchemaNames) : output).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(", ")}])`;
-				return `z.union([${members.join(", ")}])`;
+				const allDiscriminable = nodeMembers.every((m) => isObjectSchemaNode(m, cyclicSchemaNames));
+				if (node.discriminatorPropertyName && allDiscriminable) return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, ${buildList(members)})`;
+				return `z.union(${buildList(members)})`;
 			},
 			intersection(node) {
 				const members = node.members ?? [];
 				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 "";
+				if (rest.length > 0 && isObjectComposableIntersection(node, cyclicSchemaNames)) return rest.reduce((acc, member) => `${acc}.extend(${buildZodObjectShape(this, member)})`, firstBase);
+				return rest.reduce((acc, member) => {
+					const constraint = getMemberConstraint({
+						member,
+						regexType: this.options.regexType
+					});
+					if (constraint) return acc + constraint;
 					const transformed = this.transform(member);
-					if (transformed) base = `${base}.and(${transformed})`;
-				}
-				return base;
-			},
-			...options.nodes
+					return transformed ? `${acc}.and(${transformed})` : acc;
+				}, firstBase);
+			}
 		},
+		overrides: options.nodes,
 		print(node) {
 			const { keysToOmit } = this.options;
-			let base = this.transform(node);
-			if (!base) 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(", ")} })`;
-			}
+			const transformed = this.transform(node);
+			if (!transformed) return null;
+			const meta = syncSchemaRef(node);
 			return applyModifiers({
-				value: base,
+				value: (() => {
+					if (!keysToOmit?.length || meta.primitive !== "object" || meta.type === "union" && meta.discriminatorPropertyName) return transformed;
+					const unwrap = omitUnwrapChain(node);
+					const omit = `.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} })`;
+					const lazyMatch = transformed.match(/^z\.lazy\(\(\)\s*=>\s*(.+)\)$/);
+					if (lazyMatch) return `z.lazy(() => ${lazyMatch[1]}${unwrap}${omit})`;
+					return `${transformed}${unwrap}${omit}`;
+				})(),
+				schema: node,
 				nullable: meta.nullable,
 				optional: meta.optional,
 				nullish: meta.nullish,
 				defaultValue: meta.default,
-				description: meta.description
+				description: meta.description,
+				examples: meta.examples
 			});
 		}
 	};
@@ -566,8 +1265,51 @@ 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, regexType }) {
+	if (member.primitive === "string") return lengthChecksMini({
+		...ast.narrowSchema(member, "string") ?? {},
+		regexType
+	}) || 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") ?? {},
+		regexType
+	}) || void 0;
+}
 /**
-* Zod v4 **Mini** printer built with `definePrinter`.
+* Builds the `{ key: value, … }` shape for an object node with the functional `zod/mini` modifiers,
+* shared by the `z.object(...)` and `z.extend(...)` renderings so they stay in lockstep.
+*/
+function buildZodMiniObjectShape(ctx, node) {
+	const objectNode = ast.narrowSchema(node, "object");
+	if (!objectNode) return "{}";
+	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && containsCircularRef(schema, { circularSchemas: ctx.options.cyclicSchemas });
+	return buildObject(mapSchemaProperties(objectNode, (schema) => {
+		const hasSelfRef = isCyclic(schema);
+		const savedCyclicSchemas = ctx.options.cyclicSchemas;
+		if (hasSelfRef) ctx.options.cyclicSchemas = void 0;
+		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 }) => {
+		const { schema } = property;
+		const meta = syncSchemaRef(schema);
+		const value = applyMiniModifiers({
+			value: baseOutput,
+			schema,
+			nullable: meta.nullable,
+			optional: schema.optional || property.required === false,
+			nullish: schema.nullish,
+			defaultValue: meta.default
+		});
+		return isCyclic(schema) ? lazyGetter({
+			name: propName,
+			body: value
+		}) : `${objectKey(propName)}: ${value}`;
+	}));
+}
+/**
+* Zod v4 Mini printer built with `definePrinter`.
 *
 * Converts a `SchemaNode` AST into a Zod v4 code string using the functional API
 * (`z.optional(z.string())`) for improved tree-shaking. See {@link printerZod} for the chainable API.
@@ -578,7 +1320,8 @@ function strictOneOfMember(member, node) {
 * const code = printer.print(optionalStringNode) // "z.optional(z.string())"
 * ```
 */
-const printerZodMini = ast.definePrinter((options) => {
+const printerZodMini = ast.createPrinter((options) => {
+	const cyclicSchemaNames = options.cyclicSchemas;
 	return {
 		name: "zod-mini",
 		options,
@@ -590,7 +1333,10 @@ const printerZodMini = ast.definePrinter((options) => {
 			boolean: () => "z.boolean()",
 			null: () => "z.null()",
 			string(node) {
-				return `z.string()${lengthChecksMini(node)}`;
+				return `z.string()${lengthChecksMini({
+					...node,
+					regexType: this.options.regexType
+				})}`;
 			},
 			number(node) {
 				return `z.number()${numberChecksMini(node)}`;
@@ -613,13 +1359,22 @@ const printerZodMini = ast.definePrinter((options) => {
 				return "z.date()";
 			},
 			uuid(node) {
-				return `${this.options.guidType === "guid" ? "z.guid()" : "z.uuid()"}${lengthChecksMini(node)}`;
+				return `${this.options.guidType === "guid" ? "z.guid()" : "z.uuid()"}${lengthChecksMini({
+					...node,
+					regexType: this.options.regexType
+				})}`;
 			},
 			email(node) {
-				return `z.email()${lengthChecksMini(node)}`;
+				return `z.email()${lengthChecksMini({
+					...node,
+					regexType: this.options.regexType
+				})}`;
 			},
 			url(node) {
-				return `z.url()${lengthChecksMini(node)}`;
+				return `z.url()${lengthChecksMini({
+					...node,
+					regexType: this.options.regexType
+				})}`;
 			},
 			ipv4: () => "z.ipv4()",
 			ipv6: () => "z.ipv6()",
@@ -631,105 +1386,95 @@ const printerZodMini = ast.definePrinter((options) => {
 					if (literals.length === 1) return literals[0];
 					return `z.union([${literals.join(", ")}])`;
 				}
-				return `z.enum([${nonNullValues.map(formatLiteral).join(", ")}])`;
+				return buildEnum(nonNullValues);
 			},
 			ref(node) {
-				if (!node.name) return void 0;
-				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.name) return null;
+				const refName = ast.resolveRefName(node);
+				if (!refName) return null;
+				const resolvedName = node.ref ? this.options.resolver?.name(refName) ?? refName : node.name;
 				if (node.ref && this.options.cyclicSchemas?.has(refName)) return `z.lazy(() => ${resolvedName})`;
 				return resolvedName;
 			},
 			object(node) {
-				return `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 });
-					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;
-					const value = applyMiniModifiers({
-						value: this.options.wrapOutput ? this.options.wrapOutput({
-							output: baseOutput,
-							schema
-						}) || baseOutput : baseOutput,
-						nullable: isNullable,
-						optional: isOptional,
-						nullish: isNullish,
-						defaultValue: meta.default
+				const entries = node.properties ?? [];
+				const objectBase = `z.object(${buildZodMiniObjectShape(this, node)})`;
+				const patterns = node.patternProperties ? Object.entries(node.patternProperties) : [];
+				if (node.additionalProperties && node.additionalProperties !== true) {
+					const catchallType = this.transform(node.additionalProperties);
+					return catchallType ? `z.catchall(${objectBase}, ${catchallType})` : objectBase;
+				}
+				if (node.additionalProperties === true) return `z.catchall(${objectBase}, ${this.transform(ast.factory.createSchema({ type: "unknown" }))})`;
+				if (node.additionalProperties === false && patterns.length === 0) return objectBase.replace(/^z\.object\(/, "z.strictObject(");
+				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;
 					});
-					if (hasSelfRef) return `get "${propName}"() { return ${value} }`;
-					return `"${propName}": ${value}`;
-				}).join(",\n    ")}\n    })`;
+					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;
 			},
 			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(${mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean).join(", ") || this.transform(ast.factory.createSchema({ type: "unknown" }))})${lengthChecksMini({
+					...node,
+					regexType: this.options.regexType
+				})}`;
+				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(", ")}])`;
+				return `z.tuple(${buildList(mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean))})`;
 			},
 			union(node) {
 				const nodeMembers = node.members ?? [];
-				const members = nodeMembers.map((memberNode) => {
-					const member = this.transform(memberNode);
-					return member && node.strategy === "one" ? strictOneOfMember(member, memberNode) : member;
-				}).filter(Boolean);
+				const members = mapSchemaMembers(node, (memberNode) => this.transform(memberNode)).map(({ schema, output }) => output && node.strategy === "one" ? strictOneOfMember(output, schema) : output).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(", ")}])`;
-				return `z.union([${members.join(", ")}])`;
+				const allDiscriminable = nodeMembers.every((m) => isObjectSchemaNode(m, cyclicSchemaNames));
+				if (node.discriminatorPropertyName && allDiscriminable) return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, ${buildList(members)})`;
+				return `z.union(${buildList(members)})`;
 			},
 			intersection(node) {
 				const members = node.members ?? [];
 				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 "";
+				if (rest.length > 0 && isObjectComposableIntersection(node, cyclicSchemaNames)) return rest.reduce((acc, member) => `z.extend(${acc}, ${buildZodMiniObjectShape(this, member)})`, firstBase);
+				return rest.reduce((acc, member) => {
+					const constraint = getMemberConstraintMini({
+						member,
+						regexType: this.options.regexType
+					});
+					if (constraint) return acc + constraint;
 					const transformed = this.transform(member);
-					if (transformed) base = `z.intersection(${base}, ${transformed})`;
-				}
-				return base;
-			},
-			...options.nodes
+					return transformed ? `z.intersection(${acc}, ${transformed})` : acc;
+				}, firstBase);
+			}
 		},
+		overrides: options.nodes,
 		print(node) {
 			const { keysToOmit } = this.options;
-			let base = this.transform(node);
-			if (!base) 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(", ")} })`;
-			}
+			const transformed = this.transform(node);
+			if (!transformed) return null;
+			const meta = syncSchemaRef(node);
 			return applyMiniModifiers({
-				value: base,
+				value: (() => {
+					if (!keysToOmit?.length || meta.primitive !== "object" || meta.type === "union" && meta.discriminatorPropertyName) return transformed;
+					const unwrap = omitUnwrapChain(node);
+					const omit = `.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} })`;
+					const lazyMatch = transformed.match(/^z\.lazy\(\(\)\s*=>\s*(.+)\)$/);
+					if (lazyMatch) return `z.lazy(() => ${lazyMatch[1]}${unwrap}${omit})`;
+					return `${transformed}${unwrap}${omit}`;
+				})(),
+				schema: node,
 				nullable: meta.nullable,
 				optional: meta.optional,
 				nullish: meta.nullish,
@@ -740,66 +1485,143 @@ const printerZodMini = ast.definePrinter((options) => {
 });
 //#endregion
 //#region src/generators/zodGenerator.tsx
+const zodPrinterCache = /* @__PURE__ */ new WeakMap();
+const zodMiniPrinterCache = /* @__PURE__ */ new WeakMap();
+/**
+* Returns the cached `output`/`input` direction printers for a resolver, building them on
+* first use. The `input` printer encodes `Date → string` for request bodies, and `output` decodes
+* `string → Date` for responses. Schemas without `dateType: 'date'` fields print identically.
+*/
+function getStdPrinters(resolver, params) {
+	const cached = zodPrinterCache.get(resolver);
+	if (cached && cached.coercion === params.coercion && cached.guidType === params.guidType && cached.regexType === params.regexType && cached.dateType === params.dateType && cached.nodes === params.nodes) return {
+		output: cached.output,
+		input: cached.input
+	};
+	const output = printerZod({
+		...params,
+		resolver,
+		direction: "output"
+	});
+	const input = printerZod({
+		...params,
+		resolver,
+		direction: "input"
+	});
+	zodPrinterCache.set(resolver, {
+		output,
+		input,
+		coercion: params.coercion,
+		guidType: params.guidType,
+		regexType: params.regexType,
+		dateType: params.dateType,
+		nodes: params.nodes
+	});
+	return {
+		output,
+		input
+	};
+}
+function getMiniPrinter(resolver, params) {
+	const cached = zodMiniPrinterCache.get(resolver);
+	if (cached && cached.guidType === params.guidType && cached.regexType === params.regexType && cached.nodes === params.nodes) return cached.printer;
+	const p = printerZodMini({
+		...params,
+		resolver
+	});
+	zodMiniPrinterCache.set(resolver, {
+		printer: p,
+		guidType: params.guidType,
+		regexType: params.regexType,
+		nodes: params.nodes
+	});
+	return p;
+}
+/**
+* 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,
 	schema(node, ctx) {
 		const { adapter, config, resolver, root } = ctx;
-		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, printer } = ctx.options;
-		const dateType = adapter.options.dateType;
+		const { output, coercion, guidType, regexType, mini, inferred, importPath, group, printer } = ctx.options;
+		const dateType = getOasAdapter(adapter).options.dateType;
 		if (!node.name) return;
-		const mode = ctx.getMode(output);
 		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
-		const imports = adapter.getImports(node, (schemaName) => ({
-			name: resolver.resolveSchemaName(schemaName),
-			path: resolver.resolveFile({
+		const cyclicSchemas = new Set(ctx.meta.circularNames);
+		const hasCodec = !mini && containsCodec(node);
+		const codecRefNames = new Set(hasCodec ? collectCodecRefNames(node) : []);
+		const importEntries = resolver.imports({
+			node,
+			root,
+			output,
+			group: group ?? void 0
+		});
+		const inputImportEntries = hasCodec ? [...codecRefNames].map((schemaName) => ({
+			name: [resolver.schema.inputName(schemaName)],
+			path: resolver.file({
 				name: schemaName,
-				extname: ".ts"
-			}, {
+				extname: ".ts",
 				root,
 				output,
-				group
+				group: group ?? void 0
 			}).path
-		}));
+		})) : [];
+		const seenImports = /* @__PURE__ */ new Set();
+		const imports = [...importEntries, ...inputImportEntries].filter((imp) => {
+			const key = `${Array.isArray(imp.name) ? imp.name.join(",") : imp.name}|${imp.path}`;
+			if (seenImports.has(key)) return false;
+			seenImports.add(key);
+			return true;
+		});
 		const meta = {
-			name: resolver.resolveSchemaName(node.name),
-			file: resolver.resolveFile({
+			name: resolver.name(node.name),
+			file: resolver.file({
 				name: node.name,
-				extname: ".ts"
-			}, {
+				extname: ".ts",
 				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({
+		const inferTypeName = inferred ? resolver.schema.typeName(node.name) : null;
+		const stdPrinters = mini ? null : getStdPrinters(resolver, {
 			coercion,
 			guidType,
+			regexType,
 			dateType,
-			wrapOutput,
-			resolver,
 			cyclicSchemas,
 			nodes: printer?.nodes
 		});
+		const schemaPrinter = mini ? getMiniPrinter(resolver, {
+			guidType,
+			regexType,
+			cyclicSchemas,
+			nodes: printer?.nodes
+		}) : stdPrinters.output;
 		return /* @__PURE__ */ jsxs(File, {
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
-			banner: resolver.resolveBanner(adapter.inputNode, {
+			banner: resolver.default.banner(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
-			footer: resolver.resolveFooter(adapter.inputNode, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
 			children: [
 				/* @__PURE__ */ jsx(File.Import, {
@@ -807,70 +1629,90 @@ const zodGenerator = defineGenerator({
 					path: importPath,
 					isNameSpace: isZodImport
 				}),
-				mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+				imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
 					root: meta.file.path,
 					path: imp.path,
 					name: imp.name
-				}, [node.name, imp.path].join("-"))),
+				}, [
+					node.name,
+					imp.path,
+					imp.name
+				].join("-"))),
 				/* @__PURE__ */ jsx(Zod, {
 					name: meta.name,
 					node,
 					printer: schemaPrinter,
-					inferTypeName
+					inferTypeName,
+					cyclic: cyclicSchemas.has(node.name)
+				}),
+				hasCodec && stdPrinters && /* @__PURE__ */ jsx(Zod, {
+					name: resolver.schema.inputName(node.name),
+					node,
+					printer: stdPrinters.input,
+					inferTypeName: inferred ? resolver.schema.inputTypeName(node.name) : null,
+					cyclic: cyclicSchemas.has(node.name)
 				})
 			]
 		});
 	},
 	operation(node, ctx) {
+		if (!ast.isHttpOperationNode(node)) return null;
 		const { adapter, config, resolver, root } = ctx;
-		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = ctx.options;
-		const dateType = adapter.options.dateType;
-		const mode = ctx.getMode(output);
+		const { output, coercion, guidType, regexType, mini, inferred, importPath, group, printer } = ctx.options;
+		const dateType = getOasAdapter(adapter).options.dateType;
 		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
-		const params = ast.caseParams(node.parameters, paramsCasing);
-		const meta = { file: resolver.resolveFile({
+		const meta = { file: resolver.file({
 			name: node.operationId,
 			extname: ".ts",
 			tag: node.tags[0] ?? "default",
-			path: node.path
-		}, {
+			path: node.path,
 			root,
 			output,
-			group
+			group: group ?? void 0
 		}) };
-		const cyclicSchemas = adapter.inputNode ? ast.findCircularSchemas(adapter.inputNode.schemas) : void 0;
-		function renderSchemaEntry({ schema, name, keysToOmit }) {
+		const cyclicSchemas = new Set(ctx.meta.circularNames);
+		function renderSchemaEntry({ schema, name, keysToOmit, direction = "output" }) {
 			if (!schema) return null;
-			const inferTypeName = inferred ? resolver.resolveTypeName(name) : void 0;
-			const imports = adapter.getImports(schema, (schemaName) => ({
-				name: resolver.resolveSchemaName(schemaName),
-				path: resolver.resolveFile({
-					name: schemaName,
-					extname: ".ts"
-				}, {
-					root,
-					output,
-					group
-				}).path
-			}));
-			const schemaPrinter = mini ? printerZodMini({
+			const inferTypeName = inferred ? resolver.schema.type(name) : null;
+			const codecRefNames = direction === "input" && !mini ? new Set(collectCodecRefNames(schema)) : null;
+			const imports = resolver.imports({
+				node: schema,
+				root,
+				output,
+				group: group ?? void 0,
+				name: (schemaName) => codecRefNames?.has(schemaName) ? resolver.schema.inputName(schemaName) : resolver.name(schemaName)
+			});
+			const schemaPrinter = mini ? keysToOmit?.length ? printerZodMini({
 				guidType,
-				wrapOutput,
+				regexType,
 				resolver,
 				keysToOmit,
 				cyclicSchemas,
 				nodes: printer?.nodes
-			}) : printerZod({
+			}) : getMiniPrinter(resolver, {
+				guidType,
+				regexType,
+				cyclicSchemas,
+				nodes: printer?.nodes
+			}) : keysToOmit?.length ? printerZod({
 				coercion,
 				guidType,
+				regexType,
 				dateType,
-				wrapOutput,
 				resolver,
 				keysToOmit,
 				cyclicSchemas,
+				nodes: printer?.nodes,
+				direction
+			}) : getStdPrinters(resolver, {
+				coercion,
+				guidType,
+				regexType,
+				dateType,
+				cyclicSchemas,
 				nodes: printer?.nodes
-			});
-			return /* @__PURE__ */ jsxs(Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+			})[direction];
+			return /* @__PURE__ */ jsxs(Fragment, { children: [imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
 				root: meta.file.path,
 				path: imp.path,
 				name: imp.name
@@ -882,56 +1724,140 @@ const zodGenerator = defineGenerator({
 				name,
 				node: schema,
 				printer: schemaPrinter,
-				inferTypeName
+				inferTypeName,
+				cyclic: false
 			})] });
 		}
-		const paramSchemas = params.map((param) => renderSchemaEntry({
-			schema: param.schema,
-			name: resolver.resolveParamName(node, param)
-		}));
-		const responseSchemas = node.responses.map((res) => renderSchemaEntry({
-			schema: res.schema,
-			name: resolver.resolveResponseStatusName(node, res.statusCode),
-			keysToOmit: res.keysToOmit
-		}));
-		const responsesWithSchema = node.responses.filter((res) => res.schema);
-		const responseUnionSchema = responsesWithSchema.length > 0 ? (() => {
-			const responseUnionName = resolver.resolveResponseName(node);
-			if (new Set(responsesWithSchema.flatMap((res) => res.schema ? adapter.getImports(res.schema, (schemaName) => ({
-				name: resolver.resolveSchemaName(schemaName),
-				path: ""
-			})).flatMap((imp) => Array.isArray(imp.name) ? imp.name : [imp.name]) : [])).has(responseUnionName)) return null;
-			const members = responsesWithSchema.map((res) => ast.createSchema({
+		function buildContentTypeVariants(entries, baseName, decorate, direction) {
+			const variants = resolveContentTypeVariants(entries, baseName);
+			const unionSchema = ast.factory.createSchema({
+				type: "union",
+				members: variants.map((variant) => ast.factory.createSchema({
+					type: "ref",
+					name: variant.name
+				}))
+			});
+			return /* @__PURE__ */ jsxs(Fragment, { children: [variants.map((variant) => renderSchemaEntry({
+				schema: decorate ? decorate(variant.schema) : variant.schema,
+				name: variant.name,
+				keysToOmit: variant.keysToOmit,
+				direction
+			})), renderSchemaEntry({
+				schema: unionSchema,
+				name: baseName,
+				direction
+			})] });
+		}
+		function buildResponseUnion({ responses, name, fallbackUnknown }) {
+			if (new Set(responses.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? collectRefNames(entry.schema).map((refName) => resolver.name(refName)) : []))).has(name)) return null;
+			const members = responses.map((res) => ast.factory.createSchema({
 				type: "ref",
-				name: resolver.resolveResponseStatusName(node, res.statusCode)
+				name: resolver.response.status(node, res.statusCode)
 			}));
+			if (fallbackUnknown && members.length === 0) return renderSchemaEntry({
+				schema: ast.factory.createSchema({ type: "unknown" }),
+				name
+			});
 			return renderSchemaEntry({
-				schema: members.length === 1 ? members[0] : ast.createSchema({
+				schema: members.length === 1 ? members[0] : ast.factory.createSchema({
 					type: "union",
 					members
 				}),
-				name: responseUnionName
+				name
+			});
+		}
+		const paramSchemas = node.parameters.map((param) => renderSchemaEntry({
+			schema: param.schema,
+			name: resolver.param.name(node, param),
+			direction: "input"
+		}));
+		const responseSchemas = node.responses.map((res) => {
+			const variants = (res.content ?? []).filter((entry) => entry.schema);
+			if (variants.length > 1) return buildContentTypeVariants(res.content, resolver.response.status(node, res.statusCode));
+			const primary = variants[0] ?? res.content?.[0];
+			return renderSchemaEntry({
+				schema: primary?.schema ?? null,
+				name: resolver.response.status(node, res.statusCode),
+				keysToOmit: primary?.keysToOmit
 			});
-		})() : null;
-		const requestSchema = node.requestBody?.content?.[0]?.schema ? renderSchemaEntry({
-			schema: {
-				...node.requestBody.content[0].schema,
-				description: node.requestBody.description ?? node.requestBody.content[0].schema.description
+		});
+		const responsesWithSchema = node.responses.filter((res) => res.content?.some((entry) => entry.schema));
+		const successResponsesWithSchema = getSuccessResponses(responsesWithSchema);
+		const responseUnionSchema = responsesWithSchema.length > 0 ? buildResponseUnion({
+			responses: successResponsesWithSchema,
+			name: resolver.response.response(node),
+			fallbackUnknown: true
+		}) : null;
+		const errorResponsesWithSchema = responsesWithSchema.filter((res) => !isSuccessStatusCode(res.statusCode));
+		const errorUnionSchema = errorResponsesWithSchema.length > 0 ? buildResponseUnion({
+			responses: errorResponsesWithSchema,
+			name: resolver.response.error(node),
+			fallbackUnknown: false
+		}) : null;
+		const requestBodyContent = node.requestBody?.content ?? [];
+		const requestSchema = (() => {
+			if (requestBodyContent.length === 0) return null;
+			if (requestBodyContent.length === 1) {
+				const entry = requestBodyContent[0];
+				if (!entry.schema) return null;
+				return renderSchemaEntry({
+					schema: {
+						...entry.schema,
+						description: node.requestBody.description ?? entry.schema.description
+					},
+					name: resolver.response.body(node),
+					keysToOmit: entry.keysToOmit,
+					direction: "input"
+				});
+			}
+			return buildContentTypeVariants(requestBodyContent, resolver.response.body(node), (schema) => ({
+				...schema,
+				description: node.requestBody.description ?? schema.description
+			}), "input");
+		})();
+		const { path, query, header } = getOperationParameters(node);
+		const paramGroupSchemas = inferred ? [
+			{
+				kind: "path",
+				params: path
+			},
+			{
+				kind: "query",
+				params: query
 			},
-			name: resolver.resolveDataName(node),
-			keysToOmit: node.requestBody.content[0].keysToOmit
+			{
+				kind: "headers",
+				params: header
+			}
+		].filter(({ params }) => params.length > 0).map(({ kind, params }) => renderSchemaEntry({
+			schema: buildGroupedParamsSchema({ params }),
+			name: resolver.param[kind](node, params[0]),
+			direction: "input"
+		})) : [];
+		const optionsSchema = inferred ? renderSchemaEntry({
+			schema: buildOptionsSchema(node, resolver),
+			name: resolver.name(`${node.operationId} Options`),
+			direction: "input"
 		}) : null;
 		return /* @__PURE__ */ jsxs(File, {
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
-			banner: resolver.resolveBanner(adapter.inputNode, {
+			banner: resolver.default.banner(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
-			footer: resolver.resolveFooter(adapter.inputNode, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
 			children: [
 				/* @__PURE__ */ jsx(File.Import, {
@@ -942,78 +1868,10 @@ const zodGenerator = defineGenerator({
 				paramSchemas,
 				responseSchemas,
 				responseUnionSchema,
-				requestSchema
-			]
-		});
-	},
-	operations(nodes, ctx) {
-		const { adapter, config, resolver, root } = ctx;
-		const { output, importPath, group, operations, paramsCasing } = ctx.options;
-		if (!operations) return;
-		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
-		const meta = { file: resolver.resolveFile({
-			name: "operations",
-			extname: ".ts"
-		}, {
-			root,
-			output,
-			group
-		}) };
-		const transformedOperations = nodes.map((node) => {
-			return {
-				node,
-				data: buildSchemaNames(node, {
-					params: ast.caseParams(node.parameters, paramsCasing),
-					resolver
-				})
-			};
-		});
-		const imports = transformedOperations.flatMap(({ node, data }) => {
-			const names = [
-				data.request,
-				...Object.values(data.responses),
-				...Object.values(data.parameters)
-			].filter(Boolean);
-			const opFile = resolver.resolveFile({
-				name: node.operationId,
-				extname: ".ts",
-				tag: node.tags[0] ?? "default",
-				path: node.path
-			}, {
-				root,
-				output,
-				group
-			});
-			return names.map((name) => /* @__PURE__ */ jsx(File.Import, {
-				name: [name],
-				root: meta.file.path,
-				path: opFile.path
-			}, [name, opFile.path].join("-")));
-		});
-		return /* @__PURE__ */ jsxs(File, {
-			baseName: meta.file.baseName,
-			path: meta.file.path,
-			meta: meta.file.meta,
-			banner: resolver.resolveBanner(adapter.inputNode, {
-				output,
-				config
-			}),
-			footer: resolver.resolveFooter(adapter.inputNode, {
-				output,
-				config
-			}),
-			children: [
-				/* @__PURE__ */ jsx(File.Import, {
-					isTypeOnly: true,
-					name: isZodImport ? "z" : ["z"],
-					path: importPath,
-					isNameSpace: isZodImport
-				}),
-				imports,
-				/* @__PURE__ */ jsx(Operations, {
-					name: "operations",
-					operations: transformedOperations
-				})
+				errorUnionSchema,
+				requestSchema,
+				paramGroupSchemas,
+				optionsSchema
 			]
 		});
 	}
@@ -1021,92 +1879,90 @@ 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
+* with a `SchemaType` suffix (`PetSchemaType`), so the value and the type
+* never share an identifier even when the schema name is all-uppercase.
 *
-* 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.name('list pets')          // 'listPetsSchema'
+* resolverZod.schema.typeName('pet')     // 'PetSchemaType'
+* ```
 */
-const resolverZod = defineResolver(() => {
-	return {
-		name: "default",
-		pluginName: "plugin-zod",
-		default(name, type) {
-			return camelCase(name, {
-				isFile: type === "file",
-				suffix: type ? "schema" : void 0
-			});
-		},
-		resolveSchemaName(name) {
-			return camelCase(name, { suffix: "schema" });
-		},
-		resolveSchemaTypeName(name) {
-			return pascalCase(name, { suffix: "schema" });
-		},
-		resolveTypeName(name) {
-			return pascalCase(name);
-		},
-		resolvePathName(name, type) {
-			return this.default(name, type);
-		},
-		resolveParamName(node, param) {
-			return this.resolveSchemaName(`${node.operationId} ${param.in} ${param.name}`);
-		},
-		resolveResponseStatusName(node, statusCode) {
-			return this.resolveSchemaName(`${node.operationId} Status ${statusCode}`);
-		},
-		resolveDataName(node) {
-			return this.resolveSchemaName(`${node.operationId} Data`);
-		},
-		resolveResponsesName(node) {
-			return this.resolveSchemaName(`${node.operationId} Responses`);
+const resolverZod = createResolver({
+	pluginName: "plugin-zod",
+	name(name) {
+		return ensureValidVarName(camelCase(name, { suffix: "schema" }));
+	},
+	file: createCasedFile((part) => camelCase(part, { suffix: "schema" })),
+	schema: {
+		typeName(name) {
+			return ensureValidVarName(pascalCase(name, { suffix: "schema type" }));
 		},
-		resolveResponseName(node) {
-			return this.resolveSchemaName(`${node.operationId} Response`);
+		type(name) {
+			return ensureValidVarName(pascalCase(name, { suffix: "type" }));
 		},
-		resolvePathParamsName(node, param) {
-			return this.resolveParamName(node, param);
+		inputName(name) {
+			return this.name(`${name} input`);
 		},
-		resolveQueryParamsName(node, param) {
-			return this.resolveParamName(node, param);
+		inputTypeName(name) {
+			return this.schema.typeName(`${name} input`);
+		}
+	},
+	param: createOperationParamResolver(),
+	response: {
+		...createOperationResponseResolver(),
+		error(node) {
+			return this.name(`${node.operationId} Error`);
 		},
-		resolveHeaderParamsName(node, param) {
-			return this.resolveParamName(node, param);
+		options(node) {
+			return this.schema.type(this.name(`${node.operationId} Options`));
 		}
-	};
+	}
 });
 //#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-axios` or
+* `@kubb/plugin-fetch` and set the client's `validator: 'zod'` to validate every response
+* automatically.
 *
-* @example Zod schema generator
+* @example
 * ```ts
-* import pluginZod from '@kubb/plugin-zod'
+* import { defineConfig } from 'kubb/config'
+* import { pluginTs } from '@kubb/plugin-ts'
+* import { pluginZod } from '@kubb/plugin-zod'
+*
 * export default defineConfig({
-*   plugins: [pluginZod({ output: { path: 'zod' } })]
+*   input: './petStore.yaml',
+*   output: { path: './src/gen' },
+*   plugins: [
+*     pluginTs(),
+*     pluginZod({
+*       output: { path: './zod' },
+*       inferred: true,
+*     }),
+*   ],
 * })
 * ```
 */
 const pluginZod = definePlugin((options) => {
 	const { output = {
 		path: "zod",
-		barrelType: "named"
-	}, group, exclude = [], include, override = [], typed = false, operations = false, mini = false, guidType = "uuid", importPath = mini ? "zod/mini" : "zod", coercion = false, inferred = false, wrapOutput = void 0, paramsCasing, printer, resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = options;
-	const groupConfig = group ? {
-		...group,
-		name: (ctx) => {
-			if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-			return `${camelCase(ctx.group)}Controller`;
-		}
-	} : void 0;
+		barrel: { type: "named" }
+	}, group, exclude = [], include, override = [], mini = false, guidType = "uuid", regexType = "literal", importPath = mini ? "zod/mini" : "zod", coercion = false, inferred = false, printer, resolver: userResolver, macros: userMacros } = options;
+	const groupConfig = createGroupConfig(group);
 	return {
 		name: pluginZodName,
 		options,
@@ -1117,24 +1973,17 @@ const pluginZod = definePlugin((options) => {
 				include,
 				override,
 				group: groupConfig,
-				typed,
 				importPath,
 				coercion,
-				operations,
 				inferred,
 				guidType,
+				regexType,
 				mini,
-				wrapOutput,
-				paramsCasing,
 				printer
 			});
-			ctx.setResolver(userResolver ? {
-				...resolverZod,
-				...userResolver
-			} : resolverZod);
-			if (userTransformer) ctx.setTransformer(userTransformer);
+			ctx.setResolver(userResolver ? Resolver.merge(resolverZod, userResolver) : resolverZod);
+			if (userMacros?.length) ctx.setMacros(userMacros);
 			ctx.addGenerator(zodGenerator);
-			for (const gen of userGenerators) ctx.addGenerator(gen);
 		} }
 	};
 });