zod-openapi 5.0.0-beta.2 → 5.0.0-beta.3

package/dist/components.chunk.cjs

@@ -622,9 +622,7 @@ const createSchema = (schema, ctx = {
   ctx.registry ?? (ctx.registry = createRegistry());
   ctx.opts ?? (ctx.opts = {});
   ctx.io ?? (ctx.io = "output");
-  const registrySchemas = Object.fromEntries(
-    ctx.registry.schemas[ctx.io].schemas
-  );
+  const registrySchemas = Object.fromEntries(ctx.registry.schemas[ctx.io]);
   const schemas = {
     zodOpenApiCreateSchema: { zodType: schema }
   };
@@ -639,181 +637,121 @@ const createSchema = (schema, ctx = {
     components: jsonSchemas.components
   };
 };
-const createSchemas = (schemas, {
-  registry,
-  io,
-  opts
-}) => {
-  var _a, _b, _c, _d, _e, _f;
-  const schemaRegistry = v4.registry();
-  const globalsInSchemas = /* @__PURE__ */ new Map();
+const createSchemas = (schemas, ctx) => {
+  var _a, _b;
+  const entries = {};
   for (const [name, { zodType }] of Object.entries(schemas)) {
-    const id = (_a = v4.globalRegistry.get(zodType)) == null ? void 0 : _a.id;
-    if (id) {
-      globalsInSchemas.set(name, id);
-    }
-    schemaRegistry.add(zodType, { id: name });
+    entries[name] = zodType;
   }
+  const schemaRegistry = v4.object(entries);
   const outputIds = /* @__PURE__ */ new Map();
   const jsonSchema = v4.toJSONSchema(schemaRegistry, {
-    override(ctx) {
-      const meta = ctx.zodSchema.meta();
+    override(context) {
+      const meta = context.zodSchema.meta();
       if ((meta == null ? void 0 : meta.outputId) && (meta == null ? void 0 : meta.id)) {
         outputIds.set(meta.id, meta.outputId);
       }
-      if (ctx.jsonSchema.$ref) {
+      if (context.jsonSchema.$ref) {
         return;
       }
-      const enrichedContext = { ...ctx, io };
+      const enrichedContext = { ...context, io: ctx.io };
       override(enrichedContext);
-      if (typeof opts.override === "function") {
-        opts.override(enrichedContext);
+      if (typeof ctx.opts.override === "function") {
+        ctx.opts.override(enrichedContext);
       }
       if (typeof (meta == null ? void 0 : meta.override) === "function") {
         meta.override(enrichedContext);
-        delete ctx.jsonSchema.override;
+        delete context.jsonSchema.override;
       }
       if (typeof (meta == null ? void 0 : meta.override) === "object" && meta.override !== null) {
-        Object.assign(ctx.jsonSchema, meta.override);
-        delete ctx.jsonSchema.override;
+        Object.assign(context.jsonSchema, meta.override);
+        delete context.jsonSchema.override;
       }
-      delete ctx.jsonSchema.$schema;
-      delete ctx.jsonSchema.id;
-      deleteZodOpenApiMeta(ctx.jsonSchema);
-      validate(enrichedContext, opts);
+      delete context.jsonSchema.$schema;
+      delete context.jsonSchema.id;
+      deleteZodOpenApiMeta(context.jsonSchema);
+      validate(enrichedContext, ctx.opts);
     },
-    io,
-    unrepresentable: "any",
-    uri: (id) => `#/components/schemas/${id}`
+    io: ctx.io,
+    unrepresentable: "any"
   });
-  const sharedDefs = ((_b = jsonSchema.schemas.__shared) == null ? void 0 : _b.$defs) ?? {};
-  (_c = jsonSchema.schemas).__shared ?? (_c.__shared = { $defs: sharedDefs });
-  const componentsToReplace = /* @__PURE__ */ new Map();
-  for (const [key, value] of Object.entries(sharedDefs)) {
-    if (/^schema\d+$/.exec(key)) {
-      const componentName = `__schema${registry.schemas.dynamicSchemaCount++}`;
-      componentsToReplace.set(`__shared#/$defs/${key}`, componentName);
-      delete sharedDefs[key];
-      sharedDefs[componentName] = value;
-      continue;
-    }
-    componentsToReplace.set(`__shared#/$defs/${key}`, key);
-  }
-  for (const value of Object.values(jsonSchema.schemas)) {
-    delete value.$schema;
-    delete value.id;
-  }
-  const dynamicComponent = /* @__PURE__ */ new Map();
-  const patched = JSON.stringify(jsonSchema).replace(
-    /"#\/components\/schemas\/([^"]+)"/g,
-    (_, match) => {
-      const replacement = componentsToReplace.get(match);
-      if (replacement) {
-        return `"#/components/schemas/${replacement}"`;
-      }
-      const component = registry.schemas.ids.get(match);
-      if (component) {
-        return `"#/components/schemas/${match}`;
-      }
-      const globalInSchema = globalsInSchemas.get(match);
-      if (globalInSchema) {
-        componentsToReplace.set(match, globalInSchema);
-        dynamicComponent.set(match, globalInSchema);
-        return `"#/components/schemas/${globalInSchema}"`;
-      }
-      const manualSchema = registry.schemas.manual.get(match);
-      if (manualSchema) {
-        componentsToReplace.set(match, manualSchema.key);
-        dynamicComponent.set(match, manualSchema.key);
-        manualSchema.io[io].used = true;
-        return `"#/components/schemas/${manualSchema.key}"`;
+  const components = jsonSchema.$defs ?? {};
+  const dynamicComponents = /* @__PURE__ */ new Map();
+  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) {
+        components[newName] = value;
+        delete components[key];
       }
-      const componentName = `__schema${registry.schemas.dynamicSchemaCount++}`;
-      componentsToReplace.set(match, componentName);
-      dynamicComponent.set(match, componentName);
-      return `"#/components/schemas/${componentName}"`;
     }
+  }
+  const parsedJsonSchema = JSON.parse(
+    JSON.stringify(jsonSchema).replace(
+      /"#\/\$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++;
+        }
+        return `"#/components/schemas/${match}"`;
+      }
+    )
   );
-  const patchedJsonSchema = JSON.parse(patched);
-  const components = ((_d = patchedJsonSchema.schemas.__shared) == null ? void 0 : _d.$defs) ?? {};
-  (_e = patchedJsonSchema.schemas).__shared ?? (_e.__shared = { $defs: components });
-  for (const [key, value] of registry.schemas.manual) {
-    if (value.io[io].used) {
-      dynamicComponent.set(key, value.key);
+  for (const [key, value] of ctx.registry.schemas.manual) {
+    if (value.io[ctx.io].used === 1 && ((_a = parsedJsonSchema.properties) == null ? void 0 : _a[value.identifier]) && ((_b = parsedJsonSchema.$defs) == null ? void 0 : _b[key])) {
+      parsedJsonSchema.properties[value.identifier] = parsedJsonSchema.$defs[key];
+      delete parsedJsonSchema.$defs[key];
+      continue;
     }
   }
-  for (const [key, value] of globalsInSchemas) {
-    dynamicComponent.set(key, value);
-  }
-  for (const [key, value] of dynamicComponent) {
-    const component = patchedJsonSchema.schemas[key];
-    patchedJsonSchema.schemas[key] = {
-      $ref: `#/components/schemas/${value}`
-    };
-    components[value] = component;
-  }
-  const renamedComponents = renameComponents(components, outputIds, {
-    registry
-  });
-  if (renamedComponents.size === 0) {
-    delete patchedJsonSchema.schemas.__shared;
+  const renamedComponents = renameComponents(
+    parsedJsonSchema.$defs ?? {},
+    outputIds,
+    ctx
+  );
+  if (!renamedComponents.size) {
     return {
-      schemas: patchedJsonSchema.schemas,
-      components
+      schemas: parsedJsonSchema.properties,
+      components: parsedJsonSchema.$defs ?? {}
     };
   }
-  const renamedStringified = JSON.stringify(patchedJsonSchema).replace(
-    /"#\/components\/schemas\/([^"]+)"/g,
-    (_, match) => {
-      const newName = renamedComponents.get(match);
-      if (newName) {
-        return `"#/components/schemas/${newName}"`;
+  const renamedJsonSchema = JSON.parse(
+    JSON.stringify(parsedJsonSchema).replace(
+      /"#\/components\/schemas\/([^"]+)"/g,
+      (_, match) => {
+        const replacement = renamedComponents.get(match);
+        if (replacement) {
+          return `"#/components/schemas/${replacement}"`;
+        }
+        return `"#/components/schemas/${match}"`;
       }
-      return `"#/components/schemas/${match}"`;
-    }
+    )
   );
-  const renamedJsonSchema = JSON.parse(renamedStringified);
-  const renamedJsonSchemaComponents = ((_f = renamedJsonSchema.schemas.__shared) == null ? void 0 : _f.$defs) ?? {};
-  delete renamedJsonSchema.schemas.__shared;
   return {
-    schemas: renamedJsonSchema.schemas,
-    components: renamedJsonSchemaComponents
+    schemas: renamedJsonSchema.properties,
+    components: renamedJsonSchema.$defs ?? {}
   };
 };
 const createRegistry = (components) => {
   const registry = {
     schemas: {
       dynamicSchemaCount: 0,
-      input: {
-        seen: /* @__PURE__ */ new WeakMap(),
-        schemas: /* @__PURE__ */ new Map()
-      },
-      output: {
-        seen: /* @__PURE__ */ new WeakMap(),
-        schemas: /* @__PURE__ */ new Map()
-      },
+      input: /* @__PURE__ */ new Map(),
+      output: /* @__PURE__ */ new Map(),
       ids: /* @__PURE__ */ new Map(),
       manual: /* @__PURE__ */ new Map(),
       setSchema: (key, schema, io) => {
-        const seenSchema = registry.schemas[io].seen.get(schema);
-        if (seenSchema) {
-          if (seenSchema.type === "manual") {
-            const manualSchema = registry.schemas.manual.get(seenSchema.id);
-            if (!manualSchema) {
-              throw new Error(
-                `Manual schema "${key}" not found in registry for ${io} IO.`
-              );
-            }
-            manualSchema.io[io].used = true;
-          }
-          return seenSchema.schemaObject;
-        }
         const schemaObject = {};
-        registry.schemas[io].schemas.set(key, {
+        registry.schemas[io].set(key, {
           schemaObject,
           zodType: schema
         });
-        registry.schemas[io].seen.set(schema, { type: "schema", schemaObject });
         return schemaObject;
       }
     },
@@ -863,36 +801,36 @@ const registerSchemas = (schemas, registry) => {
       const inputSchemaObject = {};
       const outputSchemaObject = {};
       const identifier = `components > schemas > ${key}`;
-      registry.schemas.input.schemas.set(identifier, {
+      registry.schemas.input.set(identifier, {
         zodType: schema,
         schemaObject: inputSchemaObject
       });
-      registry.schemas.input.seen.set(schema, {
-        type: "manual",
-        schemaObject: inputSchemaObject,
-        id: identifier
-      });
-      registry.schemas.output.schemas.set(identifier, {
+      registry.schemas.output.set(identifier, {
         zodType: schema,
         schemaObject: outputSchemaObject
       });
-      registry.schemas.output.seen.set(schema, {
-        type: "manual",
-        schemaObject: outputSchemaObject,
-        id: identifier
-      });
-      registry.schemas.manual.set(identifier, {
-        key,
+      registry.schemas.manual.set(key, {
+        identifier,
         io: {
           input: {
-            schemaObject: inputSchemaObject
+            schemaObject: inputSchemaObject,
+            used: 0
           },
           output: {
-            schemaObject: outputSchemaObject
+            schemaObject: outputSchemaObject,
+            used: 0
           }
         },
         zodType: schema
       });
+      const meta = core.globalRegistry.get(schema);
+      if (meta == null ? void 0 : meta.id) {
+        continue;
+      }
+      core.globalRegistry.add(schema, {
+        ...meta,
+        id: key
+      });
       continue;
     }
     registry.schemas.ids.set(key, schema);
@@ -1025,14 +963,14 @@ const registerPathItems = (pathItems, registry) => {
 };
 const createIOSchemas = (ctx) => {
   const { schemas, components } = createSchemas(
-    Object.fromEntries(ctx.registry.schemas[ctx.io].schemas),
+    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].schemas.get(key);
+    const ioSchema = ctx.registry.schemas[ctx.io].get(key);
     if (ioSchema) {
       Object.assign(ioSchema.schemaObject, schema);
     }
@@ -1040,11 +978,11 @@ const createIOSchemas = (ctx) => {
 };
 const createManualSchemas = (registry) => {
   var _a;
-  for (const [, value] of registry.schemas.manual) {
-    if (!value.io.input.used && !value.io.output.used) {
+  for (const [key, value] of registry.schemas.manual) {
+    if (value.io.input.used === 1) {
       const io = ((_a = core.globalRegistry.get(value.zodType)) == null ? void 0 : _a.unusedIO) ?? "output";
       const schema = value.io[io].schemaObject;
-      registry.schemas.ids.set(value.key, schema);
+      registry.schemas.ids.set(key, schema);
     }
   }
 };

package/dist/components.chunk.mjs

@@ -1,5 +1,5 @@
 import { globalRegistry as globalRegistry$1 } from "zod/v4/core";
-import { globalRegistry, registry, toJSONSchema } from "zod/v4";
+import { globalRegistry, object, toJSONSchema } from "zod/v4";
 const isAnyZodType = (schema) => typeof schema === "object" && schema !== null && "_zod" in schema;
 const unwrapZodObject = (zodType, io, path) => {
   const def = zodType._zod.def;
@@ -273,7 +273,7 @@ const createResponses = (responses, ctx, path) => {
   }
   return responsesObject;
 };
-const createOperation = (operationObject, registry2, path) => {
+const createOperation = (operationObject, registry, path) => {
   const {
     parameters,
     requestParams,
@@ -286,7 +286,7 @@ const createOperation = (operationObject, registry2, path) => {
   const maybeManualParameters = createManualParameters(
     parameters,
     {
-      registry: registry2,
+      registry,
       io: "input"
     },
     [...path, "parameters"]
@@ -294,7 +294,7 @@ const createOperation = (operationObject, registry2, path) => {
   const maybeRequestParams = createParameters(
     requestParams,
     {
-      registry: registry2,
+      registry,
       io: "input"
     },
     [...path, "requestParams"]
@@ -308,7 +308,7 @@ const createOperation = (operationObject, registry2, path) => {
   const maybeRequestBody = createRequestBody(
     requestBody,
     {
-      registry: registry2,
+      registry,
       io: "input"
     },
     [...path, "requestBody"]
@@ -319,7 +319,7 @@ const createOperation = (operationObject, registry2, path) => {
   const maybeResponses = createResponses(
     responses,
     {
-      registry: registry2,
+      registry,
       io: "output"
     },
     [...path, "responses"]
@@ -327,7 +327,7 @@ const createOperation = (operationObject, registry2, path) => {
   if (maybeResponses) {
     operation.responses = maybeResponses;
   }
-  const maybeCallbacks = createCallbacks(callbacks, registry2, [
+  const maybeCallbacks = createCallbacks(callbacks, registry, [
     ...path,
     "callbacks"
   ]);
@@ -336,14 +336,14 @@ const createOperation = (operationObject, registry2, path) => {
   }
   return operation;
 };
-const createPathItem = (pathItem, registry2, path) => {
+const createPathItem = (pathItem, registry, 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,
-        registry2,
+        registry,
         [...path, key]
       );
       continue;
@@ -352,7 +352,7 @@ const createPathItem = (pathItem, registry2, path) => {
       pathItemObject[key] = createManualParameters(
         value,
         {
-          registry: registry2,
+          registry,
           io: "input"
         },
         [...path, key]
@@ -365,14 +365,14 @@ const createPathItem = (pathItem, registry2, path) => {
     const ref = {
       $ref: `#/components/pathItems/${id}`
     };
-    registry2.pathItems.ids.set(id, pathItemObject);
-    registry2.pathItems.seen.set(pathItem, ref);
+    registry.pathItems.ids.set(id, pathItemObject);
+    registry.pathItems.seen.set(pathItem, ref);
     return ref;
   }
-  registry2.pathItems.seen.set(pathItem, pathItemObject);
+  registry.pathItems.seen.set(pathItem, pathItemObject);
   return pathItemObject;
 };
-const createPaths = (paths, registry2, path) => {
+const createPaths = (paths, registry, path) => {
   if (!paths) {
     return void 0;
   }
@@ -382,15 +382,15 @@ const createPaths = (paths, registry2, path) => {
       pathsObject[singlePath] = pathItemObject;
       continue;
     }
-    pathsObject[singlePath] = createPathItem(pathItemObject, registry2, [
+    pathsObject[singlePath] = createPathItem(pathItemObject, registry, [
       ...path,
       singlePath
     ]);
   }
   return pathsObject;
 };
-const createCallback = (callbackObject, registry2, path) => {
-  const seenCallback = registry2.callbacks.seen.get(callbackObject);
+const createCallback = (callbackObject, registry, path) => {
+  const seenCallback = registry.callbacks.seen.get(callbackObject);
   if (seenCallback) {
     return seenCallback;
   }
@@ -403,7 +403,7 @@ const createCallback = (callbackObject, registry2, path) => {
     }
     callback[name] = createPathItem(
       pathItem,
-      registry2,
+      registry,
       [...path, name]
     );
   }
@@ -411,14 +411,14 @@ const createCallback = (callbackObject, registry2, path) => {
     const ref = {
       $ref: `#/components/callbacks/${id}`
     };
-    registry2.callbacks.ids.set(id, callback);
-    registry2.callbacks.seen.set(callbackObject, ref);
+    registry.callbacks.ids.set(id, callback);
+    registry.callbacks.seen.set(callbackObject, ref);
     return ref;
   }
-  registry2.callbacks.seen.set(callbackObject, callback);
+  registry.callbacks.seen.set(callbackObject, callback);
   return callback;
 };
-const createCallbacks = (callbacks, registry2, path) => {
+const createCallbacks = (callbacks, registry, path) => {
   if (!callbacks) {
     return void 0;
   }
@@ -430,7 +430,7 @@ const createCallbacks = (callbacks, registry2, path) => {
     }
     callbacksObject[name] = createCallback(
       value,
-      registry2,
+      registry,
       [...path, name]
     );
   }
@@ -579,7 +579,7 @@ const renameComponents = (components, outputIds, ctx) => {
   }
   return componentsToRename;
 };
-const isDependencyPure = (componentDependencies, stringifiedComponents, registry2, key, visited = /* @__PURE__ */ new Set()) => {
+const isDependencyPure = (componentDependencies, stringifiedComponents, registry, key, visited = /* @__PURE__ */ new Set()) => {
   if (visited.has(key)) {
     return true;
   }
@@ -588,7 +588,7 @@ const isDependencyPure = (componentDependencies, stringifiedComponents, registry
     return dependencies.pure;
   }
   const stringified = stringifiedComponents.get(key);
-  const component = registry2.schemas.ids.get(key);
+  const component = registry.schemas.ids.get(key);
   if (component && stringified !== JSON.stringify(component)) {
     dependencies.pure = false;
     return false;
@@ -598,7 +598,7 @@ const isDependencyPure = (componentDependencies, stringifiedComponents, registry
     (dep) => isDependencyPure(
       componentDependencies,
       stringifiedComponents,
-      registry2,
+      registry,
       dep,
       new Set(visited)
     )
@@ -621,9 +621,7 @@ const createSchema = (schema, ctx = {
   ctx.registry ?? (ctx.registry = createRegistry());
   ctx.opts ?? (ctx.opts = {});
   ctx.io ?? (ctx.io = "output");
-  const registrySchemas = Object.fromEntries(
-    ctx.registry.schemas[ctx.io].schemas
-  );
+  const registrySchemas = Object.fromEntries(ctx.registry.schemas[ctx.io]);
   const schemas = {
     zodOpenApiCreateSchema: { zodType: schema }
   };
@@ -638,181 +636,121 @@ const createSchema = (schema, ctx = {
     components: jsonSchemas.components
   };
 };
-const createSchemas = (schemas, {
-  registry: registry$1,
-  io,
-  opts
-}) => {
-  var _a, _b, _c, _d, _e, _f;
-  const schemaRegistry = registry();
-  const globalsInSchemas = /* @__PURE__ */ new Map();
+const createSchemas = (schemas, ctx) => {
+  var _a, _b;
+  const entries = {};
   for (const [name, { zodType }] of Object.entries(schemas)) {
-    const id = (_a = globalRegistry.get(zodType)) == null ? void 0 : _a.id;
-    if (id) {
-      globalsInSchemas.set(name, id);
-    }
-    schemaRegistry.add(zodType, { id: name });
+    entries[name] = zodType;
   }
+  const schemaRegistry = object(entries);
   const outputIds = /* @__PURE__ */ new Map();
   const jsonSchema = toJSONSchema(schemaRegistry, {
-    override(ctx) {
-      const meta = ctx.zodSchema.meta();
+    override(context) {
+      const meta = context.zodSchema.meta();
       if ((meta == null ? void 0 : meta.outputId) && (meta == null ? void 0 : meta.id)) {
         outputIds.set(meta.id, meta.outputId);
       }
-      if (ctx.jsonSchema.$ref) {
+      if (context.jsonSchema.$ref) {
         return;
       }
-      const enrichedContext = { ...ctx, io };
+      const enrichedContext = { ...context, io: ctx.io };
       override(enrichedContext);
-      if (typeof opts.override === "function") {
-        opts.override(enrichedContext);
+      if (typeof ctx.opts.override === "function") {
+        ctx.opts.override(enrichedContext);
       }
       if (typeof (meta == null ? void 0 : meta.override) === "function") {
         meta.override(enrichedContext);
-        delete ctx.jsonSchema.override;
+        delete context.jsonSchema.override;
       }
       if (typeof (meta == null ? void 0 : meta.override) === "object" && meta.override !== null) {
-        Object.assign(ctx.jsonSchema, meta.override);
-        delete ctx.jsonSchema.override;
+        Object.assign(context.jsonSchema, meta.override);
+        delete context.jsonSchema.override;
       }
-      delete ctx.jsonSchema.$schema;
-      delete ctx.jsonSchema.id;
-      deleteZodOpenApiMeta(ctx.jsonSchema);
-      validate(enrichedContext, opts);
+      delete context.jsonSchema.$schema;
+      delete context.jsonSchema.id;
+      deleteZodOpenApiMeta(context.jsonSchema);
+      validate(enrichedContext, ctx.opts);
     },
-    io,
-    unrepresentable: "any",
-    uri: (id) => `#/components/schemas/${id}`
+    io: ctx.io,
+    unrepresentable: "any"
   });
-  const sharedDefs = ((_b = jsonSchema.schemas.__shared) == null ? void 0 : _b.$defs) ?? {};
-  (_c = jsonSchema.schemas).__shared ?? (_c.__shared = { $defs: sharedDefs });
-  const componentsToReplace = /* @__PURE__ */ new Map();
-  for (const [key, value] of Object.entries(sharedDefs)) {
-    if (/^schema\d+$/.exec(key)) {
-      const componentName = `__schema${registry$1.schemas.dynamicSchemaCount++}`;
-      componentsToReplace.set(`__shared#/$defs/${key}`, componentName);
-      delete sharedDefs[key];
-      sharedDefs[componentName] = value;
-      continue;
-    }
-    componentsToReplace.set(`__shared#/$defs/${key}`, key);
-  }
-  for (const value of Object.values(jsonSchema.schemas)) {
-    delete value.$schema;
-    delete value.id;
-  }
-  const dynamicComponent = /* @__PURE__ */ new Map();
-  const patched = JSON.stringify(jsonSchema).replace(
-    /"#\/components\/schemas\/([^"]+)"/g,
-    (_, match) => {
-      const replacement = componentsToReplace.get(match);
-      if (replacement) {
-        return `"#/components/schemas/${replacement}"`;
-      }
-      const component = registry$1.schemas.ids.get(match);
-      if (component) {
-        return `"#/components/schemas/${match}`;
-      }
-      const globalInSchema = globalsInSchemas.get(match);
-      if (globalInSchema) {
-        componentsToReplace.set(match, globalInSchema);
-        dynamicComponent.set(match, globalInSchema);
-        return `"#/components/schemas/${globalInSchema}"`;
-      }
-      const manualSchema = registry$1.schemas.manual.get(match);
-      if (manualSchema) {
-        componentsToReplace.set(match, manualSchema.key);
-        dynamicComponent.set(match, manualSchema.key);
-        manualSchema.io[io].used = true;
-        return `"#/components/schemas/${manualSchema.key}"`;
+  const components = jsonSchema.$defs ?? {};
+  const dynamicComponents = /* @__PURE__ */ new Map();
+  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) {
+        components[newName] = value;
+        delete components[key];
       }
-      const componentName = `__schema${registry$1.schemas.dynamicSchemaCount++}`;
-      componentsToReplace.set(match, componentName);
-      dynamicComponent.set(match, componentName);
-      return `"#/components/schemas/${componentName}"`;
     }
+  }
+  const parsedJsonSchema = JSON.parse(
+    JSON.stringify(jsonSchema).replace(
+      /"#\/\$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++;
+        }
+        return `"#/components/schemas/${match}"`;
+      }
+    )
   );
-  const patchedJsonSchema = JSON.parse(patched);
-  const components = ((_d = patchedJsonSchema.schemas.__shared) == null ? void 0 : _d.$defs) ?? {};
-  (_e = patchedJsonSchema.schemas).__shared ?? (_e.__shared = { $defs: components });
-  for (const [key, value] of registry$1.schemas.manual) {
-    if (value.io[io].used) {
-      dynamicComponent.set(key, value.key);
+  for (const [key, value] of ctx.registry.schemas.manual) {
+    if (value.io[ctx.io].used === 1 && ((_a = parsedJsonSchema.properties) == null ? void 0 : _a[value.identifier]) && ((_b = parsedJsonSchema.$defs) == null ? void 0 : _b[key])) {
+      parsedJsonSchema.properties[value.identifier] = parsedJsonSchema.$defs[key];
+      delete parsedJsonSchema.$defs[key];
+      continue;
     }
   }
-  for (const [key, value] of globalsInSchemas) {
-    dynamicComponent.set(key, value);
-  }
-  for (const [key, value] of dynamicComponent) {
-    const component = patchedJsonSchema.schemas[key];
-    patchedJsonSchema.schemas[key] = {
-      $ref: `#/components/schemas/${value}`
-    };
-    components[value] = component;
-  }
-  const renamedComponents = renameComponents(components, outputIds, {
-    registry: registry$1
-  });
-  if (renamedComponents.size === 0) {
-    delete patchedJsonSchema.schemas.__shared;
+  const renamedComponents = renameComponents(
+    parsedJsonSchema.$defs ?? {},
+    outputIds,
+    ctx
+  );
+  if (!renamedComponents.size) {
     return {
-      schemas: patchedJsonSchema.schemas,
-      components
+      schemas: parsedJsonSchema.properties,
+      components: parsedJsonSchema.$defs ?? {}
     };
   }
-  const renamedStringified = JSON.stringify(patchedJsonSchema).replace(
-    /"#\/components\/schemas\/([^"]+)"/g,
-    (_, match) => {
-      const newName = renamedComponents.get(match);
-      if (newName) {
-        return `"#/components/schemas/${newName}"`;
+  const renamedJsonSchema = JSON.parse(
+    JSON.stringify(parsedJsonSchema).replace(
+      /"#\/components\/schemas\/([^"]+)"/g,
+      (_, match) => {
+        const replacement = renamedComponents.get(match);
+        if (replacement) {
+          return `"#/components/schemas/${replacement}"`;
+        }
+        return `"#/components/schemas/${match}"`;
       }
-      return `"#/components/schemas/${match}"`;
-    }
+    )
   );
-  const renamedJsonSchema = JSON.parse(renamedStringified);
-  const renamedJsonSchemaComponents = ((_f = renamedJsonSchema.schemas.__shared) == null ? void 0 : _f.$defs) ?? {};
-  delete renamedJsonSchema.schemas.__shared;
   return {
-    schemas: renamedJsonSchema.schemas,
-    components: renamedJsonSchemaComponents
+    schemas: renamedJsonSchema.properties,
+    components: renamedJsonSchema.$defs ?? {}
   };
 };
 const createRegistry = (components) => {
-  const registry2 = {
+  const registry = {
     schemas: {
       dynamicSchemaCount: 0,
-      input: {
-        seen: /* @__PURE__ */ new WeakMap(),
-        schemas: /* @__PURE__ */ new Map()
-      },
-      output: {
-        seen: /* @__PURE__ */ new WeakMap(),
-        schemas: /* @__PURE__ */ new Map()
-      },
+      input: /* @__PURE__ */ new Map(),
+      output: /* @__PURE__ */ new Map(),
       ids: /* @__PURE__ */ new Map(),
       manual: /* @__PURE__ */ new Map(),
       setSchema: (key, schema, io) => {
-        const seenSchema = registry2.schemas[io].seen.get(schema);
-        if (seenSchema) {
-          if (seenSchema.type === "manual") {
-            const manualSchema = registry2.schemas.manual.get(seenSchema.id);
-            if (!manualSchema) {
-              throw new Error(
-                `Manual schema "${key}" not found in registry for ${io} IO.`
-              );
-            }
-            manualSchema.io[io].used = true;
-          }
-          return seenSchema.schemaObject;
-        }
         const schemaObject = {};
-        registry2.schemas[io].schemas.set(key, {
+        registry.schemas[io].set(key, {
           schemaObject,
           zodType: schema
         });
-        registry2.schemas[io].seen.set(schema, { type: "schema", schemaObject });
         return schemaObject;
       }
     },
@@ -841,68 +779,68 @@ const createRegistry = (components) => {
       seen: /* @__PURE__ */ new WeakMap()
     }
   };
-  registerSchemas(components == null ? void 0 : components.schemas, registry2);
-  registerParameters(components == null ? void 0 : components.parameters, registry2);
-  registerHeaders(components == null ? void 0 : components.headers, registry2);
-  registerResponses(components == null ? void 0 : components.responses, registry2);
-  registerPathItems(components == null ? void 0 : components.pathItems, registry2);
-  registerRequestBodies(components == null ? void 0 : components.requestBodies, registry2);
-  registerCallbacks(components == null ? void 0 : components.callbacks, registry2);
-  return registry2;
+  registerSchemas(components == null ? void 0 : components.schemas, registry);
+  registerParameters(components == null ? void 0 : components.parameters, registry);
+  registerHeaders(components == null ? void 0 : components.headers, registry);
+  registerResponses(components == null ? void 0 : components.responses, registry);
+  registerPathItems(components == null ? void 0 : components.pathItems, registry);
+  registerRequestBodies(components == null ? void 0 : components.requestBodies, registry);
+  registerCallbacks(components == null ? void 0 : components.callbacks, registry);
+  return registry;
 };
-const registerSchemas = (schemas, registry2) => {
+const registerSchemas = (schemas, registry) => {
   if (!schemas) {
     return;
   }
   for (const [key, schema] of Object.entries(schemas)) {
-    if (registry2.schemas.ids.has(key)) {
+    if (registry.schemas.ids.has(key)) {
       throw new Error(`Schema "${key}" is already registered`);
     }
     if (isAnyZodType(schema)) {
       const inputSchemaObject = {};
       const outputSchemaObject = {};
       const identifier = `components > schemas > ${key}`;
-      registry2.schemas.input.schemas.set(identifier, {
+      registry.schemas.input.set(identifier, {
         zodType: schema,
         schemaObject: inputSchemaObject
       });
-      registry2.schemas.input.seen.set(schema, {
-        type: "manual",
-        schemaObject: inputSchemaObject,
-        id: identifier
-      });
-      registry2.schemas.output.schemas.set(identifier, {
+      registry.schemas.output.set(identifier, {
         zodType: schema,
         schemaObject: outputSchemaObject
       });
-      registry2.schemas.output.seen.set(schema, {
-        type: "manual",
-        schemaObject: outputSchemaObject,
-        id: identifier
-      });
-      registry2.schemas.manual.set(identifier, {
-        key,
+      registry.schemas.manual.set(key, {
+        identifier,
         io: {
           input: {
-            schemaObject: inputSchemaObject
+            schemaObject: inputSchemaObject,
+            used: 0
           },
           output: {
-            schemaObject: outputSchemaObject
+            schemaObject: outputSchemaObject,
+            used: 0
           }
         },
         zodType: schema
       });
+      const meta = globalRegistry$1.get(schema);
+      if (meta == null ? void 0 : meta.id) {
+        continue;
+      }
+      globalRegistry$1.add(schema, {
+        ...meta,
+        id: key
+      });
       continue;
     }
-    registry2.schemas.ids.set(key, schema);
+    registry.schemas.ids.set(key, schema);
   }
 };
-const registerParameters = (parameters, registry2) => {
+const registerParameters = (parameters, registry) => {
   if (!parameters) {
     return;
   }
   for (const [key, schema] of Object.entries(parameters)) {
-    if (registry2.parameters.ids.has(key)) {
+    if (registry.parameters.ids.has(key)) {
       throw new Error(`Parameter "${key}" is already registered`);
     }
     if (isAnyZodType(schema)) {
@@ -911,24 +849,24 @@ const registerParameters = (parameters, registry2) => {
         schema,
         void 0,
         {
-          registry: registry2,
+          registry,
           io: "input"
         },
         path
       );
-      registry2.parameters.ids.set(key, paramObject);
-      registry2.parameters.seen.set(schema, paramObject);
+      registry.parameters.ids.set(key, paramObject);
+      registry.parameters.seen.set(schema, paramObject);
       continue;
     }
-    registry2.parameters.ids.set(key, schema);
+    registry.parameters.ids.set(key, schema);
   }
 };
-const registerHeaders = (headers, registry2) => {
+const registerHeaders = (headers, registry) => {
   if (!headers) {
     return;
   }
   for (const [key, schema] of Object.entries(headers)) {
-    if (registry2.headers.ids.has(key)) {
+    if (registry.headers.ids.has(key)) {
       throw new Error(`Header "${key}" is already registered`);
     }
     if (isAnyZodType(schema)) {
@@ -936,45 +874,45 @@ const registerHeaders = (headers, registry2) => {
       const headerObject = createHeader(
         schema,
         {
-          registry: registry2,
+          registry,
           io: "output"
         },
         path
       );
-      registry2.headers.ids.set(key, headerObject);
-      registry2.headers.seen.set(schema, headerObject);
+      registry.headers.ids.set(key, headerObject);
+      registry.headers.seen.set(schema, headerObject);
       continue;
     }
-    registry2.headers.ids.set(key, schema);
+    registry.headers.ids.set(key, schema);
   }
 };
-const registerResponses = (responses, registry2) => {
+const registerResponses = (responses, registry) => {
   if (!responses) {
     return;
   }
   for (const [key, schema] of Object.entries(responses)) {
     const path = ["components", "responses", key];
-    if (registry2.responses.ids.has(key)) {
+    if (registry.responses.ids.has(key)) {
       throw new Error(`Response "${key}" is already registered`);
     }
     const responseObject = createResponse(
       schema,
       {
-        registry: registry2,
+        registry,
         io: "output"
       },
       path
     );
-    registry2.responses.ids.set(key, responseObject);
-    registry2.responses.seen.set(schema, responseObject);
+    registry.responses.ids.set(key, responseObject);
+    registry.responses.seen.set(schema, responseObject);
   }
 };
-const registerRequestBodies = (requestBodies, registry2) => {
+const registerRequestBodies = (requestBodies, registry) => {
   if (!requestBodies) {
     return;
   }
   for (const [key, schema] of Object.entries(requestBodies)) {
-    if (registry2.requestBodies.ids.has(key)) {
+    if (registry.requestBodies.ids.has(key)) {
       throw new Error(`RequestBody "${key}" is already registered`);
     }
     if (isAnyZodType(schema)) {
@@ -982,96 +920,96 @@ const registerRequestBodies = (requestBodies, registry2) => {
       const requestBodyObject = createRequestBody(
         schema,
         {
-          registry: registry2,
+          registry,
           io: "input"
         },
         path
       );
-      registry2.requestBodies.ids.set(key, requestBodyObject);
+      registry.requestBodies.ids.set(key, requestBodyObject);
       continue;
     }
-    registry2.requestBodies.ids.set(key, schema);
+    registry.requestBodies.ids.set(key, schema);
   }
 };
-const registerCallbacks = (callbacks, registry2) => {
+const registerCallbacks = (callbacks, registry) => {
   if (!callbacks) {
     return;
   }
   for (const [key, schema] of Object.entries(callbacks)) {
-    if (registry2.callbacks.ids.has(key)) {
+    if (registry.callbacks.ids.has(key)) {
       throw new Error(`Callback "${key}" is already registered`);
     }
     const path = ["components", "callbacks", key];
-    const callbackObject = createCallback(schema, registry2, path);
-    registry2.callbacks.ids.set(key, callbackObject);
-    registry2.callbacks.seen.set(schema, callbackObject);
+    const callbackObject = createCallback(schema, registry, path);
+    registry.callbacks.ids.set(key, callbackObject);
+    registry.callbacks.seen.set(schema, callbackObject);
   }
 };
-const registerPathItems = (pathItems, registry2) => {
+const registerPathItems = (pathItems, registry) => {
   if (!pathItems) {
     return;
   }
   for (const [key, schema] of Object.entries(pathItems)) {
-    if (registry2.pathItems.ids.has(key)) {
+    if (registry.pathItems.ids.has(key)) {
       throw new Error(`PathItem "${key}" is already registered`);
     }
     const path = ["components", "pathItems", key];
-    const pathItemObject = createPathItem(schema, registry2, path);
-    registry2.pathItems.ids.set(key, pathItemObject);
-    registry2.pathItems.seen.set(schema, pathItemObject);
+    const pathItemObject = createPathItem(schema, registry, path);
+    registry.pathItems.ids.set(key, pathItemObject);
+    registry.pathItems.seen.set(schema, pathItemObject);
     continue;
   }
 };
 const createIOSchemas = (ctx) => {
   const { schemas, components } = createSchemas(
-    Object.fromEntries(ctx.registry.schemas[ctx.io].schemas),
+    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].schemas.get(key);
+    const ioSchema = ctx.registry.schemas[ctx.io].get(key);
     if (ioSchema) {
       Object.assign(ioSchema.schemaObject, schema);
     }
   }
 };
-const createManualSchemas = (registry2) => {
+const createManualSchemas = (registry) => {
   var _a;
-  for (const [, value] of registry2.schemas.manual) {
-    if (!value.io.input.used && !value.io.output.used) {
+  for (const [key, value] of registry.schemas.manual) {
+    if (value.io.input.used === 1) {
       const io = ((_a = globalRegistry$1.get(value.zodType)) == null ? void 0 : _a.unusedIO) ?? "output";
       const schema = value.io[io].schemaObject;
-      registry2.schemas.ids.set(value.key, schema);
+      registry.schemas.ids.set(key, schema);
     }
   }
 };
-const createComponents = (registry2, opts) => {
-  createIOSchemas({ registry: registry2, io: "input", opts });
-  createIOSchemas({ registry: registry2, io: "output", opts });
-  createManualSchemas(registry2);
+const createComponents = (registry, opts) => {
+  createIOSchemas({ registry, io: "input", opts });
+  createIOSchemas({ registry, io: "output", opts });
+  createManualSchemas(registry);
   const components = {};
-  if (registry2.schemas.ids.size > 0) {
-    components.schemas = Object.fromEntries(registry2.schemas.ids);
+  if (registry.schemas.ids.size > 0) {
+    components.schemas = Object.fromEntries(registry.schemas.ids);
   }
-  if (registry2.headers.ids.size > 0) {
-    components.headers = Object.fromEntries(registry2.headers.ids);
+  if (registry.headers.ids.size > 0) {
+    components.headers = Object.fromEntries(registry.headers.ids);
   }
-  if (registry2.requestBodies.ids.size > 0) {
-    components.requestBodies = Object.fromEntries(registry2.requestBodies.ids);
+  if (registry.requestBodies.ids.size > 0) {
+    components.requestBodies = Object.fromEntries(registry.requestBodies.ids);
   }
-  if (registry2.responses.ids.size > 0) {
-    components.responses = Object.fromEntries(registry2.responses.ids);
+  if (registry.responses.ids.size > 0) {
+    components.responses = Object.fromEntries(registry.responses.ids);
   }
-  if (registry2.parameters.ids.size > 0) {
-    components.parameters = Object.fromEntries(registry2.parameters.ids);
+  if (registry.parameters.ids.size > 0) {
+    components.parameters = Object.fromEntries(registry.parameters.ids);
   }
-  if (registry2.callbacks.ids.size > 0) {
-    components.callbacks = Object.fromEntries(registry2.callbacks.ids);
+  if (registry.callbacks.ids.size > 0) {
+    components.callbacks = Object.fromEntries(registry.callbacks.ids);
   }
-  if (registry2.pathItems.ids.size > 0) {
-    components.pathItems = Object.fromEntries(registry2.pathItems.ids);
+  if (registry.pathItems.ids.size > 0) {
+    components.pathItems = Object.fromEntries(registry.pathItems.ids);
   }
   return components;
 };

package/dist/create/components.d.ts

@@ -8,44 +8,24 @@ interface ComponentRegistry {
      */
     schemas: {
         dynamicSchemaCount: number;
-        input: {
-            seen: WeakMap<$ZodType, {
-                type: 'manual';
-                id: string;
-                schemaObject: SchemaObject | ReferenceObject;
-            } | {
-                type: 'schema';
-                schemaObject: SchemaObject | ReferenceObject;
-            }>;
-            schemas: Map<string, {
-                zodType: $ZodType;
-                schemaObject: SchemaObject | ReferenceObject;
-            }>;
-        };
-        output: {
-            seen: WeakMap<$ZodType, {
-                type: 'manual';
-                id: string;
-                schemaObject: SchemaObject | ReferenceObject;
-            } | {
-                type: 'schema';
-                schemaObject: SchemaObject | ReferenceObject;
-            }>;
-            schemas: Map<string, {
-                zodType: $ZodType;
-                schemaObject: SchemaObject | ReferenceObject;
-            }>;
-        };
+        input: Map<string, {
+            zodType: $ZodType;
+            schemaObject: SchemaObject | ReferenceObject;
+        }>;
+        output: Map<string, {
+            zodType: $ZodType;
+            schemaObject: SchemaObject | ReferenceObject;
+        }>;
         ids: Map<string, SchemaObject | ReferenceObject>;
         manual: Map<string, {
-            key: string;
+            identifier: string;
             io: {
                 input: {
-                    used?: true;
+                    used: number;
                     schemaObject: SchemaObject;
                 };
                 output: {
-                    used?: true;
+                    used: number;
                     schemaObject: SchemaObject;
                 };
             };

package/dist/create/schema/schema.d.ts

@@ -2,7 +2,7 @@ import { core } from 'zod/v4';
 import { CreateDocumentOptions } from '../document.js';
 import { ComponentRegistry } from '../components.js';
 import '../../zod.js';
-import { ReferenceObject, SchemaObject } from '../../openapi3-ts/dist/model/openapi31.js';
+import { SchemaObject, ReferenceObject } from '../../openapi3-ts/dist/model/openapi31.js';
 
 interface SchemaResult {
     schema: SchemaObject | ReferenceObject;
@@ -13,7 +13,7 @@ declare const createSchema: (schema: core.$ZodType, ctx?: {
     io?: "input" | "output";
     opts?: CreateDocumentOptions;
 }) => {
-    schema: ReferenceObject | SchemaObject;
+    schema: SchemaObject | ReferenceObject;
     components: Record<string, SchemaObject>;
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-openapi",
-  "version": "5.0.0-beta.2",
+  "version": "5.0.0-beta.3",
   "description": "Convert Zod Schemas to OpenAPI v3.x documentation",
   "keywords": [
     "typescript",