zod-openapi 5.0.0-beta.8 → 5.0.0-beta.9

package/README.md

@@ -48,7 +48,7 @@ Generates an OpenAPI documentation object.
 
 ```typescript
 import 'zod-openapi/extend';
-import { z } from 'zod';
+import { z } from 'zod/v4';
 import { createDocument } from 'zod-openapi';
 
 const jobId = z.string().openapi({
@@ -191,7 +191,7 @@ Creates an OpenAPI Schema Object along with any registered components. OpenAPI 3
 
 ```typescript
 import 'zod-openapi/extend';
-import { z } from 'zod';
+import { z } from 'zod/v4';
 import { createSchema } from 'zod-openapi';
 
 const jobId = z.string().openapi({

package/dist/api.d.mts

@@ -1,4 +1,4 @@
-import { ComponentRegistry, Override, ParameterLocation, ParameterObject, ReferenceObject, createComponents, createRegistry } from "./components-DzDcF4aG.mjs";
+import { ComponentRegistry, Override, ParameterLocation, ParameterObject, ReferenceObject, createComponents, createRegistry } from "./components-26wns3Hd.mjs";
 import { $ZodObject, $ZodType, $ZodTypes } from "zod/v4/core";
 import { core } from "zod/v4";
 

package/dist/api.d.ts

@@ -1,4 +1,4 @@
-import { ComponentRegistry, Override, ParameterLocation, ParameterObject, ReferenceObject, createComponents, createRegistry } from "./components-BBthgA_z.js";
+import { ComponentRegistry, Override, ParameterLocation, ParameterObject, ReferenceObject, createComponents, createRegistry } from "./components-CokUEQbL.js";
 import { $ZodObject, $ZodType, $ZodTypes } from "zod/v4/core";
 import { core } from "zod/v4";
 

package/dist/api.js

@@ -1,8 +1,7 @@
-const require_zod = require('./zod-i2t01GF0.js');
-const require_components = require('./components-BaA49bb2.js');
+const require_components = require('./components-CB3cj8u3.js');
 
 exports.createComponents = require_components.createComponents;
 exports.createParameter = require_components.createParameter;
 exports.createRegistry = require_components.createRegistry;
-exports.isAnyZodType = require_zod.isAnyZodType;
+exports.isAnyZodType = require_components.isAnyZodType;
 exports.unwrapZodObject = require_components.unwrapZodObject;

package/dist/api.mjs

@@ -1,4 +1,3 @@
-import { isAnyZodType } from "./zod-BvA30wad.mjs";
-import { createComponents, createParameter, createRegistry, unwrapZodObject } from "./components-DMRr6ft0.mjs";
+import { createComponents, createParameter, createRegistry, isAnyZodType, unwrapZodObject } from "./components-0QHfGwg0.mjs";
 
 export { createComponents, createParameter, createRegistry, isAnyZodType, unwrapZodObject };

package/dist/{components-DMRr6ft0.mjs → components-0QHfGwg0.mjs}

@@ -1,8 +1,10 @@
-import { isAnyZodType } from "./zod-BvA30wad.mjs";
 import { globalRegistry } from "zod/v4/core";
-import { globalRegistry as globalRegistry$1, object, toJSONSchema } from "zod/v4";
-import { registerSchemas } from "./create/componentsSideEffects";
+import { globalRegistry as globalRegistry$1, object, registry, toJSONSchema } from "zod/v4";
 
+//#region src/zod.ts
+const isAnyZodType = (schema) => typeof schema === "object" && schema !== null && "_zod" in schema;
+
+//#endregion
 //#region src/create/object.ts
 const unwrapZodObject = (zodType, io, path) => {
 	const def = zodType._zod.def;
@@ -217,43 +219,43 @@ const createResponses = (responses, ctx, path) => {
 
 //#endregion
 //#region src/create/paths.ts
-const createOperation = (operationObject, registry, path) => {
+const createOperation = (operationObject, registry$1, path) => {
 	const { parameters, requestParams, requestBody, responses, callbacks,...rest } = operationObject;
 	const operation = rest;
 	const maybeManualParameters = createManualParameters(parameters, {
-		registry,
+		registry: registry$1,
 		io: "input"
 	}, [...path, "parameters"]);
 	const maybeRequestParams = createParameters(requestParams, {
-		registry,
+		registry: registry$1,
 		io: "input"
 	}, [...path, "requestParams"]);
 	if (maybeRequestParams || maybeManualParameters) operation.parameters = [...maybeRequestParams ?? [], ...maybeManualParameters ?? []];
 	const maybeRequestBody = createRequestBody(requestBody, {
-		registry,
+		registry: registry$1,
 		io: "input"
 	}, [...path, "requestBody"]);
 	if (maybeRequestBody) operation.requestBody = maybeRequestBody;
 	const maybeResponses = createResponses(responses, {
-		registry,
+		registry: registry$1,
 		io: "output"
 	}, [...path, "responses"]);
 	if (maybeResponses) operation.responses = maybeResponses;
-	const maybeCallbacks = createCallbacks(callbacks, registry, [...path, "callbacks"]);
+	const maybeCallbacks = createCallbacks(callbacks, registry$1, [...path, "callbacks"]);
 	if (maybeCallbacks) operation.callbacks = maybeCallbacks;
 	return operation;
 };
-const createPathItem = (pathItem, registry, path) => {
+const createPathItem = (pathItem, registry$1, path) => {
 	const pathItemObject = {};
 	const { id,...rest } = pathItem;
 	for (const [key, value] of Object.entries(rest)) {
 		if (key === "get" || key === "put" || key === "post" || key === "delete" || key === "options" || key === "head" || key === "patch" || key === "trace") {
-			pathItemObject[key] = createOperation(value, registry, [...path, key]);
+			pathItemObject[key] = createOperation(value, registry$1, [...path, key]);
 			continue;
 		}
 		if (key === "parameters") {
 			pathItemObject[key] = createManualParameters(value, {
-				registry,
+				registry: registry$1,
 				io: "input"
 			}, [...path, key]);
 			continue;
@@ -262,14 +264,14 @@ const createPathItem = (pathItem, registry, path) => {
 	}
 	if (id) {
 		const ref = { $ref: `#/components/pathItems/${id}` };
-		registry.pathItems.ids.set(id, pathItemObject);
-		registry.pathItems.seen.set(pathItem, ref);
+		registry$1.pathItems.ids.set(id, pathItemObject);
+		registry$1.pathItems.seen.set(pathItem, ref);
 		return ref;
 	}
-	registry.pathItems.seen.set(pathItem, pathItemObject);
+	registry$1.pathItems.seen.set(pathItem, pathItemObject);
 	return pathItemObject;
 };
-const createPaths = (paths, registry, path) => {
+const createPaths = (paths, registry$1, path) => {
 	if (!paths) return void 0;
 	const pathsObject = {};
 	for (const [singlePath, pathItemObject] of Object.entries(paths)) {
@@ -277,15 +279,15 @@ const createPaths = (paths, registry, path) => {
 			pathsObject[singlePath] = pathItemObject;
 			continue;
 		}
-		pathsObject[singlePath] = createPathItem(pathItemObject, registry, [...path, singlePath]);
+		pathsObject[singlePath] = createPathItem(pathItemObject, registry$1, [...path, singlePath]);
 	}
 	return pathsObject;
 };
 
 //#endregion
 //#region src/create/callbacks.ts
-const createCallback = (callbackObject, registry, path) => {
-	const seenCallback = registry.callbacks.seen.get(callbackObject);
+const createCallback = (callbackObject, registry$1, path) => {
+	const seenCallback = registry$1.callbacks.seen.get(callbackObject);
 	if (seenCallback) return seenCallback;
 	const { id,...rest } = callbackObject;
 	const callback = {};
@@ -294,18 +296,18 @@ const createCallback = (callbackObject, registry, path) => {
 			callback[name] = pathItem;
 			continue;
 		}
-		callback[name] = createPathItem(pathItem, registry, [...path, name]);
+		callback[name] = createPathItem(pathItem, registry$1, [...path, name]);
 	}
 	if (id) {
 		const ref = { $ref: `#/components/callbacks/${id}` };
-		registry.callbacks.ids.set(id, callback);
-		registry.callbacks.seen.set(callbackObject, ref);
+		registry$1.callbacks.ids.set(id, callback);
+		registry$1.callbacks.seen.set(callbackObject, ref);
 		return ref;
 	}
-	registry.callbacks.seen.set(callbackObject, callback);
+	registry$1.callbacks.seen.set(callbackObject, callback);
 	return callback;
 };
-const createCallbacks = (callbacks, registry, path) => {
+const createCallbacks = (callbacks, registry$1, path) => {
 	if (!callbacks) return void 0;
 	const callbacksObject = {};
 	for (const [name, value] of Object.entries(callbacks)) {
@@ -313,7 +315,7 @@ const createCallbacks = (callbacks, registry, path) => {
 			callbacksObject[name] = value;
 			continue;
 		}
-		callbacksObject[name] = createCallback(value, registry, [...path, name]);
+		callbacksObject[name] = createCallback(value, registry$1, [...path, name]);
 	}
 	return callbacksObject;
 };
@@ -395,6 +397,7 @@ const validate = (ctx, opts) => {
 //#region src/create/schema/rename.ts
 const renameComponents = (components, outputIds, ctx) => {
 	const componentsToRename = /* @__PURE__ */ new Map();
+	if (ctx.io === "input") return componentsToRename;
 	const componentDependencies = /* @__PURE__ */ new Map();
 	const stringifiedComponents = /* @__PURE__ */ new Map();
 	for (const [key, value] of Object.entries(components)) {
@@ -420,18 +423,18 @@ const renameComponents = (components, outputIds, ctx) => {
 	}
 	return componentsToRename;
 };
-const isDependencyPure = (componentDependencies, stringifiedComponents, registry, key, visited = /* @__PURE__ */ new Set()) => {
+const isDependencyPure = (componentDependencies, stringifiedComponents, registry$1, key, visited = /* @__PURE__ */ new Set()) => {
 	if (visited.has(key)) return true;
 	const dependencies = componentDependencies.get(key);
 	if (dependencies.pure !== void 0) return dependencies.pure;
 	const stringified = stringifiedComponents.get(key);
-	const component = registry.schemas.ids.get(key);
+	const component = registry$1.schemas.ids.get(key);
 	if (component && stringified !== JSON.stringify(component)) {
 		dependencies.pure = false;
 		return false;
 	}
 	visited.add(key);
-	const result = [...dependencies.dependencies].every((dep) => isDependencyPure(componentDependencies, stringifiedComponents, registry, dep, new Set(visited)));
+	const result = [...dependencies.dependencies].every((dep) => isDependencyPure(componentDependencies, stringifiedComponents, registry$1, dep, new Set(visited)));
 	dependencies.pure = result;
 	return result;
 };
@@ -469,9 +472,11 @@ const createSchema = (schema, ctx = {
 const createSchemas = (schemas, ctx) => {
 	const entries = {};
 	for (const [name, { zodType }] of Object.entries(schemas)) entries[name] = zodType;
-	const schemaRegistry = object(entries);
+	const zodRegistry = registry();
+	zodRegistry.add(object(entries), { id: "zodOpenApiCreateSchema" });
+	for (const [id, { zodType }] of ctx.registry.schemas.manual) zodRegistry.add(zodType, { id });
 	const outputIds = /* @__PURE__ */ new Map();
-	const jsonSchema = toJSONSchema(schemaRegistry, {
+	const jsonSchema = toJSONSchema(zodRegistry, {
 		override(context) {
 			const meta = context.zodSchema.meta();
 			if (meta?.outputId && meta?.id) outputIds.set(meta.id, meta.outputId);
@@ -498,11 +503,13 @@ const createSchemas = (schemas, ctx) => {
 		io: ctx.io,
 		unrepresentable: "any",
 		reused: ctx.opts.reused,
-		cycles: ctx.opts.cycles
+		cycles: ctx.opts.cycles,
+		uri: (id) => id === "__shared" ? `#ZOD_OPENAPI/${id}` : `#ZOD_OPENAPI/__shared#/$defs/${id}`
 	});
-	const components = jsonSchema.$defs ?? {};
+	const components = jsonSchema.schemas.__shared?.$defs ?? {};
+	jsonSchema.schemas.__shared ??= { $defs: components };
 	const dynamicComponents = /* @__PURE__ */ new Map();
-	for (const [key, value] of Object.entries(components)) if (/^__schema\d+$/.test(key)) {
+	for (const [key, value] of Object.entries(components)) if (/^schema\d+$/.test(key)) {
 		const newName = `__schema${ctx.registry.schemas.dynamicSchemaCount++}`;
 		dynamicComponents.set(key, `"#/components/schemas/${newName}"`);
 		if (newName !== key) {
@@ -510,38 +517,59 @@ const createSchemas = (schemas, ctx) => {
 			delete components[key];
 		}
 	}
-	const parsedJsonSchema = JSON.parse(JSON.stringify(jsonSchema).replace(/"#\/\$defs\/([^"]+)"/g, (_, match) => {
+	const manualUsed = {};
+	const parsedJsonSchema = JSON.parse(JSON.stringify(jsonSchema).replace(/"#ZOD_OPENAPI\/__shared#\/\$defs\/([^"]+)"/g, (_, match) => {
 		const dynamic = dynamicComponents.get(match);
 		if (dynamic) return dynamic;
 		const manualComponent = ctx.registry.schemas.manual.get(match);
-		if (manualComponent) manualComponent.io[ctx.io].used++;
+		if (manualComponent) manualUsed[match] = true;
 		return `"#/components/schemas/${match}"`;
 	}));
-	for (const [key, value] of ctx.registry.schemas.manual) if (value.io[ctx.io].used === 1 && parsedJsonSchema.properties?.[value.identifier] && parsedJsonSchema.$defs?.[key]) {
-		parsedJsonSchema.properties[value.identifier] = parsedJsonSchema.$defs[key];
-		delete parsedJsonSchema.$defs[key];
-		continue;
+	const parsedComponents = parsedJsonSchema.schemas.__shared?.$defs ?? {};
+	parsedJsonSchema.schemas.__shared ??= { $defs: parsedComponents };
+	for (const [key] of ctx.registry.schemas.manual) {
+		const manualComponent = parsedJsonSchema.schemas[key];
+		if (!manualComponent) continue;
+		delete manualComponent.$schema;
+		delete manualComponent.id;
+		if (manualUsed[key]) {
+			delete manualComponent.$schema;
+			delete manualComponent.id;
+			if (parsedComponents[key]) throw new Error(`Component "${key}" is already registered as a component in the registry`);
+			parsedComponents[key] = manualComponent;
+		}
+	}
+	const componentsToRename = renameComponents(parsedComponents, outputIds, ctx);
+	if (!componentsToRename.size) {
+		const parsedSchemas = parsedJsonSchema.schemas.zodOpenApiCreateSchema?.properties;
+		delete parsedJsonSchema.schemas.zodOpenApiCreateSchema;
+		delete parsedJsonSchema.schemas.__shared;
+		return {
+			schemas: parsedSchemas,
+			components: parsedComponents,
+			manual: parsedJsonSchema.schemas
+		};
 	}
-	const renamedComponents = renameComponents(parsedJsonSchema.$defs ?? {}, outputIds, ctx);
-	if (!renamedComponents.size) return {
-		schemas: parsedJsonSchema.properties,
-		components: parsedJsonSchema.$defs ?? {}
-	};
 	const renamedJsonSchema = JSON.parse(JSON.stringify(parsedJsonSchema).replace(/"#\/components\/schemas\/([^"]+)"/g, (_, match) => {
-		const replacement = renamedComponents.get(match);
+		const replacement = componentsToRename.get(match);
 		if (replacement) return `"#/components/schemas/${replacement}"`;
 		return `"#/components/schemas/${match}"`;
 	}));
+	const renamedSchemas = renamedJsonSchema.schemas.zodOpenApiCreateSchema?.properties;
+	const renamedComponents = renamedJsonSchema.schemas.__shared?.$defs ?? {};
+	delete renamedJsonSchema.schemas.zodOpenApiCreateSchema;
+	delete renamedJsonSchema.schemas.__shared;
 	return {
-		schemas: renamedJsonSchema.properties,
-		components: renamedJsonSchema.$defs ?? {}
+		schemas: renamedSchemas,
+		components: renamedComponents,
+		manual: renamedJsonSchema.schemas
 	};
 };
 
 //#endregion
 //#region src/create/components.ts
 const createRegistry = (components) => {
-	const registry = {
+	const registry$1 = {
 		schemas: {
 			dynamicSchemaCount: 0,
 			input: /* @__PURE__ */ new Map(),
@@ -550,7 +578,7 @@ const createRegistry = (components) => {
 			manual: /* @__PURE__ */ new Map(),
 			setSchema: (key, schema, io) => {
 				const schemaObject = {};
-				registry.schemas[io].set(key, {
+				registry$1.schemas[io].set(key, {
 					schemaObject,
 					zodType: schema
 				});
@@ -582,19 +610,35 @@ const createRegistry = (components) => {
 			seen: /* @__PURE__ */ new WeakMap()
 		}
 	};
-	registerSchemas(components?.schemas, registry);
-	registerParameters(components?.parameters, registry);
-	registerHeaders(components?.headers, registry);
-	registerResponses(components?.responses, registry);
-	registerPathItems(components?.pathItems, registry);
-	registerRequestBodies(components?.requestBodies, registry);
-	registerCallbacks(components?.callbacks, registry);
-	return registry;
-};
-const registerParameters = (parameters, registry) => {
+	registerSchemas(components?.schemas, registry$1);
+	registerParameters(components?.parameters, registry$1);
+	registerHeaders(components?.headers, registry$1);
+	registerResponses(components?.responses, registry$1);
+	registerPathItems(components?.pathItems, registry$1);
+	registerRequestBodies(components?.requestBodies, registry$1);
+	registerCallbacks(components?.callbacks, registry$1);
+	return registry$1;
+};
+const registerSchemas = (schemas, registry$1) => {
+	if (!schemas) return;
+	for (const [key, schema] of Object.entries(schemas)) {
+		if (registry$1.schemas.ids.has(key)) throw new Error(`Schema "${key}" is already registered`);
+		if (isAnyZodType(schema)) {
+			const id = globalRegistry.get(schema)?.id ?? key;
+			registry$1.schemas.manual.set(id, {
+				input: { schemaObject: {} },
+				output: { schemaObject: {} },
+				zodType: schema
+			});
+			continue;
+		}
+		registry$1.schemas.ids.set(key, schema);
+	}
+};
+const registerParameters = (parameters, registry$1) => {
 	if (!parameters) return;
 	for (const [key, schema] of Object.entries(parameters)) {
-		if (registry.parameters.ids.has(key)) throw new Error(`Parameter "${key}" is already registered`);
+		if (registry$1.parameters.ids.has(key)) throw new Error(`Parameter "${key}" is already registered`);
 		if (isAnyZodType(schema)) {
 			const path = [
 				"components",
@@ -602,20 +646,20 @@ const registerParameters = (parameters, registry) => {
 				key
 			];
 			const paramObject = createParameter(schema, void 0, {
-				registry,
+				registry: registry$1,
 				io: "input"
 			}, path);
-			registry.parameters.ids.set(key, paramObject);
-			registry.parameters.seen.set(schema, paramObject);
+			registry$1.parameters.ids.set(key, paramObject);
+			registry$1.parameters.seen.set(schema, paramObject);
 			continue;
 		}
-		registry.parameters.ids.set(key, schema);
+		registry$1.parameters.ids.set(key, schema);
 	}
 };
-const registerHeaders = (headers, registry) => {
+const registerHeaders = (headers, registry$1) => {
 	if (!headers) return;
 	for (const [key, schema] of Object.entries(headers)) {
-		if (registry.headers.ids.has(key)) throw new Error(`Header "${key}" is already registered`);
+		if (registry$1.headers.ids.has(key)) throw new Error(`Header "${key}" is already registered`);
 		if (isAnyZodType(schema)) {
 			const path = [
 				"components",
@@ -623,17 +667,17 @@ const registerHeaders = (headers, registry) => {
 				key
 			];
 			const headerObject = createHeader(schema, {
-				registry,
+				registry: registry$1,
 				io: "output"
 			}, path);
-			registry.headers.ids.set(key, headerObject);
-			registry.headers.seen.set(schema, headerObject);
+			registry$1.headers.ids.set(key, headerObject);
+			registry$1.headers.seen.set(schema, headerObject);
 			continue;
 		}
-		registry.headers.ids.set(key, schema);
+		registry$1.headers.ids.set(key, schema);
 	}
 };
-const registerResponses = (responses, registry) => {
+const registerResponses = (responses, registry$1) => {
 	if (!responses) return;
 	for (const [key, schema] of Object.entries(responses)) {
 		const path = [
@@ -641,19 +685,19 @@ const registerResponses = (responses, registry) => {
 			"responses",
 			key
 		];
-		if (registry.responses.ids.has(key)) throw new Error(`Response "${key}" is already registered`);
+		if (registry$1.responses.ids.has(key)) throw new Error(`Response "${key}" is already registered`);
 		const responseObject = createResponse(schema, {
-			registry,
+			registry: registry$1,
 			io: "output"
 		}, path);
-		registry.responses.ids.set(key, responseObject);
-		registry.responses.seen.set(schema, responseObject);
+		registry$1.responses.ids.set(key, responseObject);
+		registry$1.responses.seen.set(schema, responseObject);
 	}
 };
-const registerRequestBodies = (requestBodies, registry) => {
+const registerRequestBodies = (requestBodies, registry$1) => {
 	if (!requestBodies) return;
 	for (const [key, schema] of Object.entries(requestBodies)) {
-		if (registry.requestBodies.ids.has(key)) throw new Error(`RequestBody "${key}" is already registered`);
+		if (registry$1.requestBodies.ids.has(key)) throw new Error(`RequestBody "${key}" is already registered`);
 		if (isAnyZodType(schema)) {
 			const path = [
 				"components",
@@ -661,81 +705,87 @@ const registerRequestBodies = (requestBodies, registry) => {
 				key
 			];
 			const requestBodyObject = createRequestBody(schema, {
-				registry,
+				registry: registry$1,
 				io: "input"
 			}, path);
-			registry.requestBodies.ids.set(key, requestBodyObject);
+			registry$1.requestBodies.ids.set(key, requestBodyObject);
 			continue;
 		}
-		registry.requestBodies.ids.set(key, schema);
+		registry$1.requestBodies.ids.set(key, schema);
 	}
 };
-const registerCallbacks = (callbacks, registry) => {
+const registerCallbacks = (callbacks, registry$1) => {
 	if (!callbacks) return;
 	for (const [key, schema] of Object.entries(callbacks)) {
-		if (registry.callbacks.ids.has(key)) throw new Error(`Callback "${key}" is already registered`);
+		if (registry$1.callbacks.ids.has(key)) throw new Error(`Callback "${key}" is already registered`);
 		const path = [
 			"components",
 			"callbacks",
 			key
 		];
-		const callbackObject = createCallback(schema, registry, path);
-		registry.callbacks.ids.set(key, callbackObject);
-		registry.callbacks.seen.set(schema, callbackObject);
+		const callbackObject = createCallback(schema, registry$1, path);
+		registry$1.callbacks.ids.set(key, callbackObject);
+		registry$1.callbacks.seen.set(schema, callbackObject);
 	}
 };
-const registerPathItems = (pathItems, registry) => {
+const registerPathItems = (pathItems, registry$1) => {
 	if (!pathItems) return;
 	for (const [key, schema] of Object.entries(pathItems)) {
-		if (registry.pathItems.ids.has(key)) throw new Error(`PathItem "${key}" is already registered`);
+		if (registry$1.pathItems.ids.has(key)) throw new Error(`PathItem "${key}" is already registered`);
 		const path = [
 			"components",
 			"pathItems",
 			key
 		];
-		const pathItemObject = createPathItem(schema, registry, path);
-		registry.pathItems.ids.set(key, pathItemObject);
-		registry.pathItems.seen.set(schema, pathItemObject);
+		const pathItemObject = createPathItem(schema, registry$1, path);
+		registry$1.pathItems.ids.set(key, pathItemObject);
+		registry$1.pathItems.seen.set(schema, pathItemObject);
 		continue;
 	}
 };
 const createIOSchemas = (ctx) => {
-	const { schemas, components } = createSchemas(Object.fromEntries(ctx.registry.schemas[ctx.io]), ctx);
+	const { schemas, components, manual } = createSchemas(Object.fromEntries(ctx.registry.schemas[ctx.io]), ctx);
 	for (const [key, schema] of Object.entries(components)) ctx.registry.schemas.ids.set(key, schema);
 	for (const [key, schema] of Object.entries(schemas)) {
 		const ioSchema = ctx.registry.schemas[ctx.io].get(key);
 		if (ioSchema) Object.assign(ioSchema.schemaObject, schema);
 	}
+	for (const [key, value] of Object.entries(manual)) {
+		const manualSchema = ctx.registry.schemas.manual.get(key);
+		if (!manualSchema) continue;
+		if (components[key]) manualSchema[ctx.io].used = true;
+		Object.assign(manualSchema[ctx.io].schemaObject, value);
+	}
 };
-const createManualSchemas = (registry) => {
-	for (const [key, value] of registry.schemas.manual) if (value.io.input.used === 1) {
+const createManualSchemas = (registry$1) => {
+	for (const [key, value] of registry$1.schemas.manual) if (!value.input.used) {
 		const io = globalRegistry.get(value.zodType)?.unusedIO ?? "output";
-		const schema = value.io[io].schemaObject;
-		registry.schemas.ids.set(key, schema);
+		const schema = value[io].schemaObject;
+		registry$1.schemas.ids.set(key, schema);
 	}
 };
-const createComponents = (registry, opts) => {
+const createComponents = (registry$1, opts) => {
 	createIOSchemas({
-		registry,
+		registry: registry$1,
 		io: "input",
 		opts
 	});
 	createIOSchemas({
-		registry,
+		registry: registry$1,
 		io: "output",
 		opts
 	});
-	createManualSchemas(registry);
+	createManualSchemas(registry$1);
 	const components = {};
-	if (registry.schemas.ids.size > 0) components.schemas = Object.fromEntries(registry.schemas.ids);
-	if (registry.headers.ids.size > 0) components.headers = Object.fromEntries(registry.headers.ids);
-	if (registry.requestBodies.ids.size > 0) components.requestBodies = Object.fromEntries(registry.requestBodies.ids);
-	if (registry.responses.ids.size > 0) components.responses = Object.fromEntries(registry.responses.ids);
-	if (registry.parameters.ids.size > 0) components.parameters = Object.fromEntries(registry.parameters.ids);
-	if (registry.callbacks.ids.size > 0) components.callbacks = Object.fromEntries(registry.callbacks.ids);
-	if (registry.pathItems.ids.size > 0) components.pathItems = Object.fromEntries(registry.pathItems.ids);
+	if (registry$1.schemas.ids.size > 0) components.schemas = Object.fromEntries(registry$1.schemas.ids);
+	if (registry$1.headers.ids.size > 0) components.headers = Object.fromEntries(registry$1.headers.ids);
+	if (registry$1.requestBodies.ids.size > 0) components.requestBodies = Object.fromEntries(registry$1.requestBodies.ids);
+	if (registry$1.responses.ids.size > 0) components.responses = Object.fromEntries(registry$1.responses.ids);
+	if (registry$1.parameters.ids.size > 0) components.parameters = Object.fromEntries(registry$1.parameters.ids);
+	if (registry$1.callbacks.ids.size > 0) components.callbacks = Object.fromEntries(registry$1.callbacks.ids);
+	if (registry$1.pathItems.ids.size > 0) components.pathItems = Object.fromEntries(registry$1.pathItems.ids);
 	return components;
 };
 
 //#endregion
-export { createComponents, createParameter, createPaths, createRegistry, createSchema, unwrapZodObject };
+export { createComponents, createParameter, createPaths, createRegistry, createSchema, isAnyZodType, unwrapZodObject };

package/dist/{components-BBthgA_z.d.ts → components-26wns3Hd.d.mts}

@@ -1,5 +1,4 @@
 import { $ZodType, $ZodTypes } from "zod/v4/core";
-import { ZodType, ZodTypeDef } from "zod";
 import { core } from "zod/v4";
 
 //#region src/openapi3-ts/dist/model/specification-extension.d.ts
@@ -445,7 +444,6 @@ interface ZodOpenApiObject extends Omit<OpenAPIObject, 'openapi' | 'paths' | 'we
   webhooks?: ZodOpenApiPathsObject;
   components?: ZodOpenApiComponentsObject;
 }
-type ZodObjectInputType<Output = unknown, Def extends ZodTypeDef = ZodTypeDef, Input = Record<string, unknown>> = ZodType<Output, Def, Input>;
 type ZodObjectInput = $ZodType<unknown, Record<string, unknown>>;
 type OverrideType = $ZodTypes['_zod']['def']['type'];
 interface CreateDocumentOptions {
@@ -496,16 +494,13 @@ interface ComponentRegistry {
     }>;
     ids: Map<string, SchemaObject | ReferenceObject>;
     manual: Map<string, {
-      identifier: string;
-      io: {
-        input: {
-          used: number;
-          schemaObject: SchemaObject;
-        };
-        output: {
-          used: number;
-          schemaObject: SchemaObject;
-        };
+      input: {
+        used?: true;
+        schemaObject: SchemaObject;
+      };
+      output: {
+        used?: true;
+        schemaObject: SchemaObject;
       };
       zodType: $ZodType;
     }>;
@@ -539,4 +534,4 @@ interface ComponentRegistry {
 declare const createRegistry: (components?: ZodOpenApiComponentsObject) => ComponentRegistry;
 declare const createComponents: (registry: ComponentRegistry, opts: CreateDocumentOptions) => ComponentsObject;
 //#endregion
-export { BaseParameterObject, CallbackObject, CallbacksObject, ComponentRegistry, ComponentsObject, ContactObject, ContentObject, CreateDocumentOptions, DiscriminatorObject, EncodingObject, EncodingPropertyObject, ExampleObject, ExamplesObject, ExternalDocumentationObject, HeaderObject, HeadersObject, IExtensionName, IExtensionType, ISpecificationExtension, InfoObject, LicenseObject, LinkObject, LinkParametersObject, LinksObject, MediaTypeObject, OAuthFlowObject, OAuthFlowsObject, OpenAPIObject, OperationObject, Override, ParameterLocation, ParameterObject, ParameterStyle, PathItemObject, PathObject, PathsObject, ReferenceObject, RequestBodyObject, ResponseObject, ResponsesObject, SchemaObject, SchemaObjectType, SchemasObject, ScopesObject, SecurityRequirementObject, SecuritySchemeObject, SecuritySchemeType, ServerObject, ServerVariableObject, TagObject, XmlObject, ZodObjectInput, ZodObjectInputType, ZodOpenApiCallbackObject, ZodOpenApiCallbacksObject, ZodOpenApiComponentsObject, ZodOpenApiContentObject, ZodOpenApiHeaderObject, ZodOpenApiHeadersObject, ZodOpenApiMediaTypeObject, ZodOpenApiObject, ZodOpenApiOperationObject, ZodOpenApiParameterObject, ZodOpenApiParameters, ZodOpenApiPathItemObject, ZodOpenApiPathsObject, ZodOpenApiRequestBody, ZodOpenApiRequestBodyObject, ZodOpenApiResponseObject, ZodOpenApiResponsesObject, ZodOpenApiSchemaObject, ZodOpenApiVersion, createComponents, createDocument, createRegistry };
+export { BaseParameterObject, CallbackObject, CallbacksObject, ComponentRegistry, ComponentsObject, ContactObject, ContentObject, CreateDocumentOptions, DiscriminatorObject, EncodingObject, EncodingPropertyObject, ExampleObject, ExamplesObject, ExternalDocumentationObject, HeaderObject, HeadersObject, IExtensionName, IExtensionType, ISpecificationExtension, InfoObject, LicenseObject, LinkObject, LinkParametersObject, LinksObject, MediaTypeObject, OAuthFlowObject, OAuthFlowsObject, OpenAPIObject, OperationObject, Override, ParameterLocation, ParameterObject, ParameterStyle, PathItemObject, PathObject, PathsObject, ReferenceObject, RequestBodyObject, ResponseObject, ResponsesObject, SchemaObject, SchemaObjectType, SchemasObject, ScopesObject, SecurityRequirementObject, SecuritySchemeObject, SecuritySchemeType, ServerObject, ServerVariableObject, TagObject, XmlObject, ZodObjectInput, ZodOpenApiCallbackObject, ZodOpenApiCallbacksObject, ZodOpenApiComponentsObject, ZodOpenApiContentObject, ZodOpenApiHeaderObject, ZodOpenApiHeadersObject, ZodOpenApiMediaTypeObject, ZodOpenApiObject, ZodOpenApiOperationObject, ZodOpenApiParameterObject, ZodOpenApiParameters, ZodOpenApiPathItemObject, ZodOpenApiPathsObject, ZodOpenApiRequestBody, ZodOpenApiRequestBodyObject, ZodOpenApiResponseObject, ZodOpenApiResponsesObject, ZodOpenApiSchemaObject, ZodOpenApiVersion, createComponents, createDocument, createRegistry };