@kubb/plugin-zod 5.0.0-beta.80 → 5.0.0-beta.84

package/dist/index.js

@@ -1,8 +1,7 @@
 import { t as __name } from "./rolldown-runtime-C0LytTxp.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 { buildList, buildObject, containsCircularRef, extractRefName, lazyGetter, mapSchemaItems, mapSchemaMembers, mapSchemaProperties, objectKey, stringify, syncSchemaRef, toRegExpString } from "@kubb/ast/utils";
+import { ast, defineGenerator, definePlugin, defineResolver } from "kubb/kit";
+import { Const, File, Type, jsxRenderer } from "kubb/jsx";
+import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -386,12 +385,12 @@ function containsCodec(node, seen = /* @__PURE__ */ new Set()) {
 	if (hasCodec(node)) return true;
 	if (node.type === "ref") {
 		if (!node.ref) return false;
-		const refName = extractRefName(node.ref);
+		const refName = ast.extractRefName(node.ref);
 		if (refName) {
 			if (seen.has(refName)) return false;
 			seen.add(refName);
 		}
-		const resolved = syncSchemaRef(node);
+		const resolved = ast.syncSchemaRef(node);
 		if (resolved.type === "ref") return false;
 		return containsCodec(resolved, seen);
 	}
@@ -407,14 +406,54 @@ function containsCodec(node, seen = /* @__PURE__ */ new Set()) {
 * them to their input (encode) variant.
 */
 function collectCodecRefNames(node) {
-	return ast.collect(node, { schema: (n) => n.type === "ref" && n.ref && containsCodec(n) ? extractRefName(n.ref) ?? void 0 : void 0 });
+	return ast.collect(node, { schema: (n) => n.type === "ref" && n.ref && containsCodec(n) ? ast.extractRefName(n.ref) ?? 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 = (node.ref ? ast.extractRefName(node.ref) : void 0) ?? node.name;
+		if (refName && cyclicSchemas?.has(refName)) return false;
+		const resolved = ast.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.
 * Objects become `{}`, primitives become their string representation, strings are quoted.
 */
 function formatDefault(value) {
-	if (typeof value === "string") return stringify(value);
+	if (typeof value === "string") return ast.stringify(value);
 	if (typeof value === "object" && value !== null) return "{}";
 	return String(value ?? "");
 }
@@ -450,7 +489,7 @@ function defaultLiteral(node, value) {
 * Strings are quoted; numbers and booleans are emitted raw.
 */
 function formatLiteral(v) {
-	if (typeof v === "string") return stringify(v);
+	if (typeof v === "string") return ast.stringify(v);
 	return String(v);
 }
 /**
@@ -492,7 +531,8 @@ function patternKeySchemaMini({ patterns, regexType }) {
 	})}))`;
 }
 function patternKeySource({ patterns, regexType }) {
-	return toRegExpString(patterns.length === 1 ? patterns[0] : patterns.map((pattern) => `(${pattern})`).join("|"), regexFunc(regexType));
+	const source = patterns.length === 1 ? patterns[0] : patterns.map((pattern) => `(${pattern})`).join("|");
+	return ast.toRegExpString(source, regexFunc(regexType));
 }
 /**
 * Build `.min()` / `.max()` / `.gt()` / `.lt()` constraint chains for numbers
@@ -515,7 +555,7 @@ function lengthConstraints({ min, max, pattern, regexType }) {
 	return [
 		min !== void 0 ? `.min(${min})` : "",
 		max !== void 0 ? `.max(${max})` : "",
-		pattern !== void 0 ? `.regex(${toRegExpString(pattern, regexFunc(regexType))})` : ""
+		pattern !== void 0 ? `.regex(${ast.toRegExpString(pattern, regexFunc(regexType))})` : ""
 	].join("");
 }
 /**
@@ -537,7 +577,7 @@ 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, regexFunc(regexType))})`);
+	if (pattern !== void 0) checks.push(`z.regex(${ast.toRegExpString(pattern, regexFunc(regexType))})`);
 	return checks.length ? `.check(${checks.join(", ")})` : "";
 }
 /**
@@ -553,7 +593,7 @@ function applyModifiers({ value, schema, nullable, optional, nullish, defaultVal
 	})();
 	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;
+	const withDescription = description ? `${withDefault}.describe(${ast.stringify(description)})` : withDefault;
 	return examples?.length ? `${withDescription}.meta({ examples: [${examples.map(formatDefault).join(", ")}] })` : withDescription;
 }
 function modifierDepth(schema) {
@@ -596,9 +636,9 @@ 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 refName = (node.ref ? extractRefName(node.ref) : void 0) ?? node.name;
+		const refName = (node.ref ? ast.extractRefName(node.ref) : void 0) ?? node.name;
 		if (refName && cyclicSchemas?.has(refName)) return member;
-		const schema = syncSchemaRef(node);
+		const schema = ast.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()`;
 	}
@@ -617,6 +657,42 @@ function getMemberConstraint({ member, 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 && ast.containsCircularRef(schema, { circularSchemas: ctx.options.cyclicSchemas });
+	const entries = ast.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 = ast.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) ? ast.lazyGetter({
+			name: propName,
+			body: value
+		}) : `${ast.objectKey(propName)}: ${value}`;
+	});
+	return ast.buildObject(entries);
+}
+/**
 * Zod v4 printer built with `definePrinter`.
 *
 * Converts a `SchemaNode` AST into a Zod v4 code string using the chainable API
@@ -657,7 +733,10 @@ const printerZod = ast.createPrinter((options) => {
 			},
 			date(node) {
 				const codec = getCodec(node);
-				if (codec) return this.options.direction === "input" ? codec.encode(node) : codec.decode(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) {
@@ -703,45 +782,15 @@ const printerZod = ast.createPrinter((options) => {
 			},
 			ref(node) {
 				if (!node.name) return null;
-				const refName = node.ref ? this.options.nameMapping?.get(node.ref) ?? extractRefName(node.ref) ?? node.name : node.name;
+				const refName = node.ref ? this.options.nameMapping?.get(node.ref) ?? ast.extractRefName(node.ref) ?? node.name : node.name;
 				const useInputVariant = node.ref != null && this.options.direction === "input" && containsCodec(node);
 				const resolvedName = node.ref ? useInputVariant ? this.options.resolver?.resolveInputSchemaName(refName) ?? refName : this.options.resolver?.default(refName, "function") ?? refName : node.name;
 				if (node.ref && this.options.cyclicSchemas?.has(refName)) return `z.lazy(() => ${resolvedName})`;
 				return resolvedName;
 			},
 			object(node) {
-				const isCyclic = (schema) => this.options.cyclicSchemas != null && containsCircularRef(schema, { circularSchemas: this.options.cyclicSchemas });
-				const entries = mapSchemaProperties(node, (schema) => {
-					const hasSelfRef = isCyclic(schema);
-					const savedCyclicSchemas = this.options.cyclicSchemas;
-					if (hasSelfRef) this.options.cyclicSchemas = void 0;
-					const baseOutput = this.transform(schema) ?? this.transform(ast.factory.createSchema({ type: "unknown" }));
-					if (hasSelfRef) this.options.cyclicSchemas = savedCyclicSchemas;
-					return baseOutput;
-				}).map(({ name: propName, property, output: baseOutput }) => {
-					const { schema } = property;
-					const meta = syncSchemaRef(schema);
-					const wrappedOutput = this.options.wrapOutput ? this.options.wrapOutput({
-						output: baseOutput,
-						schema
-					}) || baseOutput : baseOutput;
-					const descriptionToApply = schema.type !== "ref" && meta.type === "ref" ? void 0 : meta.description;
-					const value = applyModifiers({
-						value: wrappedOutput,
-						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}`;
-				});
-				const objectBase = `z.object(${buildObject(entries)})`;
+				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) {
@@ -767,23 +816,24 @@ const printerZod = ast.createPrinter((options) => {
 				})();
 			},
 			array(node) {
-				const base = `z.array(${mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean).join(", ") || this.transform(ast.factory.createSchema({ type: "unknown" }))})${lengthConstraints({
+				const base = `z.array(${ast.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(${buildList(mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean))})`;
+				const items = ast.mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean);
+				return `z.tuple(${ast.buildList(items)})`;
 			},
 			union(node) {
 				const nodeMembers = node.members ?? [];
-				const members = mapSchemaMembers(node, (memberNode) => this.transform(memberNode)).map(({ schema, output }) => output && node.strategy === "one" ? strictOneOfMember$1(output, schema, cyclicSchemaNames) : output).filter(Boolean);
+				const members = ast.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];
-				const allDiscriminable = nodeMembers.every((m) => (m.type === "ref" ? syncSchemaRef(m) : m).type !== "intersection");
-				if (node.discriminatorPropertyName && allDiscriminable) return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, ${buildList(members)})`;
-				return `z.union(${buildList(members)})`;
+				const allDiscriminable = nodeMembers.every((m) => isObjectSchemaNode(m, cyclicSchemaNames));
+				if (node.discriminatorPropertyName && allDiscriminable) return `z.discriminatedUnion(${ast.stringify(node.discriminatorPropertyName)}, ${ast.buildList(members)})`;
+				return `z.union(${ast.buildList(members)})`;
 			},
 			intersection(node) {
 				const members = node.members ?? [];
@@ -792,6 +842,7 @@ const printerZod = ast.createPrinter((options) => {
 				if (!first) return "";
 				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,
@@ -801,14 +852,14 @@ const printerZod = ast.createPrinter((options) => {
 					const transformed = this.transform(member);
 					return transformed ? `${acc}.and(${transformed})` : acc;
 				}, firstBase);
-			},
-			...options.nodes
+			}
 		},
+		overrides: options.nodes,
 		print(node) {
 			const { keysToOmit } = this.options;
 			const transformed = this.transform(node);
 			if (!transformed) return null;
-			const meta = syncSchemaRef(node);
+			const meta = ast.syncSchemaRef(node);
 			return applyModifiers({
 				value: (() => {
 					if (!keysToOmit?.length || meta.primitive !== "object" || meta.type === "union" && meta.discriminatorPropertyName) return transformed;
@@ -847,7 +898,40 @@ function getMemberConstraintMini({ member, 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 && ast.containsCircularRef(schema, { circularSchemas: ctx.options.cyclicSchemas });
+	const entries = ast.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 = ast.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) ? ast.lazyGetter({
+			name: propName,
+			body: value
+		}) : `${ast.objectKey(propName)}: ${value}`;
+	});
+	return ast.buildObject(entries);
+}
+/**
+* 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.
@@ -859,6 +943,7 @@ function getMemberConstraintMini({ member, regexType }) {
 * ```
 */
 const printerZodMini = ast.createPrinter((options) => {
+	const cyclicSchemaNames = options.cyclicSchemas;
 	return {
 		name: "zod-mini",
 		options,
@@ -927,40 +1012,14 @@ const printerZodMini = ast.createPrinter((options) => {
 			},
 			ref(node) {
 				if (!node.name) return null;
-				const refName = node.ref ? this.options.nameMapping?.get(node.ref) ?? extractRefName(node.ref) ?? node.name : node.name;
+				const refName = node.ref ? this.options.nameMapping?.get(node.ref) ?? ast.extractRefName(node.ref) ?? node.name : node.name;
 				const resolvedName = node.ref ? this.options.resolver?.default(refName, "function") ?? refName : node.name;
 				if (node.ref && this.options.cyclicSchemas?.has(refName)) return `z.lazy(() => ${resolvedName})`;
 				return resolvedName;
 			},
 			object(node) {
-				const isCyclic = (schema) => this.options.cyclicSchemas != null && containsCircularRef(schema, { circularSchemas: this.options.cyclicSchemas });
-				const entries = mapSchemaProperties(node, (schema) => {
-					const hasSelfRef = isCyclic(schema);
-					const savedCyclicSchemas = this.options.cyclicSchemas;
-					if (hasSelfRef) this.options.cyclicSchemas = void 0;
-					const baseOutput = this.transform(schema) ?? this.transform(ast.factory.createSchema({ type: "unknown" }));
-					if (hasSelfRef) this.options.cyclicSchemas = savedCyclicSchemas;
-					return baseOutput;
-				}).map(({ name: propName, property, output: baseOutput }) => {
-					const { schema } = property;
-					const meta = syncSchemaRef(schema);
-					const value = applyMiniModifiers({
-						value: this.options.wrapOutput ? this.options.wrapOutput({
-							output: baseOutput,
-							schema
-						}) || baseOutput : 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}`;
-				});
-				const objectBase = `z.object(${buildObject(entries)})`;
+				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);
@@ -984,23 +1043,24 @@ const printerZodMini = ast.createPrinter((options) => {
 				return objectBase;
 			},
 			array(node) {
-				const base = `z.array(${mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean).join(", ") || this.transform(ast.factory.createSchema({ type: "unknown" }))})${lengthChecksMini({
+				const base = `z.array(${ast.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(${buildList(mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean))})`;
+				const items = ast.mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean);
+				return `z.tuple(${ast.buildList(items)})`;
 			},
 			union(node) {
 				const nodeMembers = node.members ?? [];
-				const members = mapSchemaMembers(node, (memberNode) => this.transform(memberNode)).map(({ schema, output }) => output && node.strategy === "one" ? strictOneOfMember(output, schema) : output).filter(Boolean);
+				const members = ast.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];
-				const allDiscriminable = nodeMembers.every((m) => (m.type === "ref" ? syncSchemaRef(m) : m).type !== "intersection");
-				if (node.discriminatorPropertyName && allDiscriminable) return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, ${buildList(members)})`;
-				return `z.union(${buildList(members)})`;
+				const allDiscriminable = nodeMembers.every((m) => isObjectSchemaNode(m, cyclicSchemaNames));
+				if (node.discriminatorPropertyName && allDiscriminable) return `z.discriminatedUnion(${ast.stringify(node.discriminatorPropertyName)}, ${ast.buildList(members)})`;
+				return `z.union(${ast.buildList(members)})`;
 			},
 			intersection(node) {
 				const members = node.members ?? [];
@@ -1009,6 +1069,7 @@ const printerZodMini = ast.createPrinter((options) => {
 				if (!first) return "";
 				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,
@@ -1018,14 +1079,14 @@ const printerZodMini = ast.createPrinter((options) => {
 					const transformed = this.transform(member);
 					return transformed ? `z.intersection(${acc}, ${transformed})` : acc;
 				}, firstBase);
-			},
-			...options.nodes
+			}
 		},
+		overrides: options.nodes,
 		print(node) {
 			const { keysToOmit } = this.options;
 			const transformed = this.transform(node);
 			if (!transformed) return null;
-			const meta = syncSchemaRef(node);
+			const meta = ast.syncSchemaRef(node);
 			return applyMiniModifiers({
 				value: (() => {
 					if (!keysToOmit?.length || meta.primitive !== "object" || meta.type === "union" && meta.discriminatorPropertyName) return transformed;
@@ -1050,12 +1111,12 @@ 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; `output` decodes
+* 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) return {
+	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
 	};
@@ -1077,7 +1138,8 @@ function getStdPrinters(resolver, params) {
 		coercion: params.coercion,
 		guidType: params.guidType,
 		regexType: params.regexType,
-		dateType: params.dateType
+		dateType: params.dateType,
+		nodes: params.nodes
 	});
 	return {
 		output,
@@ -1086,7 +1148,7 @@ function getStdPrinters(resolver, params) {
 }
 function getMiniPrinter(resolver, params) {
 	const cached = zodMiniPrinterCache.get(resolver);
-	if (cached && cached.guidType === params.guidType && cached.regexType === params.regexType) return cached.printer;
+	if (cached && cached.guidType === params.guidType && cached.regexType === params.regexType && cached.nodes === params.nodes) return cached.printer;
 	const p = printerZodMini({
 		...params,
 		resolver
@@ -1094,7 +1156,8 @@ function getMiniPrinter(resolver, params) {
 	zodMiniPrinterCache.set(resolver, {
 		printer: p,
 		guidType: params.guidType,
-		regexType: params.regexType
+		regexType: params.regexType,
+		nodes: params.nodes
 	});
 	return p;
 }
@@ -1109,7 +1172,7 @@ const zodGenerator = defineGenerator({
 	renderer: jsxRenderer,
 	schema(node, ctx) {
 		const { adapter, config, resolver, root } = ctx;
-		const { output, coercion, guidType, regexType, mini, wrapOutput, inferred, importPath, group, printer } = ctx.options;
+		const { output, coercion, guidType, regexType, mini, inferred, importPath, group, printer } = ctx.options;
 		const dateType = adapter.options.dateType;
 		if (!node.name) return;
 		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
@@ -1163,7 +1226,6 @@ const zodGenerator = defineGenerator({
 			guidType,
 			regexType,
 			dateType,
-			wrapOutput,
 			cyclicSchemas,
 			nameMapping,
 			nodes: printer?.nodes
@@ -1171,7 +1233,6 @@ const zodGenerator = defineGenerator({
 		const schemaPrinter = mini ? getMiniPrinter(resolver, {
 			guidType,
 			regexType,
-			wrapOutput,
 			cyclicSchemas,
 			nameMapping,
 			nodes: printer?.nodes
@@ -1231,7 +1292,7 @@ const zodGenerator = defineGenerator({
 	operation(node, ctx) {
 		if (!ast.isHttpOperationNode(node)) return null;
 		const { adapter, config, resolver, root } = ctx;
-		const { output, coercion, guidType, regexType, mini, wrapOutput, inferred, importPath, group, printer } = ctx.options;
+		const { output, coercion, guidType, regexType, mini, inferred, importPath, group, printer } = ctx.options;
 		const dateType = adapter.options.dateType;
 		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
 		const params = caseParams(node.parameters, "camelcase");
@@ -1265,7 +1326,6 @@ const zodGenerator = defineGenerator({
 			const schemaPrinter = mini ? keysToOmit?.length ? printerZodMini({
 				guidType,
 				regexType,
-				wrapOutput,
 				resolver,
 				keysToOmit,
 				cyclicSchemas,
@@ -1274,7 +1334,6 @@ const zodGenerator = defineGenerator({
 			}) : getMiniPrinter(resolver, {
 				guidType,
 				regexType,
-				wrapOutput,
 				cyclicSchemas,
 				nameMapping,
 				nodes: printer?.nodes
@@ -1283,7 +1342,6 @@ const zodGenerator = defineGenerator({
 				guidType,
 				regexType,
 				dateType,
-				wrapOutput,
 				resolver,
 				keysToOmit,
 				cyclicSchemas,
@@ -1295,7 +1353,6 @@ const zodGenerator = defineGenerator({
 				guidType,
 				regexType,
 				dateType,
-				wrapOutput,
 				cyclicSchemas,
 				nameMapping,
 				nodes: printer?.nodes
@@ -1538,7 +1595,7 @@ const pluginZodName = "plugin-zod";
 *
 * @example
 * ```ts
-* import { defineConfig } from 'kubb'
+* import { defineConfig } from 'kubb/config'
 * import { pluginTs } from '@kubb/plugin-ts'
 * import { pluginZod } from '@kubb/plugin-zod'
 *
@@ -1549,7 +1606,7 @@ const pluginZodName = "plugin-zod";
 *     pluginTs(),
 *     pluginZod({
 *       output: { path: './zod' },
-*       typed: true,
+*       inferred: true,
 *     }),
 *   ],
 * })
@@ -1559,7 +1616,7 @@ const pluginZod = definePlugin((options) => {
 	const { output = {
 		path: "zod",
 		barrel: { type: "named" }
-	}, group, exclude = [], include, override = [], typed = false, mini = false, guidType = "uuid", regexType = "literal", importPath = mini ? "zod/mini" : "zod", coercion = false, inferred = false, wrapOutput = void 0, printer, resolver: userResolver, macros: userMacros } = options;
+	}, 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,
@@ -1571,14 +1628,12 @@ const pluginZod = definePlugin((options) => {
 				include,
 				override,
 				group: groupConfig,
-				typed,
 				importPath,
 				coercion,
 				inferred,
 				guidType,
 				regexType,
 				mini,
-				wrapOutput,
 				printer
 			});
 			ctx.setResolver(userResolver ? {