@temporary-name/server 1.9.3-alpha.fb7b7d19964e1b2def7056f4345b63d6fcacce10 → 1.9.3-alpha.fb7e3a67f82deaeffad5063e136b2f3c03c4b5b3

package/dist/index.mjs

@@ -1,19 +1,23 @@
-import { assertNever, splitFirst, ORPCError, onError, resolveMaybeOptionalOptions, isTypescriptObject, isPropertyKey } from '@temporary-name/shared';
-export { AsyncIteratorClass, EventPublisher, ORPCError, asyncIteratorToStream as eventIteratorToStream, isDefinedError, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@temporary-name/shared';
+import { assertNever, splitFirst, onError, isObject, toArray, guard, resolveMaybeOptionalOptions, isTypescriptObject, isPropertyKey } from '@temporary-name/shared';
+export { AsyncIteratorClass, EventPublisher, asyncIteratorToStream as eventIteratorToStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@temporary-name/shared';
 import * as z from '@temporary-name/zod';
 import { SchemaClass, object, core, gatingContext } from '@temporary-name/zod';
+export { z as baseZ };
+import { U as UnauthorizedError, P as Procedure, m as mergePrefix, a as mergeTags, b as enhanceRouter, C as Contract, p as parseEndpointDefinition, c as mergeRoute, d as prefixRoute, f as addMiddleware, l as lazyInternal, h as getLazyMeta, u as unlazy, j as isProcedure } from './shared/server.DvgWQUGK.mjs';
+export { A as APIError, B as BadRequestError, F as ForbiddenError, I as InternalServerError, L as LAZY_SYMBOL, N as NotFoundError, V as ValidationError, x as createAccessibleLazyRouter, e as encodeError, D as endpointRegex, g as getDynamicParams, w as getRouter, i as isAPIErrorStatus, E as isDevelopment, o as isLazy, q as isStartWithMiddlewares, n as lazy, k as makeErrors, v as mergeMiddlewares, r as resolveContractProcedures, s as standardizeHTTPPath, t as toAPIError, y as traverseContractProcedures, z as unlazyRouter } from './shared/server.DvgWQUGK.mjs';
 import { g as getCookie } from './shared/server.C1RJffw4.mjs';
-import { P as Procedure, m as mergePrefix, a as mergeTags, e as enhanceRouter, C as Contract, p as parseEndpointDefinition, b as mergeRoute, c as prefixRoute, d as addMiddleware, l as lazyInternal, f as getLazyMeta, u as unlazy, i as isProcedure, h as isLazy, j as getRouter } from './shared/server.ChOv1yG3.mjs';
-export { L as LAZY_SYMBOL, V as ValidationError, q as createAccessibleLazyRouter, w as endpointRegex, g as getDynamicParams, n as isStartWithMiddlewares, k as lazy, o as mergeMiddlewares, r as resolveContractProcedures, s as standardizeHTTPPath, t as traverseContractProcedures, v as unlazyRouter } from './shared/server.ChOv1yG3.mjs';
-import { c as createProcedureClient } from './shared/server.Cza0RB3u.mjs';
-export { m as mergeCurrentContext, a as middlewareOutputFn } from './shared/server.Cza0RB3u.mjs';
-export { e as eventIterator, g as getEventIteratorSchemaDetails } from './shared/server.YUvuxHty.mjs';
+import { c as createProcedureClient } from './shared/server.D2NXNHIf.mjs';
+export { m as mergeCurrentContext, a as middlewareOutputFn } from './shared/server.D2NXNHIf.mjs';
+import { J as JsonSchemaXNativeType } from './shared/server.-tR-4rQ5.mjs';
+export { b as JSON_SCHEMA_INPUT_REGISTRY, c as JSON_SCHEMA_OUTPUT_REGISTRY, a as JSON_SCHEMA_REGISTRY, Z as ZodToJsonSchemaConverter, e as eventIterator, g as getEventIteratorSchemaDetails } from './shared/server.-tR-4rQ5.mjs';
 export { getEventMeta, withEventMeta } from '@temporary-name/standard-server';
 import 'cookie';
+import '@temporary-name/server/openapi';
+import 'zod/v4/core';
 
 function validateTokenPrefix(prefix, token) {
   if (prefix && !token.startsWith(prefix)) {
-    throw new ORPCError("UNAUTHORIZED", { message: `Invalid auth token. It must start with "${prefix}"` });
+    throw new UnauthorizedError({ message: `Invalid auth token. It must start with "${prefix}"` });
   }
 }
 function validateTokenAuth(config, token, options) {
@@ -185,6 +189,12 @@ class ProcedureBuilder extends Contract {
       middlewares: addMiddleware(this["~orpc"].middlewares, middleware)
     });
   }
+  useErrors(errorMap) {
+    return new this.constructor({
+      ...this["~orpc"],
+      errorMap
+    });
+  }
   // The default of false for ValidatedAuthContext is used when you pass in the type 'none'. We use false
   // because we can't use null or undefined (see ValidatedAuthContext) but we still want it to be falsy.
   useAuth(config) {
@@ -199,7 +209,7 @@ class ProcedureBuilder extends Contract {
           if (authConfigs.length > 1) {
             authDescriptions = `one of: ${authDescriptions}`;
           }
-          throw new ORPCError("UNAUTHORIZED", {
+          throw new UnauthorizedError({
             message: `Authentication required. You must provide ${authDescriptions}`
           });
         }
@@ -305,6 +315,7 @@ class Builder extends BuilderWithMiddlewares {
 const baseApi = new Builder({
   route: {},
   meta: {},
+  errorMap: {},
   inputValidationIndex: 0,
   outputValidationIndex: 0,
   middlewares: [
@@ -319,6 +330,332 @@ const baseApi = new Builder({
   authConfigs: []
 });
 
+const FLEXIBLE_DATE_FORMAT_REGEX = /^[^-]+-[^-]+-[^-]+$/;
+class experimental_JsonSchemaCoercer {
+  coerce(schema, value, options = {}) {
+    const [, coerced] = this.#coerce(schema, value, options);
+    return coerced;
+  }
+  #coerce(schema, originalValue, options) {
+    if (typeof schema === "boolean") {
+      return [schema, originalValue];
+    }
+    if (Array.isArray(schema.type)) {
+      return this.#coerce(
+        {
+          anyOf: schema.type.map((type) => ({ ...schema, type }))
+        },
+        originalValue,
+        options
+      );
+    }
+    let coerced = originalValue;
+    let satisfied = true;
+    if (typeof schema.$ref === "string") {
+      const refSchema = options?.components?.[schema.$ref];
+      if (refSchema !== void 0) {
+        const [subSatisfied, subCoerced] = this.#coerce(refSchema, coerced, options);
+        coerced = subCoerced;
+        satisfied = subSatisfied;
+      }
+    }
+    const enumValues = schema.const !== void 0 ? [schema.const] : schema.enum;
+    if (enumValues !== void 0 && !enumValues.includes(coerced)) {
+      if (typeof coerced === "string") {
+        const numberValue = this.#stringToNumber(coerced);
+        if (enumValues.includes(numberValue)) {
+          coerced = numberValue;
+        } else {
+          const booleanValue = this.#stringToBoolean(coerced);
+          if (enumValues.includes(booleanValue)) {
+            coerced = booleanValue;
+          } else {
+            satisfied = false;
+          }
+        }
+      } else {
+        satisfied = false;
+      }
+    }
+    if (typeof schema.type === "string") {
+      switch (schema.type) {
+        case "null": {
+          if (coerced !== null) {
+            satisfied = false;
+          }
+          break;
+        }
+        case "string": {
+          if (typeof coerced !== "string") {
+            satisfied = false;
+          }
+          break;
+        }
+        case "number": {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToNumber(coerced);
+          }
+          if (typeof coerced !== "number") {
+            satisfied = false;
+          }
+          break;
+        }
+        case "integer": {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToInteger(coerced);
+          }
+          if (typeof coerced !== "number" || !Number.isInteger(coerced)) {
+            satisfied = false;
+          }
+          break;
+        }
+        case "boolean": {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToBoolean(coerced);
+          }
+          if (typeof coerced !== "boolean") {
+            satisfied = false;
+          }
+          break;
+        }
+        case "array": {
+          if (Array.isArray(coerced)) {
+            const prefixItemSchemas = "prefixItems" in schema ? toArray(schema.prefixItems) : Array.isArray(schema.items) ? schema.items : [];
+            const itemSchema = Array.isArray(schema.items) ? schema.additionalItems : schema.items;
+            let shouldUseCoercedItems = false;
+            const coercedItems = coerced.map((item, i) => {
+              const subSchema = prefixItemSchemas[i] ?? itemSchema;
+              if (subSchema === void 0) {
+                satisfied = false;
+                return item;
+              }
+              const [subSatisfied, subCoerced] = this.#coerce(subSchema, item, options);
+              if (!subSatisfied) {
+                satisfied = false;
+              }
+              if (subCoerced !== item) {
+                shouldUseCoercedItems = true;
+              }
+              return subCoerced;
+            });
+            if (coercedItems.length < prefixItemSchemas.length) {
+              satisfied = false;
+            }
+            if (shouldUseCoercedItems) {
+              coerced = coercedItems;
+            }
+          } else {
+            satisfied = false;
+          }
+          break;
+        }
+        case "object": {
+          if (Array.isArray(coerced)) {
+            coerced = { ...coerced };
+          }
+          if (isObject(coerced)) {
+            let shouldUseCoercedItems = false;
+            const coercedItems = {};
+            const patternProperties = Object.entries(schema.patternProperties ?? {}).map(
+              ([key, value]) => [new RegExp(key), value]
+            );
+            for (const key in coerced) {
+              const value = coerced[key];
+              const subSchema = schema.properties?.[key] ?? patternProperties.find(([pattern]) => pattern.test(key))?.[1] ?? schema.additionalProperties;
+              if (value === void 0 && !schema.required?.includes(key)) {
+                coercedItems[key] = value;
+              } else if (subSchema === void 0) {
+                coercedItems[key] = value;
+                satisfied = false;
+              } else {
+                const [subSatisfied, subCoerced] = this.#coerce(subSchema, value, options);
+                coercedItems[key] = subCoerced;
+                if (!subSatisfied) {
+                  satisfied = false;
+                }
+                if (subCoerced !== value) {
+                  shouldUseCoercedItems = true;
+                }
+              }
+            }
+            if (schema.required?.some((key) => !Object.hasOwn(coercedItems, key))) {
+              satisfied = false;
+            }
+            if (shouldUseCoercedItems) {
+              coerced = coercedItems;
+            }
+          } else {
+            satisfied = false;
+          }
+          break;
+        }
+      }
+    }
+    if ("x-native-type" in schema && typeof schema["x-native-type"] === "string") {
+      switch (schema["x-native-type"]) {
+        case JsonSchemaXNativeType.Date: {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToDate(coerced);
+          }
+          if (!(coerced instanceof Date)) {
+            satisfied = false;
+          }
+          break;
+        }
+        case JsonSchemaXNativeType.BigInt: {
+          switch (typeof coerced) {
+            case "string":
+              coerced = this.#stringToBigInt(coerced);
+              break;
+            case "number":
+              coerced = this.#numberToBigInt(coerced);
+              break;
+          }
+          if (typeof coerced !== "bigint") {
+            satisfied = false;
+          }
+          break;
+        }
+        case JsonSchemaXNativeType.RegExp: {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToRegExp(coerced);
+          }
+          if (!(coerced instanceof RegExp)) {
+            satisfied = false;
+          }
+          break;
+        }
+        case JsonSchemaXNativeType.Url: {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToURL(coerced);
+          }
+          if (!(coerced instanceof URL)) {
+            satisfied = false;
+          }
+          break;
+        }
+        case JsonSchemaXNativeType.Set: {
+          if (Array.isArray(coerced)) {
+            coerced = this.#arrayToSet(coerced);
+          }
+          if (!(coerced instanceof Set)) {
+            satisfied = false;
+          }
+          break;
+        }
+        case JsonSchemaXNativeType.Map: {
+          if (Array.isArray(coerced)) {
+            coerced = this.#arrayToMap(coerced);
+          }
+          if (!(coerced instanceof Map)) {
+            satisfied = false;
+          }
+          break;
+        }
+      }
+    }
+    if (schema.allOf) {
+      for (const subSchema of schema.allOf) {
+        const [subSatisfied, subCoerced] = this.#coerce(subSchema, coerced, options);
+        coerced = subCoerced;
+        if (!subSatisfied) {
+          satisfied = false;
+        }
+      }
+    }
+    for (const key of ["anyOf", "oneOf"]) {
+      if (schema[key]) {
+        let bestOptions;
+        for (const subSchema of schema[key]) {
+          const [subSatisfied, subCoerced] = this.#coerce(subSchema, coerced, options);
+          if (subSatisfied) {
+            if (!bestOptions || subCoerced === coerced) {
+              bestOptions = { coerced: subCoerced, satisfied: subSatisfied };
+            }
+            if (subCoerced === coerced) {
+              break;
+            }
+          }
+        }
+        coerced = bestOptions ? bestOptions.coerced : coerced;
+        satisfied = bestOptions ? bestOptions.satisfied : false;
+      }
+    }
+    if (typeof schema.not !== "undefined") {
+      const [notSatisfied] = this.#coerce(schema.not, coerced, options);
+      if (notSatisfied) {
+        satisfied = false;
+      }
+    }
+    return [satisfied, coerced];
+  }
+  #stringToNumber(value) {
+    const num = Number.parseFloat(value);
+    if (Number.isNaN(num) || num !== Number(value)) {
+      return value;
+    }
+    return num;
+  }
+  #stringToInteger(value) {
+    const num = Number.parseInt(value);
+    if (Number.isNaN(num) || num !== Number(value)) {
+      return value;
+    }
+    return num;
+  }
+  #stringToBoolean(value) {
+    const lower = value.toLowerCase();
+    if (lower === "false" || lower === "off") {
+      return false;
+    }
+    if (lower === "true" || lower === "on") {
+      return true;
+    }
+    return value;
+  }
+  #stringToBigInt(value) {
+    return guard(() => BigInt(value)) ?? value;
+  }
+  #numberToBigInt(value) {
+    return guard(() => BigInt(value)) ?? value;
+  }
+  #stringToDate(value) {
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime()) || !FLEXIBLE_DATE_FORMAT_REGEX.test(value)) {
+      return value;
+    }
+    return date;
+  }
+  #stringToRegExp(value) {
+    const match = value.match(/^\/(.*)\/([a-z]*)$/);
+    if (match) {
+      const [, pattern, flags] = match;
+      return guard(() => new RegExp(pattern, flags)) ?? value;
+    }
+    return value;
+  }
+  #stringToURL(value) {
+    return guard(() => new URL(value)) ?? value;
+  }
+  #arrayToSet(value) {
+    const set = new Set(value);
+    if (set.size !== value.length) {
+      return value;
+    }
+    return set;
+  }
+  #arrayToMap(value) {
+    if (value.some((item) => !Array.isArray(item) || item.length !== 2)) {
+      return value;
+    }
+    const result = new Map(value);
+    if (result.size !== value.length) {
+      return value;
+    }
+    return result;
+  }
+}
+
 function createAssertedLazyProcedure(lazied) {
   const lazyProcedure = lazyInternal(async () => {
     const { default: maybeProcedure } = await unlazy(lazied);
@@ -338,31 +675,6 @@ function call(procedure, input, ...rest) {
   return createProcedureClient(procedure, options)(input, options);
 }
 
-function createRouterClient(router, ...rest) {
-  const options = resolveMaybeOptionalOptions(rest);
-  if (isProcedure(router)) {
-    const caller = createProcedureClient(router, options);
-    return caller;
-  }
-  const procedureCaller = isLazy(router) ? createProcedureClient(createAssertedLazyProcedure(router), options) : {};
-  const recursive = new Proxy(procedureCaller, {
-    get(target, key) {
-      if (typeof key !== "string") {
-        return Reflect.get(target, key);
-      }
-      const next = getRouter(router, [key]);
-      if (!next) {
-        return Reflect.get(target, key);
-      }
-      return createRouterClient(next, {
-        ...rest[0],
-        path: [...rest[0]?.path ?? [], key]
-      });
-    }
-  });
-  return recursive;
-}
-
 function isSchemaIssue(issue) {
   if (!isTypescriptObject(issue) || typeof issue.message !== "string") {
     return false;
@@ -380,4 +692,4 @@ function isSchemaIssue(issue) {
   return true;
 }
 
-export { Builder, BuilderWithMiddlewares, Contract, DecoratedProcedure, Procedure, ProcedureBuilder, addMiddleware, baseApi, call, createAssertedLazyProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, getLazyMeta, getRouter, initialSchemas, isLazy, isProcedure, isSchemaIssue, lazyInternal, mergeMeta, parseEndpointDefinition, unlazy };
+export { Builder, BuilderWithMiddlewares, Contract, DecoratedProcedure, JsonSchemaXNativeType, Procedure, ProcedureBuilder, UnauthorizedError, addMiddleware, baseApi, call, createAssertedLazyProcedure, createProcedureClient, decorateMiddleware, enhanceRouter, experimental_JsonSchemaCoercer, getLazyMeta, initialSchemas, isProcedure, isSchemaIssue, lazyInternal, mergeMeta, parseEndpointDefinition, unlazy };

package/dist/openapi/index.d.mts

@@ -1,10 +1,11 @@
 import { Contract } from '@temporary-name/server';
 import { OpenAPI, Promisable, Value, HTTPPath, HTTPMethod } from '@temporary-name/shared';
 export { OpenAPI } from '@temporary-name/shared';
-import { ZodToJsonSchemaConverterOptions } from '@temporary-name/json-schema';
-import { d as AnySchema, b as Contract$1, a9 as TraverseContractProcedureCallbackOptions, $ as ContractRouter, u as AnyRouter } from '../shared/server.DXPMDozZ.mjs';
+import { Z as ZodToJsonSchemaConverterOptions } from '../shared/server.CjPiuQYH.mjs';
+import { d as AnySchema, b as Contract$1, ao as TraverseContractProcedureCallbackOptions, ac as ContractRouter, ad as AnyRouter } from '../shared/server.BwcJq6aP.mjs';
 import { JSONSchema } from '@temporary-name/interop/json-schema-typed/draft-2020-12';
 export { JSONSchema, ContentEncoding as JSONSchemaContentEncoding, Format as JSONSchemaFormat, TypeName as JSONSchemaTypeName } from '@temporary-name/interop/json-schema-typed/draft-2020-12';
+import '@temporary-name/server/openapi';
 import '@temporary-name/zod';
 
 type OverrideOperationValue = Partial<OpenAPI.OperationObject> | ((current: OpenAPI.OperationObject, procedure: Contract) => OpenAPI.OperationObject);

package/dist/openapi/index.d.ts

@@ -1,10 +1,11 @@
 import { Contract } from '@temporary-name/server';
 import { OpenAPI, Promisable, Value, HTTPPath, HTTPMethod } from '@temporary-name/shared';
 export { OpenAPI } from '@temporary-name/shared';
-import { ZodToJsonSchemaConverterOptions } from '@temporary-name/json-schema';
-import { d as AnySchema, b as Contract$1, a9 as TraverseContractProcedureCallbackOptions, $ as ContractRouter, u as AnyRouter } from '../shared/server.DXPMDozZ.js';
+import { Z as ZodToJsonSchemaConverterOptions } from '../shared/server.CjPiuQYH.js';
+import { d as AnySchema, b as Contract$1, ao as TraverseContractProcedureCallbackOptions, ac as ContractRouter, ad as AnyRouter } from '../shared/server.BwcJq6aP.js';
 import { JSONSchema } from '@temporary-name/interop/json-schema-typed/draft-2020-12';
 export { JSONSchema, ContentEncoding as JSONSchemaContentEncoding, Format as JSONSchemaFormat, TypeName as JSONSchemaTypeName } from '@temporary-name/interop/json-schema-typed/draft-2020-12';
+import '@temporary-name/server/openapi';
 import '@temporary-name/zod';
 
 type OverrideOperationValue = Partial<OpenAPI.OperationObject> | ((current: OpenAPI.OperationObject, procedure: Contract) => OpenAPI.OperationObject);

package/dist/openapi/index.mjs

@@ -1,12 +1,12 @@
-import { ZodToJsonSchemaConverter } from '@temporary-name/json-schema';
-import { isObject, stringifyJSON, findDeepMatches, clone, value, fallbackContractConfig, toHttpPath, assertNever, isORPCErrorStatus } from '@temporary-name/shared';
-import { j as jsonSerialize } from '../shared/server.CQIFwyhc.mjs';
-import '@temporary-name/standard-server';
-import { g as getEventIteratorSchemaDetails } from '../shared/server.YUvuxHty.mjs';
-import { s as standardizeHTTPPath, r as resolveContractProcedures, g as getDynamicParams } from '../shared/server.ChOv1yG3.mjs';
+import { isObject, stringifyJSON, findDeepMatches, clone, value, fallbackContractConfig, toHttpPath, assertNever } from '@temporary-name/shared';
+import * as z from '@temporary-name/zod';
+import { s as standardizeHTTPPath, r as resolveContractProcedures, g as getDynamicParams, i as isAPIErrorStatus } from '../shared/server.DvgWQUGK.mjs';
+import { Z as ZodToJsonSchemaConverter, g as getEventIteratorSchemaDetails } from '../shared/server.-tR-4rQ5.mjs';
 import { TypeName } from '@temporary-name/interop/json-schema-typed/draft-2020-12';
 export { ContentEncoding as JSONSchemaContentEncoding, Format as JSONSchemaFormat, TypeName as JSONSchemaTypeName } from '@temporary-name/interop/json-schema-typed/draft-2020-12';
-import '@temporary-name/zod';
+import '@temporary-name/standard-server';
+import '@temporary-name/server/openapi';
+import 'zod/v4/core';
 
 const OPERATION_EXTENDER_SYMBOL = Symbol("ORPC_OPERATION_EXTENDER");
 function customOpenAPIOperation(o, extend) {
@@ -425,6 +425,7 @@ async function generateOpenApiSpec(router, options = {}) {
         }
         await handleRequest(doc, operationObjectRef, def, baseSchemaConvertOptions, converter);
         await handleSuccessResponse(doc, operationObjectRef, def, baseSchemaConvertOptions, converter);
+        await handleErrorResponse(doc, operationObjectRef, def, baseSchemaConvertOptions, converter);
       }
       if (typeof def.route.spec === "function") {
         operationObjectRef = def.route.spec(operationObjectRef);
@@ -449,19 +450,18 @@ ${e.message}`
 ${errors.join("\n\n")}`
     );
   }
-  return jsonSerialize(doc)[0];
+  return doc;
 }
 async function resolveCommonSchemas(doc, commonSchemas, converter) {
   let undefinedErrorJsonSchema = {
     type: "object",
     properties: {
-      defined: { const: false },
       code: { type: "string" },
       status: { type: "number" },
       message: { type: "string" },
       data: {}
     },
-    required: ["defined", "code", "status", "message"]
+    required: ["code", "status", "message"]
   };
   const baseSchemaConvertOptions = {};
   if (commonSchemas) {
@@ -539,11 +539,9 @@ async function handleRequest(doc, ref, def, baseSchemaConvertOptions, converter)
   } else {
     const error = new OpenAPIGeneratorError("Params set via path do not match those on the route");
     if (!isObjectSchema(pathSchema)) {
-      console.log("FOO", pathSchema);
       throw error;
     }
     if (!checkParamsSchema(pathSchema, [])) {
-      console.log("BAR", pathSchema);
       throw error;
     }
   }
@@ -641,7 +639,7 @@ async function handleSuccessResponse(doc, ref, def, baseSchemaConvertOptions, co
     let schemaDescription;
     if (item.properties?.status !== void 0) {
       const statusSchema = resolveOpenAPIJsonSchemaRef(doc, item.properties.status);
-      if (typeof statusSchema !== "object" || statusSchema.const === void 0 || typeof statusSchema.const !== "number" || !Number.isInteger(statusSchema.const) || isORPCErrorStatus(statusSchema.const)) {
+      if (typeof statusSchema !== "object" || statusSchema.const === void 0 || typeof statusSchema.const !== "number" || !Number.isInteger(statusSchema.const) || isAPIErrorStatus(statusSchema.const)) {
         throw error;
       }
       schemaStatus = statusSchema.const;
@@ -723,6 +721,59 @@ function authConfigToSecurityScheme(authConfig) {
       assertNever(authConfig, `Unsupported auth config type: ${authConfig.type}`);
   }
 }
+async function handleErrorResponse(doc, ref, def, baseSchemaConvertOptions, converter) {
+  const errorMap = def.errorMap;
+  const errorResponsesByStatus = {};
+  for (const code in errorMap) {
+    const errorClass = errorMap[code];
+    if (!errorClass) {
+      continue;
+    }
+    const status = errorClass.status;
+    const type = errorClass.type;
+    const defaultMessage = errorClass.defaultMessage;
+    errorResponsesByStatus[status] ??= { status, errorSchemaVariants: [] };
+    const extraZod = z.object(errorClass.extraSchema).strict();
+    const [, extraSchema] = await converter(extraZod, {
+      ...baseSchemaConvertOptions,
+      strategy: "output"
+    });
+    if (!isObjectSchema(extraSchema)) {
+      throw new OpenAPIGeneratorError(
+        `Error response extra schema must be an object, but got: ${stringifyJSON(extraSchema)}`
+      );
+    }
+    errorResponsesByStatus[status].errorSchemaVariants.push({
+      type: "object",
+      properties: {
+        type: { const: type },
+        message: { type: "string", default: defaultMessage },
+        ...extraSchema.properties
+      },
+      required: ["type", "message", ...extraSchema.required ?? []]
+    });
+  }
+  ref.responses ??= {};
+  for (const statusString in errorResponsesByStatus) {
+    const errorResponse = errorResponsesByStatus[statusString];
+    if (statusString === "500") {
+      console.log(
+        errorResponse.errorSchemaVariants,
+        toOpenAPIContent({
+          oneOf: errorResponse.errorSchemaVariants
+        })
+      );
+    }
+    ref.responses[statusString] = {
+      description: statusString,
+      content: toOpenAPIContent(
+        errorResponse.errorSchemaVariants.length === 1 ? errorResponse.errorSchemaVariants[0] : {
+          oneOf: errorResponse.errorSchemaVariants
+        }
+      )
+    };
+  }
+}
 
 const oo = {
   spec: customOpenAPIOperation