@kubb/plugin-zod 5.9.0-canary.20261111T122006 → 5.9.1

package/dist/index.js

@@ -1,143 +1,407 @@
-import { Diagnostics, Resolver, addGenerator, ast, camelCase, containsCircularRef, createResolver, defineExtension, defineGenerator, pascalCase, setMacros, setResolver, syncSchemaRef } from "@kubb/kit";
+import { Diagnostics, Resolver, addGenerator, ast, casing, createPrinter, createResolver, defineExtension, defineGenerator, setMacros, setResolver, text } from "@kubb/kit";
 import { Const, File, Function, Type, jsxRenderer } from "@kubb/renderer-jsx";
 import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
-// ../../internals/shared/src/operation.ts
+// ../../internals/utils/src/reserved.ts
 /**
-* Builds the `ResolverFileParams` every operation generator passes to
-* `resolver.file`: a file named `name`, tagged by the operation's first
-* tag (or `'default'`), at the operation's path. Centralizes the entry object
-* that was repeated at dozens of call sites across the client and query plugins.
+* JavaScript and Java reserved words.
+* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+*/
+const reservedWords = /* @__PURE__ */ new Set([
+	"abstract",
+	"arguments",
+	"await",
+	"boolean",
+	"break",
+	"byte",
+	"case",
+	"catch",
+	"char",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"double",
+	"else",
+	"enum",
+	"eval",
+	"export",
+	"extends",
+	"false",
+	"final",
+	"finally",
+	"float",
+	"for",
+	"function",
+	"goto",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"int",
+	"interface",
+	"let",
+	"long",
+	"native",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"short",
+	"static",
+	"super",
+	"switch",
+	"synchronized",
+	"this",
+	"throw",
+	"throws",
+	"transient",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"volatile",
+	"while",
+	"with",
+	"yield",
+	"Array",
+	"Date",
+	"hasOwnProperty",
+	"Infinity",
+	"isFinite",
+	"isNaN",
+	"isPrototypeOf",
+	"length",
+	"Math",
+	"name",
+	"NaN",
+	"Number",
+	"Object",
+	"prototype",
+	"String",
+	"toString",
+	"undefined",
+	"valueOf"
+]);
+/**
+* Returns `true` when `name` is a syntactically valid JavaScript variable name.
 *
 * @example
 * ```ts
-* resolver.file(operationFileEntry(node, node.operationId), { root, output, group })
+* isValidVarName('status')  // true
+* isValidVarName('class')   // false (reserved word)
+* isValidVarName('42foo')   // false (starts with digit)
 * ```
 */
-function operationFileEntry(node, name, extname = ".ts") {
-	return {
-		name,
-		extname,
-		tag: node.tags[0] ?? "default",
-		path: node.path
-	};
+function isValidVarName(name) {
+	if (!name || reservedWords.has(name)) return false;
+	return isIdentifier(name);
 }
 /**
-* Resolves the file a schema-emitting plugin (`plugin-ts`, `plugin-zod`, `plugin-faker`) writes
-* `node` to, cached in `ctx.memo` under the resolver's plugin name and the
-* operation. The plugin itself and every plugin that imports from it call this, so they all get
-* the same path.
+* Returns `name` when it's a syntactically valid JavaScript variable name,
+* otherwise prefixes it with `_` so the result is a valid identifier.
 *
-* When that path matches the file of a component schema in `ctx.driver.inputNode`, ignoring case, the file name
-* gets an `Operation` suffix: operation `point` goes to `PointOperation.ts` next to schema `Point.ts`.
-* Otherwise the two merge into one file, or overwrite each other on a case-insensitive file system.
-* Only the file name changes. The declarations keep their names.
+* 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 Resolve `plugin-ts`'s file for the current operation
+* @example
 * ```ts
-* const fileTs = resolveOperationFile({ ctx, node, resolver: tsResolver, root, output })
+* ensureValidVarName('409')             // '_409'
+* ensureValidVarName('504AccountCancel') // '_504AccountCancel'
+* ensureValidVarName('Pet')              // 'Pet'
+* ensureValidVarName('class')            // '_class'
 * ```
 */
-function resolveOperationFile(options) {
-	const { ctx, node, resolver, root, output } = options;
-	const { memo } = ctx;
-	const location = {
-		root,
-		output,
-		group: options.group ?? void 0
-	};
-	return memo(`${resolver.pluginName}:operationFile:${node.operationId}`, () => {
-		const schemaPaths = memo(`${resolver.pluginName}:schemaFilePaths`, () => new Set((ctx.driver.inputNode?.schemas ?? []).flatMap((schema) => schema.name ? [resolver.file({
-			name: schema.name,
-			extname: ".ts",
-			...location
-		}).path.toLowerCase()] : [])));
-		let file = resolver.file({
-			...operationFileEntry(node, node.operationId),
-			...location
-		});
-		for (let name = `${node.operationId}Operation`; schemaPaths.has(file.path.toLowerCase()); name += "Operation") {
-			const next = resolver.file({
-				...operationFileEntry(node, name),
-				...location
-			});
-			if (next.path === file.path) break;
-			file = next;
-		}
-		return file;
-	});
-}
-function baseContentType(contentType) {
-	return contentType.split(";")[0].trim().toLowerCase();
+function ensureValidVarName(name) {
+	if (!name || isValidVarName(name)) return name;
+	return `_${name}`;
 }
 /**
-* Whether a content entry is a sequence of JSON values the adapter marks as a stream, such as `application/jsonl`,
-* `application/x-ndjson`, `application/json-seq`, or any media type with an OpenAPI 3.2 `itemSchema`.
+* 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 isJsonLines(entry) {
-	const baseType = baseContentType(entry.contentType);
-	return Boolean(entry.stream) && baseType !== "text/event-stream" && !baseType.startsWith("multipart/");
-}
-function isJsonContentType(baseType) {
-	return baseType === "application/json" || baseType.endsWith("+json") || baseType === "text/json";
+function isIdentifier(name) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
+// ../../internals/utils/src/codegen.ts
 /**
-* Parser for one response content entry.
+* 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.
 *
-* JSON stays unset so the runtime detects it. `text/event-stream` and JSON Lines are streams. A binary schema
-* (`format: binary` / `contentMediaType`) is a blob even when the media type is not a well-known
-* binary type. Other `text/*` is text, and `application/octet-stream`, `application/pdf`,
-* `image/*`, `audio/*`, and `video/*` are blobs.
+* @example
+* ```ts
+* buildObject(['id: z.number()', 'name: z.string()'])
+* // '{\n  id: z.number(),\n  name: z.string(),\n}'
+* ```
 */
-function responseTypeForContent(entry) {
-	const baseType = baseContentType(entry.contentType);
-	if (!baseType) return void 0;
-	if (baseType === "text/event-stream" || isJsonLines(entry)) return "stream";
-	if (isJsonContentType(baseType)) return void 0;
-	if (entry.schema?.type === "blob") return "blob";
-	if (baseType.startsWith("text/")) return "text";
-	if (isBinaryContentType(baseType)) return "blob";
-}
-function isBinaryContentType(baseType) {
-	return baseType === "application/octet-stream" || baseType === "application/pdf" || /^(image|audio|video)\//.test(baseType);
+function buildObject(entries) {
+	if (entries.length === 0) return "{}";
+	return `{\n${entries.map((entry) => `${text.indent({ text: entry })},`).join("\n")}\n}`;
 }
 /**
-* 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`).
+* 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 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("");
+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) => `${text.indent({ text: item })},`).join("\n")}\n${close}`;
 }
 /**
-* Appends a content-type suffix to a base name, keeping a trailing `Data` segment last
-* (e.g. `AddPetData` + `Json` → `AddPetJsonData`, `AddPetStatus200` + `Xml` → `AddPetStatus200Xml`).
+* 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 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;
+function lazyGetter({ name, body }) {
+	return `get ${objectKey(name)}() { return ${body} }`;
 }
 /**
-* Returns the entry with the schema of the value the client returns: `string` for a body read as text, such as `Pet` on
-* `application/xml`, and `blob` for `image/*`, `audio/*`, `video/*`, PDF, and octet-stream. A binary schema elsewhere is a `Blob`
-* only through `parseAs: 'blob'`, which needs every entry in `entries` binary. JSON, vendor (`application/vnd.*`), stream,
-* schemaless, and wildcard entries keep their schema. `entries` is the response's full list of content types.
+* An object key, quoted only when it is not identifier-shaped. Reserved words such as `class` stay bare.
+*
+* @example
+* ```ts
+* objectKey('x-total') // "'x-total'"
+* ```
 */
-function toResponseContent(entry, entries = [entry]) {
-	const { contentType, schema } = entry;
-	if (!schema || entry.stream) return entry;
-	const baseType = baseContentType(contentType);
-	const resolved = ast.resolveRef(schema);
-	if (isBinaryContentType(baseType)) return resolved.type === "blob" ? entry : {
-		...entry,
-		schema: ast.factory.createSchema({ type: "blob" }),
-		keysToOmit: null
-	};
-	const isPlainMediaType = Boolean(baseType) && !isJsonContentType(baseType) && !baseType.includes("*");
+function objectKey(name) {
+	return isIdentifier(name) ? name : text.quote(name);
+}
+// ../../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 = casing.camel) {
+	const parts = name.split(/\.(?=[a-zA-Z])/);
+	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : casing.camel(part)).filter(Boolean).join("/");
+}
+// ../../internals/utils/src/strings.ts
+const NEEDS_UNICODE = /(?<!\\)(?:\\\\)*\\[pPu]\{|[\u{10000}-\u{10FFFF}]/u;
+const KEPT_ESCAPE = /[A-Za-z0-9^$\\.*+?()[\]{}|/]/;
+/**
+* Drops the backslash from escapes that the `u` flag rejects: an escaped punctuation character that is
+* not a syntax character, and `\-` outside a class. Both match the same character without the backslash.
+*/
+function dropIdentityEscapes(pattern) {
+	let inClass = false;
+	return pattern.replace(/\\(.)|[[\]]/gs, (match, escaped) => {
+		if (escaped === void 0) {
+			inClass = match === "[";
+			return match;
+		}
+		return KEPT_ESCAPE.test(escaped) || escaped === "-" && inClass ? match : escaped;
+	});
+}
+/**
+* Builds the `RegExp` for a pattern, adding the `u` flag when it uses `\p{...}`, `\P{...}` or `\u{...}`, or
+* holds a character outside the BMP. A pattern that is not valid under `u` keeps the flags it came with.
+*/
+function toRegExp(pattern, flags) {
+	if (flags?.includes("u") || !NEEDS_UNICODE.test(pattern)) return new RegExp(pattern, flags);
+	try {
+		return new RegExp(dropIdentityEscapes(pattern), `${flags ?? ""}u`);
+	} catch {
+		return new RegExp(pattern, flags);
+	}
+}
+/**
+* Converts a pattern string into a `new RegExp(...)` constructor call or a regex literal string.
+* Inline flags expressed as a `^(?im)` prefix are extracted and applied to the resulting expression.
+* Pass `null` as the second argument to emit a `/pattern/flags` literal instead.
+*
+* @example
+* ```ts
+* toRegExpString('^(?im)foo')       // 'new RegExp("^foo", "im")'
+* toRegExpString('^(?im)foo', null) // '/^foo/im'
+* ```
+*/
+function toRegExpString(pattern, func = "RegExp") {
+	const raw = text.unquote(pattern);
+	const match = raw.match(/^\^(\(\?([igmsuy]+)\))/i);
+	const replacementTarget = match?.[1] ?? "";
+	const matchedFlags = match?.[2];
+	const { source, flags } = toRegExp(raw.replace(/^\\?\//, "").replace(/\\?\/$/, "").replace(replacementTarget, ""), matchedFlags);
+	if (func === null) return `/${source}/${flags}`;
+	return `new ${func}(${JSON.stringify(source)}${flags ? `, ${JSON.stringify(flags)}` : ""})`;
+}
+// ../../internals/shared/src/operation.ts
+/**
+* Builds the `ResolverFileParams` every operation generator passes to
+* `resolver.file`: a file named `name`, tagged by the operation's first
+* tag (or `'default'`), at the operation's path. Centralizes the entry object
+* that was repeated at dozens of call sites across the client and query plugins.
+*
+* @example
+* ```ts
+* resolver.file(operationFileEntry(node, node.operationId), { root, output, group })
+* ```
+*/
+function operationFileEntry(node, name, extname = ".ts") {
+	return {
+		name,
+		extname,
+		tag: node.tags[0] ?? "default",
+		path: node.path
+	};
+}
+/**
+* Resolves the file a schema-emitting plugin (`plugin-ts`, `plugin-zod`, `plugin-faker`) writes
+* `node` to, cached in `ctx.memo` under the resolver's plugin name and the
+* operation. The plugin itself and every plugin that imports from it call this, so they all get
+* the same path.
+*
+* When that path matches the file of a component schema in `ctx.driver.inputNode`, ignoring case, the file name
+* gets an `Operation` suffix: operation `point` goes to `PointOperation.ts` next to schema `Point.ts`.
+* Otherwise the two merge into one file, or overwrite each other on a case-insensitive file system.
+* Only the file name changes. The declarations keep their names.
+*
+* @example Resolve `plugin-ts`'s file for the current operation
+* ```ts
+* const fileTs = resolveOperationFile({ ctx, node, resolver: tsResolver, root, output })
+* ```
+*/
+function resolveOperationFile(options) {
+	const { ctx, node, resolver, root, output } = options;
+	const { memo } = ctx;
+	const location = {
+		root,
+		output,
+		group: options.group ?? void 0
+	};
+	return memo(`${resolver.pluginName}:operationFile:${node.operationId}`, () => {
+		const schemaPaths = memo(`${resolver.pluginName}:schemaFilePaths`, () => new Set((ctx.driver.inputNode?.schemas ?? []).flatMap((schema) => schema.name ? [resolver.file({
+			name: schema.name,
+			extname: ".ts",
+			...location
+		}).path.toLowerCase()] : [])));
+		let file = resolver.file({
+			...operationFileEntry(node, node.operationId),
+			...location
+		});
+		for (let name = `${node.operationId}Operation`; schemaPaths.has(file.path.toLowerCase()); name += "Operation") {
+			const next = resolver.file({
+				...operationFileEntry(node, name),
+				...location
+			});
+			if (next.path === file.path) break;
+			file = next;
+		}
+		return file;
+	});
+}
+/**
+* How a content entry is framed as a stream: `'events'` for Server-Sent Events, `'lines'` for JSON Lines.
+*/
+function getStreamFraming(entry) {
+	if (ast.mediaType.getBase(entry) === "text/event-stream") return "events";
+	return entry.stream && ast.mediaType.isStream(entry) ? "lines" : void 0;
+}
+/**
+* Parser for one response content entry.
+*
+* JSON stays unset so the runtime detects it. `text/event-stream` and JSON Lines are streams. A binary schema
+* (`format: binary` / `contentMediaType`) is a blob even when the media type is not a well-known
+* binary type. Other `text/*` is text, and `application/octet-stream`, `application/pdf`,
+* `image/*`, `audio/*`, and `video/*` are blobs.
+*/
+function responseTypeForContent(entry) {
+	const baseType = ast.mediaType.getBase(entry);
+	if (!baseType) return void 0;
+	if (getStreamFraming(entry)) return "stream";
+	if (ast.mediaType.isJson(baseType)) return void 0;
+	if (entry.schema?.type === "blob") return "blob";
+	if (baseType.startsWith("text/")) return "text";
+	if (isBinaryContentType(baseType)) return "blob";
+}
+function isBinaryContentType(baseType) {
+	return baseType === "application/octet-stream" || baseType === "application/pdf" || /^(image|audio|video)\//.test(baseType);
+}
+/**
+* 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;
+}
+/**
+* Returns the entry with the schema of the value the client returns: `string` for a body read as text, such as `Pet` on
+* `application/xml`, and `blob` for `image/*`, `audio/*`, `video/*`, PDF, and octet-stream. A binary schema elsewhere is a `Blob`
+* only through `parseAs: 'blob'`, which needs every entry in `entries` binary. JSON, vendor (`application/vnd.*`), stream,
+* schemaless, and wildcard entries keep their schema. `entries` is the response's full list of content types.
+*/
+function toResponseContent(entry, entries = [entry]) {
+	const { contentType, schema } = entry;
+	if (!schema || entry.stream) return entry;
+	const baseType = ast.mediaType.getBase(contentType);
+	const resolved = ast.ref.getSchema(schema);
+	if (isBinaryContentType(baseType)) return resolved.type === "blob" ? entry : {
+		...entry,
+		schema: ast.factory.createSchema({ type: "blob" }),
+		keysToOmit: null
+	};
+	const isPlainMediaType = Boolean(baseType) && !ast.mediaType.isJson(baseType) && !baseType.includes("*");
 	if (resolved.type === "blob") return isPlainMediaType && !entries.every((item) => item.schema?.type === "blob") ? {
 		...entry,
 		schema: ast.factory.createSchema({ type: "string" }),
@@ -180,50 +444,6 @@ function resolveContentTypeVariants(entries, baseName) {
 		};
 	});
 }
-const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
-/**
-* An OpenAPI 3.2 `querystring` parameter is the whole query string, so a form-encoded object becomes one query parameter
-* per property, typed and serialized like any other.
-* Another content type, such as JSON, stays one parameter named after it, and the runtime sends its value as the whole query string.
-*/
-function spreadQuerystring(param) {
-	const schema = param.schema.type === "ref" ? param.schema.schema : param.schema;
-	const formEncoded = !param.contentType || param.contentType.split(";")[0].trim().toLowerCase() === "application/x-www-form-urlencoded";
-	if (schema?.type !== "object" || !formEncoded) return [param];
-	return schema.properties.map((property) => ast.factory.createParameter({
-		name: property.name,
-		in: "query",
-		schema: property.schema,
-		required: param.required && property.required
-	}));
-}
-/**
-* Groups an operation's parameters by location (`path`/`query`/`header`/`cookie`), deduping each
-* group by name. Every plugin generator visiting the same `OperationNode` shares one AST instance
-* (see `KubbDriver`), so the result is cached per node to avoid re-filtering and re-deduping the
-* same parameters once per plugin.
-*/
-function getOperationParameters(node) {
-	const cached = operationParameterGroupsByNode.get(node);
-	if (cached) return cached;
-	const dedupe = (params) => {
-		const seen = /* @__PURE__ */ new Set();
-		return params.filter((param) => {
-			if (seen.has(param.name)) return false;
-			seen.add(param.name);
-			return true;
-		});
-	};
-	const group = (location) => dedupe(node.parameters.filter((param) => param.in === location));
-	const groups = {
-		path: group("path"),
-		query: dedupe([...group("query"), ...group("querystring").flatMap(spreadQuerystring)]),
-		header: group("header"),
-		cookie: group("cookie")
-	};
-	operationParameterGroupsByNode.set(node, groups);
-	return groups;
-}
 /**
 * Whether the operation declares more than one request media type with a schema, so a caller must pick one on `contentType`.
 */
@@ -239,8 +459,8 @@ function hasRequestContentTypeChoice(node) {
 * than a record.
 */
 function buildOptionsSchema(node, resolver, { pairContentTypes = false } = {}) {
-	const { path, query, header, cookie } = getOperationParameters(node);
-	const hasBody = Boolean(node.requestBody?.content?.[0]?.schema);
+	const { path, query, header, cookie } = ast.http.groupParameters(node);
+	const hasBody = Boolean(ast.http.requestBody.getSchema(node));
 	const createNever = () => ast.factory.createSchema({
 		type: "never",
 		primitive: void 0,
@@ -331,9 +551,10 @@ function buildOptionsSchema(node, resolver, { pairContentTypes = false } = {}) {
 * The schema a status occupies in the `<Name>Responses` record. A status that documents several
 * content types becomes a `{ contentType; data }` union so the runtime can surface the negotiated type
 * on `result.parsed`, while the standalone `<Name>StatusNNN` alias stays the plain body union that the
-* query hooks and `result.data` use.
+* query hooks and `result.data` use. With `streamData`, the stream variant of a 2xx status holds that schema, since the
+* client returns its body unread.
 */
-function buildResponseRecordEntry(node, res, resolver) {
+function buildResponseRecordEntry(node, res, resolver, streamData) {
 	const statusName = resolver.response.status(node, res.statusCode);
 	const variants = (res.content ?? []).filter((entry) => entry.schema);
 	if (variants.length <= 1) return ast.factory.createSchema({
@@ -350,12 +571,12 @@ function buildResponseRecordEntry(node, res, resolver) {
 				required: true,
 				schema: ast.factory.createSchema({
 					type: "enum",
-					enumValues: [baseContentType(variant.contentType)]
+					enumValues: [ast.mediaType.getBase(variant)]
 				})
 			}), ast.factory.createProperty({
 				name: "data",
 				required: true,
-				schema: ast.factory.createSchema({
+				schema: streamData && ast.http.status.isSuccess(res) && ast.mediaType.isStream(variant) ? streamData : ast.factory.createSchema({
 					type: "ref",
 					name: variant.name
 				})
@@ -371,29 +592,20 @@ function buildResponseRecordEntry(node, res, resolver) {
 * Always emits the keyed record, even when an operation declares no responses. An operation with no
 * responses renders as an empty object, which keeps every consumer's import (for example the axios
 * SDK's `RequestResult<XResponses>`) resolvable instead of pointing at a missing export.
+*
+* `streamData` is the type of a stream variant's `data`, such as a `ReadableStream<Uint8Array>` reference.
 */
-function buildResponses(node, resolver) {
+function buildResponses(node, resolver, { streamData } = {}) {
 	return ast.factory.createSchema({
 		type: "object",
 		primitive: "object",
 		properties: node.responses.map((res) => ast.factory.createProperty({
 			name: String(res.statusCode),
 			required: true,
-			schema: buildResponseRecordEntry(node, res, resolver)
+			schema: buildResponseRecordEntry(node, res, resolver, streamData)
 		}))
 	});
 }
-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));
-}
 // ../../internals/shared/src/adapter.ts
 /**
 * Narrows the generic `Adapter` from a generator context to the OpenAPI adapter,
@@ -407,344 +619,15 @@ function getSuccessResponses(responses) {
 * const { dateType } = getOasAdapter(ctx.adapter).options
 * ```
 */
-function getOasAdapter(adapter) {
-	if (adapter.name !== "oas") throw new Diagnostics.Error({
-		code: Diagnostics.code.adapterRequired,
-		severity: "error",
-		message: `Expected the OpenAPI adapter (adapterOas), but received "${adapter.name}".`,
-		help: "Set `adapter: adapterOas()` in kubb.config.ts.",
-		location: { kind: "config" }
-	});
-	return adapter;
-}
-// ../../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",
-	"await",
-	"boolean",
-	"break",
-	"byte",
-	"case",
-	"catch",
-	"char",
-	"class",
-	"const",
-	"continue",
-	"debugger",
-	"default",
-	"delete",
-	"do",
-	"double",
-	"else",
-	"enum",
-	"eval",
-	"export",
-	"extends",
-	"false",
-	"final",
-	"finally",
-	"float",
-	"for",
-	"function",
-	"goto",
-	"if",
-	"implements",
-	"import",
-	"in",
-	"instanceof",
-	"int",
-	"interface",
-	"let",
-	"long",
-	"native",
-	"new",
-	"null",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"return",
-	"short",
-	"static",
-	"super",
-	"switch",
-	"synchronized",
-	"this",
-	"throw",
-	"throws",
-	"transient",
-	"true",
-	"try",
-	"typeof",
-	"var",
-	"void",
-	"volatile",
-	"while",
-	"with",
-	"yield",
-	"Array",
-	"Date",
-	"hasOwnProperty",
-	"Infinity",
-	"isFinite",
-	"isNaN",
-	"isPrototypeOf",
-	"length",
-	"Math",
-	"name",
-	"NaN",
-	"Number",
-	"Object",
-	"prototype",
-	"String",
-	"toString",
-	"undefined",
-	"valueOf"
-]);
-/**
-* Returns `true` when `name` is a syntactically valid JavaScript variable name.
-*
-* @example
-* ```ts
-* isValidVarName('status')  // true
-* isValidVarName('class')   // false (reserved word)
-* isValidVarName('42foo')   // false (starts with digit)
-* ```
-*/
-function isValidVarName(name) {
-	if (!name || reservedWords.has(name)) return false;
-	return isIdentifier(name);
-}
-/**
-* Returns `name` when it's a syntactically valid JavaScript variable name,
-* otherwise prefixes it with `_` so the result is a valid identifier.
-*
-* Useful for sanitizing OpenAPI schema names or operation IDs that start with
-* a digit (e.g. `409`, `504AccountCancel`) before using them as exported
-* variable, type, or function names.
-*
-* @example
-* ```ts
-* ensureValidVarName('409')             // '_409'
-* ensureValidVarName('504AccountCancel') // '_504AccountCancel'
-* ensureValidVarName('Pet')              // 'Pet'
-* ensureValidVarName('class')            // '_class'
-* ```
-*/
-function ensureValidVarName(name) {
-	if (!name || isValidVarName(name)) return name;
-	return `_${name}`;
-}
-/**
-* 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);
-}
-// ../../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) {
-		const first = text[0];
-		const last = text[text.length - 1];
-		if (first === "\"" && last === "\"" || first === "'" && last === "'" || first === "`" && last === "`") return text.slice(1, -1);
-	}
-	return text;
-}
-/**
-* Serializes a primitive to a single-quoted string literal, stripping any surrounding quotes first.
-*
-* Escaping runs through `JSON.stringify`, then the result switches to single quotes so the generated
-* code matches the repo style without a formatter.
-*
-* @example
-* ```ts
-* stringify('hello')   // "'hello'"
-* stringify('"hello"') // "'hello'"
-* ```
-*/
-function stringify(value) {
-	if (value === void 0 || value === null) return "''";
-	return `'${JSON.stringify(trimQuotes(value.toString())).slice(1, -1).replace(/\\"/g, "\"").replace(/'/g, "\\'")}'`;
-}
-const NEEDS_UNICODE = /(?<!\\)(?:\\\\)*\\[pPu]\{|[\u{10000}-\u{10FFFF}]/u;
-const KEPT_ESCAPE = /[A-Za-z0-9^$\\.*+?()[\]{}|/]/;
-/**
-* Drops the backslash from escapes that the `u` flag rejects: an escaped punctuation character that is
-* not a syntax character, and `\-` outside a class. Both match the same character without the backslash.
-*/
-function dropIdentityEscapes(pattern) {
-	let inClass = false;
-	return pattern.replace(/\\(.)|[[\]]/gs, (match, escaped) => {
-		if (escaped === void 0) {
-			inClass = match === "[";
-			return match;
-		}
-		return KEPT_ESCAPE.test(escaped) || escaped === "-" && inClass ? match : escaped;
-	});
-}
-/**
-* Builds the `RegExp` for a pattern, adding the `u` flag when it uses `\p{...}`, `\P{...}` or `\u{...}`, or
-* holds a character outside the BMP. A pattern that is not valid under `u` keeps the flags it came with.
-*/
-function toRegExp(pattern, flags) {
-	if (flags?.includes("u") || !NEEDS_UNICODE.test(pattern)) return new RegExp(pattern, flags);
-	try {
-		return new RegExp(dropIdentityEscapes(pattern), `${flags ?? ""}u`);
-	} catch {
-		return new RegExp(pattern, flags);
-	}
-}
-/**
-* Converts a pattern string into a `new RegExp(...)` constructor call or a regex literal string.
-* Inline flags expressed as a `^(?im)` prefix are extracted and applied to the resulting expression.
-* Pass `null` as the second argument to emit a `/pattern/flags` literal instead.
-*
-* @example
-* ```ts
-* toRegExpString('^(?im)foo')       // 'new RegExp("^foo", "im")'
-* toRegExpString('^(?im)foo', null) // '/^foo/im'
-* ```
-*/
-function toRegExpString(text, func = "RegExp") {
-	const raw = trimQuotes(text);
-	const match = raw.match(/^\^(\(\?([igmsuy]+)\))/i);
-	const replacementTarget = match?.[1] ?? "";
-	const matchedFlags = match?.[2];
-	const { source, flags } = toRegExp(raw.replace(/^\\?\//, "").replace(/\\?\/$/, "").replace(replacementTarget, ""), matchedFlags);
-	if (func === null) return `/${source}/${flags}`;
-	return `new ${func}(${JSON.stringify(source)}${flags ? `, ${JSON.stringify(flags)}` : ""})`;
-}
-// ../../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} }`;
-}
-// ../../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("/");
+function getOasAdapter(adapter) {
+	if (adapter.name !== "oas") throw new Diagnostics.Error({
+		code: Diagnostics.code.adapterRequired,
+		severity: "error",
+		message: `Expected the OpenAPI adapter (adapterOas), but received "${adapter.name}".`,
+		help: "Set `adapter: adapterOas()` in kubb.config.ts.",
+		location: { kind: "config" }
+	});
+	return adapter;
 }
 // ../../internals/shared/src/resolver.ts
 /**
@@ -834,6 +717,13 @@ function createOperationResponseResolver() {
 				name
 			});
 		},
+		headers(node, statusCode) {
+			const name = this.name(`${node.operationId} Status ${statusCode} Headers`);
+			return this.resolveName({
+				key: operationKey(node, "response", "headers", statusCode),
+				name
+			});
+		},
 		body(node) {
 			const name = this.name(`${node.operationId} Body`);
 			return this.resolveName({
@@ -875,147 +765,7 @@ function createCasedFile(caseLast) {
 * Names of the schemas in a circular reference chain, computed once per build.
 */
 function getCircularNames(ctx) {
-	return ctx.memo("circularNames:set", () => ast.findCircularSchemas(ctx.driver.inputNode?.schemas ?? []));
-}
-// ../../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
-	};
-}
-// ../../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)
-	}));
-}
-// src/components/Zod.tsx
-function Zod({ name, node, printer, inferTypeName, inferKind = "infer", typeGuards, isName, assertName, mini, cyclic, compile }) {
-	const output = printer.print(node);
-	const printerImports = printer.drainImports();
-	if (!output) return;
-	const needsAnnotation = cyclic && node.type !== "object";
-	const isBare = ast.isBareRef(node, printer.options.keysToOmit);
-	const isCyclic = Boolean(cyclic || printer.options.cyclicSchemas && containsCircularRef(node, { circularSchemas: printer.options.cyclicSchemas }));
-	const value = Boolean(compile) && !isBare && !isCyclic ? typeof compile === "object" && compile.strict ? `z.compile(${output}, { strict: true })` : `z.compile(${output})` : output;
-	const targetType = inferTypeName ?? `z.infer<typeof ${name}>`;
-	const shouldGenerateIs = isName && (typeof typeGuards === "object" ? typeGuards.is ?? true : Boolean(typeGuards));
-	const shouldGenerateAssert = assertName && (typeof typeGuards === "object" ? typeGuards.assert ?? true : Boolean(typeGuards));
-	return /* @__PURE__ */ jsxs(Fragment, { children: [
-		printerImports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
-			name: imp.name,
-			path: imp.path,
-			root: imp.root,
-			isTypeOnly: imp.isTypeOnly,
-			isNameSpace: imp.isNameSpace
-		}, [
-			name,
-			imp.path,
-			imp.name
-		].join("-"))),
-		/* @__PURE__ */ jsx(File.Source, {
-			name,
-			isExportable: true,
-			isIndexable: true,
-			children: /* @__PURE__ */ jsx(Const, {
-				export: true,
-				name,
-				type: needsAnnotation ? "z.ZodType" : void 0,
-				children: value
-			})
-		}),
-		inferTypeName && /* @__PURE__ */ jsx(File.Source, {
-			name: inferTypeName,
-			isExportable: true,
-			isIndexable: true,
-			isTypeOnly: true,
-			children: /* @__PURE__ */ jsx(Type, {
-				export: true,
-				name: inferTypeName,
-				children: `z.${inferKind}<typeof ${name}>`
-			})
-		}),
-		shouldGenerateIs && /* @__PURE__ */ jsx(File.Source, {
-			name: isName,
-			isExportable: true,
-			isIndexable: true,
-			children: /* @__PURE__ */ jsx(Const, {
-				export: true,
-				name: isName,
-				JSDoc: { comments: [`Type guard for {@link ${name}}`] },
-				children: mini ? `(data: unknown): data is ${targetType} => z.validate(${name}, data)` : `(data: unknown): data is ${targetType} => ${name}.validate(data)`
-			})
-		}),
-		shouldGenerateAssert && /* @__PURE__ */ jsx(File.Source, {
-			name: assertName,
-			isExportable: true,
-			isIndexable: true,
-			children: /* @__PURE__ */ jsx(Function, {
-				export: true,
-				name: assertName,
-				params: "data: unknown",
-				returnType: `asserts data is ${targetType}`,
-				JSDoc: { comments: [`Asserter for {@link ${name}}`, "@throws {z.ZodError} If data is invalid"] },
-				children: mini ? `if (!z.validate(${name}, data)) {\n  z.parse(${name}, data)\n}` : `if (!${name}.validate(data)) {\n  ${name}.parse(data)\n}`
-			})
-		})
-	] });
+	return ctx.memo("circularNames:set", () => ast.graph.getCircularNames(ctx.driver.inputNode?.schemas ?? []));
 }
 // src/utils.ts
 /**
@@ -1036,7 +786,7 @@ function shouldCoerce(coercion, type) {
 */
 function isClosedKeySchema(node) {
 	if (!node) return false;
-	const resolved = syncSchemaRef(node);
+	const resolved = ast.ref.mergeSchema(node);
 	if (resolved.type === "enum") return true;
 	if (resolved.type === "union") {
 		const members = resolved.members ?? [];
@@ -1046,12 +796,12 @@ function isClosedKeySchema(node) {
 }
 /**
 * Whether the node is a plain inline object whose shape can be lifted into an `.extend({ … })`
-* argument. Property counts, a catchall, `patternProperties`, or a nullable/optional wrapper cannot, so those stay
+* argument. Input checks, a catchall, `patternProperties`, or a nullable/optional wrapper cannot, so those stay
 * on `.and(…)`.
 */
 function isPlainInlineObject(node) {
 	if (node.type !== "object") return false;
-	if (node.minProperties !== void 0 || node.maxProperties !== void 0) return false;
+	if (hasInputChecks(node)) return false;
 	if (node.nullable || node.optional || node.nullish) return false;
 	const hasAdditionalProperties = node.additionalProperties !== void 0;
 	const hasPatternProperties = Boolean(node.patternProperties);
@@ -1062,21 +812,21 @@ function isPlainInlineObject(node) {
 * `z.discriminatedUnion` option. Covers object nodes, `$ref`s that resolve to (or are still
 * unresolved) objects, single-member unions of an object, and object-composable `allOf`.
 *
-* Property counts render as a pipe. A ref into `cyclicSchemas` renders as `z.lazy(…)`.
+* Input checks, such as property counts and `conditionals`, render as a pipe. A ref into `cyclicSchemas` renders as `z.lazy(…)`.
 */
 function isObjectSchemaNode(node, cyclicSchemas) {
 	if (node.nullable || node.optional || node.nullish) return false;
+	if (hasInputChecks(node)) return false;
 	if (node.type === "object") {
-		if (node.minProperties !== void 0 || node.maxProperties !== void 0) return false;
 		const hasProperties = Boolean(node.properties?.length);
 		const hasTypedAdditionalProperties = Boolean(node.additionalProperties && node.additionalProperties !== true);
 		const hasPatternProperties = Boolean(node.patternProperties);
 		return !(!hasProperties && (hasTypedAdditionalProperties || hasPatternProperties || node.propertyNames));
 	}
 	if (node.type === "ref") {
-		const refName = ast.resolveRefName(node);
+		const refName = ast.ref.getName(node);
 		if (refName && cyclicSchemas?.has(refName)) return false;
-		const resolved = syncSchemaRef(node);
+		const resolved = ast.ref.mergeSchema(node);
 		return resolved.type === "ref" || isObjectSchemaNode(resolved, cyclicSchemas);
 	}
 	if (node.type === "union") {
@@ -1099,23 +849,23 @@ function preserveRequiredProperties(members) {
 	const hasRequiredProperty = ({ node, propertyName, seen = /* @__PURE__ */ new Set() }) => {
 		if (seen.has(node)) return false;
 		seen.add(node);
-		const resolved = syncSchemaRef(node);
-		const composition = ast.narrowSchema(resolved, ast.schemaTypes.intersection) ?? ast.narrowSchema(resolved, ast.schemaTypes.union);
+		const resolved = ast.ref.mergeSchema(node);
+		const composition = ast.schema.narrow(resolved, ast.schema.types.intersection) ?? ast.schema.narrow(resolved, ast.schema.types.union);
 		if (composition) {
-			if (composition.type === ast.schemaTypes.union && composition.members?.length !== 1) return false;
+			if (composition.type === ast.schema.types.union && composition.members?.length !== 1) return false;
 			return composition.members?.some((child) => hasRequiredProperty({
 				node: child,
 				propertyName,
 				seen
 			})) ?? false;
 		}
-		return ast.resolveSchemaProperties({
+		return ast.schema.findProperties({
 			node: resolved,
 			propertyName
 		}).some((property) => property.required !== false && !property.schema.optional && !property.schema.nullish);
 	};
 	return members.map((member, index) => {
-		const object = ast.narrowSchema(member, ast.schemaTypes.object);
+		const object = ast.schema.narrow(member, ast.schema.types.object);
 		if (!object || index === 0) return member;
 		return {
 			...object,
@@ -1144,7 +894,7 @@ function preserveRequiredProperties(members) {
 * representation, strings are quoted.
 */
 function formatDefault(value) {
-	if (typeof value === "string") return stringify(value);
+	if (typeof value === "string") return text.quote(value);
 	if (typeof value === "object" && value !== null) return JSON.stringify(value);
 	return String(value ?? "");
 }
@@ -1159,16 +909,17 @@ function formatDefault(value) {
 */
 function defaultLiteral(node, value) {
 	if (value === null) return null;
-	const resolved = node ? syncSchemaRef(node) : void 0;
-	if (resolved && ast.narrowSchema(resolved, "bigint")) {
+	const resolved = node ? ast.ref.mergeSchema(node) : void 0;
+	if (resolved?.type === "blob") return null;
+	if (resolved && ast.schema.narrow(resolved, "bigint")) {
 		if (typeof value === "bigint") return `BigInt(${value})`;
 		if (typeof value === "number" && Number.isInteger(value)) return `BigInt(${value})`;
 		return null;
 	}
-	if (resolved && ast.narrowSchema(resolved, "array")) return Array.isArray(value) ? JSON.stringify(value) : null;
-	const enumNode = resolved ? ast.narrowSchema(resolved, "enum") : void 0;
+	if (resolved && ast.schema.narrow(resolved, "array")) return Array.isArray(value) ? JSON.stringify(value) : null;
+	const enumNode = resolved ? ast.schema.narrow(resolved, "enum") : void 0;
 	if (enumNode) {
-		const values = enumNode.namedEnumValues?.map((member) => member.value) ?? enumNode.enumValues ?? [];
+		const values = ast.schema.getLiterals(enumNode);
 		if (values.length) {
 			const match = values.find((member) => member === value || String(member) === String(value));
 			return match != null ? formatDefault(match) : null;
@@ -1237,13 +988,13 @@ function patternKeySchemaMini({ patterns, regexType }) {
 * Build `.min()` / `.max()` / `.gt()` / `.lt()` constraint chains for numbers
 * using the standard chainable Zod v4 API.
 */
-function numberConstraints({ min, max, exclusiveMinimum, exclusiveMaximum, multipleOf }) {
+function numberConstraints({ min, max, exclusive, multipleOf }, suffix = "") {
 	return [
-		min !== void 0 ? `.min(${min})` : "",
-		max !== void 0 ? `.max(${max})` : "",
-		exclusiveMinimum !== void 0 ? `.gt(${exclusiveMinimum})` : "",
-		exclusiveMaximum !== void 0 ? `.lt(${exclusiveMaximum})` : "",
-		multipleOf !== void 0 ? `.multipleOf(${multipleOf})` : ""
+		min !== void 0 ? `.min(${min}${suffix})` : "",
+		max !== void 0 ? `.max(${max}${suffix})` : "",
+		exclusive?.min !== void 0 ? `.gt(${exclusive.min}${suffix})` : "",
+		exclusive?.max !== void 0 ? `.lt(${exclusive.max}${suffix})` : "",
+		multipleOf !== void 0 ? `.multipleOf(${multipleOf}${suffix})` : ""
 	].join("");
 }
 /**
@@ -1258,36 +1009,71 @@ function lengthConstraints({ min, max, pattern, regexType }) {
 	].join("");
 }
 /**
+* Numeric bounds for a bigint: the inclusive, whole, safe bounds faker mocks against, and a whole, safe `multipleOf`.
+*/
+function bigintConstraints({ min, max, exclusive, multipleOf }) {
+	return {
+		...ast.schema.getNumberBounds({
+			min,
+			max,
+			exclusive,
+			integer: true
+		}),
+		multipleOf: Number.isSafeInteger(multipleOf) ? multipleOf : void 0
+	};
+}
+/**
 * Build `.check(z.minimum(), z.maximum())` for `zod/mini` numeric constraints.
 */
-function numberChecksMini({ min, max, exclusiveMinimum, exclusiveMaximum, multipleOf }) {
-	const checks = [];
-	if (min !== void 0) checks.push(`z.minimum(${min})`);
-	if (max !== void 0) checks.push(`z.maximum(${max})`);
-	if (exclusiveMinimum !== void 0) checks.push(`z.minimum(${exclusiveMinimum}, { exclusive: true })`);
-	if (exclusiveMaximum !== void 0) checks.push(`z.maximum(${exclusiveMaximum}, { exclusive: true })`);
-	if (multipleOf !== void 0) checks.push(`z.multipleOf(${multipleOf})`);
+function numberChecksMini({ min, max, exclusive, multipleOf }, suffix = "") {
+	const checks = [
+		min !== void 0 && `z.minimum(${min}${suffix})`,
+		max !== void 0 && `z.maximum(${max}${suffix})`,
+		exclusive?.min !== void 0 && `z.gt(${exclusive.min}${suffix})`,
+		exclusive?.max !== void 0 && `z.lt(${exclusive.max}${suffix})`,
+		multipleOf !== void 0 && `z.multipleOf(${multipleOf}${suffix})`
+	].filter(Boolean);
 	return checks.length ? `.check(${checks.join(", ")})` : "";
 }
 /**
 * Build `.check(z.minLength(), z.maxLength(), z.regex())` for `zod/mini` length constraints.
 */
 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(${regexSource(pattern, regexType)})`);
+	const checks = [
+		min !== void 0 && `z.minLength(${min})`,
+		max !== void 0 && `z.maxLength(${max})`,
+		pattern !== void 0 && `z.regex(${regexSource(pattern, regexType)})`
+	].filter(Boolean);
 	return checks.length ? `.check(${checks.join(", ")})` : "";
 }
 /**
-* Checks property counts before object parsing strips unknown keys or inserts defaults.
+* Whether `propertyNames` needs its own check: `z.record` checks the keys of a map, but `z.object` and a record keyed by
+* `patternProperties` do not.
+*/
+function hasKeyCheck(node) {
+	if (node.type !== "object" || !node.propertyNames) return false;
+	const hasTypedAdditionalProperties = Boolean(node.additionalProperties && node.additionalProperties !== true);
+	return node.properties.length > 0 || Boolean(node.patternProperties) && !hasTypedAdditionalProperties;
+}
+/**
+* Whether the node prints inside `z.pipe(z.unknown().check(…), …)`, see {@link inputChecks}.
+*/
+function hasInputChecks(node) {
+	return Boolean(node.conditionals?.length) || node.type === "object" && (node.min !== void 0 || node.max !== void 0) || hasKeyCheck(node);
+}
+/**
+* Checks the raw input, before parsing strips unknown keys or inserts defaults: property counts, key names, then the
+* printed `conditionals`.
 */
-function objectConstraints({ value, node }) {
-	if (node.type !== "object") return value;
-	const checks = [];
+function inputChecks({ value, node, keySchema, conditionals }) {
 	const skip = "typeof value !== \"object\" || value === null || Array.isArray(value)";
-	if (node.minProperties !== void 0) checks.push(`z.refine(value => ${skip} || Object.keys(value).length >= ${node.minProperties}, { message: "Object must have at least ${node.minProperties} properties" })`);
-	if (node.maxProperties !== void 0) checks.push(`z.refine(value => ${skip} || Object.keys(value).length <= ${node.maxProperties}, { message: "Object must have at most ${node.maxProperties} properties" })`);
+	const { min, max } = node.type === "object" ? node : {};
+	const checks = [
+		min !== void 0 && `z.refine(value => ${skip} || Object.keys(value).length >= ${min}, { message: "Object must have at least ${min} properties" })`,
+		max !== void 0 && `z.refine(value => ${skip} || Object.keys(value).length <= ${max}, { message: "Object must have at most ${max} properties" })`,
+		keySchema && `z.refine(value => ${skip} || Object.keys(value).every((key) => ${keySchema}.safeParse(key).success), { message: "Object keys must match the property names schema" })`,
+		...conditionals
+	].filter(Boolean);
 	return checks.length ? `z.pipe(z.unknown().check(${checks.join(", ")}), ${value})` : value;
 }
 /**
@@ -1303,8 +1089,8 @@ 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;
-	return examples?.length ? `${withDescription}.meta({ examples: [${examples.map(formatDefault).join(", ")}] })` : withDescription;
+	const withDescription = description ? `${withDefault}.describe(${text.quote(description)})` : withDefault;
+	return examples?.length ? `${withDescription}.meta({ examples: [${examples.map((example) => example === null ? "null" : formatDefault(example)).join(", ")}] })` : withDescription;
 }
 function modifierDepth(schema) {
 	if (schema.nullish || schema.nullable && schema.optional) return 2;
@@ -1322,7 +1108,7 @@ function modifierDepth(schema) {
 * `.unwrap()`, so its printer passes `._zod.def.innerType` as the `step`.
 */
 function omitUnwrapChain(node, step = ".unwrap()") {
-	const ref = ast.narrowSchema(node, "ref");
+	const ref = ast.schema.narrow(node, "ref");
 	if (!ref) return "";
 	const target = ref.schema ?? ref;
 	const depth = modifierDepth(target) + (target.default !== void 0 ? 1 : 0);
@@ -1344,7 +1130,7 @@ function applyMiniModifiers({ value, schema, nullable, optional, nullish, defaul
 /**
 * Calls for string `format`s with a dedicated Zod constructor; a `Map` so `constructor` cannot hit `Object.prototype`.
 */
-const STRING_FORMAT_CALLS = /* @__PURE__ */ new Map([
+const stringFormatCalls = /* @__PURE__ */ new Map([
 	["byte", "z.base64()"],
 	["base64", "z.base64()"],
 	["base64url", "z.base64url()"],
@@ -1355,6 +1141,16 @@ const STRING_FORMAT_CALLS = /* @__PURE__ */ new Map([
 	["hostname", "z.hostname()"]
 ]);
 /**
+* Calls for a string's `contentEncoding` with a dedicated Zod constructor.
+*/
+const contentEncodingCalls = /* @__PURE__ */ new Map([["base64", "z.base64()"], ["base64url", "z.base64url()"]]);
+/**
+* The check for a string that holds a JSON document: it must parse, and the parsed value must pass `schema`.
+*/
+function jsonContentCheck(schema) {
+	return `(value) => { try { return ${schema}.safeParse(JSON.parse(value)).success } catch { return false } }, { message: "String must hold JSON that matches its content schema" }`;
+}
+/**
 * Marks an inline `oneOf` object strict, so `object()` builds `z.strictObject(...)` and no eager `.shape` read hits a deferred getter.
 */
 function strictOneOfNode(node) {
@@ -1367,13 +1163,14 @@ function strictOneOfNode(node) {
 * The constraint chain an `allOf` member adds to a bare string, number or array; each printer passes its own renderers.
 */
 function getMemberConstraint({ member, regexType, lengths, numbers }) {
+	if (hasInputChecks(member) || ast.schema.narrow(member, "array")?.contains) return void 0;
 	if (member.primitive === "string") return lengths({
-		...ast.narrowSchema(member, "string") ?? {},
+		...ast.schema.narrow(member, "string") ?? {},
 		regexType
 	}) || void 0;
-	if (member.primitive === "number" || member.primitive === "integer") return numbers(ast.narrowSchema(member, "number") ?? ast.narrowSchema(member, "integer") ?? {}) || void 0;
+	if (member.primitive === "number" || member.primitive === "integer") return numbers(ast.schema.narrow(member, "number") ?? ast.schema.narrow(member, "integer") ?? {}) || void 0;
 	if (member.primitive === "array") return lengths({
-		...ast.narrowSchema(member, "array") ?? {},
+		...ast.schema.narrow(member, "array") ?? {},
 		regexType
 	}) || void 0;
 }
@@ -1381,24 +1178,26 @@ function getMemberConstraint({ member, regexType, lengths, numbers }) {
 * Builds the `{ key: value, … }` shape shared by the `z.object(...)` and `.extend(...)` renderings.
 */
 function buildObjectShape(ctx, node, renderProperty) {
-	const objectNode = ast.narrowSchema(node, "object");
+	const objectNode = ast.schema.narrow(node, "object");
 	if (!objectNode) return "{}";
-	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && containsCircularRef(schema, { circularSchemas: ctx.options.cyclicSchemas });
-	return buildObject(mapSchemaProperties(objectNode, (schema) => {
+	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && ast.graph.containsCircular(schema, { circularSchemas: ctx.options.cyclicSchemas });
+	const transformed = objectNode.properties.map(({ 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, property, output: value }) => {
-		const { schema } = property;
+	});
+	return buildObject(objectNode.properties.map((property, index) => {
+		const { name, schema } = property;
+		const value = transformed[index];
 		return renderProperty({
 			name,
 			value,
 			schema,
 			required: property.required,
-			meta: syncSchemaRef(schema),
+			meta: ast.ref.mergeSchema(schema),
 			cyclic: isCyclic(schema)
 		});
 	}));
@@ -1410,14 +1209,14 @@ function printWithOmit(ctx, node, modify, mini = false) {
 	const { keysToOmit } = ctx.options;
 	const transformed = ctx.transform(node);
 	if (!transformed) return null;
-	const meta = syncSchemaRef(node);
+	const meta = ast.ref.mergeSchema(node);
 	return modify((() => {
 		if (!keysToOmit?.length || meta.primitive !== "object" || meta.type === "union" && meta.discriminatorPropertyName) return transformed;
 		const unwrap = omitUnwrapChain(node, mini ? "._zod.def.innerType" : ".unwrap()");
 		const mask = `{ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} }`;
 		const omit = (target) => {
 			const inner = `${target}${unwrap}`;
-			const hasObjectConstraints = meta.type === "object" && (meta.minProperties !== void 0 || meta.maxProperties !== void 0);
+			const hasObjectConstraints = hasInputChecks(meta);
 			const pipe = mini ? `${inner}._zod.def` : inner;
 			const object = hasObjectConstraints ? `${pipe}.out` : inner;
 			const omitted = mini ? `z.omit(${object}, ${mask})` : `${object}.omit(${mask})`;
@@ -1436,7 +1235,7 @@ function printWithOmit(ctx, node, modify, mini = false) {
 function getLiteralUnion({ node, options }) {
 	if (node.strategy === "one" && options.oneOfType === "xor" || options.nodes?.enum) return void 0;
 	const values = (node.members ?? []).map((member) => {
-		const enumNode = ast.narrowSchema(member, ast.schemaTypes.enum);
+		const enumNode = ast.schema.narrow(member, ast.schema.types.enum);
 		return enumNode && !enumNode.name && !enumNode.nullable && !enumNode.namedEnumValues && enumNode.enumValues?.length === 1 ? enumNode.enumValues[0] : void 0;
 	});
 	if (!values.length || !values.every((value) => value !== void 0 && value !== null)) return void 0;
@@ -1449,11 +1248,11 @@ function getLiteralUnion({ node, options }) {
 * Whether a discriminated union member's discriminator property prints as a coerced literal union.
 */
 function hasCoercedDiscriminator({ member, propertyName, options }) {
-	return ast.resolveSchemaProperties({
+	return ast.schema.findProperties({
 		node: member,
 		propertyName
 	}).some(({ schema }) => {
-		const resolved = syncSchemaRef(schema);
+		const resolved = ast.ref.mergeSchema(schema);
 		return resolved.type === "union" && !!getLiteralUnion({
 			node: resolved,
 			options
@@ -1461,7 +1260,48 @@ function hasCoercedDiscriminator({ member, propertyName, options }) {
 	});
 }
 /**
-* Builds the scalar handlers both dialects share. They never recurse into children. The temporal
+* Whether `z.compile(schema, { strict: true })` throws for the node. Zod runs an unsupported schema below an object
+* property or an array, tuple or record item on its runtime parser, so only a coerced scalar or a `z.xor` that compiles
+* inline with the root throws: the node itself, or one reached through refs and union or intersection members.
+* `siblings` resolves a generated ref, which names another schema of the same file and carries no target.
+*
+* Mirrors the built-in handlers, so a type with a `printer.nodes` override is judged as if it printed the built-in output.
+*/
+function throwsOnStrictCompile({ node, options, siblings, seen = /* @__PURE__ */ new Set() }) {
+	if (!node || seen.has(node)) return false;
+	seen.add(node);
+	const throws = (child) => throwsOnStrictCompile({
+		node: child,
+		options,
+		siblings,
+		seen
+	});
+	switch (node.type) {
+		case ast.schema.types.ref: return throws(node.schema ?? (node.ref || !node.name ? void 0 : siblings?.get(node.name)));
+		case ast.schema.types.union:
+			if (node.strategy === "one" && options.oneOfType === "xor") return true;
+			return !!getLiteralUnion({
+				node,
+				options
+			})?.coerce || (node.members ?? []).some(throws);
+		case ast.schema.types.intersection: return (node.members ?? []).some(throws);
+		case ast.schema.types.bigint: return true;
+		case ast.schema.types.string: return shouldCoerce(options.coercion, "strings");
+		case ast.schema.types.number:
+		case ast.schema.types.integer: return shouldCoerce(options.coercion, "numbers");
+		case ast.schema.types.date: return node.representation === "date" && options.direction !== "encode" && shouldCoerce(options.coercion, "dates");
+		default: return false;
+	}
+}
+function hasPlainDiscriminator({ member, propertyName }) {
+	const schemas = ast.schema.findProperties({
+		node: member,
+		propertyName
+	});
+	return schemas.length > 0 && !schemas.some(({ schema }) => ast.schema.getLiterals(ast.ref.mergeSchema(schema)).length > 0);
+}
+/**
+* Builds the scalar handlers both dialects share. Only a string with a `contentSchema` recurses into a child. The temporal
 * scalars and `bigint` differ per dialect, so each printer adds its own.
 */
 function buildScalarNodes(dialect) {
@@ -1474,18 +1314,20 @@ function buildScalarNodes(dialect) {
 		null: () => "z.null()",
 		string(node) {
 			const coerce = shouldCoerce(this.options.coercion, "strings");
-			const call = coerce ? void 0 : STRING_FORMAT_CALLS.get(node.format);
-			if (call) return `${call}${dialect.lengths({
-				...node,
-				regexType: this.options.regexType
-			})}`;
-			const base = coerce ? "z.coerce.string()" : "z.string()";
+			const base = (coerce ? void 0 : stringFormatCalls.get(node.format) ?? contentEncodingCalls.get(node.content?.encoding?.toLowerCase())) ?? (coerce ? "z.coerce.string()" : "z.string()");
 			const pattern = node.pattern ?? integerFormatPattern(node.format);
-			return `${base}${dialect.lengths({
+			const value = `${base}${dialect.lengths({
 				...node,
 				pattern,
 				regexType: this.options.regexType
 			})}`;
+			const contentNode = ast.schema.getEmbeddedJson(node);
+			if (!contentNode) return value;
+			const direction = this.options.direction;
+			this.options.direction = "decode";
+			const contentSchema = this.transform(contentNode);
+			this.options.direction = direction;
+			return contentSchema ? dialect.refine(value, jsonContentCheck(contentSchema)) : value;
 		},
 		number(node) {
 			return `${shouldCoerce(this.options.coercion, "numbers") ? "z.coerce.number()" : "z.number()"}${dialect.numbers(node)}`;
@@ -1518,7 +1360,7 @@ function buildScalarNodes(dialect) {
 		ipv6: () => "z.ipv6()",
 		blob: () => "z.instanceof(Blob)",
 		enum(node) {
-			const nonNullValues = (node.namedEnumValues?.map((v) => v.value) ?? node.enumValues ?? []).filter((v) => v !== null);
+			const nonNullValues = ast.schema.getLiterals(node).filter((v) => v !== null);
 			if (node.namedEnumValues?.length) {
 				const literals = nonNullValues.map((v) => buildLiteral(v));
 				if (literals.length === 1) return literals[0];
@@ -1537,11 +1379,12 @@ function buildScalarNodes(dialect) {
 */
 function buildZodNodes(dialect, cyclicSchemas) {
 	const unionsWithSiblings = /* @__PURE__ */ new WeakSet();
+	const printNullable = (schema, output) => output && schema.nullable ? dialect.nullable(output) : output;
 	return {
 		...buildScalarNodes(dialect),
 		ref(node) {
 			if (!node.name) return null;
-			const refName = ast.resolveRefName(node);
+			const refName = ast.ref.getName(node);
 			if (!refName) return null;
 			const useInputVariant = node.ref != null && (dialect.useInputVariant?.(node, this.options) ?? false);
 			const resolvedName = node.ref ? useInputVariant ? this.options.resolver?.schema.inputName(refName) ?? refName : this.options.resolver?.name(refName) ?? refName : node.name;
@@ -1556,47 +1399,50 @@ function buildZodNodes(dialect, cyclicSchemas) {
 			const isStrict = node.additionalProperties === false && patterns.length === 0;
 			const isLoose = node.additionalProperties === true;
 			const objectBase = `${isStrict ? "z.strictObject" : isLoose ? "z.looseObject" : "z.object"}(${dialect.objectShape(this, node)})`;
-			return objectConstraints({
-				value: (() => {
-					const recordFn = isClosedKeySchema(propertyNamesNode) ? "z.partialRecord" : "z.record";
-					if (node.additionalProperties && node.additionalProperties !== true) {
-						const catchallType = this.transform(node.additionalProperties);
-						if (entries.length === 0) return catchallType ? `${recordFn}(${propertyNamesKeySchema || "z.string()"}, ${catchallType})` : objectBase;
-						return catchallType ? dialect.catchall(objectBase, catchallType) : objectBase;
-					}
-					if (entries.length === 0 && patterns.length === 0 && propertyNamesKeySchema && !isStrict) {
-						const unknownType = this.transform(ast.factory.createSchema({ type: ast.schemaTypes.unknown }));
-						return `${recordFn}(${propertyNamesKeySchema}, ${unknownType})`;
-					}
-					if (node.additionalProperties === true) return objectBase;
-					if (isStrict) return objectBase;
-					if (patterns.length > 0) {
-						const values = patterns.map(([, valueSchema]) => {
-							const valueType = this.transform(valueSchema) ?? this.transform(ast.factory.createSchema({ type: ast.schemaTypes.unknown }));
-							return valueSchema.nullable ? dialect.nullable(valueType) : valueType;
-						});
-						const distinct = [...new Set(values)];
-						const value = distinct.length === 1 ? distinct[0] : `z.union([${distinct.join(", ")}])`;
-						if (entries.length > 0) return dialect.catchall(objectBase, value);
-						return `z.record(${dialect.patternKey({
-							patterns: patterns.map(([pattern]) => pattern),
-							regexType: this.options.regexType
-						})}, ${value})`;
-					}
-					return objectBase;
-				})(),
-				node
-			});
+			return (() => {
+				const recordFn = isClosedKeySchema(propertyNamesNode) ? "z.partialRecord" : "z.record";
+				if (node.additionalProperties && node.additionalProperties !== true) {
+					const catchallType = this.transform(node.additionalProperties);
+					if (entries.length === 0) return catchallType ? `${recordFn}(${propertyNamesKeySchema || "z.string()"}, ${catchallType})` : objectBase;
+					return catchallType ? dialect.catchall(objectBase, catchallType) : objectBase;
+				}
+				if (entries.length === 0 && patterns.length === 0 && propertyNamesKeySchema && !isStrict) {
+					const unknownType = this.transform(ast.factory.createSchema({ type: ast.schema.types.unknown }));
+					return `${recordFn}(${propertyNamesKeySchema}, ${unknownType})`;
+				}
+				if (node.additionalProperties === true) return objectBase;
+				if (isStrict) return objectBase;
+				if (patterns.length > 0) {
+					const values = patterns.map(([, valueSchema]) => {
+						const valueType = this.transform(valueSchema) ?? this.transform(ast.factory.createSchema({ type: ast.schema.types.unknown }));
+						return valueSchema.nullable ? dialect.nullable(valueType) : valueType;
+					});
+					const distinct = [...new Set(values)];
+					const value = distinct.length === 1 ? distinct[0] : `z.union([${distinct.join(", ")}])`;
+					if (entries.length > 0) return dialect.catchall(objectBase, value);
+					return `z.record(${dialect.patternKey({
+						patterns: patterns.map(([pattern]) => pattern),
+						regexType: this.options.regexType
+					})}, ${value})`;
+				}
+				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: ast.schemaTypes.unknown }))})${dialect.lengths({
+			const base = `z.array(${(node.items ?? []).map((item) => printNullable(item, this.transform(item))).filter(Boolean).join(", ") || this.transform(ast.factory.createSchema({ type: ast.schema.types.unknown }))})${dialect.lengths({
 				...node,
 				regexType: this.options.regexType
 			})}`;
-			return node.unique ? dialect.unique(base) : base;
+			const unique = node.unique ? dialect.unique(base) : base;
+			const contains = node.contains && containsCheck(this, node.contains);
+			return contains ? dialect.refine(unique, contains) : unique;
 		},
 		tuple(node) {
-			return `z.tuple(${buildList(mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean))})`;
+			const items = (node.items ?? []).map((item) => printNullable(item, this.transform(item))).filter(Boolean);
+			const rest = node.rest ? this.transform(node.rest) : void 0;
+			const tuple = `z.tuple(${buildList(items)}${rest ? `, ${rest}` : ""})`;
+			const contains = node.contains && containsCheck(this, node.contains);
+			return contains ? dialect.refine(tuple, contains) : tuple;
 		},
 		union(node) {
 			const literalUnion = getLiteralUnion({
@@ -1609,24 +1455,30 @@ function buildZodNodes(dialect, cyclicSchemas) {
 			}
 			const nodeMembers = node.members ?? [];
 			const { discriminatorPropertyName } = node;
-			const isDiscriminated = !!discriminatorPropertyName && nodeMembers.every((m) => isObjectSchemaNode(m, cyclicSchemas)) && !nodeMembers.some((m) => hasCoercedDiscriminator({
+			const isDiscriminated = !!discriminatorPropertyName && nodeMembers.every((m) => isObjectSchemaNode(m, cyclicSchemas) && !hasPlainDiscriminator({
+				member: m,
+				propertyName: discriminatorPropertyName
+			})) && !nodeMembers.some((m) => hasCoercedDiscriminator({
 				member: m,
 				propertyName: discriminatorPropertyName,
 				options: this.options
 			}));
 			const isXor = node.strategy === "one" && !isDiscriminated && this.options.oneOfType === "xor";
-			const isStrict = node.strategy === "one" && !isXor && !unionsWithSiblings.has(node);
-			const members = mapSchemaMembers(node, (memberNode) => this.transform(isStrict ? strictOneOfNode(memberNode) : memberNode)).map(({ schema, output }) => output && isStrict && dialect.strictMember ? dialect.strictMember(output, schema, cyclicSchemas) : output).filter(Boolean);
+			const isStrict = node.strategy === "one" && !isXor && !isDiscriminated && !unionsWithSiblings.has(node);
+			const members = (node.members ?? []).map((memberNode) => {
+				const output = this.transform(isStrict ? strictOneOfNode(memberNode) : memberNode);
+				return output && isStrict && dialect.strictMember ? dialect.strictMember(output, memberNode, cyclicSchemas) : output;
+			}).map((output, index) => printNullable(nodeMembers[index], output)).filter(Boolean);
 			if (members.length === 0) return "";
 			if (members.length === 1) return members[0];
-			if (isDiscriminated) return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, ${buildList(members)})`;
+			if (isDiscriminated) return `z.discriminatedUnion(${text.quote(node.discriminatorPropertyName)}, ${buildList(members)})`;
 			if (isXor) return `z.xor(${buildList(members)})`;
 			return `z.union(${buildList(members)})`;
 		},
 		intersection(node) {
 			const members = node.members ?? [];
 			if (members.length === 0) return "";
-			const hasSiblingProperties = members.some((member) => member.type === ast.schemaTypes.object && member.properties.length > 0);
+			const hasSiblingProperties = members.some((member) => member.type === ast.schema.types.object && member.properties.length > 0);
 			const transform = (member) => {
 				if (!hasSiblingProperties) return this.transform(member);
 				unionsWithSiblings.add(member);
@@ -1640,7 +1492,18 @@ function buildZodNodes(dialect, cyclicSchemas) {
 			if (!first) return "";
 			const firstBase = transform(first);
 			if (!firstBase) return "";
-			if (rest.length > 0 && isObjectComposableIntersection(node, cyclicSchemas)) return preserveRequiredProperties(members).slice(1).reduce((acc, member) => dialect.extend(acc, dialect.objectShape(this, member)), firstBase);
+			if (rest.length > 0 && isObjectComposableIntersection(node, cyclicSchemas)) {
+				const discriminator = ast.schema.narrow(first, ast.schema.types.union)?.discriminatorPropertyName;
+				return preserveRequiredProperties(members).slice(1).reduce((acc, member) => {
+					const object = ast.schema.narrow(member, ast.schema.types.object);
+					if (!discriminator || !object?.properties.some((property) => property.name === discriminator)) return dialect.extend(acc, dialect.objectShape(this, member));
+					const properties = object.properties.filter((property) => property.name !== discriminator);
+					return properties.length ? dialect.extend(acc, dialect.objectShape(this, {
+						...object,
+						properties
+					})) : acc;
+				}, firstBase);
+			}
 			return rest.reduce((acc, member) => {
 				const constraint = getMemberConstraint({
 					member,
@@ -1655,15 +1518,162 @@ function buildZodNodes(dialect, cyclicSchemas) {
 		}
 	};
 }
+function containsCheck(ctx, { schema, min = 1, max }) {
+	if (min === 0 && max === void 0) return null;
+	const countBounds = [`count >= ${min}`, max !== void 0 && `count <= ${max}`].filter(Boolean).join(" && ");
+	const message = max !== void 0 ? `Array must contain ${min} to ${max} matching items` : `Array must contain at least ${min} matching items`;
+	return `(items) => { const count = items.filter((item) => ${ctx.transform(schema) ?? "z.unknown()"}.safeParse(item).success).length; return ${countBounds} }, { message: ${text.quote(message)} }`;
+}
+function conditionExpression(ctx, schema) {
+	if (!schema) return "true";
+	const object = ast.schema.narrow(schema, ast.schema.types.object);
+	const keyOnlyNames = object?.properties.filter((property) => property.required && property.schema.type === ast.schema.types.unknown).map((property) => property.name) ?? [];
+	const restSchema = object ? {
+		...object,
+		properties: object.properties.filter((property) => !keyOnlyNames.includes(property.name))
+	} : schema;
+	const isOnlyKeys = keyOnlyNames.length > 0 && restSchema.type === "object" && restSchema.properties.length === 0 && restSchema.additionalProperties === void 0 && !restSchema.patternProperties && !restSchema.propertyNames && !hasInputChecks(restSchema);
+	return [keyOnlyNames.length > 0 && `typeof value === "object" && value !== null && ${JSON.stringify(keyOnlyNames)}.every((key) => key in value)`, !isOnlyKeys && `${ctx.transform(restSchema) ?? "z.unknown()"}.safeParse(value).success`].filter(Boolean).join(" && ");
+}
+/**
+* Wraps each handler so its output first checks the raw input, see {@link inputChecks}.
+*/
+function withInputChecks(nodes) {
+	const wrapHandler = (type) => {
+		const handler = nodes[type];
+		if (!handler) return [];
+		const checkedHandler = function(node) {
+			const output = handler.call(this, node);
+			if (!output || !hasInputChecks(node)) return output;
+			return inputChecks({
+				value: output,
+				node,
+				keySchema: hasKeyCheck(node) ? this.transform(node.propertyNames) : void 0,
+				conditionals: (node.conditionals ?? []).map((entry) => `z.refine((value) => (${conditionExpression(this, entry.if)} ? ${conditionExpression(this, entry.then)} : ${conditionExpression(this, entry.else)}), { message: "Value does not meet a conditional schema" })`)
+			});
+		};
+		return [[type, checkedHandler]];
+	};
+	return Object.fromEntries(Object.values(ast.schema.types).flatMap(wrapHandler));
+}
+// src/components/Zod.tsx
+/**
+* Whether the schema reaches a circular schema through its refs. `containsCircular` reads the refs the node holds,
+* while Zod refuses to compile a cycle anywhere below the root. A generated ref carries no target, so `siblings` resolves it.
+*/
+function reachesCycle({ node, siblings, cyclicSchemas, seen = /* @__PURE__ */ new Set() }) {
+	if (!cyclicSchemas?.size || seen.has(node)) return false;
+	seen.add(node);
+	return ast.schema.find(node, {
+		followRefs: true,
+		predicate(schema) {
+			if (schema.type !== ast.schema.types.ref) return false;
+			const name = ast.ref.getName(schema);
+			if (name && cyclicSchemas.has(name)) return true;
+			const sibling = schema.ref || !schema.name ? void 0 : siblings?.get(schema.name);
+			return !!sibling && reachesCycle({
+				node: sibling,
+				siblings,
+				cyclicSchemas,
+				seen
+			});
+		}
+	}) !== void 0;
+}
+function Zod({ name, node, printer, inferTypeName, inferKind = "infer", typeGuards, isName, assertName, mini, cyclic, compile, siblings }) {
+	const output = printer.print(node);
+	const printerImports = printer.drainImports();
+	if (!output) return;
+	const needsAnnotation = cyclic && node.type !== "object";
+	const isAlias = ast.ref.isAlias(node, printer.options.keysToOmit);
+	const isCyclic = Boolean(cyclic || printer.options.cyclicSchemas && ast.graph.containsCircular(node, { circularSchemas: printer.options.cyclicSchemas }));
+	const isStrict = typeof compile === "object" && Boolean(compile.strict);
+	const throwsOnCompile = isStrict && (throwsOnStrictCompile({
+		node,
+		options: printer.options,
+		siblings
+	}) || reachesCycle({
+		node,
+		siblings,
+		cyclicSchemas: printer.options.cyclicSchemas
+	}));
+	const value = Boolean(compile) && !isAlias && !isCyclic && !throwsOnCompile ? isStrict ? `z.compile(${output}, { strict: true })` : `z.compile(${output})` : output;
+	const targetType = inferTypeName ?? `z.infer<typeof ${name}>`;
+	const shouldGenerateIs = isName && (typeof typeGuards === "object" ? typeGuards.is ?? true : Boolean(typeGuards));
+	const shouldGenerateAssert = assertName && (typeof typeGuards === "object" ? typeGuards.assert ?? true : Boolean(typeGuards));
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		printerImports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+			name: imp.name,
+			path: imp.path,
+			root: imp.root,
+			isTypeOnly: imp.isTypeOnly,
+			isNameSpace: imp.isNameSpace
+		}, [
+			name,
+			imp.path,
+			imp.name
+		].join("-"))),
+		/* @__PURE__ */ jsx(File.Source, {
+			name,
+			isExportable: true,
+			isIndexable: true,
+			children: /* @__PURE__ */ jsx(Const, {
+				export: true,
+				name,
+				type: needsAnnotation ? mini ? "z.ZodMiniType" : "z.ZodType" : void 0,
+				children: value
+			})
+		}),
+		inferTypeName && /* @__PURE__ */ jsx(File.Source, {
+			name: inferTypeName,
+			isExportable: true,
+			isIndexable: true,
+			isTypeOnly: true,
+			children: /* @__PURE__ */ jsx(Type, {
+				export: true,
+				name: inferTypeName,
+				children: `z.${inferKind}<typeof ${name}>`
+			})
+		}),
+		shouldGenerateIs && /* @__PURE__ */ jsx(File.Source, {
+			name: isName,
+			isExportable: true,
+			isIndexable: true,
+			children: /* @__PURE__ */ jsx(Const, {
+				export: true,
+				name: isName,
+				JSDoc: { comments: [`Type guard for {@link ${name}}`] },
+				children: mini ? `(data: unknown): data is ${targetType} => z.validate(${name}, data)` : `(data: unknown): data is ${targetType} => ${name}.validate(data)`
+			})
+		}),
+		shouldGenerateAssert && /* @__PURE__ */ jsx(File.Source, {
+			name: assertName,
+			isExportable: true,
+			isIndexable: true,
+			children: /* @__PURE__ */ jsx(Function, {
+				export: true,
+				name: assertName,
+				params: "data: unknown",
+				returnType: `asserts data is ${targetType}`,
+				JSDoc: { comments: [`Asserter for {@link ${name}}`, "@throws {z.ZodError} If data is invalid"] },
+				children: mini ? `if (!z.validate(${name}, data)) {\n  z.parse(${name}, data)\n}` : `if (!${name}.validate(data)) {\n  ${name}.parse(data)\n}`
+			})
+		})
+	] });
+}
 // src/printers/printerZod.ts
 function strictOneOfMember(member, node, cyclicSchemas) {
-	if (node.type === ast.schemaTypes.ref) {
+	if (node.type === ast.schema.types.ref) {
 		if (member.startsWith("z.lazy(")) return member;
-		const refName = ast.resolveRefName(node);
+		const refName = ast.ref.getName(node);
 		if (refName && cyclicSchemas?.has(refName)) return member;
-		const schema = syncSchemaRef(node);
+		const schema = ast.ref.mergeSchema(node);
 		if (schema.nullable || schema.optional || node.nullable || node.optional) return member;
-		if (schema.type === ast.schemaTypes.object && (schema.additionalProperties === void 0 || schema.additionalProperties === false)) return `${member}.strict()`;
+		if (schema.type === ast.schema.types.object && (schema.additionalProperties === void 0 || schema.additionalProperties === false)) {
+			const checks = [node, node.schema].filter((entry) => entry && hasInputChecks(entry)).length;
+			if (checks === 2) return member;
+			return checks ? `z.pipe(${member}.in, ${member}.out.strict())` : `${member}.strict()`;
+		}
 	}
 	return member;
 }
@@ -1679,7 +1689,7 @@ function buildZodObjectShape(ctx, node) {
 			optional: schema.optional || required === false,
 			nullish: schema.nullish,
 			defaultValue: meta.default,
-			description: schema.type !== ast.schemaTypes.ref && meta.type === ast.schemaTypes.ref ? void 0 : meta.description,
+			description: schema.type !== ast.schema.types.ref && meta.type === ast.schema.types.ref ? void 0 : meta.description,
 			examples: meta.examples
 		});
 		if (!cyclic) return `${objectKey(name)}: ${body}`;
@@ -1700,21 +1710,22 @@ function buildZodObjectShape(ctx, node) {
 function recursiveGetterType({ ctx, schema, required }) {
 	function baseType(schema) {
 		if (ctx.options.nodes?.[schema.type]) return void 0;
-		if (schema.type === ast.schemaTypes.ref) {
+		if (schema.type === ast.schema.types.ref) {
 			const saved = ctx.options.cyclicSchemas;
 			ctx.options.cyclicSchemas = void 0;
 			const name = ctx.transform(schema);
 			ctx.options.cyclicSchemas = saved;
 			return name ? `typeof ${name}` : void 0;
 		}
-		if (schema.type === ast.schemaTypes.array && schema.items?.length === 1) {
+		if (schema.type === ast.schema.types.array && schema.items?.length === 1) {
 			const item = baseType(schema.items[0]);
-			return item ? `z.ZodArray<${item}>` : void 0;
+			if (!item) return void 0;
+			return `z.ZodArray<${schema.items[0].nullable ? `z.ZodNullable<${item}>` : item}>`;
 		}
 	}
 	const base = baseType(schema);
 	if (!base) return void 0;
-	const meta = syncSchemaRef(schema);
+	const meta = ast.ref.mergeSchema(schema);
 	const optional = schema.optional || required === false;
 	const wrapped = (() => {
 		if (schema.nullish || meta.nullable && optional) return `z.ZodOptional<z.ZodNullable<${base}>>`;
@@ -1729,12 +1740,12 @@ function recursiveGetterType({ ctx, schema, required }) {
 * `direction` themselves, so {@link containsDirectionalNode} probes their children instead.
 */
 const CONTAINER_TYPES = /* @__PURE__ */ new Set([
-	ast.schemaTypes.object,
-	ast.schemaTypes.array,
-	ast.schemaTypes.tuple,
-	ast.schemaTypes.union,
-	ast.schemaTypes.intersection,
-	ast.schemaTypes.ref
+	ast.schema.types.object,
+	ast.schema.types.array,
+	ast.schema.types.tuple,
+	ast.schema.types.union,
+	ast.schema.types.intersection,
+	ast.schema.types.ref
 ]);
 /**
 * Runs the node's effective handler (a `printer.nodes` override, else the built-in) once per
@@ -1765,22 +1776,31 @@ function variesByDirection({ node, printerOptions }) {
 */
 function containsDirectionalNode({ node, printerOptions }) {
 	if (!node) return false;
-	return ast.findSchema(node, {
+	return ast.schema.find(node, {
 		predicate: (schema) => variesByDirection({
 			node: schema,
 			printerOptions
 		}),
-		followRefs: true
+		followRefs: true,
+		cache: getDirectionalCache(printerOptions)
 	}) !== void 0;
 }
 /**
+* The `find` cache for {@link containsDirectionalNode}, one per plugin per build and per option set
+* the probe reads. A `printer.nodes` override has no string key, so it searches without a cache.
+*/
+function getDirectionalCache({ resolver, nodes, coercion, dateType }) {
+	if (!resolver || nodes) return void 0;
+	return resolver.memo(`zodDirectionalNodes:${shouldCoerce(coercion, "dates")}:${dateType}`, () => /* @__PURE__ */ new WeakMap());
+}
+/**
 * Names of the `$ref` schemas the generator should route to their input (encode) variant.
 */
 function collectDirectionalRefNames({ node, printerOptions }) {
-	return ast.collectSync(node, { schema: (n) => n.type === ast.schemaTypes.ref && n.ref && containsDirectionalNode({
+	return ast.node.collect(node, { schema: (n) => n.type === ast.schema.types.ref && n.ref && containsDirectionalNode({
 		node: n,
 		printerOptions
-	}) ? ast.resolveRefName(n) ?? void 0 : void 0 });
+	}) ? ast.ref.getName(n) ?? void 0 : void 0 });
 }
 /**
 * Handlers that never recurse into children, so {@link variesByDirection} can call one directly
@@ -1802,6 +1822,7 @@ const standardDialect = {
 	coercedNumber: (schema) => `z.coerce.number().pipe(${schema})`,
 	catchall: (object, value) => `${object}.catchall(${value})`,
 	nullable: (value) => `${value}.nullable()`,
+	refine: (value, check) => `${value}.refine(${check})`,
 	unique: (array) => `${array}.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })`,
 	extend: (base, shape) => `${base}.extend(${shape})`,
 	intersection: (left, right) => `${left}.and(${right})`,
@@ -1813,8 +1834,8 @@ const standardDialect = {
 };
 const scalarNodes = {
 	...buildScalarNodes(standardDialect),
-	bigint() {
-		return "z.coerce.bigint()";
+	bigint(node) {
+		return `z.coerce.bigint()${numberConstraints(bigintConstraints(node), "n")}`;
 	},
 	date(node) {
 		if (node.representation !== "date") return "z.iso.date()";
@@ -1847,14 +1868,14 @@ const scalarNodes = {
 * const code = printer.print(stringNode) // "z.string()"
 * ```
 */
-const printerZod = ast.createPrinter((options) => {
+const printerZod = createPrinter((options) => {
 	return {
 		name: "zod",
 		options,
-		nodes: {
+		nodes: withInputChecks({
 			...buildZodNodes(standardDialect, options.cyclicSchemas),
 			...scalarNodes
-		},
+		}),
 		overrides: options.nodes,
 		print(node) {
 			return printWithOmit(this, node, (value, meta) => applyModifiers({
@@ -1911,18 +1932,19 @@ const miniDialect = {
 	coercedNumber: (schema) => `z.pipe(z.coerce.number(), ${schema})`,
 	catchall: (object, value) => `z.catchall(${object}, ${value})`,
 	nullable: (value) => `z.nullable(${value})`,
+	refine: (value, check) => `${value}.check(z.refine(${check}))`,
 	unique: (array) => `${array}.check(z.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" }))`,
 	extend: (base, shape) => `z.extend(${base}, ${shape})`,
 	intersection: (left, right) => `z.intersection(${left}, ${right})`
 };
-const printerZodMini = ast.createPrinter((options) => {
+const printerZodMini = createPrinter((options) => {
 	return {
 		name: "zod-mini",
 		options,
-		nodes: {
+		nodes: withInputChecks({
 			...buildZodNodes(miniDialect, options.cyclicSchemas),
 			bigint(node) {
-				return `z.coerce.bigint()${numberChecksMini(node)}`;
+				return `z.coerce.bigint()${numberChecksMini(bigintConstraints(node), "n")}`;
 			},
 			date(node) {
 				if (node.representation === "string") return "z.iso.date()";
@@ -1935,7 +1957,7 @@ const printerZodMini = ast.createPrinter((options) => {
 				if (node.representation === "string") return "z.iso.time()";
 				return "z.date()";
 			}
-		},
+		}),
 		overrides: options.nodes,
 		print(node) {
 			return printWithOmit(this, node, (value, meta) => applyMiniModifiers({
@@ -2022,7 +2044,8 @@ const zodGenerator = defineGenerator({
 			node,
 			root,
 			output,
-			group: group ?? void 0
+			group: group ?? void 0,
+			checks: true
 		});
 		const inputImportEntries = hasDirectionalNode ? [...directionalRefNames].map((schemaName) => ({
 			name: [resolver.schema.inputName(schemaName)],
@@ -2113,7 +2136,7 @@ const zodGenerator = defineGenerator({
 		});
 	},
 	operation(node, ctx) {
-		if (!ast.isHttpOperationNode(node)) return null;
+		if (!ast.http.isOperation(node)) return null;
 		const { adapter, config, resolver, root } = ctx;
 		const { output, coercion, guidType, regexType, oneOfType, compile, mini, inferred, importPath, group, printer } = ctx.options;
 		const dateType = getOasAdapter(adapter).options.dateType;
@@ -2136,23 +2159,26 @@ const zodGenerator = defineGenerator({
 			cyclicSchemas: getCircularNames(ctx),
 			nodes: printer?.nodes
 		};
+		const siblings = /* @__PURE__ */ new Map();
 		function renderSchemaEntry({ schema, name, keysToOmit, direction = "decode" }) {
 			if (!schema) return null;
+			siblings.set(name, schema);
 			const directionalRefNames = direction === "encode" && !mini ? new Set(collectDirectionalRefNames({
 				node: schema,
 				printerOptions
 			})) : null;
+			const schemaPrinter = getPrinter(resolver, {
+				...printerOptions,
+				keysToOmit
+			}, mini, direction);
 			const imports = resolver.imports({
 				node: schema,
 				root,
 				output,
 				group: group ?? void 0,
+				checks: true,
 				name: (schemaName) => directionalRefNames?.has(schemaName) ? resolver.schema.inputName(schemaName) : resolver.name(schemaName)
 			});
-			const schemaPrinter = getPrinter(resolver, {
-				...printerOptions,
-				keysToOmit
-			}, mini, direction);
 			return /* @__PURE__ */ jsxs(Fragment, { children: [imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
 				root: meta.file.path,
 				path: imp.path,
@@ -2168,7 +2194,8 @@ const zodGenerator = defineGenerator({
 				inferTypeName: inferred ? resolver.schema.type(name) : null,
 				inferKind: aliasKind(inferred, direction),
 				cyclic: false,
-				compile
+				compile,
+				siblings
 			})] });
 		}
 		function buildContentTypeVariants(entries, baseName, decorate, direction) {
@@ -2192,7 +2219,7 @@ const zodGenerator = defineGenerator({
 			})] });
 		}
 		function buildResponseUnion({ responses, name, fallbackUnknown }) {
-			if (new Set(responses.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? ast.collectImportedRefNames(entry.schema).map((refName) => resolver.name(refName)) : []))).has(name)) return null;
+			if (new Set(ast.http.responses.getImportedNames(responses).map((refName) => resolver.name(refName))).has(name)) return null;
 			const members = responses.map((res) => ast.factory.createSchema({
 				type: "ref",
 				name: resolver.response.status(node, res.statusCode)
@@ -2225,14 +2252,27 @@ const zodGenerator = defineGenerator({
 				keysToOmit: primary?.keysToOmit
 			});
 		});
+		const toParamsSchema = (params) => ast.factory.createSchema({
+			type: "object",
+			primitive: "object",
+			properties: params.map((param) => ast.factory.createProperty({
+				name: param.name,
+				required: param.required,
+				schema: param.schema
+			}))
+		});
+		const responseHeaderSchemas = node.responses.map((res) => res.headers?.length ? renderSchemaEntry({
+			schema: toParamsSchema(res.headers),
+			name: resolver.response.headers(node, res.statusCode)
+		}) : null);
 		const responsesWithSchema = node.responses.filter((res) => res.content?.some((entry) => entry.schema));
-		const successResponsesWithSchema = getSuccessResponses(responsesWithSchema);
+		const successResponsesWithSchema = responsesWithSchema.filter((res) => ast.http.status.isSuccess(res));
 		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 errorResponsesWithSchema = responsesWithSchema.filter((res) => !ast.http.status.isSuccess(res));
 		const errorUnionSchema = errorResponsesWithSchema.length > 0 ? buildResponseUnion({
 			responses: errorResponsesWithSchema,
 			name: resolver.response.error(node),
@@ -2259,7 +2299,7 @@ const zodGenerator = defineGenerator({
 				description: node.requestBody.description ?? schema.description
 			}), "encode");
 		})();
-		const { path, query, header, cookie } = getOperationParameters(node);
+		const { path, query, header, cookie } = ast.http.groupParameters(node);
 		const paramGroupSchemas = [
 			{
 				kind: "path",
@@ -2278,15 +2318,7 @@ const zodGenerator = defineGenerator({
 				params: cookie
 			}
 		].filter(({ params }) => params.length > 0).map(({ kind, params }) => renderSchemaEntry({
-			schema: ast.factory.createSchema({
-				type: "object",
-				primitive: "object",
-				properties: params.map((param) => ast.factory.createProperty({
-					name: param.name,
-					required: param.required,
-					schema: param.schema
-				}))
-			}),
+			schema: toParamsSchema(params),
 			name: resolver.param[kind](node, params[0]),
 			direction: "encode"
 		}));
@@ -2327,6 +2359,7 @@ const zodGenerator = defineGenerator({
 				}),
 				paramSchemas,
 				responseSchemas,
+				responseHeaderSchemas,
 				responseUnionSchema,
 				errorUnionSchema,
 				requestSchema,
@@ -2339,11 +2372,11 @@ const zodGenerator = defineGenerator({
 });
 // kubb-extension.json
 var compatibility = {
-	"kubb": ">=5.16.0",
+	"kubb": ">=5.18.4",
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.9.0-canary.20261111T122006";
+var version = "5.9.1";
 // src/resolvers/resolverZod.ts
 /**
 * Default resolver used by `@kubb/plugin-zod`. Decides the names and file
@@ -2363,15 +2396,15 @@ var version = "5.9.0-canary.20261111T122006";
 const resolverZod = createResolver({
 	pluginName: "plugin-zod",
 	name(name) {
-		return this.memo(`name:${name}`, () => ensureValidVarName(camelCase(name, { suffix: "schema" })));
+		return this.memo(`name:${name}`, () => ensureValidVarName(casing.camel(name, { suffix: "schema" })));
 	},
-	file: createCasedFile((part) => camelCase(part, { suffix: "schema" })),
+	file: createCasedFile((part) => casing.camel(part, { suffix: "schema" })),
 	schema: {
 		typeName(name) {
-			return this.memo(`typeName:${name}`, () => ensureValidVarName(pascalCase(name, { suffix: "schema type" })));
+			return this.memo(`typeName:${name}`, () => ensureValidVarName(casing.pascal(name, { suffix: "schema type" })));
 		},
 		type(name) {
-			return this.memo(`type:${name}`, () => ensureValidVarName(pascalCase(name, { suffix: "type" })));
+			return this.memo(`type:${name}`, () => ensureValidVarName(casing.pascal(name, { suffix: "type" })));
 		},
 		inputName(name) {
 			return this.name(`${name} input`);
@@ -2380,10 +2413,10 @@ const resolverZod = createResolver({
 			return this.schema.typeName(`${name} input`);
 		},
 		isName(name) {
-			return ensureValidVarName(camelCase(name, { prefix: "is" }));
+			return ensureValidVarName(casing.camel(name, { prefix: "is" }));
 		},
 		assertName(name) {
-			return ensureValidVarName(camelCase(name, { prefix: "assert" }));
+			return ensureValidVarName(casing.camel(name, { prefix: "assert" }));
 		}
 	},
 	param: createOperationParamResolver(),
@@ -2457,7 +2490,7 @@ const pluginZod = defineExtension({
 			exclude,
 			include,
 			override,
-			group: createGroupConfig(group),
+			group: group ?? null,
 			importPath,
 			coercion,
 			inferred: inferred === "direction" ? "codec" : inferred,