@hey-api/openapi-ts 0.92.4 → 0.93.0

package/dist/{init-BxMu9GWq.mjs → init-BVQKw3ZX.mjs}

@@ -1,6 +1,6 @@
 import { createRequire } from "node:module";
 import { StructureModel, detectInteractiveSession, fromRef, isNode, isRef, isSymbol, loadConfigFile, log, nodeBrand, ref, refs } from "@hey-api/codegen-core";
-import { ConfigError, OperationPath, OperationStrategy, applyNaming, createOperationKey, createSchemaProcessor, deduplicateSchema, definePluginConfig, dependencyFactory, ensureDirSync, escapeComment, findTsConfigPath, getInput, getLogs, getParser, hasOperationDataRequired, hasParameterGroupObjectRequired, loadTsConfig, mappers, operationPagination, operationResponsesMap, parseUrl, pathToJsonPointer, pathToName, refToName, resolveSource, satisfies, statusCodeToGroup, toCase, valueToObject } from "@hey-api/shared";
+import { ConfigError, OperationPath, OperationStrategy, applyNaming, childContext, createOperationKey, createSchemaProcessor, createSchemaWalker, deduplicateSchema, definePluginConfig, dependencyFactory, ensureDirSync, escapeComment, findTsConfigPath, getInput, getLogs, getParser, hasOperationDataRequired, hasParameterGroupObjectRequired, loadTsConfig, mappers, operationPagination, operationResponsesMap, parseUrl, pathToJsonPointer, pathToName, refToName, resolveSource, satisfies, statusCodeToGroup, toCase, valueToObject } from "@hey-api/shared";
 import colors from "ansi-colors";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -2627,18 +2627,18 @@ f.await.set((...args) => new AwaitTsDsl(...args));
 const Mixed$27 = ArgsMixin(AsMixin(ExprMixin(TypeArgsMixin(TsDsl))));
 var CallTsDsl = class extends Mixed$27 {
 	"~dsl" = "CallTsDsl";
-	_callExpr;
-	constructor(expr, ...args) {
+	_callee;
+	constructor(callee, ...args) {
 		super();
-		this._callExpr = ref(expr);
+		this._callee = ref(callee);
 		this.args(...args);
 	}
 	analyze(ctx$1) {
 		super.analyze(ctx$1);
-		ctx$1.analyze(this._callExpr);
+		ctx$1.analyze(this._callee);
 	}
 	toAst() {
-		return ts.factory.createCallExpression(this.$node(this._callExpr), this.$generics(), this.$args());
+		return ts.factory.createCallExpression(this.$node(this._callee), this.$generics(), this.$args());
 	}
 };
 f.call.set((...args) => new CallTsDsl(...args));
@@ -4827,7 +4827,7 @@ function implementFn(args) {
 		role: "response"
 	}), (t$1, s) => t$1.extends(s).default(s), (t$1) => t$1.default("undefined"))), (m) => m.generic("ThrowOnError", (t) => t.extends("boolean").default(("throwOnError" in client.config ? client.config.throwOnError : false) ?? false))).params(...opParameters.parameters).do(...statements);
 }
-function toNode(model, plugin) {
+function toNode$1(model, plugin) {
 	if (model.virtual) {
 		const nodes$1 = [];
 		for (const item of model.itemsFrom(source$1)) {
@@ -5337,6 +5337,16 @@ function getClientBundlePaths(pluginName) {
 	};
 }
 /**
+* Converts an {@link OutputHeader} value to a string prefix for file content.
+* Returns an empty string when the header is null, undefined, or a function
+* (functions require a render context which is not available for bundled files).
+*/
+function outputHeaderToPrefix(header) {
+	if (header == null || typeof header === "function") return "";
+	const content = (typeof header === "string" ? header.split(/\r?\n/) : header.flatMap((line) => line.split(/\r?\n/))).join("\n");
+	return content ? `${content}\n\n` : "";
+}
+/**
 * Returns absolute path to the client folder. This is hard-coded for now.
 */
 function clientFolderAbsolutePath(config) {
@@ -5372,7 +5382,7 @@ function renameFile({ filePath, project, renamed }) {
 		renamed.set(name, renamedName);
 	}
 }
-function replaceImports({ filePath, isDevMode: isDevMode$1, meta, renamed }) {
+function replaceImports({ filePath, header, isDevMode: isDevMode$1, meta, renamed }) {
 	let content = fs.readFileSync(filePath, "utf8");
 	if (isDevMode$1) {
 		content = content.replace(/from\s+['"]\.\.\/\.\.\/client-core\/bundle\//g, "from '../core/");
@@ -5386,17 +5396,16 @@ function replaceImports({ filePath, isDevMode: isDevMode$1, meta, renamed }) {
 		const replacedName = (renamed.get(fileName) ?? fileName) + (meta.importFileExtension ? meta.importFileExtension : extension);
 		return match.slice(0, importIndex) + [importDir, replacedName].filter(Boolean).join("/") + match.slice(importIndex + importPath.length);
 	});
-	content = `// This file is auto-generated by @hey-api/openapi-ts
-
-${content}`;
+	content = `${header ?? ""}${content}`;
 	fs.writeFileSync(filePath, content, "utf8");
 }
 /**
 * Creates a `client` folder containing the same modules as the client package.
 */
-function generateClientBundle({ meta, outputPath, plugin, project }) {
+function generateClientBundle({ header, meta, outputPath, plugin, project }) {
 	const renamed = /* @__PURE__ */ new Map();
 	const devMode = isDevMode();
+	const headerPrefix = outputHeaderToPrefix(header);
 	if (plugin.name.startsWith("@hey-api/client-")) {
 		const { clientPath, corePath } = getClientBundlePaths(plugin.name);
 		const coreOutputPath = path.resolve(outputPath, "core");
@@ -5422,6 +5431,7 @@ function generateClientBundle({ meta, outputPath, plugin, project }) {
 		const coreFiles = fs.readdirSync(coreOutputPath);
 		for (const file of coreFiles) replaceImports({
 			filePath: path.resolve(coreOutputPath, file),
+			header: headerPrefix,
 			isDevMode: devMode,
 			meta,
 			renamed
@@ -5429,6 +5439,7 @@ function generateClientBundle({ meta, outputPath, plugin, project }) {
 		const clientFiles = fs.readdirSync(clientOutputPath);
 		for (const file of clientFiles) replaceImports({
 			filePath: path.resolve(clientOutputPath, file),
+			header: headerPrefix,
 			isDevMode: devMode,
 			meta,
 			renamed
@@ -6185,7 +6196,7 @@ const handlerV1$2 = ({ plugin }) => {
 	const allDependencies = [];
 	const allNodes = [];
 	for (const node of structure.walk()) {
-		const { dependencies, nodes } = toNode(node, plugin);
+		const { dependencies, nodes } = toNode$1(node, plugin);
 		allDependencies.push(...dependencies ?? []);
 		allNodes.push(...nodes);
 	}
@@ -6646,7 +6657,7 @@ const operationToDataType$1 = ({ operation, plugin, state }) => {
 		tags: fromRef(state.tags),
 		tool: "typescript"
 	} });
-	const node = $.type.alias(symbol).export().type(irSchemaToAst$5({
+	const node = $.type.alias(symbol).export().type(irSchemaToAst$1({
 		plugin,
 		schema: data,
 		state
@@ -6670,7 +6681,7 @@ const operationToType = ({ operation, plugin, state }) => {
 			tags: fromRef(state.tags),
 			tool: "typescript"
 		} });
-		const node = $.type.alias(symbolErrors).export().type(irSchemaToAst$5({
+		const node = $.type.alias(symbolErrors).export().type(irSchemaToAst$1({
 			plugin,
 			schema: errors,
 			state
@@ -6703,7 +6714,7 @@ const operationToType = ({ operation, plugin, state }) => {
 			tags: fromRef(state.tags),
 			tool: "typescript"
 		} });
-		const node = $.type.alias(symbolResponses).export().type(irSchemaToAst$5({
+		const node = $.type.alias(symbolResponses).export().type(irSchemaToAst$1({
 			plugin,
 			schema: responses,
 			state
@@ -6747,7 +6758,7 @@ const operationToDataType = ({ operation, plugin, state }) => {
 			tags: fromRef(state.tags),
 			tool: "typescript"
 		} });
-		const node$1 = $.type.alias(symbolWebhookPayload).export().$if(plugin.config.comments && createSchemaComment(operation.body.schema), (t, v) => t.doc(v)).type(irSchemaToAst$5({
+		const node$1 = $.type.alias(symbolWebhookPayload).export().$if(plugin.config.comments && createSchemaComment(operation.body.schema), (t, v) => t.doc(v)).type(irSchemaToAst$1({
 			plugin,
 			schema: operation.body.schema,
 			state
@@ -6773,7 +6784,7 @@ const operationToDataType = ({ operation, plugin, state }) => {
 		tags: fromRef(state.tags),
 		tool: "typescript"
 	} });
-	const node = $.type.alias(symbolWebhookRequest).export().type(irSchemaToAst$5({
+	const node = $.type.alias(symbolWebhookRequest).export().type(irSchemaToAst$1({
 		plugin,
 		schema: data,
 		state
@@ -6791,7 +6802,7 @@ const webhookToType = ({ operation, plugin, state }) => {
 
 //#endregion
 //#region src/plugins/@hey-api/typescript/v1/toAst/array.ts
-const arrayToAst$4 = ({ plugin, schema, state }) => {
+function arrayToAst$3({ plugin, schema, state }) {
 	if (!schema.items) return $.type("Array").generic($.type(plugin.config.topType));
 	schema = deduplicateSchema({
 		detectFormat: true,
@@ -6799,7 +6810,7 @@ const arrayToAst$4 = ({ plugin, schema, state }) => {
 	});
 	const itemTypes = [];
 	if (schema.items) schema.items.forEach((item, index) => {
-		const type = irSchemaToAst$5({
+		const type = irSchemaToAst$1({
 			plugin,
 			schema: item,
 			state: {
@@ -6815,19 +6826,19 @@ const arrayToAst$4 = ({ plugin, schema, state }) => {
 	});
 	if (itemTypes.length === 1) return $.type("Array").generic(itemTypes[0]);
 	return schema.logicalOperator === "and" ? $.type("Array").generic($.type.and(...itemTypes)) : $.type("Array").generic($.type.or(...itemTypes));
-};
+}
 
 //#endregion
 //#region src/plugins/@hey-api/typescript/v1/toAst/boolean.ts
-function booleanToAst$4({ schema }) {
+function booleanToAst$3({ schema }) {
 	if (schema.const !== void 0) return $.type.literal(schema.const);
 	return $.type("boolean");
 }
 
 //#endregion
 //#region src/plugins/@hey-api/typescript/v1/toAst/enum.ts
-const enumToAst$4 = ({ plugin, schema, state }) => {
-	return irSchemaToAst$5({
+function enumToAst$3({ plugin, schema, state }) {
+	return irSchemaToAst$1({
 		plugin,
 		schema: {
 			...schema,
@@ -6835,17 +6846,17 @@ const enumToAst$4 = ({ plugin, schema, state }) => {
 		},
 		state
 	});
-};
+}
 
 //#endregion
 //#region src/plugins/@hey-api/typescript/v1/toAst/never.ts
-const neverToAst$4 = (_args) => {
+const neverToAst$3 = (_args) => {
 	return $.type("never");
 };
 
 //#endregion
 //#region src/plugins/@hey-api/typescript/v1/toAst/null.ts
-const nullToAst$5 = (_args) => {
+const nullToAst$4 = (_args) => {
 	return $.type.literal(null);
 };
 
@@ -6861,14 +6872,14 @@ const numberToAst = ({ plugin, schema }) => {
 
 //#endregion
 //#region src/plugins/@hey-api/typescript/v1/toAst/object.ts
-const objectToAst$5 = ({ plugin, schema, state }) => {
+function objectToAst$4({ plugin, schema, state }) {
 	const shape = $.type.object();
 	const required = schema.required ?? [];
 	let indexSchemas = [];
 	let hasOptionalProperties = false;
 	for (const name in schema.properties) {
 		const property = schema.properties[name];
-		const propertyType = irSchemaToAst$5({
+		const propertyType = irSchemaToAst$1({
 			plugin,
 			schema: property,
 			state: {
@@ -6897,11 +6908,11 @@ const objectToAst$5 = ({ plugin, schema, state }) => {
 		if (addProps && addProps.type !== "never") indexSchemas.unshift(addProps);
 		else if (!hasPatterns && !indexSchemas.length && addProps && addProps.type === "never") indexSchemas = [addProps];
 		if (hasOptionalProperties) indexSchemas.push({ type: "undefined" });
-		const type = indexSchemas.length === 1 ? irSchemaToAst$5({
+		const type = indexSchemas.length === 1 ? irSchemaToAst$1({
 			plugin,
 			schema: indexSchemas[0],
 			state
-		}) : irSchemaToAst$5({
+		}) : irSchemaToAst$1({
 			plugin,
 			schema: {
 				items: indexSchemas,
@@ -6909,7 +6920,7 @@ const objectToAst$5 = ({ plugin, schema, state }) => {
 			},
 			state
 		});
-		if (schema.propertyNames?.$ref) return $.type.mapped("key").key(irSchemaToAst$5({
+		if (schema.propertyNames?.$ref) return $.type.mapped("key").key(irSchemaToAst$1({
 			plugin,
 			schema: { $ref: schema.propertyNames.$ref },
 			state
@@ -6917,7 +6928,7 @@ const objectToAst$5 = ({ plugin, schema, state }) => {
 		shape.idxSig("key", (i) => i.key("string").type(type));
 	}
 	return shape;
-};
+}
 
 //#endregion
 //#region src/plugins/@hey-api/typescript/v1/toAst/string.ts
@@ -6964,11 +6975,11 @@ const stringToAst$1 = ({ plugin, schema }) => {
 
 //#endregion
 //#region src/plugins/@hey-api/typescript/v1/toAst/tuple.ts
-const tupleToAst$4 = ({ plugin, schema, state }) => {
+function tupleToAst$3({ plugin, schema, state }) {
 	let itemTypes = [];
 	if (schema.const && Array.isArray(schema.const)) itemTypes = schema.const.map((value) => $.type.fromValue(value));
 	else if (schema.items) schema.items.forEach((item, index) => {
-		const type = irSchemaToAst$5({
+		const type = irSchemaToAst$1({
 			plugin,
 			schema: item,
 			state: {
@@ -6983,44 +6994,44 @@ const tupleToAst$4 = ({ plugin, schema, state }) => {
 		itemTypes.push(type);
 	});
 	return $.type.tuple(...itemTypes);
-};
+}
 
 //#endregion
 //#region src/plugins/@hey-api/typescript/v1/toAst/undefined.ts
-const undefinedToAst$4 = (_args) => {
+const undefinedToAst$3 = (_args) => {
 	return $.type("undefined");
 };
 
 //#endregion
 //#region src/plugins/@hey-api/typescript/v1/toAst/unknown.ts
-const unknownToAst$4 = ({ plugin }) => {
+function unknownToAst$3({ plugin }) {
 	return $.type(plugin.config.topType);
-};
+}
 
 //#endregion
 //#region src/plugins/@hey-api/typescript/v1/toAst/void.ts
-const voidToAst$4 = (_args) => {
+const voidToAst$3 = (_args) => {
 	return $.type("void");
 };
 
 //#endregion
 //#region src/plugins/@hey-api/typescript/v1/toAst/index.ts
-function irSchemaWithTypeToAst$5({ schema, ...args }) {
+function irSchemaWithTypeToAst$1({ schema, ...args }) {
 	const transformersPlugin = args.plugin.getPlugin("@hey-api/transformers");
 	if (transformersPlugin?.config.typeTransformers) for (const typeTransformer of transformersPlugin.config.typeTransformers) {
 		const typeNode = typeTransformer({ schema });
 		if (typeNode) return typeNode;
 	}
 	switch (schema.type) {
-		case "array": return arrayToAst$4({
+		case "array": return arrayToAst$3({
 			...args,
 			schema
 		});
-		case "boolean": return booleanToAst$4({
+		case "boolean": return booleanToAst$3({
 			...args,
 			schema
 		});
-		case "enum": return enumToAst$4({
+		case "enum": return enumToAst$3({
 			...args,
 			schema
 		});
@@ -7029,15 +7040,15 @@ function irSchemaWithTypeToAst$5({ schema, ...args }) {
 			...args,
 			schema
 		});
-		case "never": return neverToAst$4({
+		case "never": return neverToAst$3({
 			...args,
 			schema
 		});
-		case "null": return nullToAst$5({
+		case "null": return nullToAst$4({
 			...args,
 			schema
 		});
-		case "object": return objectToAst$5({
+		case "object": return objectToAst$4({
 			...args,
 			schema
 		});
@@ -7045,19 +7056,19 @@ function irSchemaWithTypeToAst$5({ schema, ...args }) {
 			...args,
 			schema
 		});
-		case "tuple": return tupleToAst$4({
+		case "tuple": return tupleToAst$3({
 			...args,
 			schema
 		});
-		case "undefined": return undefinedToAst$4({
+		case "undefined": return undefinedToAst$3({
 			...args,
 			schema
 		});
-		case "unknown": return unknownToAst$4({
+		case "unknown": return unknownToAst$3({
 			...args,
 			schema
 		});
-		case "void": return voidToAst$4({
+		case "void": return voidToAst$3({
 			...args,
 			schema
 		});
@@ -7066,7 +7077,7 @@ function irSchemaWithTypeToAst$5({ schema, ...args }) {
 
 //#endregion
 //#region src/plugins/@hey-api/typescript/v1/plugin.ts
-function irSchemaToAst$5({ plugin, schema, schemaExtractor, state }) {
+function irSchemaToAst$1({ plugin, schema, schemaExtractor, state }) {
 	if (schemaExtractor && !schema.$ref) {
 		const extracted = schemaExtractor({
 			meta: {
@@ -7099,7 +7110,7 @@ function irSchemaToAst$5({ plugin, schema, schemaExtractor, state }) {
 		}
 		return baseType;
 	}
-	if (schema.type) return irSchemaWithTypeToAst$5({
+	if (schema.type) return irSchemaWithTypeToAst$1({
 		plugin,
 		schema,
 		state
@@ -7110,20 +7121,20 @@ function irSchemaToAst$5({ plugin, schema, schemaExtractor, state }) {
 			schema
 		});
 		if (schema.items) {
-			const itemTypes = schema.items.map((item) => irSchemaToAst$5({
+			const itemTypes = schema.items.map((item) => irSchemaToAst$1({
 				plugin,
 				schema: item,
 				state
 			}));
 			return schema.logicalOperator === "and" ? $.type.and(...itemTypes) : $.type.or(...itemTypes);
 		}
-		return irSchemaToAst$5({
+		return irSchemaToAst$1({
 			plugin,
 			schema,
 			state
 		});
 	}
-	return irSchemaWithTypeToAst$5({
+	return irSchemaWithTypeToAst$1({
 		plugin,
 		schema: { type: "unknown" },
 		state
@@ -7134,7 +7145,7 @@ function handleComponent$1({ plugin, schema, state }) {
 		plugin,
 		schema,
 		state,
-		type: irSchemaToAst$5({
+		type: irSchemaToAst$1({
 			plugin,
 			schema,
 			state
@@ -7213,7 +7224,7 @@ const handlerV1$1 = ({ plugin }) => {
 //#region src/plugins/@hey-api/typescript/api.ts
 var Api$3 = class {
 	schemaToType(args) {
-		return irSchemaToAst$5(args);
+		return irSchemaToAst$1(args);
 	}
 };
 
@@ -8556,7 +8567,7 @@ function exportAst$2({ ast, plugin, schema, symbol, typeInferSymbol }) {
 
 //#endregion
 //#region src/plugins/arktype/v2/toAst/null.ts
-const nullToAst$4 = (_args) => {
+const nullToAst$3 = (_args) => {
 	const result = {};
 	result.def = identifiers$2.primitives.null;
 	return result;
@@ -8564,14 +8575,14 @@ const nullToAst$4 = (_args) => {
 
 //#endregion
 //#region src/plugins/arktype/v2/toAst/object.ts
-const objectToAst$4 = ({ plugin, schema, state }) => {
+function objectToAst$3({ plugin, schema, state }) {
 	const result = {};
 	const shape = $.object().pretty();
 	const required = schema.required ?? [];
 	for (const name in schema.properties) {
 		const property = schema.properties[name];
 		const isRequired = required.includes(name);
-		const propertyAst = irSchemaToAst$4({
+		const propertyAst = irSchemaToAst({
 			optional: !isRequired,
 			plugin,
 			schema: property,
@@ -8588,7 +8599,7 @@ const objectToAst$4 = ({ plugin, schema, state }) => {
 		shape.prop(isRequired ? name : `${name}?`, propertyAst.expression);
 	}
 	if (schema.additionalProperties && (!schema.properties || !Object.keys(schema.properties).length)) {
-		const additionalAst = irSchemaToAst$4({
+		const additionalAst = irSchemaToAst({
 			plugin,
 			schema: schema.additionalProperties,
 			state: {
@@ -8606,7 +8617,7 @@ const objectToAst$4 = ({ plugin, schema, state }) => {
 		typeName: "TODO"
 	};
 	return result;
-};
+}
 
 //#endregion
 //#region src/plugins/arktype/v2/toAst/string.ts
@@ -8651,13 +8662,13 @@ const stringToAst = ({ schema }) => {
 
 //#endregion
 //#region src/plugins/arktype/v2/toAst/index.ts
-function irSchemaWithTypeToAst$4({ schema, ...args }) {
+function irSchemaWithTypeToAst({ schema, ...args }) {
 	switch (schema.type) {
-		case "null": return nullToAst$4({
+		case "null": return nullToAst$3({
 			...args,
 			schema
 		});
-		case "object": return objectToAst$4({
+		case "object": return objectToAst$3({
 			...args,
 			schema
 		});
@@ -8675,7 +8686,7 @@ function irSchemaWithTypeToAst$4({ schema, ...args }) {
 
 //#endregion
 //#region src/plugins/arktype/v2/plugin.ts
-function irSchemaToAst$4({ plugin, schema, schemaExtractor, state }) {
+function irSchemaToAst({ plugin, schema, schemaExtractor, state }) {
 	if (schemaExtractor && !schema.$ref) {
 		const extracted = schemaExtractor({
 			meta: {
@@ -8706,7 +8717,7 @@ function irSchemaToAst$4({ plugin, schema, schemaExtractor, state }) {
 			state.hasLazyExpression["~ref"] = true;
 		}
 	} else if (schema.type) {
-		const typeAst = irSchemaWithTypeToAst$4({
+		const typeAst = irSchemaWithTypeToAst({
 			plugin,
 			schema,
 			state
@@ -8717,13 +8728,13 @@ function irSchemaToAst$4({ plugin, schema, schemaExtractor, state }) {
 		if (plugin.config.metadata && schema.description) {}
 	} else if (schema.items) {
 		schema = deduplicateSchema({ schema });
-		if (schema.items) {} else ast = irSchemaToAst$4({
+		if (schema.items) {} else ast = irSchemaToAst({
 			plugin,
 			schema,
 			state
 		});
 	} else {
-		const typeAst = irSchemaWithTypeToAst$4({
+		const typeAst = irSchemaWithTypeToAst({
 			plugin,
 			schema: { type: "unknown" },
 			state
@@ -8732,7 +8743,7 @@ function irSchemaToAst$4({ plugin, schema, schemaExtractor, state }) {
 		ast.expression = typeAst.expression;
 	}
 	if (!ast.expression) {
-		const typeAst = irSchemaWithTypeToAst$4({
+		const typeAst = irSchemaWithTypeToAst({
 			plugin,
 			schema: { type: "unknown" },
 			state
@@ -8743,7 +8754,7 @@ function irSchemaToAst$4({ plugin, schema, schemaExtractor, state }) {
 }
 function handleComponent({ plugin, schema, state }) {
 	const $ref = pathToJsonPointer(fromRef(state.path));
-	const ast = irSchemaToAst$4({
+	const ast = irSchemaToAst({
 		plugin,
 		schema,
 		state
@@ -9476,23 +9487,33 @@ const identifiers$1 = {
 
 //#endregion
 //#region src/plugins/valibot/shared/pipes.ts
-const pipesToNode = (pipes$1, plugin) => {
+function push(target, result) {
+	if (result === void 0) return target;
+	if (result instanceof Array) target.push(...result);
+	else target.push(result);
+	return target;
+}
+function toNode(pipes$1, plugin) {
 	if (!(pipes$1 instanceof Array)) return pipes$1;
+	if (pipes$1.length === 0) return $(plugin.external("valibot.v")).attr(identifiers$1.schemas.unknown).call();
 	if (pipes$1.length === 1) return pipes$1[0];
 	return $(plugin.external("valibot.v")).attr(identifiers$1.methods.pipe).call(...pipes$1);
-};
-const pushPipes = (target, pipes$1) => {
-	if (pipes$1 instanceof Array) target.push(...pipes$1);
-	else target.push(pipes$1);
-	return target;
-};
+}
 /**
 * Functions for working with pipes.
 */
 const pipes = {
-	push: pushPipes,
-	toNode: pipesToNode
+	push,
+	toNode
 };
+/**
+* Convenience function for converting pipes to a node.
+*
+* Re-exported for backward compatibility.
+*/
+function pipesToNode(p, plugin) {
+	return toNode(p, plugin);
+}
 
 //#endregion
 //#region src/plugins/valibot/v1/api.ts
@@ -9572,19 +9593,6 @@ var Api$1 = class {
 	}
 };
 
-//#endregion
-//#region src/plugins/shared/utils/coerce.ts
-const shouldCoerceToBigInt = (format) => format === "int64" || format === "uint64";
-const maybeBigInt = (value, format) => {
-	if (!shouldCoerceToBigInt(format)) return $.fromValue(value);
-	if (typeof value === "string") {
-		if (value.endsWith("n")) value = value.slice(0, -1);
-		return $("BigInt").call($.fromValue(value));
-	}
-	if (typeof value === "number") return $("BigInt").call($.fromValue(value));
-	return $.fromValue(value);
-};
-
 //#endregion
 //#region src/plugins/valibot/shared/operation-schema.ts
 function buildOperationSchema$1(operation) {
@@ -9694,7 +9702,7 @@ function irWebhookToAst$1({ operation, path: path$1, plugin, processor, tags })
 
 //#endregion
 //#region src/plugins/valibot/shared/export.ts
-function exportAst$1({ ast, meta, naming, namingAnchor, path: path$1, plugin, schema, state, tags }) {
+function exportAst$1({ final, meta, naming, namingAnchor, path: path$1, plugin, schema, tags }) {
 	const v = plugin.external("valibot.v");
 	const name = pathToName(path$1, { anchor: namingAnchor });
 	const symbol = plugin.symbol(applyNaming(name, naming), { meta: {
@@ -9704,132 +9712,114 @@ function exportAst$1({ ast, meta, naming, namingAnchor, path: path$1, plugin, sc
 		tool: "valibot",
 		...meta
 	} });
-	const statement = $.const(symbol).export().$if(plugin.config.comments && createSchemaComment(schema), (c, v$1) => c.doc(v$1)).$if(state.hasLazyExpression["~ref"], (c) => c.type($.type(v).attr(ast.typeName || identifiers$1.types.GenericSchema))).assign(pipesToNode(ast.pipes, plugin));
+	const statement = $.const(symbol).export().$if(plugin.config.comments && createSchemaComment(schema), (c, v$1) => c.doc(v$1)).$if(final.typeName, (c) => c.type($.type(v).attr(final.typeName))).assign(pipesToNode(final.pipes, plugin));
 	plugin.node(statement);
 }
 
 //#endregion
-//#region src/plugins/valibot/v1/processor.ts
-function createProcessor$3(plugin) {
-	const processor = createSchemaProcessor();
-	const hooks = [plugin.config["~hooks"]?.schemas, plugin.context.config.parser.hooks.schemas];
-	function extractor(ctx$1) {
-		if (processor.hasEmitted(ctx$1.path)) return ctx$1.schema;
-		for (const hook of hooks) if (hook?.shouldExtract?.(ctx$1)) {
-			process$1({
-				namingAnchor: processor.context.anchor,
-				tags: processor.context.tags,
-				...ctx$1
-			});
-			return { $ref: pathToJsonPointer(ctx$1.path) };
-		}
-		return ctx$1.schema;
-	}
-	function process$1(ctx$1) {
-		if (!processor.markEmitted(ctx$1.path)) return;
-		processor.withContext({
-			anchor: ctx$1.namingAnchor,
-			tags: ctx$1.tags
-		}, () => {
-			const state = refs({
-				hasLazyExpression: false,
-				path: ctx$1.path,
-				tags: ctx$1.tags
-			});
-			const ast = irSchemaToAst$3({
-				plugin,
-				schema: ctx$1.schema,
-				schemaExtractor: extractor,
-				state
-			});
-			exportAst$1({
-				...ctx$1,
-				ast,
-				plugin,
-				state
-			});
-		});
+//#region src/plugins/shared/utils/coerce.ts
+const shouldCoerceToBigInt = (format) => format === "int64" || format === "uint64";
+const maybeBigInt = (value, format) => {
+	if (!shouldCoerceToBigInt(format)) return $.fromValue(value);
+	if (typeof value === "string") {
+		if (value.endsWith("n")) value = value.slice(0, -1);
+		return $("BigInt").call($.fromValue(value));
 	}
-	return { process: process$1 };
+	if (typeof value === "number") return $("BigInt").call($.fromValue(value));
+	return $.fromValue(value);
+};
+
+//#endregion
+//#region src/plugins/valibot/shared/meta.ts
+/**
+* Creates default metadata from a schema.
+*/
+function defaultMeta(schema) {
+	return {
+		default: schema.default,
+		format: schema.format,
+		hasLazy: false,
+		nullable: false,
+		readonly: schema.accessScope === "read"
+	};
+}
+/**
+* Composes metadata from child results.
+*
+* Automatically propagates hasLazy, nullable, readonly from children.
+*
+* @param children - Results from walking child schemas
+* @param overrides - Explicit overrides (e.g., from parent schema)
+*/
+function composeMeta(children, overrides) {
+	return {
+		default: overrides?.default,
+		format: overrides?.format,
+		hasLazy: overrides?.hasLazy ?? children.some((c) => c.meta.hasLazy),
+		nullable: overrides?.nullable ?? children.some((c) => c.meta.nullable),
+		readonly: overrides?.readonly ?? children.some((c) => c.meta.readonly)
+	};
+}
+/**
+* Merges parent schema metadata with composed child metadata.
+*
+* @param parent - The parent schema
+* @param children - Results from walking child schemas
+*/
+function inheritMeta(parent, children) {
+	return composeMeta(children, {
+		default: parent.default,
+		format: parent.format,
+		nullable: false,
+		readonly: parent.accessScope === "read"
+	});
 }
 
 //#endregion
 //#region src/plugins/valibot/v1/toAst/unknown.ts
-function unknownToAst$3({ plugin }) {
+function unknownToPipes({ plugin }) {
 	return $(plugin.external("valibot.v")).attr(identifiers$1.schemas.unknown).call();
 }
 
 //#endregion
 //#region src/plugins/valibot/v1/toAst/array.ts
-function arrayToAst$3(options) {
-	const { plugin } = options;
-	let { schema } = options;
-	const result = { pipes: [] };
+function arrayToPipes(ctx$1) {
+	const { plugin, walk, walkerCtx } = ctx$1;
+	let { schema } = ctx$1;
 	const v = plugin.external("valibot.v");
-	const functionName = $(v).attr(identifiers$1.schemas.array);
-	if (!schema.items) {
-		const expression = functionName.call(unknownToAst$3({
-			...options,
-			schema: { type: "unknown" }
-		}));
-		result.pipes.push(expression);
-	} else {
+	const arrayFn = $(v).attr(identifiers$1.schemas.array);
+	const childResults = [];
+	const resultPipes = [];
+	if (!schema.items) resultPipes.push(arrayFn.call(unknownToPipes({ plugin })));
+	else {
 		schema = deduplicateSchema({ schema });
-		const itemExpressions = schema.items.map((item, index) => {
-			const itemAst = irSchemaToAst$3({
-				...options,
-				schema: item,
-				state: {
-					...options.state,
-					path: ref([
-						...fromRef(options.state.path),
-						"items",
-						index
-					])
-				}
-			});
-			if (itemAst.hasLazyExpression) result.hasLazyExpression = true;
-			return pipesToNode(itemAst.pipes, plugin);
-		});
-		if (itemExpressions.length === 1) {
-			const expression = functionName.call(...itemExpressions);
-			result.pipes.push(expression);
-		} else {
-			if (schema.logicalOperator === "and") {}
-			const expression = functionName.call(unknownToAst$3({
-				...options,
-				schema: { type: "unknown" }
-			}));
-			result.pipes.push(expression);
+		for (let i = 0; i < schema.items.length; i++) {
+			const item = schema.items[i];
+			const result = walk(item, childContext(walkerCtx, "items", i));
+			childResults.push(result);
 		}
+		if (childResults.length === 1) {
+			const itemNode = pipesToNode(ctx$1.applyModifiers(childResults[0]).pipes, plugin);
+			resultPipes.push(arrayFn.call(itemNode));
+		} else resultPipes.push(arrayFn.call(unknownToPipes({ plugin })));
 	}
-	if (schema.minItems === schema.maxItems && schema.minItems !== void 0) {
-		const expression = $(v).attr(identifiers$1.actions.length).call($.fromValue(schema.minItems));
-		result.pipes.push(expression);
-	} else {
-		if (schema.minItems !== void 0) {
-			const expression = $(v).attr(identifiers$1.actions.minLength).call($.fromValue(schema.minItems));
-			result.pipes.push(expression);
-		}
-		if (schema.maxItems !== void 0) {
-			const expression = $(v).attr(identifiers$1.actions.maxLength).call($.fromValue(schema.maxItems));
-			result.pipes.push(expression);
-		}
+	if (schema.minItems === schema.maxItems && schema.minItems !== void 0) resultPipes.push($(v).attr(identifiers$1.actions.length).call($.fromValue(schema.minItems)));
+	else {
+		if (schema.minItems !== void 0) resultPipes.push($(v).attr(identifiers$1.actions.minLength).call($.fromValue(schema.minItems)));
+		if (schema.maxItems !== void 0) resultPipes.push($(v).attr(identifiers$1.actions.maxLength).call($.fromValue(schema.maxItems)));
 	}
-	return result;
+	return {
+		childResults,
+		pipes: resultPipes
+	};
 }
 
 //#endregion
 //#region src/plugins/valibot/v1/toAst/boolean.ts
-function booleanToAst$3({ plugin, schema }) {
-	const pipes$1 = [];
+function booleanToPipes({ plugin, schema }) {
 	const v = plugin.external("valibot.v");
-	if (typeof schema.const === "boolean") {
-		pipes$1.push($(v).attr(identifiers$1.schemas.literal).call($.literal(schema.const)));
-		return pipesToNode(pipes$1, plugin);
-	}
-	pipes$1.push($(v).attr(identifiers$1.schemas.boolean).call());
-	return pipesToNode(pipes$1, plugin);
+	if (typeof schema.const === "boolean") return $(v).attr(identifiers$1.schemas.literal).call($.literal(schema.const));
+	return $(v).attr(identifiers$1.schemas.boolean).call();
 }
 
 //#endregion
@@ -9851,31 +9841,20 @@ function baseNode$15(ctx$1) {
 	const { enumMembers } = ctx$1.nodes.items(ctx$1);
 	return $(v).attr(identifiers$1.schemas.picklist).call($.array(...enumMembers));
 }
-function nullableNode$3(ctx$1) {
-	const { symbols } = ctx$1;
-	const { v } = symbols;
-	const { isNullable } = ctx$1.nodes.items(ctx$1);
-	if (!isNullable) return;
-	const currentNode = ctx$1.pipes.toNode(ctx$1.pipes.current, ctx$1.plugin);
-	return $(v).attr(identifiers$1.schemas.nullable).call(currentNode);
-}
 function enumResolver$3(ctx$1) {
 	const { enumMembers } = ctx$1.nodes.items(ctx$1);
 	if (!enumMembers.length) return ctx$1.pipes.current;
 	const baseExpression = ctx$1.nodes.base(ctx$1);
 	ctx$1.pipes.push(ctx$1.pipes.current, baseExpression);
-	const nullableExpression = ctx$1.nodes.nullable(ctx$1);
-	if (nullableExpression) return nullableExpression;
 	return ctx$1.pipes.current;
 }
-function enumToAst$3({ plugin, schema, state }) {
+function enumToPipes({ plugin, schema }) {
 	const v = plugin.external("valibot.v");
-	const { enumMembers } = itemsNode$3({
+	const { enumMembers, isNullable } = itemsNode$3({
 		$,
 		nodes: {
 			base: baseNode$15,
-			items: itemsNode$3,
-			nullable: nullableNode$3
+			items: itemsNode$3
 		},
 		pipes: {
 			...pipes,
@@ -9883,20 +9862,17 @@ function enumToAst$3({ plugin, schema, state }) {
 		},
 		plugin,
 		schema,
-		symbols: { v },
-		utils: { state }
-	});
-	if (!enumMembers.length) return unknownToAst$3({
-		plugin,
-		schema: { type: "unknown" },
-		state
+		symbols: { v }
 	});
+	if (!enumMembers.length) return {
+		isNullable,
+		pipe: unknownToPipes({ plugin })
+	};
 	const ctx$1 = {
 		$,
 		nodes: {
 			base: baseNode$15,
-			items: itemsNode$3,
-			nullable: nullableNode$3
+			items: itemsNode$3
 		},
 		pipes: {
 			...pipes,
@@ -9904,23 +9880,25 @@ function enumToAst$3({ plugin, schema, state }) {
 		},
 		plugin,
 		schema,
-		symbols: { v },
-		utils: { state }
+		symbols: { v }
 	};
 	const resolver = plugin.config["~resolvers"]?.enum;
 	const node = resolver?.(ctx$1) ?? enumResolver$3(ctx$1);
-	return ctx$1.pipes.toNode(node, plugin);
+	return {
+		isNullable,
+		pipe: ctx$1.pipes.toNode(node, plugin)
+	};
 }
 
 //#endregion
 //#region src/plugins/valibot/v1/toAst/never.ts
-function neverToAst$3({ plugin }) {
+function neverToPipes({ plugin }) {
 	return $(plugin.external("valibot.v")).attr(identifiers$1.schemas.never).call();
 }
 
 //#endregion
 //#region src/plugins/valibot/v1/toAst/null.ts
-function nullToAst$3({ plugin }) {
+function nullToPipes({ plugin }) {
 	return $(plugin.external("valibot.v")).attr(identifiers$1.schemas.null).call();
 }
 
@@ -9958,10 +9936,10 @@ function baseNode$14(ctx$1) {
 	const { schema, symbols } = ctx$1;
 	const { v } = symbols;
 	if (ctx$1.utils.shouldCoerceToBigInt(schema.format)) return [$(v).attr(identifiers$1.schemas.union).call($.array($(v).attr(identifiers$1.schemas.number).call(), $(v).attr(identifiers$1.schemas.string).call(), $(v).attr(identifiers$1.schemas.bigInt).call())), $(v).attr(identifiers$1.actions.transform).call($.func().param("x").do($("BigInt").call("x").return()))];
-	const pipes$1 = [];
-	pipes$1.push($(v).attr(identifiers$1.schemas.number).call());
-	if (schema.type === "integer") pipes$1.push($(v).attr(identifiers$1.actions.integer).call());
-	return pipes$1;
+	const result = [];
+	result.push($(v).attr(identifiers$1.schemas.number).call());
+	if (schema.type === "integer") result.push($(v).attr(identifiers$1.actions.integer).call());
+	return result;
 }
 function constNode$7(ctx$1) {
 	const { schema, symbols } = ctx$1;
@@ -9986,17 +9964,17 @@ function minNode$3(ctx$1) {
 	if (limit) return $(v).attr(identifiers$1.actions.minValue).call(ctx$1.utils.maybeBigInt(limit.minValue, schema.format), $.literal(limit.minError));
 }
 function numberResolver$3(ctx$1) {
-	const constNode$8 = ctx$1.nodes.const(ctx$1);
-	if (constNode$8) return ctx$1.pipes.push(ctx$1.pipes.current, constNode$8);
-	const baseNode$16 = ctx$1.nodes.base(ctx$1);
-	if (baseNode$16) ctx$1.pipes.push(ctx$1.pipes.current, baseNode$16);
-	const minNode$4 = ctx$1.nodes.min(ctx$1);
-	if (minNode$4) ctx$1.pipes.push(ctx$1.pipes.current, minNode$4);
-	const maxNode$4 = ctx$1.nodes.max(ctx$1);
-	if (maxNode$4) ctx$1.pipes.push(ctx$1.pipes.current, maxNode$4);
+	const constResult = ctx$1.nodes.const(ctx$1);
+	if (constResult) return ctx$1.pipes.push(ctx$1.pipes.current, constResult);
+	const baseResult = ctx$1.nodes.base(ctx$1);
+	if (baseResult) ctx$1.pipes.push(ctx$1.pipes.current, baseResult);
+	const minResult = ctx$1.nodes.min(ctx$1);
+	if (minResult) ctx$1.pipes.push(ctx$1.pipes.current, minResult);
+	const maxResult = ctx$1.nodes.max(ctx$1);
+	if (maxResult) ctx$1.pipes.push(ctx$1.pipes.current, maxResult);
 	return ctx$1.pipes.current;
 }
-function numberToNode$3({ plugin, schema }) {
+function numberToPipes({ plugin, schema }) {
 	const ctx$1 = {
 		$,
 		nodes: {
@@ -10026,25 +10004,17 @@ function numberToNode$3({ plugin, schema }) {
 //#endregion
 //#region src/plugins/valibot/v1/toAst/object.ts
 function additionalPropertiesNode$3(ctx$1) {
-	const { plugin, schema } = ctx$1;
+	const { schema } = ctx$1;
 	if (!schema.additionalProperties || !schema.additionalProperties.type) return;
 	if (schema.additionalProperties.type === "never") return null;
-	const additionalAst = irSchemaToAst$3({
-		...ctx$1,
-		schema: schema.additionalProperties,
-		state: {
-			...ctx$1.utils.state,
-			path: ref([...fromRef(ctx$1.utils.state.path), "additionalProperties"])
-		}
-	});
-	if (additionalAst.hasLazyExpression) ctx$1.utils.ast.hasLazyExpression = true;
-	return pipes.toNode(additionalAst.pipes, plugin);
+	const additionalResult = ctx$1.walk(schema.additionalProperties, childContext(ctx$1.walkerCtx, "additionalProperties"));
+	ctx$1._childResults.push(additionalResult);
+	return pipesToNode(additionalResult.pipes, ctx$1.plugin);
 }
 function baseNode$13(ctx$1) {
-	const { nodes, symbols } = ctx$1;
-	const { v } = symbols;
-	const additional = nodes.additionalProperties(ctx$1);
-	const shape = nodes.shape(ctx$1);
+	const { v } = ctx$1.symbols;
+	const additional = ctx$1.nodes.additionalProperties(ctx$1);
+	const shape = ctx$1.nodes.shape(ctx$1);
 	if (additional === null) return $(v).attr(identifiers$1.schemas.strictObject).call(shape);
 	if (additional) {
 		if (shape.isEmpty) return $(v).attr(identifiers$1.schemas.record).call($(v).attr(identifiers$1.schemas.string).call(), additional);
@@ -10056,33 +10026,25 @@ function objectResolver$3(ctx$1) {
 	return ctx$1.nodes.base(ctx$1);
 }
 function shapeNode$3(ctx$1) {
-	const { plugin, schema } = ctx$1;
+	const { schema } = ctx$1;
 	const shape = $.object().pretty();
 	for (const name in schema.properties) {
 		const property = schema.properties[name];
-		const propertyAst = irSchemaToAst$3({
-			...ctx$1,
-			optional: !schema.required?.includes(name),
-			schema: property,
-			state: {
-				...ctx$1.utils.state,
-				path: ref([
-					...fromRef(ctx$1.utils.state.path),
-					"properties",
-					name
-				])
-			}
-		});
-		if (propertyAst.hasLazyExpression) ctx$1.utils.ast.hasLazyExpression = true;
-		shape.prop(name, pipes.toNode(propertyAst.pipes, plugin));
+		const isOptional = !schema.required?.includes(name);
+		const propertyResult = ctx$1.walk(property, childContext(ctx$1.walkerCtx, "properties", name));
+		ctx$1._childResults.push(propertyResult);
+		const finalExpr = ctx$1.applyModifiers(propertyResult, { optional: isOptional });
+		shape.prop(name, pipesToNode(finalExpr.pipes, ctx$1.plugin));
 	}
 	return shape;
 }
-function objectToAst$3(options) {
-	const { plugin } = options;
-	const ctx$1 = {
-		...options,
+function objectToPipes(ctx$1) {
+	const { applyModifiers, plugin, schema, walk, walkerCtx } = ctx$1;
+	const childResults = [];
+	const extendedCtx = {
 		$,
+		_childResults: childResults,
+		applyModifiers,
 		nodes: {
 			additionalProperties: additionalPropertiesNode$3,
 			base: baseNode$13,
@@ -10092,16 +10054,19 @@ function objectToAst$3(options) {
 			...pipes,
 			current: []
 		},
+		plugin,
+		schema,
 		symbols: { v: plugin.external("valibot.v") },
-		utils: {
-			ast: {},
-			state: options.state
-		}
+		utils: { ast: {} },
+		walk,
+		walkerCtx
 	};
 	const resolver = plugin.config["~resolvers"]?.object;
-	const node = resolver?.(ctx$1) ?? objectResolver$3(ctx$1);
-	ctx$1.utils.ast.pipes = [ctx$1.pipes.toNode(node, plugin)];
-	return ctx$1.utils.ast;
+	const node = resolver?.(extendedCtx) ?? objectResolver$3(extendedCtx);
+	return {
+		childResults,
+		pipes: [extendedCtx.pipes.toNode(node, plugin)]
+	};
 }
 
 //#endregion
@@ -10173,7 +10138,14 @@ function stringResolver$3(ctx$1) {
 	if (patternNode$4) ctx$1.pipes.push(ctx$1.pipes.current, patternNode$4);
 	return ctx$1.pipes.current;
 }
-function stringToNode$3({ plugin, schema }) {
+function stringToPipes({ plugin, schema }) {
+	if (shouldCoerceToBigInt(schema.format)) return numberToPipes({
+		plugin,
+		schema: {
+			...schema,
+			type: "number"
+		}
+	});
 	const ctx$1 = {
 		$,
 		nodes: {
@@ -10200,215 +10172,361 @@ function stringToNode$3({ plugin, schema }) {
 
 //#endregion
 //#region src/plugins/valibot/v1/toAst/tuple.ts
-function tupleToAst$3(options) {
-	const { plugin, schema } = options;
-	const result = {};
+function tupleToPipes(ctx$1) {
+	const { plugin, schema, walk, walkerCtx } = ctx$1;
 	const v = plugin.external("valibot.v");
+	const childResults = [];
 	if (schema.const && Array.isArray(schema.const)) {
 		const tupleElements = schema.const.map((value) => $(v).attr(identifiers$1.schemas.literal).call($.fromValue(value)));
-		result.pipes = [$(v).attr(identifiers$1.schemas.tuple).call($.array(...tupleElements))];
-		return result;
+		return {
+			childResults: [],
+			pipes: [$(v).attr(identifiers$1.schemas.tuple).call($.array(...tupleElements))]
+		};
 	}
 	if (schema.items) {
-		const tupleElements = schema.items.map((item, index) => {
-			const schemaPipes = irSchemaToAst$3({
-				...options,
-				schema: item,
-				state: {
-					...options.state,
-					path: ref([
-						...fromRef(options.state.path),
-						"items",
-						index
-					])
-				}
-			});
-			if (schemaPipes.hasLazyExpression) result.hasLazyExpression = true;
-			return pipesToNode(schemaPipes.pipes, plugin);
-		});
-		result.pipes = [$(v).attr(identifiers$1.schemas.tuple).call($.array(...tupleElements))];
-		return result;
+		for (let i = 0; i < schema.items.length; i++) {
+			const item = schema.items[i];
+			const result = walk(item, childContext(walkerCtx, "items", i));
+			childResults.push(result);
+		}
+		const tupleElements = childResults.map((r) => pipesToNode(ctx$1.applyModifiers(r).pipes, plugin));
+		return {
+			childResults,
+			pipes: [$(v).attr(identifiers$1.schemas.tuple).call($.array(...tupleElements))]
+		};
 	}
-	return { pipes: [unknownToAst$3({
-		...options,
-		schema: { type: "unknown" }
-	})] };
+	return {
+		childResults: [],
+		pipes: [unknownToPipes({ plugin })]
+	};
 }
 
 //#endregion
 //#region src/plugins/valibot/v1/toAst/undefined.ts
-function undefinedToAst$3({ plugin }) {
+function undefinedToPipes({ plugin }) {
 	return $(plugin.external("valibot.v")).attr(identifiers$1.schemas.undefined).call();
 }
 
 //#endregion
 //#region src/plugins/valibot/v1/toAst/void.ts
-function voidToAst$3({ plugin }) {
+function voidToPipes({ plugin }) {
 	return $(plugin.external("valibot.v")).attr(identifiers$1.schemas.void).call();
 }
 
 //#endregion
-//#region src/plugins/valibot/v1/toAst/index.ts
-function irSchemaWithTypeToAst$3({ schema, ...args }) {
-	switch (schema.type) {
-		case "array": return { expression: pipesToNode(arrayToAst$3({
-			...args,
-			schema
-		}).pipes, args.plugin) };
-		case "boolean": return { expression: booleanToAst$3({
-			...args,
-			schema
-		}) };
-		case "enum": return { expression: enumToAst$3({
-			...args,
-			schema
-		}) };
-		case "integer":
-		case "number": return { expression: numberToNode$3({
-			...args,
-			schema
-		}) };
-		case "never": return { expression: neverToAst$3({
-			...args,
-			schema
-		}) };
-		case "null": return { expression: nullToAst$3({
-			...args,
-			schema
-		}) };
-		case "object": return { expression: pipesToNode(objectToAst$3({
-			...args,
-			schema
-		}).pipes, args.plugin) };
-		case "string": return { expression: shouldCoerceToBigInt(schema.format) ? numberToNode$3({
-			...args,
-			schema: {
-				...schema,
-				type: "number"
-			}
-		}) : stringToNode$3({
-			...args,
-			schema
-		}) };
-		case "tuple": return { expression: pipesToNode(tupleToAst$3({
-			...args,
-			schema
-		}).pipes, args.plugin) };
-		case "undefined": return { expression: undefinedToAst$3({
-			...args,
-			schema
-		}) };
-		case "unknown": return { expression: unknownToAst$3({
-			...args,
-			schema
-		}) };
-		case "void": return { expression: voidToAst$3({
-			...args,
-			schema
-		}) };
-	}
+//#region src/plugins/valibot/v1/walker.ts
+function getDefaultValue(meta) {
+	return meta.format ? maybeBigInt(meta.default, meta.format) : $.fromValue(meta.default);
 }
-
-//#endregion
-//#region src/plugins/valibot/v1/plugin.ts
-function irSchemaToAst$3({ optional, plugin, schema, schemaExtractor, state }) {
-	if (schemaExtractor && !schema.$ref) {
-		const extracted = schemaExtractor({
-			meta: {
-				resource: "definition",
-				resourceId: pathToJsonPointer(fromRef(state.path))
-			},
-			naming: plugin.config.definitions,
-			path: fromRef(state.path),
-			plugin,
-			schema
-		});
-		if (extracted !== schema) schema = extracted;
-	}
-	const ast = { pipes: [] };
-	const v = plugin.external("valibot.v");
-	if (schema.$ref) {
-		const query = {
-			category: "schema",
-			resource: "definition",
-			resourceId: schema.$ref,
-			tool: "valibot"
-		};
-		const refSymbol = plugin.referenceSymbol(query);
-		if (plugin.isSymbolRegistered(query)) {
-			const ref$1 = $(refSymbol);
-			ast.pipes.push(ref$1);
-		} else {
-			const lazyExpression = $(v).attr(identifiers$1.schemas.lazy).call($.func().do($(refSymbol).return()));
-			ast.pipes.push(lazyExpression);
-			state.hasLazyExpression["~ref"] = true;
-		}
-	} else if (schema.type) {
-		const typeAst = irSchemaWithTypeToAst$3({
-			plugin,
-			schema,
-			schemaExtractor,
-			state
-		});
-		ast.typeName = typeAst.anyType;
-		ast.pipes.push(typeAst.expression);
-		if (plugin.config.metadata && schema.description) {
-			const expression = $(v).attr(identifiers$1.actions.metadata).call($.object().prop("description", $.literal(schema.description)));
-			ast.pipes.push(expression);
-		}
-	} else if (schema.items) {
-		schema = deduplicateSchema({ schema });
-		if (schema.items) {
-			const itemsAst = schema.items.map((item, index) => {
-				return pipesToNode(irSchemaToAst$3({
-					plugin,
-					schema: item,
-					schemaExtractor,
-					state: {
-						...state,
-						path: ref([
-							...fromRef(state.path),
-							"items",
-							index
-						])
-					}
-				}).pipes, plugin);
+function createVisitor$3(config) {
+	const { schemaExtractor } = config;
+	return {
+		applyModifiers(result, ctx$1, options = {}) {
+			const { optional } = options;
+			const v = ctx$1.plugin.external("valibot.v");
+			const pipes$1 = [...result.pipes];
+			if (result.meta.readonly) pipes$1.push($(v).attr(identifiers$1.actions.readonly).call());
+			const hasDefault = result.meta.default !== void 0;
+			const needsOptional = optional || hasDefault;
+			const needsNullable = result.meta.nullable;
+			const innerNode = pipesToNode(pipes$1, ctx$1.plugin);
+			let finalPipes;
+			if (needsOptional && needsNullable) if (hasDefault) finalPipes = [$(v).attr(identifiers$1.schemas.nullish).call(innerNode, getDefaultValue(result.meta))];
+			else finalPipes = [$(v).attr(identifiers$1.schemas.nullish).call(innerNode)];
+			else if (needsOptional) if (hasDefault) finalPipes = [$(v).attr(identifiers$1.schemas.optional).call(innerNode, getDefaultValue(result.meta))];
+			else finalPipes = [$(v).attr(identifiers$1.schemas.optional).call(innerNode)];
+			else if (needsNullable) finalPipes = [$(v).attr(identifiers$1.schemas.nullable).call(innerNode)];
+			else finalPipes = pipes$1;
+			return {
+				pipes: finalPipes,
+				typeName: result.meta.hasLazy ? identifiers$1.types.GenericSchema : void 0
+			};
+		},
+		array(schema, ctx$1, walk) {
+			const applyModifiers = (result, opts) => this.applyModifiers(result, ctx$1, opts);
+			const { childResults, pipes: pipes$1 } = arrayToPipes({
+				applyModifiers,
+				plugin: ctx$1.plugin,
+				schema,
+				walk,
+				walkerCtx: ctx$1
+			});
+			return {
+				meta: inheritMeta(schema, childResults),
+				pipes: pipes$1
+			};
+		},
+		boolean(schema, ctx$1) {
+			const pipe = booleanToPipes({
+				plugin: ctx$1.plugin,
+				schema
+			});
+			return {
+				meta: defaultMeta(schema),
+				pipes: [pipe]
+			};
+		},
+		enum(schema, ctx$1) {
+			const { isNullable, pipe } = enumToPipes({
+				plugin: ctx$1.plugin,
+				schema
+			});
+			return {
+				meta: {
+					...defaultMeta(schema),
+					nullable: isNullable
+				},
+				pipes: [pipe]
+			};
+		},
+		integer(schema, ctx$1) {
+			const pipe = numberToPipes({
+				plugin: ctx$1.plugin,
+				schema
 			});
-			if (schema.logicalOperator === "and") {
-				const intersectExpression = $(v).attr(identifiers$1.schemas.intersect).call($.array(...itemsAst));
-				ast.pipes.push(intersectExpression);
-			} else {
-				const unionExpression = $(v).attr(identifiers$1.schemas.union).call($.array(...itemsAst));
-				ast.pipes.push(unionExpression);
+			return {
+				meta: defaultMeta(schema),
+				pipes: [pipe]
+			};
+		},
+		intercept(schema, ctx$1, walk) {
+			if (schemaExtractor && !schema.$ref) {
+				const extracted = schemaExtractor({
+					meta: {
+						resource: "definition",
+						resourceId: pathToJsonPointer(fromRef(ctx$1.path))
+					},
+					naming: ctx$1.plugin.config.definitions,
+					path: fromRef(ctx$1.path),
+					plugin: ctx$1.plugin,
+					schema
+				});
+				if (extracted !== schema) return walk(extracted, ctx$1);
 			}
-		} else {
-			const schemaPipes = irSchemaToAst$3({
-				plugin,
+		},
+		intersection(items, schemas, parentSchema, ctx$1) {
+			const v = ctx$1.plugin.external("valibot.v");
+			const itemNodes = items.map((item) => pipesToNode(item.pipes, ctx$1.plugin));
+			return {
+				meta: composeMeta(items, { default: parentSchema.default }),
+				pipes: [$(v).attr(identifiers$1.schemas.intersect).call($.array(...itemNodes))]
+			};
+		},
+		never(schema, ctx$1) {
+			const pipe = neverToPipes({
+				plugin: ctx$1.plugin,
+				schema
+			});
+			return {
+				meta: {
+					...defaultMeta(schema),
+					nullable: false,
+					readonly: false
+				},
+				pipes: [pipe]
+			};
+		},
+		null(schema, ctx$1) {
+			const pipe = nullToPipes({
+				plugin: ctx$1.plugin,
+				schema
+			});
+			return {
+				meta: {
+					...defaultMeta(schema),
+					nullable: false,
+					readonly: false
+				},
+				pipes: [pipe]
+			};
+		},
+		number(schema, ctx$1) {
+			const pipe = numberToPipes({
+				plugin: ctx$1.plugin,
+				schema
+			});
+			return {
+				meta: defaultMeta(schema),
+				pipes: [pipe]
+			};
+		},
+		object(schema, ctx$1, walk) {
+			const applyModifiers = (result, opts) => this.applyModifiers(result, ctx$1, opts);
+			const { childResults, pipes: pipes$1 } = objectToPipes({
+				applyModifiers,
+				plugin: ctx$1.plugin,
 				schema,
-				state
+				walk,
+				walkerCtx: ctx$1
+			});
+			return {
+				meta: inheritMeta(schema, childResults),
+				pipes: pipes$1
+			};
+		},
+		postProcess(result, schema, ctx$1) {
+			if (ctx$1.plugin.config.metadata && schema.description) {
+				const metadataExpr = $(ctx$1.plugin.external("valibot.v")).attr(identifiers$1.actions.metadata).call($.object().prop("description", $.literal(schema.description)));
+				return {
+					meta: result.meta,
+					pipes: [...result.pipes, metadataExpr]
+				};
+			}
+			return result;
+		},
+		reference($ref, schema, ctx$1) {
+			const v = ctx$1.plugin.external("valibot.v");
+			const query = {
+				category: "schema",
+				resource: "definition",
+				resourceId: $ref,
+				tool: "valibot"
+			};
+			const refSymbol = ctx$1.plugin.referenceSymbol(query);
+			if (ctx$1.plugin.isSymbolRegistered(query)) return {
+				meta: defaultMeta(schema),
+				pipes: [$(refSymbol)]
+			};
+			return {
+				meta: {
+					...defaultMeta(schema),
+					hasLazy: true
+				},
+				pipes: [$(v).attr(identifiers$1.schemas.lazy).call($.func().do($(refSymbol).return()))]
+			};
+		},
+		string(schema, ctx$1) {
+			const pipe = stringToPipes({
+				plugin: ctx$1.plugin,
+				schema
+			});
+			return {
+				meta: defaultMeta(schema),
+				pipes: [pipe]
+			};
+		},
+		tuple(schema, ctx$1, walk) {
+			const applyModifiers = (result, opts) => this.applyModifiers(result, ctx$1, opts);
+			const { childResults, pipes: pipes$1 } = tupleToPipes({
+				applyModifiers,
+				plugin: ctx$1.plugin,
+				schema,
+				walk,
+				walkerCtx: ctx$1
+			});
+			return {
+				meta: inheritMeta(schema, childResults),
+				pipes: pipes$1
+			};
+		},
+		undefined(schema, ctx$1) {
+			const pipe = undefinedToPipes({
+				plugin: ctx$1.plugin,
+				schema
+			});
+			return {
+				meta: {
+					...defaultMeta(schema),
+					nullable: false,
+					readonly: false
+				},
+				pipes: [pipe]
+			};
+		},
+		union(items, schemas, parentSchema, ctx$1) {
+			const v = ctx$1.plugin.external("valibot.v");
+			const hasNull = schemas.some((s) => s.type === "null") || items.some((i) => i.meta.nullable);
+			const nonNullItems = [];
+			items.forEach((item, index) => {
+				if (schemas[index].type !== "null") nonNullItems.push(item);
+			});
+			let pipes$1;
+			if (nonNullItems.length === 0) pipes$1 = [$(v).attr(identifiers$1.schemas.null).call()];
+			else if (nonNullItems.length === 1) pipes$1 = nonNullItems[0].pipes;
+			else {
+				const itemNodes = nonNullItems.map((i) => pipesToNode(i.pipes, ctx$1.plugin));
+				pipes$1 = [$(v).attr(identifiers$1.schemas.union).call($.array(...itemNodes))];
+			}
+			return {
+				meta: composeMeta(items, {
+					default: parentSchema.default,
+					nullable: hasNull
+				}),
+				pipes: pipes$1
+			};
+		},
+		unknown(schema, ctx$1) {
+			const pipe = unknownToPipes({ plugin: ctx$1.plugin });
+			return {
+				meta: {
+					...defaultMeta(schema),
+					nullable: false,
+					readonly: false
+				},
+				pipes: [pipe]
+			};
+		},
+		void(schema, ctx$1) {
+			const pipe = voidToPipes({
+				plugin: ctx$1.plugin,
+				schema
 			});
-			ast.pipes.push(...schemaPipes.pipes);
+			return {
+				meta: {
+					...defaultMeta(schema),
+					nullable: false,
+					readonly: false
+				},
+				pipes: [pipe]
+			};
 		}
-	} else {
-		const typeAst = irSchemaWithTypeToAst$3({
-			plugin,
-			schema: { type: "unknown" },
-			schemaExtractor,
-			state
-		});
-		ast.typeName = typeAst.anyType;
-		ast.pipes.push(typeAst.expression);
-	}
-	if (ast.pipes.length) {
-		if (schema.accessScope === "read") {
-			const readonlyExpression = $(v).attr(identifiers$1.actions.readonly).call();
-			ast.pipes.push(readonlyExpression);
+	};
+}
+
+//#endregion
+//#region src/plugins/valibot/v1/processor.ts
+function createProcessor$3(plugin) {
+	const processor = createSchemaProcessor();
+	const hooks = [plugin.config["~hooks"]?.schemas, plugin.context.config.parser.hooks.schemas];
+	function extractor(ctx$1) {
+		if (processor.hasEmitted(ctx$1.path)) return ctx$1.schema;
+		for (const hook of hooks) if (hook?.shouldExtract?.(ctx$1)) {
+			process$1({
+				namingAnchor: processor.context.anchor,
+				tags: processor.context.tags,
+				...ctx$1
+			});
+			return { $ref: pathToJsonPointer(ctx$1.path) };
 		}
-		if (schema.default !== void 0) ast.pipes = [$(v).attr(identifiers$1.schemas.optional).call(pipesToNode(ast.pipes, plugin), schema.type === "integer" || schema.type === "number" ? maybeBigInt(schema.default, schema.format) : $.fromValue(schema.default))];
-		else if (optional) ast.pipes = [$(v).attr(identifiers$1.schemas.optional).call(pipesToNode(ast.pipes, plugin))];
+		return ctx$1.schema;
 	}
-	return ast;
+	function process$1(ctx$1) {
+		if (!processor.markEmitted(ctx$1.path)) return;
+		processor.withContext({
+			anchor: ctx$1.namingAnchor,
+			tags: ctx$1.tags
+		}, () => {
+			const visitor = createVisitor$3({ schemaExtractor: extractor });
+			const result = createSchemaWalker(visitor)(ctx$1.schema, {
+				path: ref(ctx$1.path),
+				plugin
+			});
+			const final = visitor.applyModifiers(result, {
+				path: ref(ctx$1.path),
+				plugin
+			});
+			exportAst$1({
+				...ctx$1,
+				final,
+				plugin
+			});
+		});
+	}
+	return { process: process$1 };
 }
+
+//#endregion
+//#region src/plugins/valibot/v1/plugin.ts
 const handlerV1 = ({ plugin }) => {
 	plugin.symbol("v", {
 		external: "valibot",
@@ -10546,8 +10664,10 @@ const defineConfig$1 = definePluginConfig(defaultConfig$1);
 //#endregion
 //#region src/plugins/zod/constants.ts
 const identifiers = {
+	AnyZodObject: "AnyZodObject",
 	ZodMiniOptional: "ZodMiniOptional",
 	ZodOptional: "ZodOptional",
+	ZodTypeAny: "ZodTypeAny",
 	_default: "_default",
 	and: "and",
 	array: "array",
@@ -10585,6 +10705,7 @@ const identifiers = {
 	never: "never",
 	null: "null",
 	nullable: "nullable",
+	nullish: "nullish",
 	number: "number",
 	object: "object",
 	optional: "optional",
@@ -10945,7 +11066,7 @@ function irWebhookToAst({ operation, path: path$1, plugin, processor, tags }) {
 
 //#endregion
 //#region src/plugins/zod/shared/export.ts
-function exportAst({ ast, meta, naming, namingAnchor, path: path$1, plugin, schema, tags }) {
+function exportAst({ ast, meta, naming, namingAnchor, path: path$1, plugin, schema, state, tags }) {
 	const z = plugin.external("zod.z");
 	const name = pathToName(path$1, { anchor: namingAnchor });
 	const symbol = plugin.symbol(applyNaming(name, naming), { meta: {
@@ -10963,7 +11084,7 @@ function exportAst({ ast, meta, naming, namingAnchor, path: path$1, plugin, sche
 		variant: "infer",
 		...meta
 	} }) : void 0;
-	const statement = $.const(symbol).export().$if(plugin.config.comments && createSchemaComment(schema), (c, v) => c.doc(v)).$if(ast.typeName, (c, v) => c.type($.type(z).attr(v))).assign(ast.expression);
+	const statement = $.const(symbol).export().$if(plugin.config.comments && createSchemaComment(schema), (c, v) => c.doc(v)).$if(state.hasLazyExpression["~ref"] && state.anyType?.["~ref"], (c, v) => c.type($.type(z).attr(v))).assign(ast.expression);
 	plugin.node(statement);
 	if (typeInferSymbol) {
 		const inferType = $.type.alias(typeInferSymbol).export().type($.type(z).attr(identifiers.infer).generic($(symbol).typeofType()));
@@ -10971,88 +11092,36 @@ function exportAst({ ast, meta, naming, namingAnchor, path: path$1, plugin, sche
 	}
 }
 
-//#endregion
-//#region src/plugins/zod/mini/processor.ts
-function createProcessor$2(plugin) {
-	const processor = createSchemaProcessor();
-	const hooks = [plugin.config["~hooks"]?.schemas, plugin.context.config.parser.hooks.schemas];
-	function extractor(ctx$1) {
-		if (processor.hasEmitted(ctx$1.path)) return ctx$1.schema;
-		for (const hook of hooks) if (hook?.shouldExtract?.(ctx$1)) {
-			process$1({
-				namingAnchor: processor.context.anchor,
-				tags: processor.context.tags,
-				...ctx$1
-			});
-			return { $ref: pathToJsonPointer(ctx$1.path) };
-		}
-		return ctx$1.schema;
-	}
-	function process$1(ctx$1) {
-		if (!processor.markEmitted(ctx$1.path)) return;
-		processor.withContext({
-			anchor: ctx$1.namingAnchor,
-			tags: ctx$1.tags
-		}, () => {
-			const state = refs({
-				hasLazyExpression: false,
-				path: ctx$1.path,
-				tags: ctx$1.tags
-			});
-			const ast = irSchemaToAst$2({
-				plugin,
-				schema: ctx$1.schema,
-				schemaExtractor: extractor,
-				state
-			});
-			exportAst({
-				...ctx$1,
-				ast,
-				plugin,
-				state
-			});
-		});
-	}
-	return { process: process$1 };
-}
-
 //#endregion
 //#region src/plugins/zod/mini/toAst/unknown.ts
-const unknownToAst$2 = ({ plugin }) => {
+function unknownToAst$2({ plugin }) {
 	const z = plugin.external("zod.z");
 	const result = {};
 	result.expression = $(z).attr(identifiers.unknown).call();
 	return result;
-};
+}
 
 //#endregion
 //#region src/plugins/zod/mini/toAst/array.ts
-const arrayToAst$2 = ({ plugin, schema, state }) => {
-	const z = plugin.external("zod.z");
+function arrayToAst$2(options) {
+	const { applyModifiers, plugin, walk } = options;
+	let { schema } = options;
 	const result = {};
+	const z = plugin.external("zod.z");
 	const functionName = $(z).attr(identifiers.array);
 	if (!schema.items) result.expression = functionName.call(unknownToAst$2({
-		plugin,
-		schema: { type: "unknown" },
-		state
+		...options,
+		schema: { type: "unknown" }
 	}).expression);
 	else {
 		schema = deduplicateSchema({ schema });
 		const itemExpressions = schema.items.map((item, index) => {
-			const itemAst = irSchemaToAst$2({
-				plugin,
-				schema: item,
-				state: {
-					...state,
-					path: ref([
-						...fromRef(state.path),
-						"items",
-						index
-					])
-				}
-			});
-			if (itemAst.hasLazyExpression) result.hasLazyExpression = true;
-			return itemAst.expression;
+			const itemResult = walk(item, childContext({
+				path: options.state.path,
+				plugin: options.plugin
+			}, "items", index));
+			if (itemResult.hasLazyExpression) result.hasLazyExpression = true;
+			return applyModifiers(itemResult, { optional: false }).expression;
 		});
 		if (itemExpressions.length === 1) result.expression = functionName.call(...itemExpressions);
 		else if (schema.logicalOperator === "and") {
@@ -11074,7 +11143,7 @@ const arrayToAst$2 = ({ plugin, schema, state }) => {
 	}
 	if (checks.length > 0) result.expression = result.expression.attr(identifiers.check).call(...checks);
 	return result;
-};
+}
 
 //#endregion
 //#region src/plugins/zod/mini/toAst/boolean.ts
@@ -11129,31 +11198,21 @@ function baseNode$11(ctx$1) {
 	else if (literalMembers.length === 1) return literalMembers[0];
 	else return $(z).attr(identifiers.union).call($.array(...literalMembers));
 }
-function nullableNode$2(ctx$1) {
-	const { chain, symbols } = ctx$1;
-	const { z } = symbols;
-	const { isNullable } = ctx$1.nodes.items(ctx$1);
-	if (!isNullable) return;
-	return $(z).attr(identifiers.nullable).call(chain.current);
-}
 function enumResolver$2(ctx$1) {
 	const { literalMembers } = ctx$1.nodes.items(ctx$1);
 	if (!literalMembers.length) return ctx$1.chain.current;
 	const baseExpression = ctx$1.nodes.base(ctx$1);
 	ctx$1.chain.current = baseExpression;
-	const nullableExpression = ctx$1.nodes.nullable(ctx$1);
-	if (nullableExpression) ctx$1.chain.current = nullableExpression;
 	return ctx$1.chain.current;
 }
-const enumToAst$2 = ({ plugin, schema, state }) => {
+function enumToAst$2({ plugin, schema, state }) {
 	const z = plugin.external("zod.z");
 	const { literalMembers } = itemsNode$2({
 		$,
 		chain: { current: $(z) },
 		nodes: {
 			base: baseNode$11,
-			items: itemsNode$2,
-			nullable: nullableNode$2
+			items: itemsNode$2
 		},
 		plugin,
 		schema,
@@ -11165,16 +11224,14 @@ const enumToAst$2 = ({ plugin, schema, state }) => {
 	});
 	if (!literalMembers.length) return unknownToAst$2({
 		plugin,
-		schema: { type: "unknown" },
-		state
+		schema: { type: "unknown" }
 	});
 	const ctx$1 = {
 		$,
 		chain: { current: $(z) },
 		nodes: {
 			base: baseNode$11,
-			items: itemsNode$2,
-			nullable: nullableNode$2
+			items: itemsNode$2
 		},
 		plugin,
 		schema,
@@ -11186,25 +11243,25 @@ const enumToAst$2 = ({ plugin, schema, state }) => {
 	};
 	const resolver = plugin.config["~resolvers"]?.enum;
 	return { expression: resolver?.(ctx$1) ?? enumResolver$2(ctx$1) };
-};
+}
 
 //#endregion
 //#region src/plugins/zod/mini/toAst/never.ts
-const neverToAst$2 = ({ plugin }) => {
+function neverToAst$2({ plugin }) {
 	const z = plugin.external("zod.z");
 	const result = {};
 	result.expression = $(z).attr(identifiers.never).call();
 	return result;
-};
+}
 
 //#endregion
 //#region src/plugins/zod/mini/toAst/null.ts
-const nullToAst$2 = ({ plugin }) => {
+function nullToAst$2({ plugin }) {
 	const z = plugin.external("zod.z");
 	const result = {};
 	result.expression = $(z).attr(identifiers.null).call();
 	return result;
-};
+}
 
 //#endregion
 //#region src/plugins/zod/mini/toAst/number.ts
@@ -11254,7 +11311,7 @@ function numberResolver$2(ctx$1) {
 	if (checks.length > 0) ctx$1.chain.current = ctx$1.chain.current.attr(identifiers.check).call(...checks);
 	return ctx$1.chain.current;
 }
-const numberToNode$2 = ({ plugin, schema, state }) => {
+function numberToNode$2({ plugin, schema, state }) {
 	const ast = {};
 	const z = plugin.external("zod.z");
 	const ctx$1 = {
@@ -11280,23 +11337,16 @@ const numberToNode$2 = ({ plugin, schema, state }) => {
 	const resolver = plugin.config["~resolvers"]?.number;
 	ast.expression = resolver?.(ctx$1) ?? numberResolver$2(ctx$1);
 	return ast;
-};
+}
 
 //#endregion
 //#region src/plugins/zod/mini/toAst/object.ts
 function additionalPropertiesNode$2(ctx$1) {
-	const { plugin, schema } = ctx$1;
+	const { schema, walk, walkerCtx } = ctx$1;
 	if (!schema.additionalProperties || schema.properties && Object.keys(schema.properties).length > 0) return;
-	const additionalAst = irSchemaToAst$2({
-		plugin,
-		schema: schema.additionalProperties,
-		state: {
-			...ctx$1.utils.state,
-			path: ref([...fromRef(ctx$1.utils.state.path), "additionalProperties"])
-		}
-	});
-	if (additionalAst.hasLazyExpression) ctx$1.utils.ast.hasLazyExpression = true;
-	return additionalAst.expression;
+	const additionalResult = walk(schema.additionalProperties, childContext(walkerCtx, "additionalProperties"));
+	if (additionalResult.hasLazyExpression) ctx$1.utils.ast.hasLazyExpression = true;
+	return additionalResult.expression.expression;
 }
 function baseNode$9(ctx$1) {
 	const { nodes, symbols } = ctx$1;
@@ -11310,34 +11360,27 @@ function objectResolver$2(ctx$1) {
 	return ctx$1.nodes.base(ctx$1);
 }
 function shapeNode$2(ctx$1) {
-	const { plugin, schema } = ctx$1;
+	const { applyModifiers, schema, walk, walkerCtx } = ctx$1;
 	const shape = $.object().pretty();
 	for (const name in schema.properties) {
 		const property = schema.properties[name];
-		const propertyAst = irSchemaToAst$2({
-			optional: !schema.required?.includes(name),
-			plugin,
-			schema: property,
-			state: {
-				...ctx$1.utils.state,
-				path: ref([
-					...fromRef(ctx$1.utils.state.path),
-					"properties",
-					name
-				])
-			}
-		});
-		if (propertyAst.hasLazyExpression) {
+		const isOptional = !schema.required?.includes(name);
+		const propertyResult = walk(property, childContext(walkerCtx, "properties", name));
+		if (propertyResult.hasLazyExpression) ctx$1.utils.ast.hasLazyExpression = true;
+		const ast = applyModifiers(propertyResult, { optional: isOptional });
+		if (ast.hasLazyExpression) {
 			ctx$1.utils.ast.hasLazyExpression = true;
-			shape.getter(name, propertyAst.expression.return());
-		} else shape.prop(name, propertyAst.expression);
+			shape.getter(name, ast.expression.return());
+		} else shape.prop(name, ast.expression);
 	}
 	return shape;
 }
-const objectToAst$2 = ({ plugin, schema, state }) => {
+function objectToAst$2(options) {
+	const { plugin } = options;
 	const ast = {};
 	const z = plugin.external("zod.z");
 	const ctx$1 = {
+		...options,
 		$,
 		chain: { current: $(z) },
 		nodes: {
@@ -11346,17 +11389,16 @@ const objectToAst$2 = ({ plugin, schema, state }) => {
 			shape: shapeNode$2
 		},
 		plugin,
-		schema,
 		symbols: { z },
 		utils: {
 			ast,
-			state
+			state: options.state
 		}
 	};
 	const resolver = plugin.config["~resolvers"]?.object;
 	ast.expression = resolver?.(ctx$1) ?? objectResolver$2(ctx$1);
 	return ast;
-};
+}
 
 //#endregion
 //#region src/plugins/zod/mini/toAst/string.ts
@@ -11435,7 +11477,7 @@ function stringResolver$2(ctx$1) {
 	if (checks.length > 0) ctx$1.chain.current = ctx$1.chain.current.attr(identifiers.check).call(...checks);
 	return ctx$1.chain.current;
 }
-const stringToNode$2 = ({ plugin, schema }) => {
+function stringToNode$2({ plugin, schema }) {
 	const z = plugin.external("zod.z");
 	const ctx$1 = {
 		$,
@@ -11455,13 +11497,14 @@ const stringToNode$2 = ({ plugin, schema }) => {
 	};
 	const resolver = plugin.config["~resolvers"]?.string;
 	return { expression: resolver?.(ctx$1) ?? stringResolver$2(ctx$1) };
-};
+}
 
 //#endregion
 //#region src/plugins/zod/mini/toAst/tuple.ts
-const tupleToAst$2 = ({ plugin, schema, state }) => {
-	const z = plugin.external("zod.z");
+function tupleToAst$2(options) {
+	const { applyModifiers, plugin, schema, walk } = options;
 	const result = {};
+	const z = plugin.external("zod.z");
 	if (schema.const && Array.isArray(schema.const)) {
 		const tupleElements$1 = schema.const.map((value) => $(z).attr(identifiers.literal).call($.fromValue(value)));
 		result.expression = $(z).attr(identifiers.tuple).call($.array(...tupleElements$1));
@@ -11469,347 +11512,490 @@ const tupleToAst$2 = ({ plugin, schema, state }) => {
 	}
 	const tupleElements = [];
 	if (schema.items) schema.items.forEach((item, index) => {
-		const itemSchema = irSchemaToAst$2({
-			plugin,
-			schema: item,
-			state: {
-				...state,
-				path: ref([
-					...fromRef(state.path),
-					"items",
-					index
-				])
-			}
-		});
-		tupleElements.push(itemSchema.expression);
-		if (itemSchema.hasLazyExpression) result.hasLazyExpression = true;
+		const itemResult = walk(item, childContext({
+			path: options.state.path,
+			plugin: options.plugin
+		}, "items", index));
+		if (itemResult.hasLazyExpression) result.hasLazyExpression = true;
+		const finalExpr = applyModifiers(itemResult, { optional: false });
+		tupleElements.push(finalExpr.expression);
 	});
 	result.expression = $(z).attr(identifiers.tuple).call($.array(...tupleElements));
 	return result;
-};
+}
 
 //#endregion
 //#region src/plugins/zod/mini/toAst/undefined.ts
-const undefinedToAst$2 = ({ plugin }) => {
+function undefinedToAst$2({ plugin }) {
 	const z = plugin.external("zod.z");
 	const result = {};
 	result.expression = $(z).attr(identifiers.undefined).call();
 	return result;
-};
+}
 
 //#endregion
 //#region src/plugins/zod/mini/toAst/void.ts
-const voidToAst$2 = ({ plugin }) => {
+function voidToAst$2({ plugin }) {
 	const z = plugin.external("zod.z");
 	const result = {};
 	result.expression = $(z).attr(identifiers.void).call();
 	return result;
-};
-
-//#endregion
-//#region src/plugins/zod/mini/toAst/index.ts
-function irSchemaWithTypeToAst$2({ schema, ...args }) {
-	switch (schema.type) {
-		case "array": return arrayToAst$2({
-			...args,
-			schema
-		});
-		case "boolean": return booleanToAst$2({
-			...args,
-			schema
-		});
-		case "enum": return enumToAst$2({
-			...args,
-			schema
-		});
-		case "integer":
-		case "number": return numberToNode$2({
-			...args,
-			schema
-		});
-		case "never": return neverToAst$2({
-			...args,
-			schema
-		});
-		case "null": return nullToAst$2({
-			...args,
-			schema
-		});
-		case "object": return objectToAst$2({
-			...args,
-			schema
-		});
-		case "string": return shouldCoerceToBigInt(schema.format) ? numberToNode$2({
-			...args,
-			schema: {
-				...schema,
-				type: "number"
-			}
-		}) : stringToNode$2({
-			...args,
-			schema
-		});
-		case "tuple": return tupleToAst$2({
-			...args,
-			schema
-		});
-		case "undefined": return undefinedToAst$2({
-			...args,
-			schema
-		});
-		case "unknown": return unknownToAst$2({
-			...args,
-			schema
-		});
-		case "void": return voidToAst$2({
-			...args,
-			schema
-		});
-	}
-}
-
-//#endregion
-//#region src/plugins/zod/mini/plugin.ts
-function irSchemaToAst$2({ optional, plugin, schema, schemaExtractor, state }) {
-	if (schemaExtractor && !schema.$ref) {
-		const extracted = schemaExtractor({
-			meta: {
-				resource: "definition",
-				resourceId: pathToJsonPointer(fromRef(state.path))
-			},
-			naming: plugin.config.definitions,
-			path: fromRef(state.path),
-			plugin,
-			schema
-		});
-		if (extracted !== schema) schema = extracted;
-	}
-	let ast = {};
-	const z = plugin.external("zod.z");
-	if (schema.$ref) {
-		const query = {
-			category: "schema",
-			resource: "definition",
-			resourceId: schema.$ref,
-			tool: "zod"
-		};
-		const refSymbol = plugin.referenceSymbol(query);
-		if (plugin.isSymbolRegistered(query)) ast.expression = $(refSymbol);
-		else {
-			ast.expression = $(z).attr(identifiers.lazy).call($.func().returns("any").do($(refSymbol).return()));
-			ast.hasLazyExpression = true;
-			state.hasLazyExpression["~ref"] = true;
-		}
-	} else if (schema.type) {
-		const typeAst = irSchemaWithTypeToAst$2({
-			plugin,
-			schema,
-			state
-		});
-		ast.expression = typeAst.expression;
-		ast.hasLazyExpression = typeAst.hasLazyExpression;
-		if (plugin.config.metadata && schema.description) ast.expression = ast.expression.attr(identifiers.register).call($(z).attr(identifiers.globalRegistry), $.object().pretty().prop("description", $.literal(schema.description)));
-	} else if (schema.items) {
-		schema = deduplicateSchema({ schema });
-		if (schema.items) {
-			const itemSchemas = schema.items.map((item, index) => irSchemaToAst$2({
-				plugin,
-				schema: item,
-				state: {
-					...state,
-					path: ref([
-						...fromRef(state.path),
-						"items",
-						index
-					])
-				}
-			}));
-			if (schema.logicalOperator === "and") {
-				const firstSchema = schema.items[0];
-				if (firstSchema.logicalOperator === "or" || firstSchema.type && firstSchema.type !== "object") ast.expression = $(z).attr(identifiers.intersection).call(...itemSchemas.map((schema$1) => schema$1.expression));
-				else {
-					ast.expression = itemSchemas[0].expression;
-					itemSchemas.slice(1).forEach((schema$1) => {
-						ast.expression = $(z).attr(identifiers.intersection).call(ast.expression, schema$1.hasLazyExpression ? $(z).attr(identifiers.lazy).call($.func().do(schema$1.expression.return())) : schema$1.expression);
-					});
-				}
-			} else ast.expression = $(z).attr(identifiers.union).call($.array().pretty().elements(...itemSchemas.map((schema$1) => schema$1.expression)));
-		} else ast = irSchemaToAst$2({
-			plugin,
-			schema,
-			state
-		});
-	} else {
-		const typeAst = irSchemaWithTypeToAst$2({
-			plugin,
-			schema: { type: "unknown" },
-			state
-		});
-		ast.expression = typeAst.expression;
-	}
-	if (ast.expression) {
-		if (schema.accessScope === "read") ast.expression = $(z).attr(identifiers.readonly).call(ast.expression);
-		if (optional) {
-			ast.expression = $(z).attr(identifiers.optional).call(ast.expression);
-			ast.typeName = identifiers.ZodMiniOptional;
-		}
-		if (schema.default !== void 0) ast.expression = $(z).attr(identifiers._default).call(ast.expression, schema.type === "integer" || schema.type === "number" ? maybeBigInt(schema.default, schema.format) : $.fromValue(schema.default));
-	}
-	return ast;
 }
-const handlerMini = ({ plugin }) => {
-	plugin.symbol("z", {
-		external: getZodModule({ plugin }),
-		importKind: "namespace",
-		meta: {
-			category: "external",
-			resource: "zod.z"
-		}
-	});
-	const processor = createProcessor$2(plugin);
-	plugin.forEach("operation", "parameter", "requestBody", "schema", "webhook", (event) => {
-		switch (event.type) {
-			case "operation":
-				irOperationToAst({
-					operation: event.operation,
-					path: event._path,
-					plugin,
-					processor,
-					tags: event.tags
-				});
-				break;
-			case "parameter":
-				processor.process({
-					meta: {
-						resource: "definition",
-						resourceId: pathToJsonPointer(event._path)
-					},
-					naming: plugin.config.definitions,
-					path: event._path,
-					plugin,
-					schema: event.parameter.schema,
-					tags: event.tags
-				});
-				break;
-			case "requestBody":
-				processor.process({
-					meta: {
-						resource: "definition",
-						resourceId: pathToJsonPointer(event._path)
-					},
-					naming: plugin.config.definitions,
-					path: event._path,
-					plugin,
-					schema: event.requestBody.schema,
-					tags: event.tags
-				});
-				break;
-			case "schema":
-				processor.process({
-					meta: {
-						resource: "definition",
-						resourceId: pathToJsonPointer(event._path)
-					},
-					naming: plugin.config.definitions,
-					path: event._path,
-					plugin,
-					schema: event.schema,
-					tags: event.tags
-				});
-				break;
-			case "webhook":
-				irWebhookToAst({
-					operation: event.operation,
-					path: event._path,
-					plugin,
-					processor,
-					tags: event.tags
-				});
-				break;
-		}
-	});
-};
 
 //#endregion
-//#region src/plugins/zod/v3/processor.ts
-function createProcessor$1(plugin) {
-	const processor = createSchemaProcessor();
-	const hooks = [plugin.config["~hooks"]?.schemas, plugin.context.config.parser.hooks.schemas];
-	function extractor(ctx$1) {
-		if (processor.hasEmitted(ctx$1.path)) return ctx$1.schema;
-		for (const hook of hooks) if (hook?.shouldExtract?.(ctx$1)) {
-			process$1({
-				namingAnchor: processor.context.anchor,
-				tags: processor.context.tags,
-				...ctx$1
+//#region src/plugins/zod/mini/walker.ts
+function createVisitor$2(config) {
+	const { schemaExtractor, state } = config;
+	return {
+		applyModifiers(result, ctx$1, options = {}) {
+			const { optional } = options;
+			const z = ctx$1.plugin.external("zod.z");
+			let expression = result.expression.expression;
+			if (result.readonly) expression = $(z).attr(identifiers.readonly).call(expression);
+			const hasDefault = result.default !== void 0;
+			const needsNullable = result.nullable;
+			if (optional && needsNullable) expression = $(z).attr(identifiers.nullish).call(expression);
+			else if (optional) expression = $(z).attr(identifiers.optional).call(expression);
+			else if (needsNullable) expression = $(z).attr(identifiers.nullable).call(expression);
+			if (hasDefault) expression = $(z).attr(identifiers._default).call(expression, result.format ? maybeBigInt(result.default, result.format) : $.fromValue(result.default));
+			return { expression };
+		},
+		array(schema, ctx$1, walk) {
+			const applyModifiers = (result, opts) => this.applyModifiers(result, ctx$1, opts);
+			const ast = arrayToAst$2({
+				...ctx$1,
+				applyModifiers,
+				schema,
+				state,
+				walk
 			});
-			return { $ref: pathToJsonPointer(ctx$1.path) };
-		}
-		return ctx$1.schema;
-	}
-	function process$1(ctx$1) {
-		if (!processor.markEmitted(ctx$1.path)) return;
-		processor.withContext({
-			anchor: ctx$1.namingAnchor,
-			tags: ctx$1.tags
-		}, () => {
-			const state = refs({
-				hasLazyExpression: false,
-				path: ctx$1.path,
-				tags: ctx$1.tags
+			return {
+				default: schema.default,
+				expression: ast,
+				hasLazyExpression: state.hasLazyExpression["~ref"],
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		boolean(schema, ctx$1) {
+			const ast = booleanToAst$2({
+				...ctx$1,
+				schema
 			});
-			const ast = irSchemaToAst$1({
-				plugin,
-				schema: ctx$1.schema,
-				schemaExtractor: extractor,
+			return {
+				default: schema.default,
+				expression: ast,
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		enum(schema, ctx$1) {
+			const ast = enumToAst$2({
+				...ctx$1,
+				schema,
 				state
 			});
-			exportAst({
+			const hasNull = schema.items?.some((item) => item.type === "null" || item.const === null) ?? false;
+			return {
+				default: schema.default,
+				expression: ast,
+				nullable: hasNull,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		integer(schema, ctx$1) {
+			const ast = numberToNode$2({
 				...ctx$1,
-				ast,
-				plugin,
+				schema,
 				state
 			});
-		});
-	}
-	return { process: process$1 };
-}
-
-//#endregion
-//#region src/plugins/zod/v3/toAst/unknown.ts
-const unknownToAst$1 = ({ plugin }) => {
-	return $(plugin.external("zod.z")).attr(identifiers.unknown).call();
+			return {
+				default: schema.default,
+				expression: ast,
+				format: schema.format,
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		intercept(schema, ctx$1, walk) {
+			if (schemaExtractor && !schema.$ref) {
+				const extracted = schemaExtractor({
+					meta: {
+						resource: "definition",
+						resourceId: pathToJsonPointer(fromRef(ctx$1.path))
+					},
+					naming: ctx$1.plugin.config.definitions,
+					path: fromRef(ctx$1.path),
+					plugin: ctx$1.plugin,
+					schema
+				});
+				if (extracted !== schema) return walk(extracted, ctx$1);
+			}
+		},
+		intersection(items, schemas, parentSchema, ctx$1) {
+			const z = ctx$1.plugin.external("zod.z");
+			const hasAnyLazy = items.some((item) => item.hasLazyExpression);
+			let expression = items[0].expression.expression;
+			items.slice(1).forEach((item) => {
+				expression = $(z).attr(identifiers.intersection).call(expression, item.hasLazyExpression ? $(z).attr(identifiers.lazy).call($.func().do(item.expression.expression.return())) : item.expression.expression);
+			});
+			return {
+				default: parentSchema.default,
+				expression: { expression },
+				hasLazyExpression: hasAnyLazy,
+				nullable: items.some((i) => i.nullable),
+				readonly: items.some((i) => i.readonly)
+			};
+		},
+		never(schema, ctx$1) {
+			const ast = neverToAst$2({
+				...ctx$1,
+				schema
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				nullable: false,
+				readonly: false
+			};
+		},
+		null(schema, ctx$1) {
+			const ast = nullToAst$2({
+				...ctx$1,
+				schema
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				nullable: false,
+				readonly: false
+			};
+		},
+		number(schema, ctx$1) {
+			const ast = numberToNode$2({
+				...ctx$1,
+				schema,
+				state
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				format: schema.format,
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		object(schema, ctx$1, walk) {
+			const applyModifiers = (result, opts) => this.applyModifiers(result, ctx$1, opts);
+			const ast = objectToAst$2({
+				applyModifiers,
+				plugin: ctx$1.plugin,
+				schema,
+				state,
+				walk,
+				walkerCtx: ctx$1
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				hasLazyExpression: state.hasLazyExpression["~ref"],
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		postProcess(result, schema, ctx$1) {
+			if (ctx$1.plugin.config.metadata && schema.description) {
+				const z = ctx$1.plugin.external("zod.z");
+				return {
+					...result,
+					expression: { expression: result.expression.expression.attr(identifiers.register).call($(z).attr(identifiers.globalRegistry), $.object().pretty().prop("description", $.literal(schema.description))) }
+				};
+			}
+			return result;
+		},
+		reference($ref, schema, ctx$1) {
+			const z = ctx$1.plugin.external("zod.z");
+			const query = {
+				category: "schema",
+				resource: "definition",
+				resourceId: $ref,
+				tool: "zod"
+			};
+			const refSymbol = ctx$1.plugin.referenceSymbol(query);
+			if (ctx$1.plugin.isSymbolRegistered(query)) return {
+				default: schema.default,
+				expression: { expression: $(refSymbol) },
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+			state.hasLazyExpression["~ref"] = true;
+			return {
+				default: schema.default,
+				expression: { expression: $(z).attr(identifiers.lazy).call($.func().returns("any").do($(refSymbol).return())) },
+				hasLazyExpression: true,
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		string(schema, ctx$1) {
+			if (shouldCoerceToBigInt(schema.format)) {
+				const ast$1 = numberToNode$2({
+					plugin: ctx$1.plugin,
+					schema: {
+						...schema,
+						type: "number"
+					},
+					state
+				});
+				return {
+					default: schema.default,
+					expression: ast$1,
+					nullable: false,
+					readonly: schema.accessScope === "read"
+				};
+			}
+			const ast = stringToNode$2({
+				...ctx$1,
+				schema
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		tuple(schema, ctx$1, walk) {
+			const applyModifiers = (result, opts) => this.applyModifiers(result, ctx$1, opts);
+			const ast = tupleToAst$2({
+				...ctx$1,
+				applyModifiers,
+				schema,
+				state,
+				walk
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				hasLazyExpression: state.hasLazyExpression["~ref"],
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		undefined(schema, ctx$1) {
+			const ast = undefinedToAst$2({
+				...ctx$1,
+				schema
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				nullable: false,
+				readonly: false
+			};
+		},
+		union(items, schemas, parentSchema, ctx$1) {
+			const z = ctx$1.plugin.external("zod.z");
+			const hasAnyLazy = items.some((item) => item.hasLazyExpression);
+			const hasNull = schemas.some((s) => s.type === "null") || items.some((i) => i.nullable);
+			const nonNullItems = [];
+			items.forEach((item, index) => {
+				if (schemas[index].type !== "null") nonNullItems.push(item);
+			});
+			let expression;
+			if (nonNullItems.length === 0) expression = { expression: $(z).attr(identifiers.null).call() };
+			else if (nonNullItems.length === 1) expression = nonNullItems[0].expression;
+			else expression = { expression: $(z).attr(identifiers.union).call($.array().pretty().elements(...nonNullItems.map((item) => item.expression.expression))) };
+			return {
+				default: parentSchema.default,
+				expression,
+				hasLazyExpression: hasAnyLazy,
+				nullable: hasNull,
+				readonly: items.some((i) => i.readonly)
+			};
+		},
+		unknown(schema, ctx$1) {
+			const ast = unknownToAst$2({
+				...ctx$1,
+				schema
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				nullable: false,
+				readonly: false
+			};
+		},
+		void(schema, ctx$1) {
+			const ast = voidToAst$2({
+				...ctx$1,
+				schema
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				nullable: false,
+				readonly: false
+			};
+		}
+	};
+}
+
+//#endregion
+//#region src/plugins/zod/mini/processor.ts
+function createProcessor$2(plugin) {
+	const processor = createSchemaProcessor();
+	const hooks = [plugin.config["~hooks"]?.schemas, plugin.context.config.parser.hooks.schemas];
+	function extractor(ctx$1) {
+		if (processor.hasEmitted(ctx$1.path)) return ctx$1.schema;
+		for (const hook of hooks) if (hook?.shouldExtract?.(ctx$1)) {
+			process$1({
+				namingAnchor: processor.context.anchor,
+				tags: processor.context.tags,
+				...ctx$1
+			});
+			return { $ref: pathToJsonPointer(ctx$1.path) };
+		}
+		return ctx$1.schema;
+	}
+	function process$1(ctx$1) {
+		if (!processor.markEmitted(ctx$1.path)) return;
+		processor.withContext({
+			anchor: ctx$1.namingAnchor,
+			tags: ctx$1.tags
+		}, () => {
+			const state = refs({
+				hasLazyExpression: false,
+				path: ctx$1.path,
+				tags: ctx$1.tags
+			});
+			const visitor = createVisitor$2({
+				schemaExtractor: extractor,
+				state
+			});
+			const result = createSchemaWalker(visitor)(ctx$1.schema, {
+				path: ref(ctx$1.path),
+				plugin
+			});
+			const ast = visitor.applyModifiers(result, {
+				path: ref(ctx$1.path),
+				plugin
+			}) ?? result.expression;
+			if (result.hasLazyExpression) state.hasLazyExpression["~ref"] = true;
+			exportAst({
+				...ctx$1,
+				ast,
+				plugin,
+				state
+			});
+		});
+	}
+	return { process: process$1 };
+}
+
+//#endregion
+//#region src/plugins/zod/mini/plugin.ts
+const handlerMini = ({ plugin }) => {
+	plugin.symbol("z", {
+		external: getZodModule({ plugin }),
+		importKind: "namespace",
+		meta: {
+			category: "external",
+			resource: "zod.z"
+		}
+	});
+	const processor = createProcessor$2(plugin);
+	plugin.forEach("operation", "parameter", "requestBody", "schema", "webhook", (event) => {
+		switch (event.type) {
+			case "operation":
+				irOperationToAst({
+					operation: event.operation,
+					path: event._path,
+					plugin,
+					processor,
+					tags: event.tags
+				});
+				break;
+			case "parameter":
+				processor.process({
+					meta: {
+						resource: "definition",
+						resourceId: pathToJsonPointer(event._path)
+					},
+					naming: plugin.config.definitions,
+					path: event._path,
+					plugin,
+					schema: event.parameter.schema,
+					tags: event.tags
+				});
+				break;
+			case "requestBody":
+				processor.process({
+					meta: {
+						resource: "definition",
+						resourceId: pathToJsonPointer(event._path)
+					},
+					naming: plugin.config.definitions,
+					path: event._path,
+					plugin,
+					schema: event.requestBody.schema,
+					tags: event.tags
+				});
+				break;
+			case "schema":
+				processor.process({
+					meta: {
+						resource: "definition",
+						resourceId: pathToJsonPointer(event._path)
+					},
+					naming: plugin.config.definitions,
+					path: event._path,
+					plugin,
+					schema: event.schema,
+					tags: event.tags
+				});
+				break;
+			case "webhook":
+				irWebhookToAst({
+					operation: event.operation,
+					path: event._path,
+					plugin,
+					processor,
+					tags: event.tags
+				});
+				break;
+		}
+	});
 };
 
+//#endregion
+//#region src/plugins/zod/v3/toAst/unknown.ts
+function unknownToAst$1({ plugin }) {
+	return $(plugin.external("zod.z")).attr(identifiers.unknown).call();
+}
+
 //#endregion
 //#region src/plugins/zod/v3/toAst/array.ts
-const arrayToAst$1 = ({ plugin, schema, state }) => {
+function arrayToAst$1(options) {
+	const { applyModifiers, plugin, walk } = options;
+	let { schema } = options;
 	const z = plugin.external("zod.z");
 	const functionName = $(z).attr(identifiers.array);
 	let arrayExpression;
 	let hasLazyExpression = false;
 	if (!schema.items) arrayExpression = functionName.call(unknownToAst$1({
-		plugin,
-		schema: { type: "unknown" },
-		state
+		...options,
+		schema: { type: "unknown" }
 	}));
 	else {
 		schema = deduplicateSchema({ schema });
 		const itemExpressions = schema.items.map((item, index) => {
-			const itemAst = irSchemaToAst$1({
-				plugin,
-				schema: item,
-				state: {
-					...state,
-					path: ref([
-						...fromRef(state.path),
-						"items",
-						index
-					])
-				}
-			});
-			if (itemAst.hasLazyExpression) hasLazyExpression = true;
-			return itemAst.expression;
+			const itemResult = walk(item, childContext({
+				path: options.state.path,
+				plugin: options.plugin
+			}, "items", index));
+			if (itemResult.hasLazyExpression) hasLazyExpression = true;
+			return applyModifiers(itemResult, { optional: false }).expression;
 		});
 		if (itemExpressions.length === 1) arrayExpression = functionName.call(...itemExpressions);
 		else if (schema.logicalOperator === "and") {
@@ -11832,7 +12018,7 @@ const arrayToAst$1 = ({ plugin, schema, state }) => {
 		expression: arrayExpression,
 		hasLazyExpression
 	};
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v3/toAst/boolean.ts
@@ -11884,30 +12070,21 @@ function baseNode$7(ctx$1) {
 	else if (literalMembers.length === 1) return literalMembers[0];
 	else return $(z).attr(identifiers.union).call($.array(...literalMembers));
 }
-function nullableNode$1(ctx$1) {
-	const { chain } = ctx$1;
-	const { isNullable } = ctx$1.nodes.items(ctx$1);
-	if (!isNullable) return;
-	return chain.current.attr(identifiers.nullable).call();
-}
 function enumResolver$1(ctx$1) {
 	const { literalMembers } = ctx$1.nodes.items(ctx$1);
 	if (!literalMembers.length) return ctx$1.chain.current;
 	const baseExpression = ctx$1.nodes.base(ctx$1);
 	ctx$1.chain.current = baseExpression;
-	const nullableExpression = ctx$1.nodes.nullable(ctx$1);
-	if (nullableExpression) ctx$1.chain.current = nullableExpression;
 	return ctx$1.chain.current;
 }
-const enumToAst$1 = ({ plugin, schema, state }) => {
+function enumToAst$1({ plugin, schema, state }) {
 	const z = plugin.external("zod.z");
 	const { literalMembers } = itemsNode$1({
 		$,
 		chain: { current: $(z) },
 		nodes: {
 			base: baseNode$7,
-			items: itemsNode$1,
-			nullable: nullableNode$1
+			items: itemsNode$1
 		},
 		plugin,
 		schema,
@@ -11919,16 +12096,14 @@ const enumToAst$1 = ({ plugin, schema, state }) => {
 	});
 	if (!literalMembers.length) return unknownToAst$1({
 		plugin,
-		schema: { type: "unknown" },
-		state
+		schema: { type: "unknown" }
 	});
 	const ctx$1 = {
 		$,
 		chain: { current: $(z) },
 		nodes: {
 			base: baseNode$7,
-			items: itemsNode$1,
-			nullable: nullableNode$1
+			items: itemsNode$1
 		},
 		plugin,
 		schema,
@@ -11940,19 +12115,19 @@ const enumToAst$1 = ({ plugin, schema, state }) => {
 	};
 	const resolver = plugin.config["~resolvers"]?.enum;
 	return resolver?.(ctx$1) ?? enumResolver$1(ctx$1);
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v3/toAst/never.ts
-const neverToAst$1 = ({ plugin }) => {
+function neverToAst$1({ plugin }) {
 	return $(plugin.external("zod.z")).attr(identifiers.never).call();
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v3/toAst/null.ts
-const nullToAst$1 = ({ plugin }) => {
+function nullToAst$1({ plugin }) {
 	return $(plugin.external("zod.z")).attr(identifiers.null).call();
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v3/toAst/number.ts
@@ -11998,7 +12173,7 @@ function numberResolver$1(ctx$1) {
 	if (maxNode$4) ctx$1.chain.current = maxNode$4;
 	return ctx$1.chain.current;
 }
-const numberToNode$1 = ({ plugin, schema, state }) => {
+function numberToNode$1({ plugin, schema, state }) {
 	const ast = {};
 	const z = plugin.external("zod.z");
 	const ctx$1 = {
@@ -12023,23 +12198,16 @@ const numberToNode$1 = ({ plugin, schema, state }) => {
 	};
 	const resolver = plugin.config["~resolvers"]?.number;
 	return resolver?.(ctx$1) ?? numberResolver$1(ctx$1);
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v3/toAst/object.ts
 function additionalPropertiesNode$1(ctx$1) {
-	const { plugin, schema } = ctx$1;
+	const { schema, walk, walkerCtx } = ctx$1;
 	if (!schema.additionalProperties || schema.properties && Object.keys(schema.properties).length > 0) return;
-	const additionalAst = irSchemaToAst$1({
-		plugin,
-		schema: schema.additionalProperties,
-		state: {
-			...ctx$1.utils.state,
-			path: ref([...fromRef(ctx$1.utils.state.path), "additionalProperties"])
-		}
-	});
-	if (additionalAst.hasLazyExpression) ctx$1.utils.ast.hasLazyExpression = true;
-	return additionalAst.expression;
+	const additionalResult = walk(schema.additionalProperties, childContext(walkerCtx, "additionalProperties"));
+	if (additionalResult.hasLazyExpression) ctx$1.utils.ast.hasLazyExpression = true;
+	return additionalResult.expression.expression;
 }
 function baseNode$5(ctx$1) {
 	const { nodes, symbols } = ctx$1;
@@ -12053,32 +12221,25 @@ function objectResolver$1(ctx$1) {
 	return ctx$1.nodes.base(ctx$1);
 }
 function shapeNode$1(ctx$1) {
-	const { plugin, schema } = ctx$1;
+	const { applyModifiers, schema, walk, walkerCtx } = ctx$1;
 	const shape = $.object().pretty();
 	for (const name in schema.properties) {
 		const property = schema.properties[name];
-		const propertyAst = irSchemaToAst$1({
-			optional: !schema.required?.includes(name),
-			plugin,
-			schema: property,
-			state: {
-				...ctx$1.utils.state,
-				path: ref([
-					...fromRef(ctx$1.utils.state.path),
-					"properties",
-					name
-				])
-			}
-		});
-		if (propertyAst.hasLazyExpression) ctx$1.utils.ast.hasLazyExpression = true;
-		shape.prop(name, propertyAst.expression);
+		const isOptional = !schema.required?.includes(name);
+		const propertyResult = walk(property, childContext(walkerCtx, "properties", name));
+		if (propertyResult.hasLazyExpression) ctx$1.utils.ast.hasLazyExpression = true;
+		const ast = applyModifiers(propertyResult, { optional: isOptional });
+		if (ast.hasLazyExpression) ctx$1.utils.ast.hasLazyExpression = true;
+		shape.prop(name, ast.expression);
 	}
 	return shape;
 }
-const objectToAst$1 = ({ plugin, schema, state }) => {
+function objectToAst$1(options) {
+	const { plugin } = options;
 	const ast = {};
 	const z = plugin.external("zod.z");
 	const ctx$1 = {
+		...options,
 		$,
 		chain: { current: $(z) },
 		nodes: {
@@ -12087,20 +12248,19 @@ const objectToAst$1 = ({ plugin, schema, state }) => {
 			shape: shapeNode$1
 		},
 		plugin,
-		schema,
 		symbols: { z },
 		utils: {
 			ast,
-			state
+			state: options.state
 		}
 	};
 	const resolver = plugin.config["~resolvers"]?.object;
 	ast.expression = resolver?.(ctx$1) ?? objectResolver$1(ctx$1);
 	return {
 		...ast,
-		anyType: "AnyZodObject"
+		anyType: identifiers.AnyZodObject
 	};
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v3/toAst/string.ts
@@ -12172,7 +12332,7 @@ function stringResolver$1(ctx$1) {
 	if (patternNode$4) ctx$1.chain.current = patternNode$4;
 	return ctx$1.chain.current;
 }
-const stringToNode$1 = ({ plugin, schema }) => {
+function stringToNode$1({ plugin, schema }) {
 	const z = plugin.external("zod.z");
 	const ctx$1 = {
 		$,
@@ -12192,11 +12352,12 @@ const stringToNode$1 = ({ plugin, schema }) => {
 	};
 	const resolver = plugin.config["~resolvers"]?.string;
 	return resolver?.(ctx$1) ?? stringResolver$1(ctx$1);
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v3/toAst/tuple.ts
-const tupleToAst$1 = ({ plugin, schema, state }) => {
+function tupleToAst$1(options) {
+	const { applyModifiers, plugin, schema, walk } = options;
 	const z = plugin.external("zod.z");
 	let hasLazyExpression = false;
 	if (schema.const && Array.isArray(schema.const)) {
@@ -12208,193 +12369,391 @@ const tupleToAst$1 = ({ plugin, schema, state }) => {
 	}
 	const tupleElements = [];
 	if (schema.items) schema.items.forEach((item, index) => {
-		const itemSchema = irSchemaToAst$1({
-			plugin,
-			schema: item,
-			state: {
-				...state,
-				path: ref([
-					...fromRef(state.path),
-					"items",
-					index
-				])
-			}
-		});
-		tupleElements.push(itemSchema.expression);
-		if (itemSchema.hasLazyExpression) hasLazyExpression = true;
+		const itemResult = walk(item, childContext({
+			path: options.state.path,
+			plugin: options.plugin
+		}, "items", index));
+		if (itemResult.hasLazyExpression) hasLazyExpression = true;
+		const finalExpr = applyModifiers(itemResult, { optional: false });
+		tupleElements.push(finalExpr.expression);
 	});
 	return {
 		expression: $(z).attr(identifiers.tuple).call($.array(...tupleElements)),
 		hasLazyExpression
 	};
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v3/toAst/undefined.ts
-const undefinedToAst$1 = ({ plugin }) => {
+function undefinedToAst$1({ plugin }) {
 	return $(plugin.external("zod.z")).attr(identifiers.undefined).call();
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v3/toAst/void.ts
-const voidToAst$1 = ({ plugin }) => {
+function voidToAst$1({ plugin }) {
 	return $(plugin.external("zod.z")).attr(identifiers.void).call();
-};
+}
 
 //#endregion
-//#region src/plugins/zod/v3/toAst/index.ts
-function irSchemaWithTypeToAst$1({ schema, ...args }) {
-	switch (schema.type) {
-		case "array": return arrayToAst$1({
-			...args,
-			schema
-		});
-		case "boolean": return { expression: booleanToAst$1({
-			...args,
-			schema
-		}) };
-		case "enum": return { expression: enumToAst$1({
-			...args,
-			schema
-		}) };
-		case "integer":
-		case "number": return { expression: numberToNode$1({
-			...args,
-			schema
-		}) };
-		case "never": return { expression: neverToAst$1({
-			...args,
-			schema
-		}) };
-		case "null": return { expression: nullToAst$1({
-			...args,
-			schema
-		}) };
-		case "object": return objectToAst$1({
-			...args,
-			schema
-		});
-		case "string": return { expression: shouldCoerceToBigInt(schema.format) ? numberToNode$1({
-			...args,
-			schema: {
-				...schema,
-				type: "number"
+//#region src/plugins/zod/v3/walker.ts
+function createVisitor$1(config) {
+	const { schemaExtractor, state } = config;
+	return {
+		applyModifiers(result, ctx$1, options = {}) {
+			const { optional } = options;
+			let expression = result.expression.expression;
+			if (result.readonly) expression = expression.attr(identifiers.readonly).call();
+			const hasDefault = result.default !== void 0;
+			const needsNullable = result.nullable;
+			if (optional && needsNullable) expression = expression.attr(identifiers.nullish).call();
+			else if (optional) expression = expression.attr(identifiers.optional).call();
+			else if (needsNullable) expression = expression.attr(identifiers.nullable).call();
+			if (hasDefault) expression = expression.attr(identifiers.default).call(result.format ? maybeBigInt(result.default, result.format) : $.fromValue(result.default));
+			return { expression };
+		},
+		array(schema, ctx$1, walk) {
+			const applyModifiers = (result, opts) => this.applyModifiers(result, ctx$1, opts);
+			const ast = arrayToAst$1({
+				...ctx$1,
+				applyModifiers,
+				schema,
+				state,
+				walk
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				hasLazyExpression: state.hasLazyExpression["~ref"],
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		boolean(schema, ctx$1) {
+			const ast = booleanToAst$1({
+				...ctx$1,
+				schema
+			});
+			return {
+				default: schema.default,
+				expression: { expression: ast },
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		enum(schema, ctx$1) {
+			const ast = enumToAst$1({
+				...ctx$1,
+				schema,
+				state
+			});
+			const hasNull = schema.items?.some((item) => item.type === "null" || item.const === null) ?? false;
+			return {
+				default: schema.default,
+				expression: { expression: ast },
+				nullable: hasNull,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		integer(schema, ctx$1) {
+			const ast = numberToNode$1({
+				...ctx$1,
+				schema,
+				state
+			});
+			return {
+				default: schema.default,
+				expression: { expression: ast },
+				format: schema.format,
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		intercept(schema, ctx$1, walk) {
+			if (schemaExtractor && !schema.$ref) {
+				const extracted = schemaExtractor({
+					meta: {
+						resource: "definition",
+						resourceId: pathToJsonPointer(fromRef(ctx$1.path))
+					},
+					naming: ctx$1.plugin.config.definitions,
+					path: fromRef(ctx$1.path),
+					plugin: ctx$1.plugin,
+					schema
+				});
+				if (extracted !== schema) return walk(extracted, ctx$1);
 			}
-		}) : stringToNode$1({
-			...args,
-			schema
-		}) };
-		case "tuple": return tupleToAst$1({
-			...args,
-			schema
-		});
-		case "undefined": return { expression: undefinedToAst$1({
-			...args,
-			schema
-		}) };
-		case "unknown": return { expression: unknownToAst$1({
-			...args,
-			schema
-		}) };
-		case "void": return { expression: voidToAst$1({
-			...args,
-			schema
-		}) };
-	}
+		},
+		intersection(items, schemas, parentSchema, ctx$1) {
+			const z = ctx$1.plugin.external("zod.z");
+			const hasAnyLazy = items.some((item) => item.hasLazyExpression);
+			if (hasAnyLazy) state.anyType = ref(identifiers.ZodTypeAny);
+			const firstSchema = schemas[0];
+			let expression;
+			if (firstSchema?.logicalOperator === "or" || firstSchema?.type && firstSchema.type !== "object") expression = { expression: $(z).attr(identifiers.intersection).call(...items.map((item) => item.expression.expression)) };
+			else {
+				expression = items[0].expression;
+				items.slice(1).forEach((item) => {
+					expression = { expression: expression.expression.attr(identifiers.and).call(item.hasLazyExpression && !item.isLazy ? $(z).attr(identifiers.lazy).call($.func().do(item.expression.expression.return())) : item.expression.expression) };
+				});
+			}
+			return {
+				default: parentSchema.default,
+				expression,
+				hasLazyExpression: hasAnyLazy,
+				nullable: items.some((i) => i.nullable),
+				readonly: items.some((i) => i.readonly)
+			};
+		},
+		never(schema, ctx$1) {
+			const ast = neverToAst$1({
+				...ctx$1,
+				schema
+			});
+			return {
+				default: schema.default,
+				expression: { expression: ast },
+				nullable: false,
+				readonly: false
+			};
+		},
+		null(schema, ctx$1) {
+			const ast = nullToAst$1({
+				...ctx$1,
+				schema
+			});
+			return {
+				default: schema.default,
+				expression: { expression: ast },
+				nullable: false,
+				readonly: false
+			};
+		},
+		number(schema, ctx$1) {
+			const ast = numberToNode$1({
+				...ctx$1,
+				schema,
+				state
+			});
+			return {
+				default: schema.default,
+				expression: { expression: ast },
+				format: schema.format,
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		object(schema, ctx$1, walk) {
+			const applyModifiers = (result, opts) => this.applyModifiers(result, ctx$1, opts);
+			const ast = objectToAst$1({
+				applyModifiers,
+				plugin: ctx$1.plugin,
+				schema,
+				state,
+				walk,
+				walkerCtx: ctx$1
+			});
+			if (state.hasLazyExpression["~ref"] && ast.anyType) state.anyType = ref(ast.anyType);
+			return {
+				default: schema.default,
+				expression: ast,
+				hasLazyExpression: state.hasLazyExpression["~ref"],
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		postProcess(result, schema, ctx$1) {
+			if (ctx$1.plugin.config.metadata && schema.description) return {
+				...result,
+				expression: { expression: result.expression.expression.attr(identifiers.describe).call($.literal(schema.description)) }
+			};
+			return result;
+		},
+		reference($ref, schema, ctx$1) {
+			const z = ctx$1.plugin.external("zod.z");
+			const query = {
+				category: "schema",
+				resource: "definition",
+				resourceId: $ref,
+				tool: "zod"
+			};
+			const refSymbol = ctx$1.plugin.referenceSymbol(query);
+			if (ctx$1.plugin.isSymbolRegistered(query)) return {
+				default: schema.default,
+				expression: { expression: $(refSymbol) },
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+			state.hasLazyExpression["~ref"] = true;
+			state.anyType = ref(identifiers.ZodTypeAny);
+			return {
+				default: schema.default,
+				expression: { expression: $(z).attr(identifiers.lazy).call($.func().do($(refSymbol).return())) },
+				hasLazyExpression: true,
+				isLazy: true,
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		string(schema, ctx$1) {
+			if (shouldCoerceToBigInt(schema.format)) {
+				const ast$1 = numberToNode$1({
+					plugin: ctx$1.plugin,
+					schema: {
+						...schema,
+						type: "number"
+					},
+					state
+				});
+				return {
+					default: schema.default,
+					expression: { expression: ast$1 },
+					nullable: false,
+					readonly: schema.accessScope === "read"
+				};
+			}
+			const ast = stringToNode$1({
+				...ctx$1,
+				schema
+			});
+			return {
+				default: schema.default,
+				expression: { expression: ast },
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		tuple(schema, ctx$1, walk) {
+			const applyModifiers = (result, opts) => this.applyModifiers(result, ctx$1, opts);
+			const ast = tupleToAst$1({
+				...ctx$1,
+				applyModifiers,
+				schema,
+				state,
+				walk
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				hasLazyExpression: state.hasLazyExpression["~ref"],
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		undefined(schema, ctx$1) {
+			const ast = undefinedToAst$1({
+				...ctx$1,
+				schema
+			});
+			return {
+				default: schema.default,
+				expression: { expression: ast },
+				nullable: false,
+				readonly: false
+			};
+		},
+		union(items, schemas, parentSchema, ctx$1) {
+			const z = ctx$1.plugin.external("zod.z");
+			const hasAnyLazy = items.some((item) => item.hasLazyExpression);
+			const hasNull = schemas.some((s) => s.type === "null") || items.some((i) => i.nullable);
+			if (hasAnyLazy) state.anyType = ref(identifiers.ZodTypeAny);
+			const nonNullItems = [];
+			items.forEach((item, index) => {
+				if (schemas[index].type !== "null") nonNullItems.push(item);
+			});
+			let expression;
+			if (nonNullItems.length === 0) expression = { expression: $(z).attr(identifiers.null).call() };
+			else if (nonNullItems.length === 1) expression = nonNullItems[0].expression;
+			else expression = { expression: $(z).attr(identifiers.union).call($.array().pretty().elements(...nonNullItems.map((item) => item.expression.expression))) };
+			return {
+				default: parentSchema.default,
+				expression,
+				hasLazyExpression: hasAnyLazy,
+				nullable: hasNull,
+				readonly: items.some((i) => i.readonly)
+			};
+		},
+		unknown(schema, ctx$1) {
+			const ast = unknownToAst$1({
+				...ctx$1,
+				schema
+			});
+			return {
+				default: schema.default,
+				expression: { expression: ast },
+				nullable: false,
+				readonly: false
+			};
+		},
+		void(schema, ctx$1) {
+			const ast = voidToAst$1({
+				...ctx$1,
+				schema
+			});
+			return {
+				default: schema.default,
+				expression: { expression: ast },
+				nullable: false,
+				readonly: false
+			};
+		}
+	};
 }
 
 //#endregion
-//#region src/plugins/zod/v3/plugin.ts
-function irSchemaToAst$1({ optional, plugin, schema, schemaExtractor, state }) {
-	if (schemaExtractor && !schema.$ref) {
-		const extracted = schemaExtractor({
-			meta: {
-				resource: "definition",
-				resourceId: pathToJsonPointer(fromRef(state.path))
-			},
-			naming: plugin.config.definitions,
-			path: fromRef(state.path),
-			plugin,
-			schema
-		});
-		if (extracted !== schema) schema = extracted;
-	}
-	let ast = {};
-	const z = plugin.external("zod.z");
-	if (schema.$ref) {
-		const query = {
-			category: "schema",
-			resource: "definition",
-			resourceId: schema.$ref,
-			tool: "zod"
-		};
-		const refSymbol = plugin.referenceSymbol(query);
-		if (plugin.isSymbolRegistered(query)) ast.expression = $(refSymbol);
-		else {
-			ast.expression = $(z).attr(identifiers.lazy).call($.func().do($(refSymbol).return()));
-			ast.hasLazyExpression = true;
-			state.hasLazyExpression["~ref"] = true;
+//#region src/plugins/zod/v3/processor.ts
+function createProcessor$1(plugin) {
+	const processor = createSchemaProcessor();
+	const hooks = [plugin.config["~hooks"]?.schemas, plugin.context.config.parser.hooks.schemas];
+	function extractor(ctx$1) {
+		if (processor.hasEmitted(ctx$1.path)) return ctx$1.schema;
+		for (const hook of hooks) if (hook?.shouldExtract?.(ctx$1)) {
+			process$1({
+				namingAnchor: processor.context.anchor,
+				tags: processor.context.tags,
+				...ctx$1
+			});
+			return { $ref: pathToJsonPointer(ctx$1.path) };
 		}
-	} else if (schema.type) {
-		const typeAst = irSchemaWithTypeToAst$1({
-			plugin,
-			schema,
-			state
-		});
-		ast.expression = typeAst.expression;
-		ast.typeName = typeAst.anyType;
-		if (plugin.config.metadata && schema.description) ast.expression = ast.expression.attr(identifiers.describe).call($.literal(schema.description));
-	} else if (schema.items) {
-		schema = deduplicateSchema({ schema });
-		if (schema.items) {
-			const itemTypes = schema.items.map((item, index) => {
-				return irSchemaToAst$1({
-					plugin,
-					schema: item,
-					state: {
-						...state,
-						path: ref([
-							...fromRef(state.path),
-							"items",
-							index
-						])
-					}
-				}).expression;
+		return ctx$1.schema;
+	}
+	function process$1(ctx$1) {
+		if (!processor.markEmitted(ctx$1.path)) return;
+		processor.withContext({
+			anchor: ctx$1.namingAnchor,
+			tags: ctx$1.tags
+		}, () => {
+			const state = refs({
+				hasLazyExpression: false,
+				path: ctx$1.path,
+				tags: ctx$1.tags
+			});
+			const visitor = createVisitor$1({
+				schemaExtractor: extractor,
+				state
+			});
+			const result = createSchemaWalker(visitor)(ctx$1.schema, {
+				path: ref(ctx$1.path),
+				plugin
+			});
+			const ast = visitor.applyModifiers(result, {
+				path: ref(ctx$1.path),
+				plugin
+			}) ?? result.expression;
+			if (result.hasLazyExpression) state.hasLazyExpression["~ref"] = true;
+			exportAst({
+				...ctx$1,
+				ast,
+				plugin,
+				state
 			});
-			if (schema.logicalOperator === "and") {
-				const firstSchema = schema.items[0];
-				if (firstSchema.logicalOperator === "or" || firstSchema.type && firstSchema.type !== "object") ast.expression = $(z).attr(identifiers.intersection).call(...itemTypes);
-				else {
-					ast.expression = itemTypes[0];
-					itemTypes.slice(1).forEach((item) => {
-						ast.expression = ast.expression.attr(identifiers.and).call(item);
-					});
-				}
-			} else ast.expression = $(z).attr(identifiers.union).call($.array().pretty().elements(...itemTypes));
-		} else ast = irSchemaToAst$1({
-			plugin,
-			schema,
-			state
-		});
-	} else {
-		const typeAst = irSchemaWithTypeToAst$1({
-			plugin,
-			schema: { type: "unknown" },
-			state
 		});
-		ast.expression = typeAst.expression;
-		ast.typeName = typeAst.anyType;
-	}
-	if (ast.expression) {
-		if (schema.accessScope === "read") ast.expression = ast.expression.attr(identifiers.readonly).call();
-		if (optional) ast.expression = ast.expression.attr(identifiers.optional).call();
-		if (schema.default !== void 0) ast.expression = ast.expression.attr(identifiers.default).call(schema.type === "integer" || schema.type === "number" ? maybeBigInt(schema.default, schema.format) : $.fromValue(schema.default));
 	}
-	if (state.hasLazyExpression["~ref"]) {
-		if (!ast.typeName) ast.typeName = "ZodTypeAny";
-	} else if (ast.typeName) ast.typeName = void 0;
-	return ast;
+	return { process: process$1 };
 }
+
+//#endregion
+//#region src/plugins/zod/v3/plugin.ts
 const handlerV3 = ({ plugin }) => {
 	plugin.symbol("z", {
 		external: getZodModule({ plugin }),
@@ -12467,87 +12826,35 @@ const handlerV3 = ({ plugin }) => {
 	});
 };
 
-//#endregion
-//#region src/plugins/zod/v4/processor.ts
-function createProcessor(plugin) {
-	const processor = createSchemaProcessor();
-	const hooks = [plugin.config["~hooks"]?.schemas, plugin.context.config.parser.hooks.schemas];
-	function extractor(ctx$1) {
-		if (processor.hasEmitted(ctx$1.path)) return ctx$1.schema;
-		for (const hook of hooks) if (hook?.shouldExtract?.(ctx$1)) {
-			process$1({
-				namingAnchor: processor.context.anchor,
-				tags: processor.context.tags,
-				...ctx$1
-			});
-			return { $ref: pathToJsonPointer(ctx$1.path) };
-		}
-		return ctx$1.schema;
-	}
-	function process$1(ctx$1) {
-		if (!processor.markEmitted(ctx$1.path)) return;
-		processor.withContext({
-			anchor: ctx$1.namingAnchor,
-			tags: ctx$1.tags
-		}, () => {
-			const state = refs({
-				hasLazyExpression: false,
-				path: ctx$1.path,
-				tags: ctx$1.tags
-			});
-			const ast = irSchemaToAst({
-				plugin,
-				schema: ctx$1.schema,
-				schemaExtractor: extractor,
-				state
-			});
-			exportAst({
-				...ctx$1,
-				ast,
-				plugin,
-				state
-			});
-		});
-	}
-	return { process: process$1 };
-}
-
 //#endregion
 //#region src/plugins/zod/v4/toAst/unknown.ts
-const unknownToAst = ({ plugin }) => {
+function unknownToAst({ plugin }) {
 	const result = {};
 	result.expression = $(plugin.external("zod.z")).attr(identifiers.unknown).call();
 	return result;
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v4/toAst/array.ts
-const arrayToAst = ({ plugin, schema, state }) => {
+function arrayToAst(options) {
+	const { applyModifiers, plugin, walk } = options;
+	let { schema } = options;
 	const result = {};
 	const z = plugin.external("zod.z");
 	const functionName = $(z).attr(identifiers.array);
 	if (!schema.items) result.expression = functionName.call(unknownToAst({
-		plugin,
-		schema: { type: "unknown" },
-		state
+		...options,
+		schema: { type: "unknown" }
 	}).expression);
 	else {
 		schema = deduplicateSchema({ schema });
 		const itemExpressions = schema.items.map((item, index) => {
-			const itemAst = irSchemaToAst({
-				plugin,
-				schema: item,
-				state: {
-					...state,
-					path: ref([
-						...fromRef(state.path),
-						"items",
-						index
-					])
-				}
-			});
-			if (itemAst.hasLazyExpression) result.hasLazyExpression = true;
-			return itemAst.expression;
+			const itemResult = walk(item, childContext({
+				path: options.state.path,
+				plugin: options.plugin
+			}, "items", index));
+			if (itemResult.hasLazyExpression) result.hasLazyExpression = true;
+			return applyModifiers(itemResult, { optional: false }).expression;
 		});
 		if (itemExpressions.length === 1) result.expression = functionName.call(...itemExpressions);
 		else if (schema.logicalOperator === "and") {
@@ -12567,7 +12874,7 @@ const arrayToAst = ({ plugin, schema, state }) => {
 		if (schema.maxItems !== void 0) result.expression = result.expression.attr(identifiers.max).call($.fromValue(schema.maxItems));
 	}
 	return result;
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v4/toAst/boolean.ts
@@ -12622,31 +12929,21 @@ function baseNode$3(ctx$1) {
 	else if (literalMembers.length === 1) return literalMembers[0];
 	else return $(z).attr(identifiers.union).call($.array(...literalMembers));
 }
-function nullableNode(ctx$1) {
-	const { chain, symbols } = ctx$1;
-	const { z } = symbols;
-	const { isNullable } = ctx$1.nodes.items(ctx$1);
-	if (!isNullable) return;
-	return $(z).attr(identifiers.nullable).call(chain.current);
-}
 function enumResolver(ctx$1) {
 	const { literalMembers } = ctx$1.nodes.items(ctx$1);
 	if (!literalMembers.length) return ctx$1.chain.current;
 	const baseExpression = ctx$1.nodes.base(ctx$1);
 	ctx$1.chain.current = baseExpression;
-	const nullableExpression = ctx$1.nodes.nullable(ctx$1);
-	if (nullableExpression) ctx$1.chain.current = nullableExpression;
 	return ctx$1.chain.current;
 }
-const enumToAst = ({ plugin, schema, state }) => {
+function enumToAst({ plugin, schema, state }) {
 	const z = plugin.external("zod.z");
 	const { literalMembers } = itemsNode({
 		$,
 		chain: { current: $(z) },
 		nodes: {
 			base: baseNode$3,
-			items: itemsNode,
-			nullable: nullableNode
+			items: itemsNode
 		},
 		plugin,
 		schema,
@@ -12658,16 +12955,14 @@ const enumToAst = ({ plugin, schema, state }) => {
 	});
 	if (!literalMembers.length) return unknownToAst({
 		plugin,
-		schema: { type: "unknown" },
-		state
+		schema: { type: "unknown" }
 	});
 	const ctx$1 = {
 		$,
 		chain: { current: $(z) },
 		nodes: {
 			base: baseNode$3,
-			items: itemsNode,
-			nullable: nullableNode
+			items: itemsNode
 		},
 		plugin,
 		schema,
@@ -12679,23 +12974,23 @@ const enumToAst = ({ plugin, schema, state }) => {
 	};
 	const resolver = plugin.config["~resolvers"]?.enum;
 	return { expression: resolver?.(ctx$1) ?? enumResolver(ctx$1) };
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v4/toAst/never.ts
-const neverToAst = ({ plugin }) => {
+function neverToAst({ plugin }) {
 	const result = {};
 	result.expression = $(plugin.external("zod.z")).attr(identifiers.never).call();
 	return result;
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v4/toAst/null.ts
-const nullToAst = ({ plugin }) => {
+function nullToAst({ plugin }) {
 	const result = {};
 	result.expression = $(plugin.external("zod.z")).attr(identifiers.null).call();
 	return result;
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v4/toAst/number.ts
@@ -12741,7 +13036,7 @@ function numberResolver(ctx$1) {
 	if (maxNode$4) ctx$1.chain.current = maxNode$4;
 	return ctx$1.chain.current;
 }
-const numberToNode = ({ plugin, schema, state }) => {
+function numberToNode({ plugin, schema, state }) {
 	const ast = {};
 	const z = plugin.external("zod.z");
 	const ctx$1 = {
@@ -12767,23 +13062,16 @@ const numberToNode = ({ plugin, schema, state }) => {
 	const resolver = plugin.config["~resolvers"]?.number;
 	ast.expression = resolver?.(ctx$1) ?? numberResolver(ctx$1);
 	return ast;
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v4/toAst/object.ts
 function additionalPropertiesNode(ctx$1) {
-	const { plugin, schema } = ctx$1;
+	const { schema, walk, walkerCtx } = ctx$1;
 	if (!schema.additionalProperties || schema.properties && Object.keys(schema.properties).length > 0) return;
-	const additionalAst = irSchemaToAst({
-		plugin,
-		schema: schema.additionalProperties,
-		state: {
-			...ctx$1.utils.state,
-			path: ref([...fromRef(ctx$1.utils.state.path), "additionalProperties"])
-		}
-	});
-	if (additionalAst.hasLazyExpression) ctx$1.utils.ast.hasLazyExpression = true;
-	return additionalAst.expression;
+	const additionalResult = walk(schema.additionalProperties, childContext(walkerCtx, "additionalProperties"));
+	if (additionalResult.hasLazyExpression) ctx$1.utils.ast.hasLazyExpression = true;
+	return additionalResult.expression.expression;
 }
 function baseNode$1(ctx$1) {
 	const { nodes, symbols } = ctx$1;
@@ -12797,34 +13085,27 @@ function objectResolver(ctx$1) {
 	return ctx$1.nodes.base(ctx$1);
 }
 function shapeNode(ctx$1) {
-	const { plugin, schema } = ctx$1;
+	const { applyModifiers, schema, walk, walkerCtx } = ctx$1;
 	const shape = $.object().pretty();
 	for (const name in schema.properties) {
 		const property = schema.properties[name];
-		const propertyAst = irSchemaToAst({
-			optional: !schema.required?.includes(name),
-			plugin,
-			schema: property,
-			state: {
-				...ctx$1.utils.state,
-				path: ref([
-					...fromRef(ctx$1.utils.state.path),
-					"properties",
-					name
-				])
-			}
-		});
-		if (propertyAst.hasLazyExpression) {
+		const isOptional = !schema.required?.includes(name);
+		const propertyResult = walk(property, childContext(walkerCtx, "properties", name));
+		if (propertyResult.hasLazyExpression) ctx$1.utils.ast.hasLazyExpression = true;
+		const ast = applyModifiers(propertyResult, { optional: isOptional });
+		if (ast.hasLazyExpression) {
 			ctx$1.utils.ast.hasLazyExpression = true;
-			shape.getter(name, propertyAst.expression.return());
-		} else shape.prop(name, propertyAst.expression);
+			shape.getter(name, ast.expression.return());
+		} else shape.prop(name, ast.expression);
 	}
 	return shape;
 }
-const objectToAst = ({ plugin, schema, state }) => {
+function objectToAst(options) {
+	const { plugin } = options;
 	const ast = {};
 	const z = plugin.external("zod.z");
 	const ctx$1 = {
+		...options,
 		$,
 		chain: { current: $(z) },
 		nodes: {
@@ -12833,17 +13114,16 @@ const objectToAst = ({ plugin, schema, state }) => {
 			shape: shapeNode
 		},
 		plugin,
-		schema,
 		symbols: { z },
 		utils: {
 			ast,
-			state
+			state: options.state
 		}
 	};
 	const resolver = plugin.config["~resolvers"]?.object;
 	ast.expression = resolver?.(ctx$1) ?? objectResolver(ctx$1);
 	return ast;
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v4/toAst/string.ts
@@ -12916,7 +13196,7 @@ function stringResolver(ctx$1) {
 	if (patternNode$4) ctx$1.chain.current = patternNode$4;
 	return ctx$1.chain.current;
 }
-const stringToNode = ({ plugin, schema }) => {
+function stringToNode({ plugin, schema }) {
 	const z = plugin.external("zod.z");
 	const ctx$1 = {
 		$,
@@ -12936,11 +13216,12 @@ const stringToNode = ({ plugin, schema }) => {
 	};
 	const resolver = plugin.config["~resolvers"]?.string;
 	return { expression: resolver?.(ctx$1) ?? stringResolver(ctx$1) };
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v4/toAst/tuple.ts
-const tupleToAst = ({ plugin, schema, state }) => {
+function tupleToAst(options) {
+	const { applyModifiers, plugin, schema, walk } = options;
 	const result = {};
 	const z = plugin.external("zod.z");
 	if (schema.const && Array.isArray(schema.const)) {
@@ -12950,192 +13231,391 @@ const tupleToAst = ({ plugin, schema, state }) => {
 	}
 	const tupleElements = [];
 	if (schema.items) schema.items.forEach((item, index) => {
-		const itemSchema = irSchemaToAst({
-			plugin,
-			schema: item,
-			state: {
-				...state,
-				path: ref([
-					...fromRef(state.path),
-					"items",
-					index
-				])
-			}
-		});
-		tupleElements.push(itemSchema.expression);
-		if (itemSchema.hasLazyExpression) result.hasLazyExpression = true;
+		const itemResult = walk(item, childContext({
+			path: options.state.path,
+			plugin: options.plugin
+		}, "items", index));
+		if (itemResult.hasLazyExpression) result.hasLazyExpression = true;
+		const finalExpr = applyModifiers(itemResult, { optional: false });
+		tupleElements.push(finalExpr.expression);
 	});
 	result.expression = $(z).attr(identifiers.tuple).call($.array(...tupleElements));
 	return result;
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v4/toAst/undefined.ts
-const undefinedToAst = ({ plugin }) => {
+function undefinedToAst({ plugin }) {
 	const result = {};
 	result.expression = $(plugin.external("zod.z")).attr(identifiers.undefined).call();
 	return result;
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v4/toAst/void.ts
-const voidToAst = ({ plugin }) => {
+function voidToAst({ plugin }) {
 	const result = {};
 	result.expression = $(plugin.external("zod.z")).attr(identifiers.void).call();
 	return result;
-};
+}
 
 //#endregion
-//#region src/plugins/zod/v4/toAst/index.ts
-function irSchemaWithTypeToAst({ schema, ...args }) {
-	switch (schema.type) {
-		case "array": return arrayToAst({
-			...args,
-			schema
-		});
-		case "boolean": return booleanToAst({
-			...args,
-			schema
-		});
-		case "enum": return enumToAst({
-			...args,
-			schema
-		});
-		case "integer":
-		case "number": return numberToNode({
-			...args,
-			schema
-		});
-		case "never": return neverToAst({
-			...args,
-			schema
-		});
-		case "null": return nullToAst({
-			...args,
-			schema
-		});
-		case "object": return objectToAst({
-			...args,
-			schema
-		});
-		case "string": return shouldCoerceToBigInt(schema.format) ? numberToNode({
-			...args,
-			schema: {
-				...schema,
-				type: "number"
+//#region src/plugins/zod/v4/walker.ts
+function createVisitor(config) {
+	const { schemaExtractor, state } = config;
+	return {
+		applyModifiers(result, ctx$1, options = {}) {
+			const { optional } = options;
+			let expression = result.expression.expression;
+			if (result.readonly) expression = expression.attr(identifiers.readonly).call();
+			const hasDefault = result.default !== void 0;
+			const needsNullable = result.nullable;
+			if (optional && needsNullable) expression = expression.attr(identifiers.nullish).call();
+			else if (optional) expression = expression.attr(identifiers.optional).call();
+			else if (needsNullable) expression = expression.attr(identifiers.nullable).call();
+			if (hasDefault) expression = expression.attr(identifiers.default).call(result.format ? maybeBigInt(result.default, result.format) : $.fromValue(result.default));
+			return { expression };
+		},
+		array(schema, ctx$1, walk) {
+			const applyModifiers = (result, opts) => this.applyModifiers(result, ctx$1, opts);
+			const ast = arrayToAst({
+				...ctx$1,
+				applyModifiers,
+				schema,
+				state,
+				walk
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				hasLazyExpression: state.hasLazyExpression["~ref"],
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		boolean(schema, ctx$1) {
+			const ast = booleanToAst({
+				...ctx$1,
+				schema
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		enum(schema, ctx$1) {
+			const ast = enumToAst({
+				...ctx$1,
+				schema,
+				state
+			});
+			const hasNull = schema.items?.some((item) => item.type === "null" || item.const === null) ?? false;
+			return {
+				default: schema.default,
+				expression: ast,
+				nullable: hasNull,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		integer(schema, ctx$1) {
+			const ast = numberToNode({
+				...ctx$1,
+				schema,
+				state
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				format: schema.format,
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		intercept(schema, ctx$1, walk) {
+			if (schemaExtractor && !schema.$ref) {
+				const extracted = schemaExtractor({
+					meta: {
+						resource: "definition",
+						resourceId: pathToJsonPointer(fromRef(ctx$1.path))
+					},
+					naming: ctx$1.plugin.config.definitions,
+					path: fromRef(ctx$1.path),
+					plugin: ctx$1.plugin,
+					schema
+				});
+				if (extracted !== schema) return walk(extracted, ctx$1);
 			}
-		}) : stringToNode({
-			...args,
-			schema
-		});
-		case "tuple": return tupleToAst({
-			...args,
-			schema
-		});
-		case "undefined": return undefinedToAst({
-			...args,
-			schema
-		});
-		case "unknown": return unknownToAst({
-			...args,
-			schema
-		});
-		case "void": return voidToAst({
-			...args,
-			schema
-		});
-	}
+		},
+		intersection(items, schemas, parentSchema, ctx$1) {
+			const z = ctx$1.plugin.external("zod.z");
+			const hasAnyLazy = items.some((item) => item.hasLazyExpression);
+			const firstSchema = schemas[0];
+			let expression;
+			if (firstSchema?.logicalOperator === "or" || firstSchema?.type && firstSchema.type !== "object") expression = { expression: $(z).attr(identifiers.intersection).call(...items.map((item) => item.expression.expression)) };
+			else {
+				expression = items[0].expression;
+				items.slice(1).forEach((item) => {
+					expression = { expression: expression.expression.attr(identifiers.and).call(item.hasLazyExpression ? $(z).attr(identifiers.lazy).call($.func().do(item.expression.expression.return())) : item.expression.expression) };
+				});
+			}
+			return {
+				default: parentSchema.default,
+				expression,
+				hasLazyExpression: hasAnyLazy,
+				nullable: items.some((i) => i.nullable),
+				readonly: items.some((i) => i.readonly)
+			};
+		},
+		never(schema, ctx$1) {
+			const ast = neverToAst({
+				...ctx$1,
+				schema
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				nullable: false,
+				readonly: false
+			};
+		},
+		null(schema, ctx$1) {
+			const ast = nullToAst({
+				...ctx$1,
+				schema
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				nullable: false,
+				readonly: false
+			};
+		},
+		number(schema, ctx$1) {
+			const ast = numberToNode({
+				...ctx$1,
+				schema,
+				state
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				format: schema.format,
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		object(schema, ctx$1, walk) {
+			const applyModifiers = (result, opts) => this.applyModifiers(result, ctx$1, opts);
+			const ast = objectToAst({
+				applyModifiers,
+				plugin: ctx$1.plugin,
+				schema,
+				state,
+				walk,
+				walkerCtx: ctx$1
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				hasLazyExpression: state.hasLazyExpression["~ref"],
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		postProcess(result, schema, ctx$1) {
+			if (ctx$1.plugin.config.metadata && schema.description) {
+				const z = ctx$1.plugin.external("zod.z");
+				return {
+					...result,
+					expression: { expression: result.expression.expression.attr(identifiers.register).call($(z).attr(identifiers.globalRegistry), $.object().pretty().prop("description", $.literal(schema.description))) }
+				};
+			}
+			return result;
+		},
+		reference($ref, schema, ctx$1) {
+			const z = ctx$1.plugin.external("zod.z");
+			const query = {
+				category: "schema",
+				resource: "definition",
+				resourceId: $ref,
+				tool: "zod"
+			};
+			const refSymbol = ctx$1.plugin.referenceSymbol(query);
+			if (ctx$1.plugin.isSymbolRegistered(query)) return {
+				default: schema.default,
+				expression: { expression: $(refSymbol) },
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+			state.hasLazyExpression["~ref"] = true;
+			return {
+				default: schema.default,
+				expression: { expression: $(z).attr(identifiers.lazy).call($.func().returns("any").do($(refSymbol).return())) },
+				hasLazyExpression: true,
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		string(schema, ctx$1) {
+			if (shouldCoerceToBigInt(schema.format)) {
+				const ast$1 = numberToNode({
+					plugin: ctx$1.plugin,
+					schema: {
+						...schema,
+						type: "number"
+					},
+					state
+				});
+				return {
+					default: schema.default,
+					expression: ast$1,
+					nullable: false,
+					readonly: schema.accessScope === "read"
+				};
+			}
+			const ast = stringToNode({
+				...ctx$1,
+				schema
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		tuple(schema, ctx$1, walk) {
+			const applyModifiers = (result, opts) => this.applyModifiers(result, ctx$1, opts);
+			const ast = tupleToAst({
+				...ctx$1,
+				applyModifiers,
+				schema,
+				state,
+				walk
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				hasLazyExpression: state.hasLazyExpression["~ref"],
+				nullable: false,
+				readonly: schema.accessScope === "read"
+			};
+		},
+		undefined(schema, ctx$1) {
+			const ast = undefinedToAst({
+				...ctx$1,
+				schema
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				nullable: false,
+				readonly: false
+			};
+		},
+		union(items, schemas, parentSchema, ctx$1) {
+			const z = ctx$1.plugin.external("zod.z");
+			const hasAnyLazy = items.some((item) => item.hasLazyExpression);
+			const hasNull = schemas.some((s) => s.type === "null") || items.some((i) => i.nullable);
+			const nonNullItems = [];
+			items.forEach((item, index) => {
+				if (schemas[index].type !== "null") nonNullItems.push(item);
+			});
+			let expression;
+			if (nonNullItems.length === 0) expression = { expression: $(z).attr(identifiers.null).call() };
+			else if (nonNullItems.length === 1) expression = nonNullItems[0].expression;
+			else expression = { expression: $(z).attr(identifiers.union).call($.array().pretty().elements(...nonNullItems.map((item) => item.expression.expression))) };
+			return {
+				default: parentSchema.default,
+				expression,
+				hasLazyExpression: hasAnyLazy,
+				nullable: hasNull,
+				readonly: items.some((i) => i.readonly)
+			};
+		},
+		unknown(schema, ctx$1) {
+			const ast = unknownToAst({
+				...ctx$1,
+				schema
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				nullable: false,
+				readonly: false
+			};
+		},
+		void(schema, ctx$1) {
+			const ast = voidToAst({
+				...ctx$1,
+				schema
+			});
+			return {
+				default: schema.default,
+				expression: ast,
+				nullable: false,
+				readonly: false
+			};
+		}
+	};
 }
 
 //#endregion
-//#region src/plugins/zod/v4/plugin.ts
-function irSchemaToAst({ optional, plugin, schema, schemaExtractor, state }) {
-	if (schemaExtractor && !schema.$ref) {
-		const extracted = schemaExtractor({
-			meta: {
-				resource: "definition",
-				resourceId: pathToJsonPointer(fromRef(state.path))
-			},
-			naming: plugin.config.definitions,
-			path: fromRef(state.path),
-			plugin,
-			schema
-		});
-		if (extracted !== schema) schema = extracted;
-	}
-	let ast = {};
-	const z = plugin.external("zod.z");
-	if (schema.$ref) {
-		const query = {
-			category: "schema",
-			resource: "definition",
-			resourceId: schema.$ref,
-			tool: "zod"
-		};
-		const refSymbol = plugin.referenceSymbol(query);
-		if (plugin.isSymbolRegistered(query)) ast.expression = $(refSymbol);
-		else {
-			ast.expression = $(z).attr(identifiers.lazy).call($.func().returns("any").do($(refSymbol).return()));
-			ast.hasLazyExpression = true;
-			state.hasLazyExpression["~ref"] = true;
+//#region src/plugins/zod/v4/processor.ts
+function createProcessor(plugin) {
+	const processor = createSchemaProcessor();
+	const hooks = [plugin.config["~hooks"]?.schemas, plugin.context.config.parser.hooks.schemas];
+	function extractor(ctx$1) {
+		if (processor.hasEmitted(ctx$1.path)) return ctx$1.schema;
+		for (const hook of hooks) if (hook?.shouldExtract?.(ctx$1)) {
+			process$1({
+				namingAnchor: processor.context.anchor,
+				tags: processor.context.tags,
+				...ctx$1
+			});
+			return { $ref: pathToJsonPointer(ctx$1.path) };
 		}
-	} else if (schema.type) {
-		const typeAst = irSchemaWithTypeToAst({
-			plugin,
-			schema,
-			state
-		});
-		ast.expression = typeAst.expression;
-		ast.hasLazyExpression = typeAst.hasLazyExpression;
-		if (plugin.config.metadata && schema.description) ast.expression = ast.expression.attr(identifiers.register).call($(z).attr(identifiers.globalRegistry), $.object().pretty().prop("description", $.literal(schema.description)));
-	} else if (schema.items) {
-		schema = deduplicateSchema({ schema });
-		if (schema.items) {
-			const itemSchemas = schema.items.map((item, index) => irSchemaToAst({
+		return ctx$1.schema;
+	}
+	function process$1(ctx$1) {
+		if (!processor.markEmitted(ctx$1.path)) return;
+		processor.withContext({
+			anchor: ctx$1.namingAnchor,
+			tags: ctx$1.tags
+		}, () => {
+			const state = refs({
+				hasLazyExpression: false,
+				path: ctx$1.path,
+				tags: ctx$1.tags
+			});
+			const visitor = createVisitor({
+				schemaExtractor: extractor,
+				state
+			});
+			const result = createSchemaWalker(visitor)(ctx$1.schema, {
+				path: ref(ctx$1.path),
+				plugin
+			});
+			const ast = visitor.applyModifiers(result, {
+				path: ref(ctx$1.path),
+				plugin
+			}) ?? result.expression;
+			if (result.hasLazyExpression) state.hasLazyExpression["~ref"] = true;
+			exportAst({
+				...ctx$1,
+				ast,
 				plugin,
-				schema: item,
-				state: {
-					...state,
-					path: ref([
-						...fromRef(state.path),
-						"items",
-						index
-					])
-				}
-			}));
-			if (schema.logicalOperator === "and") {
-				const firstSchema = schema.items[0];
-				if (firstSchema.logicalOperator === "or" || firstSchema.type && firstSchema.type !== "object") ast.expression = $(z).attr(identifiers.intersection).call(...itemSchemas.map((schema$1) => schema$1.expression));
-				else {
-					ast.expression = itemSchemas[0].expression;
-					itemSchemas.slice(1).forEach((schema$1) => {
-						ast.expression = ast.expression.attr(identifiers.and).call(schema$1.hasLazyExpression ? $(z).attr(identifiers.lazy).call($.func().do(schema$1.expression.return())) : schema$1.expression);
-					});
-				}
-			} else ast.expression = $(z).attr(identifiers.union).call($.array().pretty().elements(...itemSchemas.map((schema$1) => schema$1.expression)));
-		} else ast = irSchemaToAst({
-			plugin,
-			schema,
-			state
-		});
-	} else {
-		const typeAst = irSchemaWithTypeToAst({
-			plugin,
-			schema: { type: "unknown" },
-			state
+				state
+			});
 		});
-		ast.expression = typeAst.expression;
-	}
-	if (ast.expression) {
-		if (schema.accessScope === "read") ast.expression = ast.expression.attr(identifiers.readonly).call();
-		if (optional) {
-			ast.expression = $(z).attr(identifiers.optional).call(ast.expression);
-			ast.typeName = identifiers.ZodOptional;
-		}
-		if (schema.default !== void 0) ast.expression = ast.expression.attr(identifiers.default).call(schema.type === "integer" || schema.type === "number" ? maybeBigInt(schema.default, schema.format) : $.fromValue(schema.default));
 	}
-	return ast;
+	return { process: process$1 };
 }
+
+//#endregion
+//#region src/plugins/zod/v4/plugin.ts
 const handlerV4 = ({ plugin }) => {
 	plugin.symbol("z", {
 		external: getZodModule({ plugin }),
@@ -13638,4 +14118,4 @@ async function resolveJobs({ logger, userConfigs }) {
 
 //#endregion
 export { postProcessors as _, clientDefaultConfig as a, TypeScriptRenderer as c, reserved as d, keywords as f, getTypedConfig as g, getClientPlugin as h, generateClientBundle as i, TsDslContext as l, TsDsl as m, defaultPlugins as n, clientDefaultMeta as o, regexp as p, clientPluginHandler as r, $ as s, resolveJobs as t, ctx as u };
-//# sourceMappingURL=init-BxMu9GWq.mjs.map
+//# sourceMappingURL=init-BVQKw3ZX.mjs.map