@hey-api/openapi-ts 0.92.2 → 0.92.4

package/dist/{init-DlaW5Djq.mjs → init-BxMu9GWq.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, deduplicateSchema, definePluginConfig, dependencyFactory, ensureDirSync, escapeComment, findTsConfigPath, getInput, getLogs, getParser, hasOperationDataRequired, hasParameterGroupObjectRequired, loadTsConfig, mappers, operationPagination, operationResponsesMap, parseUrl, pathToJsonPointer, refToName, resolveSource, satisfies, statusCodeToGroup, toCase, valueToObject } from "@hey-api/shared";
+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 colors from "ansi-colors";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -167,7 +167,7 @@ function getOutput(userConfig) {
 		value: userOutput
 	});
 	output.tsConfig = loadTsConfig(findTsConfigPath(__dirname$1, output.tsConfigPath));
-	if (output.importFileExtension === void 0 && (output.tsConfig?.options.moduleResolution === ts.ModuleResolutionKind.NodeNext || output.tsConfig?.options.moduleResolution === ts.ModuleResolutionKind.Node16)) output.importFileExtension = ".js";
+	if (output.importFileExtension === void 0 && (output.tsConfig?.options.moduleResolution === ts.ModuleResolutionKind.NodeNext || output.tsConfig?.options.moduleResolution === ts.ModuleResolutionKind.Node16 || output.tsConfig?.options.module === ts.ModuleKind.NodeNext || output.tsConfig?.options.module === ts.ModuleKind.Node16)) output.importFileExtension = ".js";
 	if (output.importFileExtension && !output.importFileExtension.startsWith(".")) output.importFileExtension = `.${output.importFileExtension}`;
 	output.postProcess = normalizePostProcess(userOutput.postProcess ?? legacyPostProcess);
 	output.source = resolveSource(output);
@@ -5026,7 +5026,13 @@ function implementHttpRequestFn(args) {
 		role: "data",
 		tool: "typescript"
 	});
-	return node.param("options", (p) => p.required(isRequiredOptions).type($.type(symbolOptions).generic(symbolDataType ?? "unknown").generic("ThrowOnError"))).generic("ThrowOnError", (g) => g.extends("boolean").default(false)).returns($.type(symbolHttpRequest).generic("unknown")).do($.return($("options").attr("client").optional().$if(symbolClient, (c, s) => c.coalesce(s)).attr("requestOptions").call($.object().prop("responseStyle", $.literal("data")).prop("method", $.literal(operation.method.toUpperCase())).prop("url", $.literal(operation.path)).spread("options"))));
+	const symbolResponseType = plugin.querySymbol({
+		category: "type",
+		resource: "operation",
+		resourceId: operation.id,
+		role: "response"
+	});
+	return node.param("options", (p) => p.required(isRequiredOptions).type($.type(symbolOptions).generic(symbolDataType ?? "unknown").generic("ThrowOnError"))).generic("ThrowOnError", (g) => g.extends("boolean").default(false)).returns($.type(symbolHttpRequest).generic(symbolResponseType ?? "unknown")).do($.return($("options").attr("client").optional().$if(symbolClient, (c, s) => c.coalesce(s)).attr("requestOptions").call($.object().prop("responseStyle", $.literal("data")).prop("method", $.literal(operation.method.toUpperCase())).prop("url", $.literal(operation.path)).spread("options")).generic(symbolResponseType ?? "unknown").generic("ThrowOnError")));
 }
 function implementHttpResourceFn(args) {
 	const { node, operation, plugin } = args;
@@ -5277,11 +5283,7 @@ const defaultConfig$22 = {
 				enabled: true,
 				name: "v{{name}}"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.definitions
 		});
 	},
@@ -6365,13 +6367,19 @@ const processSchemaType = ({ dataExpression, plugin, schema }) => {
 			return arrayNodes;
 		}
 		if (schema.type !== "enum") {
-			if (!(schema.items ?? []).every((item) => [
+			const hasSimpleTypes = (schema.items ?? []).every((item) => [
 				"boolean",
 				"integer",
 				"null",
 				"number",
 				"string"
-			].includes(item.type))) console.warn(`❗️ Transformers warning: schema ${JSON.stringify(schema)} is too complex and won't be currently processed. This will likely produce an incomplete transformer which is not what you want. Please open an issue if you'd like this improved https://github.com/hey-api/openapi-ts/issues`);
+			].includes(item.type));
+			const isProcessable = (schema.items ?? []).every((item) => {
+				if (item.$ref) return true;
+				if (item.logicalOperator === "and" && item.items) return true;
+				return false;
+			});
+			if (!hasSimpleTypes && !isProcessable) console.warn(`❗️ Transformers warning: schema ${JSON.stringify(schema)} is too complex and won't be currently processed. This will likely produce an incomplete transformer which is not what you want. Please open an issue if you'd like this improved https://github.com/hey-api/openapi-ts/issues`);
 		}
 	}
 	for (const transformer of plugin.config.transformers) {
@@ -6388,7 +6396,7 @@ const handler$8 = ({ plugin }) => {
 	plugin.forEach("operation", ({ operation }) => {
 		const { response } = operationResponsesMap(operation);
 		if (!response) return;
-		if (response.items && response.items.length > 1) {
+		if (response.items && response.items.length > 1 && response.logicalOperator !== "and") {
 			if (plugin.context.config.logs.level === "debug") console.warn(`❗️ Transformers warning: route ${createOperationKey(operation)} has ${response.items.length} non-void success responses. This is currently not handled and we will not generate a response transformer. Please open an issue if you'd like this feature https://github.com/hey-api/openapi-ts/issues`);
 			return;
 		}
@@ -6484,6 +6492,7 @@ const createSchemaComment = (schema) => {
 //#endregion
 //#region src/plugins/@hey-api/typescript/shared/export.ts
 const schemaToEnumObject = ({ plugin, schema }) => {
+	const keyCounts = {};
 	const typeofItems = [];
 	return {
 		obj: (schema.items ?? []).map((item, index) => {
@@ -6499,6 +6508,19 @@ const schemaToEnumObject = ({ plugin, schema }) => {
 				key = toCase(key, plugin.config.enums.case, { stripLeadingSeparators: false });
 				regexp.number.lastIndex = 0;
 				if (regexp.number.test(key) && plugin.config.enums.enabled && (plugin.config.enums.mode === "typescript" || plugin.config.enums.mode === "typescript-const")) key = `_${key}`;
+				const keyCount = (keyCounts[key] ?? 0) + 1;
+				keyCounts[key] = keyCount;
+				if (keyCount > 1) {
+					const nameConflictResolver = plugin.context.config.output?.nameConflictResolver;
+					if (nameConflictResolver) {
+						const resolvedName = nameConflictResolver({
+							attempt: keyCount - 1,
+							baseName: key
+						});
+						if (resolvedName !== null) key = resolvedName;
+						else key = `${key}${keyCount}`;
+					} else key = `${key}${keyCount}`;
+				}
 			}
 			return {
 				key,
@@ -6797,10 +6819,10 @@ const arrayToAst$4 = ({ plugin, schema, state }) => {
 
 //#endregion
 //#region src/plugins/@hey-api/typescript/v1/toAst/boolean.ts
-const booleanToAst$4 = ({ schema }) => {
+function booleanToAst$4({ 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
@@ -6983,7 +7005,7 @@ const voidToAst$4 = (_args) => {
 
 //#endregion
 //#region src/plugins/@hey-api/typescript/v1/toAst/index.ts
-const irSchemaWithTypeToAst$5 = ({ schema, ...args }) => {
+function irSchemaWithTypeToAst$5({ 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 });
@@ -7040,11 +7062,22 @@ const irSchemaWithTypeToAst$5 = ({ schema, ...args }) => {
 			schema
 		});
 	}
-};
+}
 
 //#endregion
 //#region src/plugins/@hey-api/typescript/v1/plugin.ts
-const irSchemaToAst$5 = ({ plugin, schema, state }) => {
+function irSchemaToAst$5({ plugin, schema, schemaExtractor, state }) {
+	if (schemaExtractor && !schema.$ref) {
+		const extracted = schemaExtractor({
+			meta: {
+				resource: "definition",
+				resourceId: pathToJsonPointer(fromRef(state.path))
+			},
+			path: fromRef(state.path),
+			schema
+		});
+		if (extracted !== schema) schema = extracted;
+	}
 	if (schema.symbolRef) {
 		const baseType = $.type(schema.symbolRef);
 		if (schema.omit && schema.omit.length > 0) {
@@ -7095,8 +7128,8 @@ const irSchemaToAst$5 = ({ plugin, schema, state }) => {
 		schema: { type: "unknown" },
 		state
 	});
-};
-const handleComponent$5 = ({ plugin, schema, state }) => {
+}
+function handleComponent$1({ plugin, schema, state }) {
 	exportType({
 		plugin,
 		schema,
@@ -7107,7 +7140,7 @@ const handleComponent$5 = ({ plugin, schema, state }) => {
 			state
 		})
 	});
-};
+}
 const handlerV1$1 = ({ plugin }) => {
 	const nodeClientIndex = plugin.node(null);
 	const nodeWebhooksIndex = plugin.node(null);
@@ -7127,21 +7160,21 @@ const handlerV1$1 = ({ plugin }) => {
 				});
 				break;
 			case "parameter":
-				handleComponent$5({
+				handleComponent$1({
 					plugin,
 					schema: event.parameter.schema,
 					state
 				});
 				break;
 			case "requestBody":
-				handleComponent$5({
+				handleComponent$1({
 					plugin,
 					schema: event.requestBody.schema,
 					state
 				});
 				break;
 			case "schema":
-				handleComponent$5({
+				handleComponent$1({
 					plugin,
 					schema: event.schema,
 					state
@@ -7579,11 +7612,7 @@ const defaultConfig$10 = {
 				enabled: true,
 				name: "{{name}}Mutation"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.mutationOptions
 		});
 		plugin.config.queryKeys = context.valueToObject({
@@ -7593,11 +7622,7 @@ const defaultConfig$10 = {
 				name: "{{name}}QueryKey",
 				tags: false
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.queryKeys
 		});
 		plugin.config.queryOptions = context.valueToObject({
@@ -7606,11 +7631,7 @@ const defaultConfig$10 = {
 				enabled: true,
 				name: "{{name}}Query"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.queryOptions
 		});
 	}
@@ -8034,11 +8055,7 @@ const defaultConfig$9 = {
 				name: "{{name}}InfiniteQueryKey",
 				tags: false
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.infiniteQueryKeys
 		});
 		plugin.config.infiniteQueryOptions = context.valueToObject({
@@ -8047,11 +8064,7 @@ const defaultConfig$9 = {
 				enabled: true,
 				name: "{{name}}InfiniteOptions"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.infiniteQueryOptions
 		});
 		plugin.config.mutationOptions = context.valueToObject({
@@ -8060,11 +8073,7 @@ const defaultConfig$9 = {
 				enabled: true,
 				name: "{{name}}Mutation"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.mutationOptions
 		});
 		plugin.config.queryKeys = context.valueToObject({
@@ -8074,11 +8083,7 @@ const defaultConfig$9 = {
 				name: "{{name}}QueryKey",
 				tags: false
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.queryKeys
 		});
 		plugin.config.queryOptions = context.valueToObject({
@@ -8088,11 +8093,7 @@ const defaultConfig$9 = {
 				exported: true,
 				name: "{{name}}Options"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.queryOptions
 		});
 	}
@@ -8121,11 +8122,7 @@ const defaultConfig$8 = {
 				name: "{{name}}InfiniteQueryKey",
 				tags: false
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.infiniteQueryKeys
 		});
 		plugin.config.infiniteQueryOptions = context.valueToObject({
@@ -8134,11 +8131,7 @@ const defaultConfig$8 = {
 				enabled: true,
 				name: "{{name}}InfiniteOptions"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.infiniteQueryOptions
 		});
 		plugin.config.mutationOptions = context.valueToObject({
@@ -8147,11 +8140,7 @@ const defaultConfig$8 = {
 				enabled: true,
 				name: "{{name}}Mutation"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.mutationOptions
 		});
 		plugin.config.queryKeys = context.valueToObject({
@@ -8161,11 +8150,7 @@ const defaultConfig$8 = {
 				name: "{{name}}QueryKey",
 				tags: false
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.queryKeys
 		});
 		plugin.config.queryOptions = context.valueToObject({
@@ -8175,11 +8160,7 @@ const defaultConfig$8 = {
 				exported: true,
 				name: "{{name}}Options"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.queryOptions
 		});
 		plugin.config.useQuery = context.valueToObject({
@@ -8237,11 +8218,7 @@ const defaultConfig$7 = {
 				name: "{{name}}InfiniteQueryKey",
 				tags: false
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.infiniteQueryKeys
 		});
 		plugin.config.infiniteQueryOptions = context.valueToObject({
@@ -8250,11 +8227,7 @@ const defaultConfig$7 = {
 				enabled: true,
 				name: "{{name}}InfiniteOptions"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.infiniteQueryOptions
 		});
 		plugin.config.mutationOptions = context.valueToObject({
@@ -8263,11 +8236,7 @@ const defaultConfig$7 = {
 				enabled: true,
 				name: "{{name}}Mutation"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.mutationOptions
 		});
 		plugin.config.queryKeys = context.valueToObject({
@@ -8277,11 +8246,7 @@ const defaultConfig$7 = {
 				name: "{{name}}QueryKey",
 				tags: false
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.queryKeys
 		});
 		plugin.config.queryOptions = context.valueToObject({
@@ -8291,11 +8256,7 @@ const defaultConfig$7 = {
 				exported: true,
 				name: "{{name}}Options"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.queryOptions
 		});
 	}
@@ -8324,11 +8285,7 @@ const defaultConfig$6 = {
 				name: "{{name}}InfiniteQueryKey",
 				tags: false
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.infiniteQueryKeys
 		});
 		plugin.config.infiniteQueryOptions = context.valueToObject({
@@ -8337,11 +8294,7 @@ const defaultConfig$6 = {
 				enabled: true,
 				name: "{{name}}InfiniteOptions"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.infiniteQueryOptions
 		});
 		plugin.config.mutationOptions = context.valueToObject({
@@ -8350,11 +8303,7 @@ const defaultConfig$6 = {
 				enabled: true,
 				name: "{{name}}Mutation"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.mutationOptions
 		});
 		plugin.config.queryKeys = context.valueToObject({
@@ -8364,11 +8313,7 @@ const defaultConfig$6 = {
 				name: "{{name}}QueryKey",
 				tags: false
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.queryKeys
 		});
 		plugin.config.queryOptions = context.valueToObject({
@@ -8378,11 +8323,7 @@ const defaultConfig$6 = {
 				exported: true,
 				name: "{{name}}Options"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.queryOptions
 		});
 	}
@@ -8411,11 +8352,7 @@ const defaultConfig$5 = {
 				name: "{{name}}InfiniteQueryKey",
 				tags: false
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.infiniteQueryKeys
 		});
 		plugin.config.infiniteQueryOptions = context.valueToObject({
@@ -8424,11 +8361,7 @@ const defaultConfig$5 = {
 				enabled: true,
 				name: "{{name}}InfiniteOptions"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.infiniteQueryOptions
 		});
 		plugin.config.mutationOptions = context.valueToObject({
@@ -8437,11 +8370,7 @@ const defaultConfig$5 = {
 				enabled: true,
 				name: "{{name}}Mutation"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.mutationOptions
 		});
 		plugin.config.queryKeys = context.valueToObject({
@@ -8451,11 +8380,7 @@ const defaultConfig$5 = {
 				name: "{{name}}QueryKey",
 				tags: false
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.queryKeys
 		});
 		plugin.config.queryOptions = context.valueToObject({
@@ -8465,11 +8390,7 @@ const defaultConfig$5 = {
 				exported: true,
 				name: "{{name}}Options"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.queryOptions
 		});
 	}
@@ -8623,7 +8544,7 @@ const identifiers$2 = {
 
 //#endregion
 //#region src/plugins/arktype/shared/export.ts
-const exportAst$2 = ({ ast, plugin, schema, symbol, typeInferSymbol }) => {
+function exportAst$2({ ast, plugin, schema, symbol, typeInferSymbol }) {
 	const type = plugin.external("arktype.type");
 	const statement = $.const(symbol).export().$if(plugin.config.comments && createSchemaComment(schema), (c, v) => c.doc(v)).assign($(type).call(ast.def ? $.literal(ast.def) : ast.expression));
 	plugin.node(statement);
@@ -8631,7 +8552,7 @@ const exportAst$2 = ({ ast, plugin, schema, symbol, typeInferSymbol }) => {
 		const inferType = $.type.alias(typeInferSymbol).export().type($.type(symbol).attr(identifiers$2.type.infer).typeofType());
 		plugin.node(inferType);
 	}
-};
+}
 
 //#endregion
 //#region src/plugins/arktype/v2/toAst/null.ts
@@ -8730,7 +8651,7 @@ const stringToAst = ({ schema }) => {
 
 //#endregion
 //#region src/plugins/arktype/v2/toAst/index.ts
-const irSchemaWithTypeToAst$4 = ({ schema, ...args }) => {
+function irSchemaWithTypeToAst$4({ schema, ...args }) {
 	switch (schema.type) {
 		case "null": return nullToAst$4({
 			...args,
@@ -8750,11 +8671,22 @@ const irSchemaWithTypeToAst$4 = ({ schema, ...args }) => {
 		expression: $(args.plugin.external("arktype.type")).call($.object().prop("name", $.literal("string")).prop("platform", $.literal("'android' | 'ios'")).prop("versions?", $.literal("(number | string)[]"))),
 		hasLazyExpression: false
 	};
-};
+}
 
 //#endregion
 //#region src/plugins/arktype/v2/plugin.ts
-const irSchemaToAst$4 = ({ plugin, schema, state }) => {
+function irSchemaToAst$4({ plugin, schema, schemaExtractor, state }) {
+	if (schemaExtractor && !schema.$ref) {
+		const extracted = schemaExtractor({
+			meta: {
+				resource: "definition",
+				resourceId: pathToJsonPointer(fromRef(state.path))
+			},
+			path: fromRef(state.path),
+			schema
+		});
+		if (extracted !== schema) schema = extracted;
+	}
 	let ast = {};
 	if (schema.$ref) {
 		const query = {
@@ -8808,8 +8740,8 @@ const irSchemaToAst$4 = ({ plugin, schema, state }) => {
 		ast.expression = typeAst.expression;
 	}
 	return ast;
-};
-const handleComponent$4 = ({ plugin, schema, state }) => {
+}
+function handleComponent({ plugin, schema, state }) {
 	const $ref = pathToJsonPointer(fromRef(state.path));
 	const ast = irSchemaToAst$4({
 		plugin,
@@ -8838,7 +8770,7 @@ const handleComponent$4 = ({ plugin, schema, state }) => {
 			variant: "infer"
 		} }) : void 0
 	});
-};
+}
 const handlerV2$1 = ({ plugin }) => {
 	plugin.symbol("type", {
 		external: "arktype",
@@ -8855,21 +8787,21 @@ const handlerV2$1 = ({ plugin }) => {
 		});
 		switch (event.type) {
 			case "parameter":
-				handleComponent$4({
+				handleComponent({
 					plugin,
 					schema: event.parameter.schema,
 					state
 				});
 				break;
 			case "requestBody":
-				handleComponent$4({
+				handleComponent({
 					plugin,
 					schema: event.requestBody.schema,
 					state
 				});
 				break;
 			case "schema":
-				handleComponent$4({
+				handleComponent({
 					plugin,
 					schema: event.schema,
 					state
@@ -9226,11 +9158,7 @@ const defaultConfig$2 = {
 				name: "{{name}}InfiniteQueryKey",
 				tags: false
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.infiniteQueryKeys
 		});
 		plugin.config.infiniteQueryOptions = context.valueToObject({
@@ -9239,11 +9167,7 @@ const defaultConfig$2 = {
 				enabled: true,
 				name: "{{name}}InfiniteOptions"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.infiniteQueryOptions
 		});
 		plugin.config.mutationOptions = context.valueToObject({
@@ -9252,11 +9176,7 @@ const defaultConfig$2 = {
 				enabled: true,
 				name: "{{name}}Mutation"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.mutationOptions
 		});
 		plugin.config.queryKeys = context.valueToObject({
@@ -9266,11 +9186,7 @@ const defaultConfig$2 = {
 				name: "{{name}}QueryKey",
 				tags: false
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.queryKeys
 		});
 		plugin.config.queryOptions = context.valueToObject({
@@ -9280,11 +9196,7 @@ const defaultConfig$2 = {
 				exported: true,
 				name: "{{name}}Options"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.queryOptions
 		});
 		plugin.config.useSwr = context.valueToObject({
@@ -9674,243 +9586,203 @@ const maybeBigInt = (value, format) => {
 };
 
 //#endregion
-//#region src/plugins/valibot/shared/export.ts
-const exportAst$1 = ({ ast, plugin, schema, state, symbol }) => {
-	const v = plugin.external("valibot.v");
-	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));
-	plugin.node(statement);
-};
+//#region src/plugins/valibot/shared/operation-schema.ts
+function buildOperationSchema$1(operation) {
+	const requiredProperties = /* @__PURE__ */ new Set();
+	const schema = {
+		properties: {
+			body: { type: "never" },
+			path: { type: "never" },
+			query: { type: "never" }
+		},
+		type: "object"
+	};
+	if (operation.parameters) for (const location of [
+		"header",
+		"path",
+		"query"
+	]) {
+		const params = operation.parameters[location];
+		if (!params) continue;
+		const properties = {};
+		const required = [];
+		const propKey = location === "header" ? "headers" : location;
+		for (const key in params) {
+			const parameter = params[key];
+			properties[parameter.name] = parameter.schema;
+			if (parameter.required) {
+				required.push(parameter.name);
+				requiredProperties.add(propKey);
+			}
+		}
+		if (Object.keys(properties).length) schema.properties[propKey] = {
+			properties,
+			required,
+			type: "object"
+		};
+	}
+	if (operation.body) {
+		schema.properties.body = operation.body.schema;
+		if (operation.body.required) requiredProperties.add("body");
+	}
+	schema.required = [...requiredProperties];
+	return {
+		required: schema.required,
+		schema
+	};
+}
 
 //#endregion
 //#region src/plugins/valibot/shared/operation.ts
-const irOperationToAst$1 = ({ getAst, operation, plugin, state }) => {
+function irOperationToAst$1({ operation, path: path$1, plugin, processor, tags }) {
 	if (plugin.config.requests.enabled) {
-		const requiredProperties = /* @__PURE__ */ new Set();
-		const schemaData = {
-			properties: {
-				body: { type: "never" },
-				path: { type: "never" },
-				query: { type: "never" }
-			},
-			type: "object"
-		};
-		if (operation.parameters) {
-			if (operation.parameters.header) {
-				const properties = {};
-				const required = [];
-				for (const key in operation.parameters.header) {
-					const parameter = operation.parameters.header[key];
-					properties[parameter.name] = parameter.schema;
-					if (parameter.required) {
-						required.push(parameter.name);
-						requiredProperties.add("headers");
-					}
-				}
-				if (Object.keys(properties).length) schemaData.properties.headers = {
-					properties,
-					required,
-					type: "object"
-				};
-			}
-			if (operation.parameters.path) {
-				const properties = {};
-				const required = [];
-				for (const key in operation.parameters.path) {
-					const parameter = operation.parameters.path[key];
-					properties[parameter.name] = parameter.schema;
-					if (parameter.required) {
-						required.push(parameter.name);
-						requiredProperties.add("path");
-					}
-				}
-				if (Object.keys(properties).length) schemaData.properties.path = {
-					properties,
-					required,
-					type: "object"
-				};
-			}
-			if (operation.parameters.query) {
-				const properties = {};
-				const required = [];
-				for (const key in operation.parameters.query) {
-					const parameter = operation.parameters.query[key];
-					properties[parameter.name] = parameter.schema;
-					if (parameter.required) {
-						required.push(parameter.name);
-						requiredProperties.add("query");
-					}
-				}
-				if (Object.keys(properties).length) schemaData.properties.query = {
-					properties,
-					required,
-					type: "object"
-				};
-			}
-		}
-		if (operation.body) {
-			schemaData.properties.body = operation.body.schema;
-			if (operation.body.required) requiredProperties.add("body");
-		}
-		schemaData.required = [...requiredProperties];
-		exportAst$1({
-			ast: getAst(schemaData, fromRef(state.path)),
-			plugin,
-			schema: schemaData,
-			state,
-			symbol: plugin.symbol(applyNaming(operation.id, plugin.config.requests), { meta: {
-				category: "schema",
-				path: fromRef(state.path),
+		const { schema } = buildOperationSchema$1(operation);
+		processor.process({
+			meta: {
 				resource: "operation",
 				resourceId: operation.id,
-				role: "data",
-				tags: fromRef(state.tags),
-				tool: "valibot"
-			} })
+				role: "data"
+			},
+			naming: plugin.config.requests,
+			namingAnchor: operation.id,
+			path: path$1,
+			plugin,
+			schema,
+			tags
 		});
 	}
 	if (plugin.config.responses.enabled) {
 		if (operation.responses) {
 			const { response } = operationResponsesMap(operation);
-			if (response) {
-				const path$1 = [...fromRef(state.path), "responses"];
-				exportAst$1({
-					ast: getAst(response, path$1),
-					plugin,
-					schema: response,
-					state,
-					symbol: plugin.symbol(applyNaming(operation.id, plugin.config.responses), { meta: {
-						category: "schema",
-						path: path$1,
-						resource: "operation",
-						resourceId: operation.id,
-						role: "responses",
-						tags: fromRef(state.tags),
-						tool: "valibot"
-					} })
-				});
-			}
+			if (response) processor.process({
+				meta: {
+					resource: "operation",
+					resourceId: operation.id,
+					role: "responses"
+				},
+				naming: plugin.config.responses,
+				namingAnchor: operation.id,
+				path: [...path$1, "responses"],
+				plugin,
+				schema: response,
+				tags
+			});
 		}
 	}
-};
+}
 
 //#endregion
 //#region src/plugins/valibot/shared/webhook.ts
-const irWebhookToAst$1 = ({ getAst, operation, plugin, state }) => {
+function irWebhookToAst$1({ operation, path: path$1, plugin, processor, tags }) {
 	if (plugin.config.webhooks.enabled) {
-		const requiredProperties = /* @__PURE__ */ new Set();
-		const schemaData = {
-			properties: {
-				body: { type: "never" },
-				path: { type: "never" },
-				query: { type: "never" }
-			},
-			type: "object"
-		};
-		if (operation.parameters) {
-			if (operation.parameters.header) {
-				const properties = {};
-				const required = [];
-				for (const key in operation.parameters.header) {
-					const parameter = operation.parameters.header[key];
-					properties[parameter.name] = parameter.schema;
-					if (parameter.required) {
-						required.push(parameter.name);
-						requiredProperties.add("headers");
-					}
-				}
-				if (Object.keys(properties).length) schemaData.properties.headers = {
-					properties,
-					required,
-					type: "object"
-				};
-			}
-			if (operation.parameters.path) {
-				const properties = {};
-				const required = [];
-				for (const key in operation.parameters.path) {
-					const parameter = operation.parameters.path[key];
-					properties[parameter.name] = parameter.schema;
-					if (parameter.required) {
-						required.push(parameter.name);
-						requiredProperties.add("path");
-					}
-				}
-				if (Object.keys(properties).length) schemaData.properties.path = {
-					properties,
-					required,
-					type: "object"
-				};
-			}
-			if (operation.parameters.query) {
-				const properties = {};
-				const required = [];
-				for (const key in operation.parameters.query) {
-					const parameter = operation.parameters.query[key];
-					properties[parameter.name] = parameter.schema;
-					if (parameter.required) {
-						required.push(parameter.name);
-						requiredProperties.add("query");
-					}
-				}
-				if (Object.keys(properties).length) schemaData.properties.query = {
-					properties,
-					required,
-					type: "object"
-				};
-			}
-		}
-		if (operation.body) {
-			schemaData.properties.body = operation.body.schema;
-			if (operation.body.required) requiredProperties.add("body");
-		}
-		schemaData.required = [...requiredProperties];
-		exportAst$1({
-			ast: getAst(schemaData, fromRef(state.path)),
-			plugin,
-			schema: schemaData,
-			state,
-			symbol: plugin.symbol(applyNaming(operation.id, plugin.config.webhooks), { meta: {
-				category: "schema",
-				path: fromRef(state.path),
+		const { schema } = buildOperationSchema$1(operation);
+		processor.process({
+			meta: {
 				resource: "webhook",
 				resourceId: operation.id,
-				role: "data",
-				tags: fromRef(state.tags),
-				tool: "valibot"
-			} })
+				role: "data"
+			},
+			naming: plugin.config.webhooks,
+			namingAnchor: operation.id,
+			path: path$1,
+			plugin,
+			schema,
+			tags
 		});
 	}
-};
+}
+
+//#endregion
+//#region src/plugins/valibot/shared/export.ts
+function exportAst$1({ ast, meta, naming, namingAnchor, path: path$1, plugin, schema, state, tags }) {
+	const v = plugin.external("valibot.v");
+	const name = pathToName(path$1, { anchor: namingAnchor });
+	const symbol = plugin.symbol(applyNaming(name, naming), { meta: {
+		category: "schema",
+		path: path$1,
+		tags,
+		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));
+	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
+			});
+		});
+	}
+	return { process: process$1 };
+}
 
 //#endregion
 //#region src/plugins/valibot/v1/toAst/unknown.ts
-const unknownToAst$3 = ({ plugin }) => {
+function unknownToAst$3({ plugin }) {
 	return $(plugin.external("valibot.v")).attr(identifiers$1.schemas.unknown).call();
-};
+}
 
 //#endregion
 //#region src/plugins/valibot/v1/toAst/array.ts
-const arrayToAst$3 = ({ plugin, schema, state }) => {
+function arrayToAst$3(options) {
+	const { plugin } = options;
+	let { schema } = options;
 	const result = { pipes: [] };
 	const v = plugin.external("valibot.v");
 	const functionName = $(v).attr(identifiers$1.schemas.array);
 	if (!schema.items) {
 		const expression = functionName.call(unknownToAst$3({
-			plugin,
-			schema: { type: "unknown" },
-			state
+			...options,
+			schema: { type: "unknown" }
 		}));
 		result.pipes.push(expression);
 	} else {
 		schema = deduplicateSchema({ schema });
 		const itemExpressions = schema.items.map((item, index) => {
 			const itemAst = irSchemaToAst$3({
-				plugin,
+				...options,
 				schema: item,
 				state: {
-					...state,
+					...options.state,
 					path: ref([
-						...fromRef(state.path),
+						...fromRef(options.state.path),
 						"items",
 						index
 					])
@@ -9925,9 +9797,8 @@ const arrayToAst$3 = ({ plugin, schema, state }) => {
 		} else {
 			if (schema.logicalOperator === "and") {}
 			const expression = functionName.call(unknownToAst$3({
-				plugin,
-				schema: { type: "unknown" },
-				state
+				...options,
+				schema: { type: "unknown" }
 			}));
 			result.pipes.push(expression);
 		}
@@ -9946,11 +9817,11 @@ const arrayToAst$3 = ({ plugin, schema, state }) => {
 		}
 	}
 	return result;
-};
+}
 
 //#endregion
 //#region src/plugins/valibot/v1/toAst/boolean.ts
-const booleanToAst$3 = ({ plugin, schema }) => {
+function booleanToAst$3({ plugin, schema }) {
 	const pipes$1 = [];
 	const v = plugin.external("valibot.v");
 	if (typeof schema.const === "boolean") {
@@ -9959,7 +9830,7 @@ const booleanToAst$3 = ({ plugin, schema }) => {
 	}
 	pipes$1.push($(v).attr(identifiers$1.schemas.boolean).call());
 	return pipesToNode(pipes$1, plugin);
-};
+}
 
 //#endregion
 //#region src/plugins/valibot/v1/toAst/enum.ts
@@ -9997,7 +9868,7 @@ function enumResolver$3(ctx$1) {
 	if (nullableExpression) return nullableExpression;
 	return ctx$1.pipes.current;
 }
-const enumToAst$3 = ({ plugin, schema, state }) => {
+function enumToAst$3({ plugin, schema, state }) {
 	const v = plugin.external("valibot.v");
 	const { enumMembers } = itemsNode$3({
 		$,
@@ -10039,19 +9910,19 @@ const enumToAst$3 = ({ plugin, schema, state }) => {
 	const resolver = plugin.config["~resolvers"]?.enum;
 	const node = resolver?.(ctx$1) ?? enumResolver$3(ctx$1);
 	return ctx$1.pipes.toNode(node, plugin);
-};
+}
 
 //#endregion
 //#region src/plugins/valibot/v1/toAst/never.ts
-const neverToAst$3 = ({ plugin }) => {
+function neverToAst$3({ plugin }) {
 	return $(plugin.external("valibot.v")).attr(identifiers$1.schemas.never).call();
-};
+}
 
 //#endregion
 //#region src/plugins/valibot/v1/toAst/null.ts
-const nullToAst$3 = ({ plugin }) => {
+function nullToAst$3({ plugin }) {
 	return $(plugin.external("valibot.v")).attr(identifiers$1.schemas.null).call();
-};
+}
 
 //#endregion
 //#region src/plugins/shared/utils/formats.ts
@@ -10125,7 +9996,7 @@ function numberResolver$3(ctx$1) {
 	if (maxNode$4) ctx$1.pipes.push(ctx$1.pipes.current, maxNode$4);
 	return ctx$1.pipes.current;
 }
-const numberToNode$3 = ({ plugin, schema }) => {
+function numberToNode$3({ plugin, schema }) {
 	const ctx$1 = {
 		$,
 		nodes: {
@@ -10150,7 +10021,7 @@ const numberToNode$3 = ({ plugin, schema }) => {
 	const resolver = plugin.config["~resolvers"]?.number;
 	const node = resolver?.(ctx$1) ?? numberResolver$3(ctx$1);
 	return ctx$1.pipes.toNode(node, plugin);
-};
+}
 
 //#endregion
 //#region src/plugins/valibot/v1/toAst/object.ts
@@ -10159,7 +10030,7 @@ function additionalPropertiesNode$3(ctx$1) {
 	if (!schema.additionalProperties || !schema.additionalProperties.type) return;
 	if (schema.additionalProperties.type === "never") return null;
 	const additionalAst = irSchemaToAst$3({
-		plugin,
+		...ctx$1,
 		schema: schema.additionalProperties,
 		state: {
 			...ctx$1.utils.state,
@@ -10190,8 +10061,8 @@ function shapeNode$3(ctx$1) {
 	for (const name in schema.properties) {
 		const property = schema.properties[name];
 		const propertyAst = irSchemaToAst$3({
+			...ctx$1,
 			optional: !schema.required?.includes(name),
-			plugin,
 			schema: property,
 			state: {
 				...ctx$1.utils.state,
@@ -10207,8 +10078,10 @@ function shapeNode$3(ctx$1) {
 	}
 	return shape;
 }
-const objectToAst$3 = ({ plugin, schema, state }) => {
+function objectToAst$3(options) {
+	const { plugin } = options;
 	const ctx$1 = {
+		...options,
 		$,
 		nodes: {
 			additionalProperties: additionalPropertiesNode$3,
@@ -10219,19 +10092,17 @@ const objectToAst$3 = ({ plugin, schema, state }) => {
 			...pipes,
 			current: []
 		},
-		plugin,
-		schema,
 		symbols: { v: plugin.external("valibot.v") },
 		utils: {
 			ast: {},
-			state
+			state: options.state
 		}
 	};
 	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;
-};
+}
 
 //#endregion
 //#region src/plugins/valibot/v1/toAst/string.ts
@@ -10302,7 +10173,7 @@ function stringResolver$3(ctx$1) {
 	if (patternNode$4) ctx$1.pipes.push(ctx$1.pipes.current, patternNode$4);
 	return ctx$1.pipes.current;
 }
-const stringToNode$3 = ({ plugin, schema }) => {
+function stringToNode$3({ plugin, schema }) {
 	const ctx$1 = {
 		$,
 		nodes: {
@@ -10325,11 +10196,12 @@ const stringToNode$3 = ({ plugin, schema }) => {
 	const resolver = plugin.config["~resolvers"]?.string;
 	const node = resolver?.(ctx$1) ?? stringResolver$3(ctx$1);
 	return ctx$1.pipes.toNode(node, plugin);
-};
+}
 
 //#endregion
 //#region src/plugins/valibot/v1/toAst/tuple.ts
-const tupleToAst$3 = ({ plugin, schema, state }) => {
+function tupleToAst$3(options) {
+	const { plugin, schema } = options;
 	const result = {};
 	const v = plugin.external("valibot.v");
 	if (schema.const && Array.isArray(schema.const)) {
@@ -10340,12 +10212,12 @@ const tupleToAst$3 = ({ plugin, schema, state }) => {
 	if (schema.items) {
 		const tupleElements = schema.items.map((item, index) => {
 			const schemaPipes = irSchemaToAst$3({
-				plugin,
+				...options,
 				schema: item,
 				state: {
-					...state,
+					...options.state,
 					path: ref([
-						...fromRef(state.path),
+						...fromRef(options.state.path),
 						"items",
 						index
 					])
@@ -10358,27 +10230,26 @@ const tupleToAst$3 = ({ plugin, schema, state }) => {
 		return result;
 	}
 	return { pipes: [unknownToAst$3({
-		plugin,
-		schema: { type: "unknown" },
-		state
+		...options,
+		schema: { type: "unknown" }
 	})] };
-};
+}
 
 //#endregion
 //#region src/plugins/valibot/v1/toAst/undefined.ts
-const undefinedToAst$3 = ({ plugin }) => {
+function undefinedToAst$3({ plugin }) {
 	return $(plugin.external("valibot.v")).attr(identifiers$1.schemas.undefined).call();
-};
+}
 
 //#endregion
 //#region src/plugins/valibot/v1/toAst/void.ts
-const voidToAst$3 = ({ plugin }) => {
+function voidToAst$3({ plugin }) {
 	return $(plugin.external("valibot.v")).attr(identifiers$1.schemas.void).call();
-};
+}
 
 //#endregion
 //#region src/plugins/valibot/v1/toAst/index.ts
-const irSchemaWithTypeToAst$3 = ({ schema, ...args }) => {
+function irSchemaWithTypeToAst$3({ schema, ...args }) {
 	switch (schema.type) {
 		case "array": return { expression: pipesToNode(arrayToAst$3({
 			...args,
@@ -10436,11 +10307,24 @@ const irSchemaWithTypeToAst$3 = ({ schema, ...args }) => {
 			schema
 		}) };
 	}
-};
+}
 
 //#endregion
 //#region src/plugins/valibot/v1/plugin.ts
-const irSchemaToAst$3 = ({ optional, plugin, schema, state }) => {
+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) {
@@ -10463,6 +10347,7 @@ const irSchemaToAst$3 = ({ optional, plugin, schema, state }) => {
 		const typeAst = irSchemaWithTypeToAst$3({
 			plugin,
 			schema,
+			schemaExtractor,
 			state
 		});
 		ast.typeName = typeAst.anyType;
@@ -10478,6 +10363,7 @@ const irSchemaToAst$3 = ({ optional, plugin, schema, state }) => {
 				return pipesToNode(irSchemaToAst$3({
 					plugin,
 					schema: item,
+					schemaExtractor,
 					state: {
 						...state,
 						path: ref([
@@ -10507,6 +10393,7 @@ const irSchemaToAst$3 = ({ optional, plugin, schema, state }) => {
 		const typeAst = irSchemaWithTypeToAst$3({
 			plugin,
 			schema: { type: "unknown" },
+			schemaExtractor,
 			state
 		});
 		ast.typeName = typeAst.anyType;
@@ -10521,30 +10408,7 @@ const irSchemaToAst$3 = ({ optional, plugin, schema, state }) => {
 		else if (optional) ast.pipes = [$(v).attr(identifiers$1.schemas.optional).call(pipesToNode(ast.pipes, plugin))];
 	}
 	return ast;
-};
-const handleComponent$3 = ({ plugin, schema, state }) => {
-	const $ref = pathToJsonPointer(fromRef(state.path));
-	const ast = irSchemaToAst$3({
-		plugin,
-		schema,
-		state
-	});
-	const baseName = refToName($ref);
-	exportAst$1({
-		ast,
-		plugin,
-		schema,
-		state,
-		symbol: plugin.symbol(applyNaming(baseName, plugin.config.definitions), { meta: {
-			category: "schema",
-			path: fromRef(state.path),
-			resource: "definition",
-			resourceId: $ref,
-			tags: fromRef(state.tags),
-			tool: "valibot"
-		} })
-	});
-};
+}
 const handlerV1 = ({ plugin }) => {
 	plugin.symbol("v", {
 		external: "valibot",
@@ -10554,68 +10418,64 @@ const handlerV1 = ({ plugin }) => {
 			resource: "valibot.v"
 		}
 	});
+	const processor = createProcessor$3(plugin);
 	plugin.forEach("operation", "parameter", "requestBody", "schema", "webhook", (event) => {
-		const state = refs({
-			hasLazyExpression: false,
-			path: event._path,
-			tags: event.tags
-		});
 		switch (event.type) {
 			case "operation":
 				irOperationToAst$1({
-					getAst: (schema, path$1) => {
-						return irSchemaToAst$3({
-							plugin,
-							schema,
-							state: refs({
-								hasLazyExpression: false,
-								path: path$1,
-								tags: event.tags
-							})
-						});
-					},
 					operation: event.operation,
+					path: event._path,
 					plugin,
-					state
+					processor,
+					tags: event.tags
 				});
 				break;
 			case "parameter":
-				handleComponent$3({
+				processor.process({
+					meta: {
+						resource: "definition",
+						resourceId: pathToJsonPointer(event._path)
+					},
+					naming: plugin.config.definitions,
+					path: event._path,
 					plugin,
 					schema: event.parameter.schema,
-					state
+					tags: event.tags
 				});
 				break;
 			case "requestBody":
-				handleComponent$3({
+				processor.process({
+					meta: {
+						resource: "definition",
+						resourceId: pathToJsonPointer(event._path)
+					},
+					naming: plugin.config.definitions,
+					path: event._path,
 					plugin,
 					schema: event.requestBody.schema,
-					state
+					tags: event.tags
 				});
 				break;
 			case "schema":
-				handleComponent$3({
+				processor.process({
+					meta: {
+						resource: "definition",
+						resourceId: pathToJsonPointer(event._path)
+					},
+					naming: plugin.config.definitions,
+					path: event._path,
 					plugin,
 					schema: event.schema,
-					state
+					tags: event.tags
 				});
 				break;
 			case "webhook":
 				irWebhookToAst$1({
-					getAst: (schema, path$1) => {
-						return irSchemaToAst$3({
-							plugin,
-							schema,
-							state: refs({
-								hasLazyExpression: false,
-								path: path$1,
-								tags: event.tags
-							})
-						});
-					},
 					operation: event.operation,
+					path: event._path,
 					plugin,
-					state
+					processor,
+					tags: event.tags
 				});
 				break;
 		}
@@ -10645,11 +10505,7 @@ const defaultConfig$1 = {
 				enabled: true,
 				name: "v{{name}}"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.definitions
 		});
 		plugin.config.requests = context.valueToObject({
@@ -10658,11 +10514,7 @@ const defaultConfig$1 = {
 				enabled: true,
 				name: "v{{name}}Data"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.requests
 		});
 		plugin.config.responses = context.valueToObject({
@@ -10671,11 +10523,7 @@ const defaultConfig$1 = {
 				enabled: true,
 				name: "v{{name}}Response"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.responses
 		});
 		plugin.config.webhooks = context.valueToObject({
@@ -10684,11 +10532,7 @@ const defaultConfig$1 = {
 				enabled: true,
 				name: "v{{name}}WebhookRequest"
 			},
-			mappers: {
-				boolean: (enabled) => ({ enabled }),
-				function: (name) => ({ name }),
-				string: (name) => ({ name })
-			},
+			mappers,
 			value: plugin.config.webhooks
 		});
 	},
@@ -10972,21 +10816,9 @@ var Api = class {
 	}
 };
 
-//#endregion
-//#region src/plugins/zod/shared/export.ts
-const exportAst = ({ ast, plugin, schema, symbol, typeInferSymbol }) => {
-	const z = plugin.external("zod.z");
-	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);
-	plugin.node(statement);
-	if (typeInferSymbol) {
-		const inferType = $.type.alias(typeInferSymbol).export().type($.type(z).attr(identifiers.infer).generic($(symbol).typeofType()));
-		plugin.node(inferType);
-	}
-};
-
 //#endregion
 //#region src/plugins/zod/shared/module.ts
-const getZodModule = ({ plugin }) => {
+function getZodModule({ plugin }) {
 	const version = plugin.package.getVersion("zod");
 	if (version) {
 		if (plugin.package.satisfies(version, "<4.0.0")) switch (plugin.config.compatibilityVersion) {
@@ -11002,235 +10834,187 @@ const getZodModule = ({ plugin }) => {
 		default: return "zod";
 		case "mini": return "zod/mini";
 	}
-};
+}
 
 //#endregion
-//#region src/plugins/zod/shared/operation.ts
-const irOperationToAst = ({ getAst, operation, plugin, state }) => {
-	if (plugin.config.requests.enabled) {
-		const requiredProperties = /* @__PURE__ */ new Set();
-		const schemaData = {
-			properties: {
-				body: { type: "never" },
-				path: { type: "never" },
-				query: { type: "never" }
-			},
-			type: "object"
-		};
-		if (operation.parameters) {
-			if (operation.parameters.header) {
-				const properties = {};
-				const required = [];
-				for (const key in operation.parameters.header) {
-					const parameter = operation.parameters.header[key];
-					properties[parameter.name] = parameter.schema;
-					if (parameter.required) {
-						required.push(parameter.name);
-						requiredProperties.add("headers");
-					}
-				}
-				if (Object.keys(properties).length) schemaData.properties.headers = {
-					properties,
-					required,
-					type: "object"
-				};
-			}
-			if (operation.parameters.path) {
-				const properties = {};
-				const required = [];
-				for (const key in operation.parameters.path) {
-					const parameter = operation.parameters.path[key];
-					properties[parameter.name] = parameter.schema;
-					if (parameter.required) {
-						required.push(parameter.name);
-						requiredProperties.add("path");
-					}
-				}
-				if (Object.keys(properties).length) schemaData.properties.path = {
-					properties,
-					required,
-					type: "object"
-				};
-			}
-			if (operation.parameters.query) {
-				const properties = {};
-				const required = [];
-				for (const key in operation.parameters.query) {
-					const parameter = operation.parameters.query[key];
-					properties[parameter.name] = parameter.schema;
-					if (parameter.required) {
-						required.push(parameter.name);
-						requiredProperties.add("query");
-					}
-				}
-				if (Object.keys(properties).length) schemaData.properties.query = {
-					properties,
-					required,
-					type: "object"
-				};
+//#region src/plugins/zod/shared/operation-schema.ts
+function buildOperationSchema(operation) {
+	const requiredProperties = /* @__PURE__ */ new Set();
+	const schema = {
+		properties: {
+			body: { type: "never" },
+			path: { type: "never" },
+			query: { type: "never" }
+		},
+		type: "object"
+	};
+	if (operation.parameters) for (const location of [
+		"header",
+		"path",
+		"query"
+	]) {
+		const params = operation.parameters[location];
+		if (!params) continue;
+		const properties = {};
+		const required = [];
+		const propKey = location === "header" ? "headers" : location;
+		for (const key in params) {
+			const parameter = params[key];
+			properties[parameter.name] = parameter.schema;
+			if (parameter.required) {
+				required.push(parameter.name);
+				requiredProperties.add(propKey);
 			}
 		}
-		if (operation.body) {
-			schemaData.properties.body = operation.body.schema;
-			if (operation.body.required) requiredProperties.add("body");
-		}
-		schemaData.required = [...requiredProperties];
-		exportAst({
-			ast: getAst(schemaData, fromRef(state.path)),
-			plugin,
-			schema: schemaData,
-			symbol: plugin.symbol(applyNaming(operation.id, plugin.config.requests), { meta: {
-				category: "schema",
-				path: fromRef(state.path),
-				resource: "operation",
-				resourceId: operation.id,
-				role: "data",
-				tags: fromRef(state.tags),
-				tool: "zod"
-			} }),
-			typeInferSymbol: plugin.config.requests.types.infer.enabled ? plugin.symbol(applyNaming(operation.id, plugin.config.requests.types.infer), { meta: {
-				category: "type",
-				path: fromRef(state.path),
+		if (Object.keys(properties).length) schema.properties[propKey] = {
+			properties,
+			required,
+			type: "object"
+		};
+	}
+	if (operation.body) {
+		schema.properties.body = operation.body.schema;
+		if (operation.body.required) requiredProperties.add("body");
+	}
+	schema.required = [...requiredProperties];
+	return {
+		required: schema.required,
+		schema
+	};
+}
+
+//#endregion
+//#region src/plugins/zod/shared/operation.ts
+function irOperationToAst({ operation, path: path$1, plugin, processor, tags }) {
+	if (plugin.config.requests.enabled) {
+		const { schema } = buildOperationSchema(operation);
+		processor.process({
+			meta: {
 				resource: "operation",
 				resourceId: operation.id,
-				role: "data",
-				tags: fromRef(state.tags),
-				tool: "zod",
-				variant: "infer"
-			} }) : void 0
+				role: "data"
+			},
+			naming: plugin.config.requests,
+			namingAnchor: operation.id,
+			path: path$1,
+			plugin,
+			schema,
+			tags
 		});
 	}
 	if (plugin.config.responses.enabled) {
 		if (operation.responses) {
 			const { response } = operationResponsesMap(operation);
-			if (response) {
-				const path$1 = [...fromRef(state.path), "responses"];
-				exportAst({
-					ast: getAst(response, path$1),
-					plugin,
-					schema: response,
-					symbol: plugin.symbol(applyNaming(operation.id, plugin.config.responses), { meta: {
-						category: "schema",
-						path: path$1,
-						resource: "operation",
-						resourceId: operation.id,
-						role: "responses",
-						tags: fromRef(state.tags),
-						tool: "zod"
-					} }),
-					typeInferSymbol: plugin.config.responses.types.infer.enabled ? plugin.symbol(applyNaming(operation.id, plugin.config.responses.types.infer), { meta: {
-						category: "type",
-						path: path$1,
-						resource: "operation",
-						resourceId: operation.id,
-						role: "responses",
-						tags: fromRef(state.tags),
-						tool: "zod",
-						variant: "infer"
-					} }) : void 0
-				});
-			}
+			if (response) processor.process({
+				meta: {
+					resource: "operation",
+					resourceId: operation.id,
+					role: "responses"
+				},
+				naming: plugin.config.responses,
+				namingAnchor: operation.id,
+				path: [...path$1, "responses"],
+				plugin,
+				schema: response,
+				tags
+			});
 		}
 	}
-};
+}
+
+//#endregion
+//#region src/plugins/zod/shared/webhook.ts
+function irWebhookToAst({ operation, path: path$1, plugin, processor, tags }) {
+	if (plugin.config.webhooks.enabled) {
+		const { schema } = buildOperationSchema(operation);
+		processor.process({
+			meta: {
+				resource: "webhook",
+				resourceId: operation.id,
+				role: "data"
+			},
+			naming: plugin.config.webhooks,
+			namingAnchor: operation.id,
+			path: path$1,
+			plugin,
+			schema,
+			tags
+		});
+	}
+}
+
+//#endregion
+//#region src/plugins/zod/shared/export.ts
+function exportAst({ ast, meta, naming, namingAnchor, path: path$1, plugin, schema, tags }) {
+	const z = plugin.external("zod.z");
+	const name = pathToName(path$1, { anchor: namingAnchor });
+	const symbol = plugin.symbol(applyNaming(name, naming), { meta: {
+		category: "schema",
+		path: path$1,
+		tags,
+		tool: "zod",
+		...meta
+	} });
+	const typeInferSymbol = naming.types.infer.enabled ? plugin.symbol(applyNaming(name, naming.types.infer), { meta: {
+		category: "type",
+		path: path$1,
+		tags,
+		tool: "zod",
+		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);
+	plugin.node(statement);
+	if (typeInferSymbol) {
+		const inferType = $.type.alias(typeInferSymbol).export().type($.type(z).attr(identifiers.infer).generic($(symbol).typeofType()));
+		plugin.node(inferType);
+	}
+}
 
 //#endregion
-//#region src/plugins/zod/shared/webhook.ts
-const irWebhookToAst = ({ getAst, operation, plugin, state }) => {
-	if (plugin.config.webhooks.enabled) {
-		const requiredProperties = /* @__PURE__ */ new Set();
-		const schemaData = {
-			properties: {
-				body: { type: "never" },
-				path: { type: "never" },
-				query: { type: "never" }
-			},
-			type: "object"
-		};
-		if (operation.parameters) {
-			if (operation.parameters.header) {
-				const properties = {};
-				const required = [];
-				for (const key in operation.parameters.header) {
-					const parameter = operation.parameters.header[key];
-					properties[parameter.name] = parameter.schema;
-					if (parameter.required) {
-						required.push(parameter.name);
-						requiredProperties.add("headers");
-					}
-				}
-				if (Object.keys(properties).length) schemaData.properties.headers = {
-					properties,
-					required,
-					type: "object"
-				};
-			}
-			if (operation.parameters.path) {
-				const properties = {};
-				const required = [];
-				for (const key in operation.parameters.path) {
-					const parameter = operation.parameters.path[key];
-					properties[parameter.name] = parameter.schema;
-					if (parameter.required) {
-						required.push(parameter.name);
-						requiredProperties.add("path");
-					}
-				}
-				if (Object.keys(properties).length) schemaData.properties.path = {
-					properties,
-					required,
-					type: "object"
-				};
-			}
-			if (operation.parameters.query) {
-				const properties = {};
-				const required = [];
-				for (const key in operation.parameters.query) {
-					const parameter = operation.parameters.query[key];
-					properties[parameter.name] = parameter.schema;
-					if (parameter.required) {
-						required.push(parameter.name);
-						requiredProperties.add("query");
-					}
-				}
-				if (Object.keys(properties).length) schemaData.properties.query = {
-					properties,
-					required,
-					type: "object"
-				};
-			}
-		}
-		if (operation.body) {
-			schemaData.properties.body = operation.body.schema;
-			if (operation.body.required) requiredProperties.add("body");
-		}
-		schemaData.required = [...requiredProperties];
-		exportAst({
-			ast: getAst(schemaData, fromRef(state.path)),
-			plugin,
-			schema: schemaData,
-			symbol: plugin.symbol(applyNaming(operation.id, plugin.config.webhooks), { meta: {
-				category: "schema",
-				path: fromRef(state.path),
-				resource: "webhook",
-				resourceId: operation.id,
-				role: "data",
-				tags: fromRef(state.tags),
-				tool: "zod"
-			} }),
-			typeInferSymbol: plugin.config.webhooks.types.infer.enabled ? plugin.symbol(applyNaming(operation.id, plugin.config.webhooks.types.infer), { meta: {
-				category: "type",
-				path: fromRef(state.path),
-				resource: "webhook",
-				resourceId: operation.id,
-				role: "data",
-				tags: fromRef(state.tags),
-				tool: "zod",
-				variant: "infer"
-			} }) : void 0
+//#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
@@ -11294,7 +11078,7 @@ const arrayToAst$2 = ({ plugin, schema, state }) => {
 
 //#endregion
 //#region src/plugins/zod/mini/toAst/boolean.ts
-const booleanToAst$2 = ({ plugin, schema }) => {
+function booleanToAst$2({ plugin, schema }) {
 	const result = {};
 	let chain;
 	const z = plugin.external("zod.z");
@@ -11306,7 +11090,7 @@ const booleanToAst$2 = ({ plugin, schema }) => {
 	chain = $(z).attr(identifiers.boolean).call();
 	result.expression = chain;
 	return result;
-};
+}
 
 //#endregion
 //#region src/plugins/zod/mini/toAst/enum.ts
@@ -11724,7 +11508,7 @@ const voidToAst$2 = ({ plugin }) => {
 
 //#endregion
 //#region src/plugins/zod/mini/toAst/index.ts
-const irSchemaWithTypeToAst$2 = ({ schema, ...args }) => {
+function irSchemaWithTypeToAst$2({ schema, ...args }) {
 	switch (schema.type) {
 		case "array": return arrayToAst$2({
 			...args,
@@ -11782,11 +11566,24 @@ const irSchemaWithTypeToAst$2 = ({ schema, ...args }) => {
 			schema
 		});
 	}
-};
+}
 
 //#endregion
 //#region src/plugins/zod/mini/plugin.ts
-const irSchemaToAst$2 = ({ optional, plugin, schema, state }) => {
+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) {
@@ -11859,38 +11656,7 @@ const irSchemaToAst$2 = ({ optional, plugin, schema, state }) => {
 		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 handleComponent$2 = ({ plugin, schema, state }) => {
-	const $ref = pathToJsonPointer(fromRef(state.path));
-	const ast = irSchemaToAst$2({
-		plugin,
-		schema,
-		state
-	});
-	const baseName = refToName($ref);
-	exportAst({
-		ast,
-		plugin,
-		schema,
-		symbol: plugin.symbol(applyNaming(baseName, plugin.config.definitions), { meta: {
-			category: "schema",
-			path: fromRef(state.path),
-			resource: "definition",
-			resourceId: $ref,
-			tags: fromRef(state.tags),
-			tool: "zod"
-		} }),
-		typeInferSymbol: plugin.config.definitions.types.infer.enabled ? plugin.symbol(applyNaming(baseName, plugin.config.definitions.types.infer), { meta: {
-			category: "type",
-			path: fromRef(state.path),
-			resource: "definition",
-			resourceId: $ref,
-			tags: fromRef(state.tags),
-			tool: "zod",
-			variant: "infer"
-		} }) : void 0
-	});
-};
+}
 const handlerMini = ({ plugin }) => {
 	plugin.symbol("z", {
 		external: getZodModule({ plugin }),
@@ -11900,74 +11666,115 @@ const handlerMini = ({ plugin }) => {
 			resource: "zod.z"
 		}
 	});
+	const processor = createProcessor$2(plugin);
 	plugin.forEach("operation", "parameter", "requestBody", "schema", "webhook", (event) => {
-		const state = refs({
-			hasLazyExpression: false,
-			path: event._path,
-			tags: event.tags
-		});
 		switch (event.type) {
 			case "operation":
 				irOperationToAst({
-					getAst: (schema, path$1) => {
-						return irSchemaToAst$2({
-							plugin,
-							schema,
-							state: refs({
-								hasLazyExpression: false,
-								path: path$1,
-								tags: event.tags
-							})
-						});
-					},
 					operation: event.operation,
+					path: event._path,
 					plugin,
-					state
+					processor,
+					tags: event.tags
 				});
 				break;
 			case "parameter":
-				handleComponent$2({
+				processor.process({
+					meta: {
+						resource: "definition",
+						resourceId: pathToJsonPointer(event._path)
+					},
+					naming: plugin.config.definitions,
+					path: event._path,
 					plugin,
 					schema: event.parameter.schema,
-					state
+					tags: event.tags
 				});
 				break;
 			case "requestBody":
-				handleComponent$2({
+				processor.process({
+					meta: {
+						resource: "definition",
+						resourceId: pathToJsonPointer(event._path)
+					},
+					naming: plugin.config.definitions,
+					path: event._path,
 					plugin,
 					schema: event.requestBody.schema,
-					state
+					tags: event.tags
 				});
 				break;
 			case "schema":
-				handleComponent$2({
+				processor.process({
+					meta: {
+						resource: "definition",
+						resourceId: pathToJsonPointer(event._path)
+					},
+					naming: plugin.config.definitions,
+					path: event._path,
 					plugin,
 					schema: event.schema,
-					state
+					tags: event.tags
 				});
 				break;
 			case "webhook":
 				irWebhookToAst({
-					getAst: (schema, path$1) => {
-						return irSchemaToAst$2({
-							plugin,
-							schema,
-							state: refs({
-								hasLazyExpression: false,
-								path: path$1,
-								tags: event.tags
-							})
-						});
-					},
 					operation: event.operation,
+					path: event._path,
 					plugin,
-					state
+					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
+			});
+			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$1({
+				plugin,
+				schema: ctx$1.schema,
+				schemaExtractor: extractor,
+				state
+			});
+			exportAst({
+				...ctx$1,
+				ast,
+				plugin,
+				state
+			});
+		});
+	}
+	return { process: process$1 };
+}
+
 //#endregion
 //#region src/plugins/zod/v3/toAst/unknown.ts
 const unknownToAst$1 = ({ plugin }) => {
@@ -12029,7 +11836,7 @@ const arrayToAst$1 = ({ plugin, schema, state }) => {
 
 //#endregion
 //#region src/plugins/zod/v3/toAst/boolean.ts
-const booleanToAst$1 = ({ plugin, schema }) => {
+function booleanToAst$1({ plugin, schema }) {
 	let chain;
 	const z = plugin.external("zod.z");
 	if (typeof schema.const === "boolean") {
@@ -12038,7 +11845,7 @@ const booleanToAst$1 = ({ plugin, schema }) => {
 	}
 	chain = $(z).attr(identifiers.boolean).call();
 	return chain;
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v3/toAst/enum.ts
@@ -12436,7 +12243,7 @@ const voidToAst$1 = ({ plugin }) => {
 
 //#endregion
 //#region src/plugins/zod/v3/toAst/index.ts
-const irSchemaWithTypeToAst$1 = ({ schema, ...args }) => {
+function irSchemaWithTypeToAst$1({ schema, ...args }) {
 	switch (schema.type) {
 		case "array": return arrayToAst$1({
 			...args,
@@ -12494,11 +12301,24 @@ const irSchemaWithTypeToAst$1 = ({ schema, ...args }) => {
 			schema
 		}) };
 	}
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v3/plugin.ts
-const irSchemaToAst$1 = ({ optional, plugin, schema, state }) => {
+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) {
@@ -12574,38 +12394,7 @@ const irSchemaToAst$1 = ({ optional, plugin, schema, state }) => {
 		if (!ast.typeName) ast.typeName = "ZodTypeAny";
 	} else if (ast.typeName) ast.typeName = void 0;
 	return ast;
-};
-const handleComponent$1 = ({ plugin, schema, state }) => {
-	const $ref = pathToJsonPointer(fromRef(state.path));
-	const ast = irSchemaToAst$1({
-		plugin,
-		schema,
-		state
-	});
-	const baseName = refToName($ref);
-	exportAst({
-		ast,
-		plugin,
-		schema,
-		symbol: plugin.symbol(applyNaming(baseName, plugin.config.definitions), { meta: {
-			category: "schema",
-			path: fromRef(state.path),
-			resource: "definition",
-			resourceId: $ref,
-			tags: fromRef(state.tags),
-			tool: "zod"
-		} }),
-		typeInferSymbol: plugin.config.definitions.types.infer.enabled ? plugin.symbol(applyNaming(baseName, plugin.config.definitions.types.infer), { meta: {
-			category: "type",
-			path: fromRef(state.path),
-			resource: "definition",
-			resourceId: $ref,
-			tags: fromRef(state.tags),
-			tool: "zod",
-			variant: "infer"
-		} }) : void 0
-	});
-};
+}
 const handlerV3 = ({ plugin }) => {
 	plugin.symbol("z", {
 		external: getZodModule({ plugin }),
@@ -12614,74 +12403,115 @@ const handlerV3 = ({ plugin }) => {
 			resource: "zod.z"
 		}
 	});
+	const processor = createProcessor$1(plugin);
 	plugin.forEach("operation", "parameter", "requestBody", "schema", "webhook", (event) => {
-		const state = refs({
-			hasLazyExpression: false,
-			path: event._path,
-			tags: event.tags
-		});
 		switch (event.type) {
 			case "operation":
 				irOperationToAst({
-					getAst: (schema, path$1) => {
-						return irSchemaToAst$1({
-							plugin,
-							schema,
-							state: refs({
-								hasLazyExpression: false,
-								path: path$1,
-								tags: event.tags
-							})
-						});
-					},
 					operation: event.operation,
+					path: event._path,
 					plugin,
-					state
+					processor,
+					tags: event.tags
 				});
 				break;
 			case "parameter":
-				handleComponent$1({
+				processor.process({
+					meta: {
+						resource: "definition",
+						resourceId: pathToJsonPointer(event._path)
+					},
+					naming: plugin.config.definitions,
+					path: event._path,
 					plugin,
 					schema: event.parameter.schema,
-					state
+					tags: event.tags
 				});
 				break;
 			case "requestBody":
-				handleComponent$1({
+				processor.process({
+					meta: {
+						resource: "definition",
+						resourceId: pathToJsonPointer(event._path)
+					},
+					naming: plugin.config.definitions,
+					path: event._path,
 					plugin,
 					schema: event.requestBody.schema,
-					state
+					tags: event.tags
 				});
 				break;
 			case "schema":
-				handleComponent$1({
+				processor.process({
+					meta: {
+						resource: "definition",
+						resourceId: pathToJsonPointer(event._path)
+					},
+					naming: plugin.config.definitions,
+					path: event._path,
 					plugin,
 					schema: event.schema,
-					state
+					tags: event.tags
 				});
 				break;
 			case "webhook":
 				irWebhookToAst({
-					getAst: (schema, path$1) => {
-						return irSchemaToAst$1({
-							plugin,
-							schema,
-							state: refs({
-								hasLazyExpression: false,
-								path: path$1,
-								tags: event.tags
-							})
-						});
-					},
 					operation: event.operation,
+					path: event._path,
 					plugin,
-					state
+					processor,
+					tags: event.tags
 				});
 				break;
 		}
 	});
 };
 
+//#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 }) => {
@@ -12741,7 +12571,7 @@ const arrayToAst = ({ plugin, schema, state }) => {
 
 //#endregion
 //#region src/plugins/zod/v4/toAst/boolean.ts
-const booleanToAst = ({ plugin, schema }) => {
+function booleanToAst({ plugin, schema }) {
 	const result = {};
 	let chain;
 	const z = plugin.external("zod.z");
@@ -12753,7 +12583,7 @@ const booleanToAst = ({ plugin, schema }) => {
 	chain = $(z).attr(identifiers.boolean).call();
 	result.expression = chain;
 	return result;
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v4/toAst/enum.ts
@@ -13157,7 +12987,7 @@ const voidToAst = ({ plugin }) => {
 
 //#endregion
 //#region src/plugins/zod/v4/toAst/index.ts
-const irSchemaWithTypeToAst = ({ schema, ...args }) => {
+function irSchemaWithTypeToAst({ schema, ...args }) {
 	switch (schema.type) {
 		case "array": return arrayToAst({
 			...args,
@@ -13215,11 +13045,24 @@ const irSchemaWithTypeToAst = ({ schema, ...args }) => {
 			schema
 		});
 	}
-};
+}
 
 //#endregion
 //#region src/plugins/zod/v4/plugin.ts
-const irSchemaToAst = ({ optional, plugin, schema, state }) => {
+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) {
@@ -13292,108 +13135,74 @@ const irSchemaToAst = ({ optional, plugin, schema, state }) => {
 		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;
-};
-const handleComponent = ({ plugin, schema, state }) => {
-	const $ref = pathToJsonPointer(fromRef(state.path));
-	const ast = irSchemaToAst({
-		plugin,
-		schema,
-		state
-	});
-	const baseName = refToName($ref);
-	exportAst({
-		ast,
-		plugin,
-		schema,
-		symbol: plugin.symbol(applyNaming(baseName, plugin.config.definitions), { meta: {
-			category: "schema",
-			path: fromRef(state.path),
-			resource: "definition",
-			resourceId: $ref,
-			tags: fromRef(state.tags),
-			tool: "zod"
-		} }),
-		typeInferSymbol: plugin.config.definitions.types.infer.enabled ? plugin.symbol(applyNaming(baseName, plugin.config.definitions.types.infer), { meta: {
-			category: "type",
-			path: fromRef(state.path),
-			resource: "definition",
-			resourceId: $ref,
-			tags: fromRef(state.tags),
-			tool: "zod",
-			variant: "infer"
-		} }) : void 0
-	});
-};
+}
 const handlerV4 = ({ plugin }) => {
 	plugin.symbol("z", {
 		external: getZodModule({ plugin }),
+		importKind: "namespace",
 		meta: {
 			category: "external",
 			resource: "zod.z"
 		}
 	});
+	const processor = createProcessor(plugin);
 	plugin.forEach("operation", "parameter", "requestBody", "schema", "webhook", (event) => {
-		const state = refs({
-			hasLazyExpression: false,
-			path: event._path,
-			tags: event.tags
-		});
 		switch (event.type) {
 			case "operation":
 				irOperationToAst({
-					getAst: (schema, path$1) => {
-						return irSchemaToAst({
-							plugin,
-							schema,
-							state: refs({
-								hasLazyExpression: false,
-								path: path$1,
-								tags: event.tags
-							})
-						});
-					},
 					operation: event.operation,
+					path: event._path,
 					plugin,
-					state
+					processor,
+					tags: event.tags
 				});
 				break;
 			case "parameter":
-				handleComponent({
+				processor.process({
+					meta: {
+						resource: "definition",
+						resourceId: pathToJsonPointer(event._path)
+					},
+					naming: plugin.config.definitions,
+					path: event._path,
 					plugin,
 					schema: event.parameter.schema,
-					state
+					tags: event.tags
 				});
 				break;
 			case "requestBody":
-				handleComponent({
+				processor.process({
+					meta: {
+						resource: "definition",
+						resourceId: pathToJsonPointer(event._path)
+					},
+					naming: plugin.config.definitions,
+					path: event._path,
 					plugin,
 					schema: event.requestBody.schema,
-					state
+					tags: event.tags
 				});
 				break;
 			case "schema":
-				handleComponent({
+				processor.process({
+					meta: {
+						resource: "definition",
+						resourceId: pathToJsonPointer(event._path)
+					},
+					naming: plugin.config.definitions,
+					path: event._path,
 					plugin,
 					schema: event.schema,
-					state
+					tags: event.tags
 				});
 				break;
 			case "webhook":
 				irWebhookToAst({
-					getAst: (schema, path$1) => {
-						return irSchemaToAst({
-							plugin,
-							schema,
-							state: refs({
-								hasLazyExpression: false,
-								path: path$1,
-								tags: event.tags
-							})
-						});
-					},
 					operation: event.operation,
+					path: event._path,
 					plugin,
-					state
+					processor,
+					tags: event.tags
 				});
 				break;
 		}
@@ -13829,4 +13638,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-DlaW5Djq.mjs.map
+//# sourceMappingURL=init-BxMu9GWq.mjs.map