@orval/zod 8.18.0 → 8.20.0

package/dist/index.d.mts

@@ -1,10 +1,30 @@
-import { ClientBuilder, ClientGeneratorsBuilder, ContextSpec, GeneratorDependency, GeneratorMutator, OpenApiParameterObject, OpenApiReferenceObject, OpenApiSchemaObject, PackageJson, ZodCoerceType } from "@orval/core";
+import { ClientBuilder, ClientDependenciesBuilder, ClientGeneratorsBuilder, ContextSpec, GeneratorMutator, OpenApiParameterObject, OpenApiReferenceObject, OpenApiSchemaObject, PackageJson, ZodCoerceType, ZodVariantOption, ZodVersionOption } from "@orval/core";
 
 //#region src/compatible-v4.d.ts
 declare const isZodVersionV4: (packageJson: PackageJson) => boolean;
+/**
+ * Resolves whether to emit Zod 4-style output.
+ *
+ * An explicit `override.zod.version` of `3` or `4` always wins; `'auto'` (the
+ * default) falls back to inferring from the output project's resolved `zod`
+ * version via {@link isZodVersionV4}. When no package metadata is available,
+ * `'auto'` now defaults to Zod 4 so fresh or partially-installed workspaces
+ * still get the modern baseline. This keeps generation deterministic when a
+ * target is pinned while preserving package-detection for `'auto'`.
+ */
+declare const resolveIsZodV4: (version: ZodVersionOption | undefined, packageJson: PackageJson | undefined) => boolean;
+declare const assertZodTarget: ({
+  variant,
+  isZodV4
+}: {
+  variant: ZodVariantOption | undefined;
+  isZodV4: boolean;
+}) => void;
+declare const getZodImportSource: (variant: ZodVariantOption | undefined) => "zod/mini" | "zod";
+declare const getZodTypeName: (variant: ZodVariantOption | undefined) => "ZodMiniType" | "ZodType";
 //#endregion
 //#region src/index.d.ts
-declare const getZodDependencies: () => GeneratorDependency[];
+declare const getZodDependencies: ClientDependenciesBuilder;
 declare const predefinedZodFormats: Set<string>;
 interface ZodValidationSchemaDefinition {
   functions: [string, unknown][];
@@ -47,6 +67,15 @@ declare const generateZodValidationSchemaDefinition: (schema: OpenApiSchemaObjec
    * placeholder instead of being inlined.
    */
   useReusableSchemas?: boolean;
+  /**
+   * When true, suppress File/Blob coercion for binary string fields anywhere
+   * in the tree (`format: binary` / `contentMediaType: application/octet-stream`),
+   * keeping them as `string`. Set for `application/x-www-form-urlencoded` bodies,
+   * which serialize via URLSearchParams (string-only) — mirrors core's
+   * `formDataContext.urlEncoded` handling in getScalar (#1624). Threaded into
+   * every recursive call so nested/array/composed fields are covered too.
+   */
+  urlEncoded?: boolean;
   /**
    * When true (and `isZodV4`), the top-level (named component) schema emits a
    * `.meta({ id, description?, deprecated? })` instead of `.describe(...)`.
@@ -75,7 +104,7 @@ interface ZodParamsContext {
 interface ZodParamsInjection extends Pick<ZodParamsContext, 'operationId' | 'location' | 'schemaName'> {
   mutator: GeneratorMutator;
 }
-declare const parseZodValidationSchemaDefinition: (input: ZodValidationSchemaDefinition, context: ContextSpec, coerceTypes: boolean | ZodCoerceType[] | undefined, strict: boolean, isZodV4: boolean, preprocess?: GeneratorMutator, paramsInjection?: ZodParamsInjection) => {
+declare const parseZodValidationSchemaDefinition: (input: ZodValidationSchemaDefinition, context: ContextSpec, coerceTypes: boolean | ZodCoerceType[] | undefined, strict: boolean, isZodV4: boolean, preprocess?: GeneratorMutator, paramsInjection?: ZodParamsInjection, variant?: ZodVariantOption) => {
   zod: string;
   consts: string;
   usedRefs: Set<string>;
@@ -139,5 +168,5 @@ declare const parseParameters: ({
 declare const generateZod: ClientBuilder;
 declare const builder: () => () => ClientGeneratorsBuilder;
 //#endregion
-export { ZodParamsContext, ZodParamsInjection, ZodValidationSchemaDefinition, builder, builder as default, dereference, generateFormDataZodSchema, generateZod, generateZodValidationSchemaDefinition, getZodDependencies, isZodVersionV4, parseParameters, parseZodValidationSchemaDefinition, predefinedZodFormats };
+export { ZodParamsContext, ZodParamsInjection, ZodValidationSchemaDefinition, assertZodTarget, builder, builder as default, dereference, generateFormDataZodSchema, generateZod, generateZodValidationSchemaDefinition, getZodDependencies, getZodImportSource, getZodTypeName, isZodVersionV4, parseParameters, parseZodValidationSchemaDefinition, predefinedZodFormats, resolveIsZodV4 };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { buildDynamicScope, camel, compareVersions, generateMutator, getDynamicAnchorName, getFormDataFieldFileType, getNumberWord, getRefInfo, isBoolean, isDynamicReference, isNumber, isObject, isString, jsStringEscape, jsStringLiteralEscape, logVerbose, pascal, resolveDynamicRef, resolveRef, stringify } from "@orval/core";
+import { buildDynamicScope, buildInlineDynamicScope, camel, compareVersions, generateMutator, getDynamicAnchorName, getFormDataFieldFileType, getNumberWord, getRefInfo, isBoolean, isDynamicReference, isNumber, isObject, isString, jsStringEscape, jsStringLiteralEscape, logVerbose, pascal, resolveDynamicRef, resolveRef, stringify } from "@orval/core";
 import { unique } from "remeda";
 //#region src/compatible-v4.ts
 const getZodPackageVersion = (packageJson) => {
@@ -10,6 +10,27 @@ const isZodVersionV4 = (packageJson) => {
 	const withoutRc = version.split("-")[0];
 	return compareVersions(withoutRc, "4.0.0");
 };
+/**
+* Resolves whether to emit Zod 4-style output.
+*
+* An explicit `override.zod.version` of `3` or `4` always wins; `'auto'` (the
+* default) falls back to inferring from the output project's resolved `zod`
+* version via {@link isZodVersionV4}. When no package metadata is available,
+* `'auto'` now defaults to Zod 4 so fresh or partially-installed workspaces
+* still get the modern baseline. This keeps generation deterministic when a
+* target is pinned while preserving package-detection for `'auto'`.
+*/
+const resolveIsZodV4 = (version, packageJson) => {
+	if (version === 4) return true;
+	if (version === 3) return false;
+	if (!packageJson || !getZodPackageVersion(packageJson)) return true;
+	return isZodVersionV4(packageJson);
+};
+const assertZodTarget = ({ variant, isZodV4 }) => {
+	if (variant === "mini" && !isZodV4) throw new Error("Zod Mini requires Zod 4 output. Use override.zod.version: 4 or install zod@^4 when override.zod.version is 'auto'.");
+};
+const getZodImportSource = (variant) => variant === "mini" ? "zod/mini" : "zod";
+const getZodTypeName = (variant) => variant === "mini" ? "ZodMiniType" : "ZodType";
 const getZodDateFormat = (isZodV4) => {
 	return isZodV4 ? "iso.date" : "date";
 };
@@ -38,7 +59,7 @@ const getLooseObjectFunctionName = (isZodV4) => {
 };
 //#endregion
 //#region src/index.ts
-const ZOD_DEPENDENCIES = [{
+const getZodDependencies = (_hasGlobalMutator, _hasParamsSerializerOptions, _packageJson, _httpClient, _hasTagsMutator, override) => [{
 	exports: [{
 		default: false,
 		name: "zod",
@@ -46,9 +67,8 @@ const ZOD_DEPENDENCIES = [{
 		namespaceImport: true,
 		values: true
 	}],
-	dependency: "zod"
+	dependency: getZodImportSource(override?.zod.variant)
 }];
-const getZodDependencies = () => ZOD_DEPENDENCIES;
 /**
 * values that may appear in "type". Equals SchemaObjectType
 */
@@ -94,6 +114,9 @@ const COERCIBLE_TYPES = new Set([
 	"bigint",
 	"date"
 ]);
+const PURE_COMMENT = "/*#__PURE__*/ ";
+const zodMiniCall = (fn, args = "") => `${PURE_COMMENT}zod.${fn}(${args})`;
+const zodMiniCoerceCall = (fn, args = "") => `${PURE_COMMENT}zod.coerce.${fn}(${args})`;
 const minAndMaxTypes = new Set([
 	"number",
 	"string",
@@ -190,6 +213,7 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 		schema = dereference(schema, context);
 	}
 	const useReusableSchemas = rules?.useReusableSchemas ?? false;
+	const urlEncoded = rules?.urlEncoded ?? false;
 	const consts = [];
 	const constNameRegistry = rules?.constNameRegistry ?? {};
 	const constsCounter = isNumber(constNameRegistry[name]) ? constNameRegistry[name] + 1 : 0;
@@ -231,7 +255,8 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 			required: true,
 			additionalRequired: allOfRequired,
 			constNameRegistry,
-			useReusableSchemas
+			useReusableSchemas,
+			urlEncoded
 		}));
 		if ((schema.allOf || schema.oneOf || schema.anyOf) && schema.properties) {
 			const additionalPropertiesSchema = {
@@ -245,7 +270,8 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 				required: true,
 				additionalRequired: allOfRequired,
 				constNameRegistry,
-				useReusableSchemas
+				useReusableSchemas,
+				urlEncoded
 			});
 			if (schema.oneOf || schema.anyOf) functions.push(["allOf", [{
 				functions: [[separator, baseSchemas]],
@@ -288,7 +314,8 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 		}, context, name, strict, isZodV4, {
 			required: true,
 			constNameRegistry,
-			useReusableSchemas
+			useReusableSchemas,
+			urlEncoded
 		}))]);
 		if (!required && nullable) functions.push(["nullish", void 0]);
 		else if (nullable) functions.push(["nullable", void 0]);
@@ -323,12 +350,14 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 					functions.push(["tuple", prefixItems.map((item, idx) => generateZodValidationSchemaDefinition(dereference(item, context), context, camel(`${name}-${idx}-item`), isZodV4, strict, {
 						required: true,
 						constNameRegistry,
-						useReusableSchemas
+						useReusableSchemas,
+						urlEncoded
 					}))]);
 					if (schema.items && (max ?? Number.POSITIVE_INFINITY) > prefixItems.length) functions.push(["rest", generateZodValidationSchemaDefinition(schema.items, context, camel(`${name}-item`), strict, isZodV4, {
 						required: true,
 						constNameRegistry,
-						useReusableSchemas
+						useReusableSchemas,
+						urlEncoded
 					})]);
 				}
 			}
@@ -337,7 +366,8 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 			functions.push(["array", generateZodValidationSchemaDefinition(schema.items, context, camel(`${name}-item`), strict, isZodV4, {
 				required: true,
 				constNameRegistry,
-				useReusableSchemas
+				useReusableSchemas,
+				urlEncoded
 			})]);
 			break;
 		case "string":
@@ -346,11 +376,11 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 				functions.push(["date", void 0]);
 				break;
 			}
-			if (schema.format === "binary") {
+			if (!urlEncoded && schema.format === "binary") {
 				functions.push(["instanceof", "File"]);
 				break;
 			}
-			if (schema.contentMediaType === "application/octet-stream" && !schema.contentEncoding) {
+			if (!urlEncoded && schema.contentMediaType === "application/octet-stream" && !schema.contentEncoding) {
 				functions.push(["instanceof", "File"]);
 				break;
 			}
@@ -415,7 +445,8 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 				functions.push([objectType, Object.keys(properties).map((key) => ({ [key]: rules?.propertyOverrides?.[key] ?? generateZodValidationSchemaDefinition(properties[key], context, camel(`${name}-${key}`), strict, isZodV4, {
 					required: requiredKeys.has(key),
 					constNameRegistry,
-					useReusableSchemas
+					useReusableSchemas,
+					urlEncoded
 				}) })).reduce((acc, curr) => ({
 					...acc,
 					...curr
@@ -433,7 +464,8 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 				functions.push(["additionalProperties", generateZodValidationSchemaDefinition(isBoolean(schema.additionalProperties) ? {} : schema.additionalProperties, context, name, strict, isZodV4, {
 					required: true,
 					constNameRegistry,
-					useReusableSchemas
+					useReusableSchemas,
+					urlEncoded
 				})]);
 				break;
 			}
@@ -512,7 +544,7 @@ const PARAMS_MERGE_INTO_OPTIONS_VALIDATORS = new Set([
 	"iso.datetime",
 	"iso.time"
 ]);
-const parseZodValidationSchemaDefinition = (input, context, coerceTypes = false, strict, isZodV4, preprocess, paramsInjection) => {
+const parseZodValidationSchemaDefinition = (input, context, coerceTypes = false, strict, isZodV4, preprocess, paramsInjection, variant = "classic") => {
 	if (input.functions.length === 0) return {
 		zod: "",
 		consts: "",
@@ -546,6 +578,196 @@ const parseZodValidationSchemaDefinition = (input, context, coerceTypes = false,
 		};
 		return `${paramsInjection.mutator.name}(${JSON.stringify(ctx)})`;
 	};
+	const shouldCoerce = (fn) => coerceTypes && (Array.isArray(coerceTypes) ? coerceTypes.includes(fn) : COERCIBLE_TYPES.has(fn));
+	const buildCombinedArgs = (fn, args, fieldPath) => {
+		const formattedArgs = formatFunctionArgs(args);
+		const paramsArg = buildParamsArg(fn, fieldPath);
+		if (paramsArg && formattedArgs && PARAMS_MERGE_INTO_OPTIONS_VALIDATORS.has(fn)) return `{ ...${formattedArgs}, ...${paramsArg} }`;
+		if (paramsArg) return formattedArgs ? `${formattedArgs}, ${paramsArg}` : paramsArg;
+		return formattedArgs;
+	};
+	const renderMiniDefinition = (definition, fieldPath = []) => {
+		let current;
+		const requireCurrent = (fn) => {
+			if (!current) throw new Error(`Cannot render zod mini ${fn} without a base schema`);
+			return current;
+		};
+		const renderObject = (objectArgs, objectType) => ({
+			kind: "object",
+			expr: `${zodMiniCall(objectType, `{
+${Object.entries(objectArgs).map(([key, schema]) => {
+				const rendered = renderMiniDefinition(schema, [...fieldPath, key]);
+				appendConstsChunk(schema.consts.join("\n"));
+				if (Array.isArray(coerceTypes) && coerceTypes.includes("array") && schema.functions.some(([fn]) => fn === "array")) return `  "${key}": ${zodMiniCall("pipe", `${zodMiniCall("transform", "(value) => value === undefined || Array.isArray(value) ? value : [value]")}, ${rendered.expr}`)}`;
+				return `  "${key}": ${rendered.expr}`;
+			}).join(",\n")}
+}`)}`
+		});
+		for (let index = 0; index < definition.functions.length; index++) {
+			const [fn, args = ""] = definition.functions[index];
+			if (fn === "namedRef") {
+				const refArgs = args;
+				usedRefs.add(refArgs.name);
+				current = {
+					expr: `__REF_${refArgs.name}__`,
+					kind: "ref"
+				};
+				continue;
+			}
+			if (fn === "fileOrString") {
+				current = {
+					expr: zodMiniCall("union", `[${zodMiniCall("instanceof", "File")}, ${zodMiniCall("string")}]`),
+					kind: "union"
+				};
+				continue;
+			}
+			if (fn === "allOf") {
+				const allOfArgs = args;
+				if (strict && allOfArgs.length > 0 && allOfArgs.every((partSchema) => {
+					if (partSchema.functions.length === 0) return false;
+					const firstFn = partSchema.functions[0][0];
+					return firstFn === "object" || firstFn === "strictObject";
+				})) {
+					const mergedProperties = {};
+					const allConsts = [];
+					for (const partSchema of allOfArgs) {
+						if (partSchema.consts.length > 0) allConsts.push(partSchema.consts.join("\n"));
+						const objectFunctionIndex = partSchema.functions.findIndex(([fnName]) => fnName === "object" || fnName === "strictObject");
+						if (objectFunctionIndex !== -1) {
+							const objectArgs = partSchema.functions[objectFunctionIndex][1];
+							if (isObject(objectArgs)) Object.assign(mergedProperties, objectArgs);
+						}
+					}
+					appendConstsChunk(allConsts.join("\n"));
+					current = renderObject(mergedProperties, getObjectFunctionName(true, strict));
+					continue;
+				}
+				const rendered = allOfArgs.map((partSchema) => {
+					appendConstsChunk(partSchema.consts.join("\n"));
+					return renderMiniDefinition(partSchema, fieldPath).expr;
+				});
+				if (rendered.length === 0) {
+					current = { expr: "" };
+					continue;
+				}
+				current = {
+					expr: rendered.reduce((acc, value) => acc ? zodMiniCall("intersection", `${acc}, ${value}`) : value),
+					kind: "intersection"
+				};
+				continue;
+			}
+			if (fn === "oneOf" || fn === "anyOf") {
+				const unionArgs = args;
+				if (unionArgs.length === 1) {
+					appendConstsChunk(unionArgs[0].consts.join("\n"));
+					current = renderMiniDefinition(unionArgs[0], fieldPath);
+					continue;
+				}
+				current = {
+					expr: zodMiniCall("union", `[${unionArgs.map((arg) => {
+						appendConstsChunk(arg.consts.join("\n"));
+						return renderMiniDefinition(arg, fieldPath).expr;
+					}).join(",")}]`),
+					kind: "union"
+				};
+				continue;
+			}
+			if (fn === "additionalProperties") {
+				const additionalPropertiesArgs = args;
+				const rendered = renderMiniDefinition(additionalPropertiesArgs, fieldPath);
+				if (Array.isArray(additionalPropertiesArgs.consts)) appendConstsChunk(additionalPropertiesArgs.consts.join("\n"));
+				current = {
+					expr: zodMiniCall("record", `${zodMiniCall("string")}, ${rendered.expr}`),
+					kind: "object"
+				};
+				continue;
+			}
+			if (fn === "object" || fn === "strictObject" || fn === "looseObject") {
+				current = renderObject(args, fn === "looseObject" ? "looseObject" : getObjectFunctionName(true, strict));
+				continue;
+			}
+			if (fn === "passthrough" || fn === "strict") continue;
+			if (fn === "array") {
+				const arrayArgs = args;
+				const rendered = renderMiniDefinition(arrayArgs, fieldPath);
+				if (isString(arrayArgs.consts)) appendConstsChunk(arrayArgs.consts);
+				else if (Array.isArray(arrayArgs.consts)) appendConstsChunk(arrayArgs.consts.join("\n"));
+				current = {
+					expr: zodMiniCall("array", rendered.expr),
+					kind: "array"
+				};
+				continue;
+			}
+			if (fn === "tuple") {
+				const tupleItems = args.map((x) => {
+					const rendered = renderMiniDefinition(x, fieldPath);
+					appendConstsChunk(x.consts.join("\n"));
+					return rendered.expr;
+				}).join(",\n");
+				const next = definition.functions[index + 1];
+				if (next?.[0] === "rest") {
+					const restDefinition = next[1];
+					const rest = renderMiniDefinition(restDefinition, fieldPath).expr;
+					appendConstsChunk(restDefinition.consts.join("\n"));
+					current = {
+						expr: zodMiniCall("tuple", `[${tupleItems}], ${rest}`),
+						kind: "tuple"
+					};
+					index++;
+				} else current = {
+					expr: zodMiniCall("tuple", `[${tupleItems}]`),
+					kind: "tuple"
+				};
+				continue;
+			}
+			const combinedArgs = buildCombinedArgs(fn, args, fieldPath);
+			if (fn === "optional" || fn === "nullable" || fn === "nullish") {
+				const value = requireCurrent(fn);
+				current = {
+					expr: zodMiniCall(fn, value.expr),
+					kind: value.kind
+				};
+				continue;
+			}
+			if (fn === "default") {
+				const value = requireCurrent(fn);
+				current = {
+					expr: zodMiniCall("_default", `${value.expr}, ${combinedArgs}`),
+					kind: value.kind
+				};
+				continue;
+			}
+			if (fn === "describe" || fn === "meta") {
+				const value = requireCurrent(fn);
+				current = {
+					expr: `${value.expr}.check(${zodMiniCall(fn, combinedArgs)})`,
+					kind: value.kind
+				};
+				continue;
+			}
+			if (fn === "min" || fn === "max" || fn === "gt" || fn === "lt" || fn === "multipleOf" || fn === "regex" || fn === "length") {
+				const value = requireCurrent(fn);
+				const checkName = fn === "min" ? value.kind === "number" ? "gte" : "minLength" : fn === "max" ? value.kind === "number" ? "lte" : "maxLength" : fn;
+				current = {
+					expr: `${value.expr}.check(${zodMiniCall(checkName, combinedArgs)})`,
+					kind: value.kind
+				};
+				continue;
+			}
+			if (fn !== "date" && shouldCoerce(fn) || fn === "date" && shouldCoerce(fn) && context.output.override.useDates) {
+				current = {
+					expr: zodMiniCoerceCall(fn, combinedArgs),
+					kind: fn
+				};
+				continue;
+			}
+			current = {
+				expr: zodMiniCall(fn, combinedArgs),
+				kind: fn === "enum" || fn === "literal" || fn === "stringFormat" ? "string" : fn.split(".")[0]
+			};
+		}
+		return current ?? { expr: "" };
+	};
 	const parseProperty = (property, fieldPath = []) => {
 		const [fn, args = ""] = property;
 		if (fn === "namedRef") {
@@ -658,6 +880,16 @@ ${Object.entries(objectArgs).map(([key, schema]) => {
 		return `.${fn}(${combinedArgs})`;
 	};
 	appendConstsChunk(input.consts.join("\n"));
+	if (variant === "mini") {
+		const rendered = renderMiniDefinition(input);
+		const value = preprocess ? zodMiniCall("pipe", `${zodMiniCall("transform", preprocess.name)}, ${rendered.expr}`) : rendered.expr;
+		if (consts.includes(",export")) consts = consts.replaceAll(",export", "\nexport");
+		return {
+			zod: value,
+			consts,
+			usedRefs
+		};
+	}
 	const schema = input.functions.map((prop) => parseProperty(prop)).join("");
 	const value = preprocess ? `.preprocess(${preprocess.name}, ${schema.startsWith(".") ? "zod" : ""}${schema})` : schema;
 	const zod = `${value.startsWith(".") ? "zod" : ""}${value}`;
@@ -740,17 +972,27 @@ function dereferenceProperties(schema, context) {
 	}, {});
 }
 function buildScopedContext(childContext, refName, resolvedSchema) {
-	if (!refName) return childContext;
-	const schemaName = extractSchemaNameFromRef(refName);
-	if (!schemaName) return childContext;
-	const schemaRecord = resolvedSchema;
-	const hasDynamicAnchor = typeof schemaRecord.$dynamicAnchor === "string";
-	const defs = schemaRecord.$defs;
-	const hasDefsAnchors = defs && typeof defs === "object" && Object.values(defs).some((d) => d && typeof d === "object" && "$dynamicAnchor" in d);
-	if (!hasDynamicAnchor && !hasDefsAnchors) return childContext;
+	if (refName) {
+		const schemaName = extractSchemaNameFromRef(refName);
+		if (!schemaName) return childContext;
+		const schemaRecord = resolvedSchema;
+		const hasDynamicAnchor = typeof schemaRecord.$dynamicAnchor === "string";
+		const defs = schemaRecord.$defs;
+		const hasDefsAnchors = defs && typeof defs === "object" && Object.values(defs).some((d) => d && typeof d === "object" && "$dynamicAnchor" in d);
+		if (!hasDynamicAnchor && !hasDefsAnchors) return childContext;
+		return {
+			...childContext,
+			dynamicScope: buildDynamicScope(schemaName, resolvedSchema, childContext)
+		};
+	}
+	const inlineScope = buildInlineDynamicScope(resolvedSchema);
+	if (Object.keys(inlineScope).length === 0) return childContext;
 	return {
 		...childContext,
-		dynamicScope: buildDynamicScope(schemaName, resolvedSchema, childContext)
+		dynamicScope: {
+			...childContext.dynamicScope,
+			...inlineScope
+		}
 	};
 }
 function dereferenceDynamicRef(schema, context) {
@@ -801,6 +1043,15 @@ const generateFormDataZodSchema = (schema, context, name, strict, isZodV4, encod
 		useReusableSchemas
 	});
 };
+/**
+* Parse a request body or response into a zod validation schema definition.
+*
+* Selects the relevant content type — JSON (and `+json` vendor types),
+* `multipart/form-data`, or `application/x-www-form-urlencoded`, plus
+* `text/plain` for responses — and generates the matching schema, handling
+* array roots. The url-encoded string-contract rationale lives where the flag
+* is derived (see `isFormUrlEncoded` below).
+*/
 const parseBodyAndResponse = ({ data, context, name, strict, generate, isZodV4, parseType, useReusableSchemas }) => {
 	if (!data || !generate) return {
 		input: {
@@ -813,7 +1064,9 @@ const parseBodyAndResponse = ({ data, context, name, strict, generate, isZodV4,
 	const contentEntries = Object.entries(resolvedRef.content ?? {});
 	const jsonContent = contentEntries.find(isMediaType(String.raw`^application\/([^/;]+\+)?json$`));
 	const formDataContent = contentEntries.find(isMediaType(String.raw`^multipart\/form-data$`));
-	const [contentType, mediaType] = jsonContent ? ["application/json", jsonContent[1]] : formDataContent ? ["multipart/form-data", formDataContent[1]] : [void 0, void 0];
+	const formUrlEncodedContent = contentEntries.find(isMediaType(String.raw`^application\/x-www-form-urlencoded$`));
+	const [contentType, mediaType] = jsonContent ? ["application/json", jsonContent[1]] : formDataContent ? ["multipart/form-data", formDataContent[1]] : formUrlEncodedContent ? ["application/x-www-form-urlencoded", formUrlEncodedContent[1]] : [void 0, void 0];
+	const isFormUrlEncoded = contentType === "application/x-www-form-urlencoded";
 	const schema = mediaType?.schema;
 	if (!schema) {
 		if (parseType === "response") {
@@ -844,7 +1097,8 @@ const parseBodyAndResponse = ({ data, context, name, strict, generate, isZodV4,
 		return {
 			input: generateZodValidationSchemaDefinition(parseType === "body" ? removeReadOnlyProperties(rawItems) : rawItems, context, name, strict, isZodV4, {
 				required: true,
-				useReusableSchemas
+				useReusableSchemas,
+				urlEncoded: isFormUrlEncoded
 			}),
 			isArray: true,
 			rules: {
@@ -857,7 +1111,8 @@ const parseBodyAndResponse = ({ data, context, name, strict, generate, isZodV4,
 	return {
 		input: contentType === "multipart/form-data" ? generateFormDataZodSchema(effectiveSchema, context, name, strict, isZodV4, encoding, useReusableSchemas) : generateZodValidationSchemaDefinition(effectiveSchema, context, name, strict, isZodV4, {
 			required: true,
-			useReusableSchemas
+			useReusableSchemas,
+			urlEncoded: isFormUrlEncoded
 		}),
 		isArray: false
 	};
@@ -965,7 +1220,12 @@ const parseParameters = ({ data, context, operationName, isZodV4, strict, genera
 	};
 };
 const generateZodRoute = async ({ operationId, operationName, verb, override }, { pathRoute, context, output }) => {
-	const isZodV4 = !!context.output.packageJson && isZodVersionV4(context.output.packageJson);
+	const zodVariant = context.output.override.zod.variant;
+	const isZodV4 = resolveIsZodV4(context.output.override.zod.version, context.output.packageJson);
+	assertZodTarget({
+		variant: zodVariant,
+		isZodV4
+	});
 	const useReusableSchemas = context.output.override.zod.generateReusableSchemas;
 	const spec = context.spec.paths?.[pathRoute];
 	if (spec == void 0) throw new Error(`No such path ${pathRoute} in ${context.projectName}`);
@@ -1021,7 +1281,7 @@ const generateZodRoute = async ({ operationId, operationName, verb, override },
 		location,
 		schemaName: `${pascalOperationName}${schemaSuffix}`
 	} : void 0;
-	let inputParams = parseZodValidationSchemaDefinition(parsedParameters.params, context, override.zod.coerce.param, override.zod.strict.param, isZodV4, preprocessParams, makeParamsInjection("param", "Params"));
+	let inputParams = parseZodValidationSchemaDefinition(parsedParameters.params, context, override.zod.coerce.param, override.zod.strict.param, isZodV4, preprocessParams, makeParamsInjection("param", "Params"), zodVariant);
 	const preprocessQueryParams = override.zod.preprocess?.query ? await generateMutator({
 		output,
 		mutator: override.zod.preprocess.query,
@@ -1029,7 +1289,7 @@ const generateZodRoute = async ({ operationId, operationName, verb, override },
 		workspace: context.workspace,
 		tsconfig: context.output.tsconfig
 	}) : void 0;
-	let inputQueryParams = parseZodValidationSchemaDefinition(parsedParameters.queryParams, context, override.zod.coerce.query, override.zod.strict.query, isZodV4, preprocessQueryParams, makeParamsInjection("query", "QueryParams"));
+	let inputQueryParams = parseZodValidationSchemaDefinition(parsedParameters.queryParams, context, override.zod.coerce.query, override.zod.strict.query, isZodV4, preprocessQueryParams, makeParamsInjection("query", "QueryParams"), zodVariant);
 	const preprocessHeader = override.zod.preprocess?.header ? await generateMutator({
 		output,
 		mutator: override.zod.preprocess.header,
@@ -1037,7 +1297,7 @@ const generateZodRoute = async ({ operationId, operationName, verb, override },
 		workspace: context.workspace,
 		tsconfig: context.output.tsconfig
 	}) : void 0;
-	let inputHeaders = parseZodValidationSchemaDefinition(parsedParameters.headers, context, override.zod.coerce.header, override.zod.strict.header, isZodV4, preprocessHeader, makeParamsInjection("header", "Header"));
+	let inputHeaders = parseZodValidationSchemaDefinition(parsedParameters.headers, context, override.zod.coerce.header, override.zod.strict.header, isZodV4, preprocessHeader, makeParamsInjection("header", "Header"), zodVariant);
 	const preprocessBody = override.zod.preprocess?.body ? await generateMutator({
 		output,
 		mutator: override.zod.preprocess.body,
@@ -1045,7 +1305,7 @@ const generateZodRoute = async ({ operationId, operationName, verb, override },
 		workspace: context.workspace,
 		tsconfig: context.output.tsconfig
 	}) : void 0;
-	let inputBody = parseZodValidationSchemaDefinition(parsedBody.input, context, override.zod.coerce.body, override.zod.strict.body, isZodV4, preprocessBody, makeParamsInjection("body", "Body"));
+	let inputBody = parseZodValidationSchemaDefinition(parsedBody.input, context, override.zod.coerce.body, override.zod.strict.body, isZodV4, preprocessBody, makeParamsInjection("body", "Body"), zodVariant);
 	const preprocessResponse = override.zod.preprocess?.response ? await generateMutator({
 		output,
 		mutator: override.zod.preprocess.response,
@@ -1053,7 +1313,7 @@ const generateZodRoute = async ({ operationId, operationName, verb, override },
 		workspace: context.workspace,
 		tsconfig: context.output.tsconfig
 	}) : void 0;
-	const inputResponses = parsedResponses.map((parsedResponse, index) => parseZodValidationSchemaDefinition(parsedResponse.input, context, override.zod.coerce.response, override.zod.strict.response, isZodV4, preprocessResponse, makeParamsInjection("response", responses[index][0] ? `${responses[index][0]}Response` : "Response")));
+	const inputResponses = parsedResponses.map((parsedResponse, index) => parseZodValidationSchemaDefinition(parsedResponse.input, context, override.zod.coerce.response, override.zod.strict.response, isZodV4, preprocessResponse, makeParamsInjection("response", responses[index][0] ? `${responses[index][0]}Response` : "Response"), zodVariant));
 	const SENTINEL_PATTERN = /__REF_([A-Za-z_$][A-Za-z0-9_$]*)__/g;
 	const rewriteSentinels = (s) => s.replaceAll(SENTINEL_PATTERN, (_m, name) => name);
 	const allUsedRefs = new Set([
@@ -1092,6 +1352,11 @@ const generateZodRoute = async ({ operationId, operationName, verb, override },
 	};
 	const useBrandedTypes = override.zod.useBrandedTypes;
 	const brand = (name) => useBrandedTypes ? isZodV4 ? `.brand("${name}")` : `.brand<"${name}">()` : "";
+	const zodArrayWithBounds = (itemName, rules) => {
+		const checks = [...rules?.min ? [zodMiniCall("minLength", `${rules.min}`)] : [], ...rules?.max ? [zodMiniCall("maxLength", `${rules.max}`)] : []];
+		if (zodVariant === "mini") return `${zodMiniCall("array", itemName)}${checks.map((check) => `.check(${check})`).join("")}`;
+		return `zod.array(${itemName})${rules?.min ? `.min(${rules.min})` : ""}${rules?.max ? `.max(${rules.max})` : ""}`;
+	};
 	const localTaken = new Set(allUsedRefs);
 	const allocateExportName = (baseName, hasItem) => {
 		const collides = (name) => localTaken.has(name) || hasItem && localTaken.has(`${name}Item`);
@@ -1126,7 +1391,7 @@ const generateZodRoute = async ({ operationId, operationName, verb, override },
 			...inputHeaders.zod ? [`export const ${headerName} = ${inputHeaders.zod}${brand(headerName)}`] : [],
 			...inputBody.consts ? [inputBody.consts] : [],
 			...inputBody.zod ? [parsedBody.isArray ? `export const ${bodyName}Item = ${inputBody.zod}
-export const ${bodyName} = zod.array(${bodyName}Item)${parsedBody.rules?.min ? `.min(${parsedBody.rules.min})` : ""}${parsedBody.rules?.max ? `.max(${parsedBody.rules.max})` : ""}${brand(bodyName)}` : `export const ${bodyName} = ${inputBody.zod}${brand(bodyName)}`] : [],
+export const ${bodyName} = ${zodArrayWithBounds(bodyName + "Item", parsedBody.rules)}${brand(bodyName)}` : `export const ${bodyName} = ${inputBody.zod}${brand(bodyName)}`] : [],
 			...inputResponses.flatMap((inputResponse, index) => {
 				const operationResponse = allocateExportName(pascal(`${operationName}-${responses[index][0]}-response`), parsedResponses[index].isArray);
 				if (!inputResponse.zod) {
@@ -1140,10 +1405,10 @@ export const ${bodyName} = zod.array(${bodyName}Item)${parsedBody.rules?.min ? `
 						const specResponseKeys = new Set(Object.keys(spec[verb]?.responses ?? {}));
 						isNoContent = !(specResponseKeys.has("200") || specResponseKeys.has("2XX") || specResponseKeys.has("2xx"));
 					}
-					return [`export const ${operationResponse} = ${isNoContent ? "zod.void()" : "zod.unknown()"}${brand(operationResponse)}`];
+					return [`export const ${operationResponse} = ${isNoContent ? zodVariant === "mini" ? zodMiniCall("void") : "zod.void()" : zodVariant === "mini" ? zodMiniCall("unknown") : "zod.unknown()"}${brand(operationResponse)}`];
 				}
 				return [...inputResponse.consts ? [inputResponse.consts] : [], parsedResponses[index].isArray ? `export const ${operationResponse}Item = ${inputResponse.zod}
-export const ${operationResponse} = zod.array(${operationResponse}Item)${parsedResponses[index].rules?.min ? `.min(${parsedResponses[index].rules.min})` : ""}${parsedResponses[index].rules?.max ? `.max(${parsedResponses[index].rules.max})` : ""}${brand(operationResponse)}` : `export const ${operationResponse} = ${inputResponse.zod}${brand(operationResponse)}`];
+export const ${operationResponse} = ${zodArrayWithBounds(`${operationResponse}Item`, parsedResponses[index].rules)}${brand(operationResponse)}` : `export const ${operationResponse} = ${inputResponse.zod}${brand(operationResponse)}`];
 			})
 		].join("\n\n"),
 		mutators: [
@@ -1175,6 +1440,6 @@ const zodClientBuilder = {
 };
 const builder = () => () => zodClientBuilder;
 //#endregion
-export { builder, builder as default, dereference, generateFormDataZodSchema, generateZod, generateZodValidationSchemaDefinition, getZodDependencies, isZodVersionV4, parseParameters, parseZodValidationSchemaDefinition, predefinedZodFormats };
+export { assertZodTarget, builder, builder as default, dereference, generateFormDataZodSchema, generateZod, generateZodValidationSchemaDefinition, getZodDependencies, getZodImportSource, getZodTypeName, isZodVersionV4, parseParameters, parseZodValidationSchemaDefinition, predefinedZodFormats, resolveIsZodV4 };
 
 //# sourceMappingURL=index.mjs.map