@orpc/openapi 2.0.0-beta.3 → 2.0.0-beta.31

package/dist/plugins/index.d.mts

@@ -4,7 +4,7 @@ import { Value, Promisable } from '@orpc/shared';
 import { ApiReferenceConfiguration } from '@scalar/api-reference';
 import { StandardUrl } from '@standardserver/core';
 import { SwaggerUIOptions } from 'swagger-ui';
-import { a as OpenAPIDocument } from '../shared/openapi.CYgMBSUF.mjs';
+import { OpenAPIDocument } from '../index.mjs';
 import '@hey-api/spec-types';
 import '@orpc/client';
 
@@ -22,6 +22,13 @@ interface OpenAPIReferenceHandlerPluginOptions<T extends Context, TProvider exte
      * Receives routing interceptor options when provided as a function.
      */
     spec: Value<Promisable<OpenAPIDocument>, [StandardHandlerRoutingInterceptorOptions<T>]>;
+    /**
+     * Determines whether the docs UI and OpenAPI JSON are allowed to be served for a request.
+     * When it resolves to `false`, the request falls through as unmatched,
+     * as if the plugin were not installed. Useful for restricting access
+     * to authenticated users.
+     */
+    allow?: Value<Promisable<boolean>, [StandardHandlerRoutingInterceptorOptions<T>]>;
     /**
      * The URL path at which to serve the OpenAPI JSON.
      *
@@ -71,9 +78,19 @@ interface OpenAPIReferenceHandlerPluginOptions<T extends Context, TProvider exte
      */
     docsHead?: Value<Promisable<string>, [StandardHandlerRoutingInterceptorOptions<T>]>;
 }
+/**
+ * Serves API reference documentation powered by Scalar or Swagger UI,
+ * and exposes the OpenAPI specification as JSON.
+ *
+ * @remarks
+ * **Note**: By default, the API reference UI is served from `/` and the OpenAPI specification from `/spec.json`.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/openapi-reference | OpenAPI Reference Plugin (Swagger/Scalar)}
+ */
 declare class OpenAPIReferenceHandlerPlugin<T extends Context, TProvider extends OpenAPIReferenceHandlerPluginProvider> implements StandardHandlerPlugin<T> {
     name: string;
     private readonly spec;
+    private readonly allow;
     private readonly specPath;
     private readonly provider;
     private readonly providerConfig;

package/dist/plugins/index.d.ts

@@ -4,7 +4,7 @@ import { Value, Promisable } from '@orpc/shared';
 import { ApiReferenceConfiguration } from '@scalar/api-reference';
 import { StandardUrl } from '@standardserver/core';
 import { SwaggerUIOptions } from 'swagger-ui';
-import { a as OpenAPIDocument } from '../shared/openapi.CYgMBSUF.js';
+import { OpenAPIDocument } from '../index.js';
 import '@hey-api/spec-types';
 import '@orpc/client';
 
@@ -22,6 +22,13 @@ interface OpenAPIReferenceHandlerPluginOptions<T extends Context, TProvider exte
      * Receives routing interceptor options when provided as a function.
      */
     spec: Value<Promisable<OpenAPIDocument>, [StandardHandlerRoutingInterceptorOptions<T>]>;
+    /**
+     * Determines whether the docs UI and OpenAPI JSON are allowed to be served for a request.
+     * When it resolves to `false`, the request falls through as unmatched,
+     * as if the plugin were not installed. Useful for restricting access
+     * to authenticated users.
+     */
+    allow?: Value<Promisable<boolean>, [StandardHandlerRoutingInterceptorOptions<T>]>;
     /**
      * The URL path at which to serve the OpenAPI JSON.
      *
@@ -71,9 +78,19 @@ interface OpenAPIReferenceHandlerPluginOptions<T extends Context, TProvider exte
      */
     docsHead?: Value<Promisable<string>, [StandardHandlerRoutingInterceptorOptions<T>]>;
 }
+/**
+ * Serves API reference documentation powered by Scalar or Swagger UI,
+ * and exposes the OpenAPI specification as JSON.
+ *
+ * @remarks
+ * **Note**: By default, the API reference UI is served from `/` and the OpenAPI specification from `/spec.json`.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/openapi-reference | OpenAPI Reference Plugin (Swagger/Scalar)}
+ */
 declare class OpenAPIReferenceHandlerPlugin<T extends Context, TProvider extends OpenAPIReferenceHandlerPluginProvider> implements StandardHandlerPlugin<T> {
     name: string;
     private readonly spec;
+    private readonly allow;
     private readonly specPath;
     private readonly provider;
     private readonly providerConfig;

package/dist/plugins/index.mjs

@@ -1,8 +1,9 @@
-import { toArray, matchesHttpPath, mergeHttpPath, getOpenTelemetryConfig, value, stringifyJSON } from '@orpc/shared';
+import { toArray, matchesHttpPath, mergeHttpPath, value, getOpenTelemetryConfig, stringifyJSON } from '@orpc/shared';
 
 class OpenAPIReferenceHandlerPlugin {
   name = "~openapi-reference";
   spec;
+  allow;
   specPath;
   provider;
   providerConfig;
@@ -13,6 +14,7 @@ class OpenAPIReferenceHandlerPlugin {
   docsHead;
   constructor(options) {
     this.spec = options.spec;
+    this.allow = options.allow;
     this.specPath = options.specPath ?? "/spec.json";
     this.provider = options.provider ?? "scalar";
     this.providerConfig = options.providerConfig;
@@ -44,6 +46,9 @@ class OpenAPIReferenceHandlerPlugin {
           if (!isSpecPath && !isDocsPath) {
             return result;
           }
+          if (await value(this.allow, routingInterceptorOptions) === false) {
+            return result;
+          }
           const span = getOpenTelemetryConfig()?.trace.getActiveSpan();
           const spec = await value(this.spec, routingInterceptorOptions);
           if (isSpecPath) {

package/dist/shared/{openapi.DmAa7YPO.mjs → openapi.0yE-t1W-.mjs}

@@ -1,7 +1,7 @@
-import { wrapEventIteratorPreservingMeta, toORPCError, isORPCErrorJson, createORPCErrorFromJson } from '@orpc/client';
-import { isPlainObject, isAsyncIteratorObject } from '@orpc/shared';
+import { wrapAsyncIteratorPreservingEventMeta, toORPCError, isORPCErrorJson, createORPCErrorFromJson } from '@orpc/client';
+import { isPlainObject, NullProtoObj, isAsyncIteratorObject } from '@orpc/shared';
 import { ErrorEvent } from '@standardserver/core';
-import { B as BracketNotationSerializer } from './openapi.Bt87OzTt.mjs';
+import { B as BracketNotationSerializer } from './openapi.s_p5sN-P.mjs';
 
 const DEFAULT_OPENAPI_METHOD = "POST";
 const DEFAULT_OPENAPI_SUCCESS_DESCRIPTION = "OK";
@@ -84,44 +84,116 @@ const DEFAULT_OPEN_API_JSON_SERIALIZER_HANDLERS = {
   }
 };
 class OpenAPIJsonSerializer {
-  handlers;
+  inlineBuiltInHandlers;
+  handlerEntries;
   omitUndefinedProperties;
   constructor(options = {}) {
-    this.handlers = {
-      ...DEFAULT_OPEN_API_JSON_SERIALIZER_HANDLERS,
-      ...options.handlers
-    };
     this.omitUndefinedProperties = options.omitUndefinedProperties !== false;
+    const customHandlers = options.handlers;
+    if (customHandlers === void 0) {
+      this.inlineBuiltInHandlers = true;
+      return;
+    }
+    let inlineBuiltInHandlers = true;
+    let handlerEntries = [];
+    for (const key in customHandlers) {
+      const handler = customHandlers[key];
+      if (inlineBuiltInHandlers && key in DEFAULT_OPEN_API_JSON_SERIALIZER_HANDLERS) {
+        inlineBuiltInHandlers = false;
+        break;
+      }
+      if (handler !== void 0) {
+        handlerEntries.push(handler);
+      }
+    }
+    if (!inlineBuiltInHandlers) {
+      handlerEntries = [];
+      for (const handler of Object.values({ ...DEFAULT_OPEN_API_JSON_SERIALIZER_HANDLERS, ...customHandlers })) {
+        if (handler !== void 0) {
+          handlerEntries.push(handler);
+        }
+      }
+    }
+    this.inlineBuiltInHandlers = inlineBuiltInHandlers;
+    this.handlerEntries = handlerEntries;
   }
   serialize(data) {
-    const [json, maps, blobs] = this.serializeValue(data, [], [], []);
+    const maps = [];
+    const blobs = [];
+    const json = this.serializeValue(data, [], maps, blobs);
     return { json, maps, blobs };
   }
+  /**
+   * `segments` is a shared mutable stack (push/pop while walking),
+   * so it must be copied before being stored in `maps`.
+   */
   serializeValue(data, segments, maps, blobs) {
-    for (const key in this.handlers) {
-      const handler = this.handlers[key];
-      if (handler && handler.condition(data)) {
-        const serialized = handler.serialize(data);
-        if (handler.isTerminal) {
-          return [serialized, maps, blobs];
+    if (this.inlineBuiltInHandlers) {
+      switch (typeof data) {
+        case "string":
+        case "boolean":
+          return data;
+        case "number":
+          return Number.isNaN(data) ? null : data;
+        case "undefined":
+          return null;
+        case "bigint":
+          return data.toString();
+        case "object": {
+          if (data === null) {
+            return data;
+          }
+          if (data instanceof Date) {
+            return Number.isNaN(data.getTime()) ? null : data.toISOString();
+          }
+          if (data instanceof URL) {
+            return data.toString();
+          }
+          if (data instanceof RegExp) {
+            return data.toString();
+          }
+          if (data instanceof Set) {
+            return this.serializeValue(Array.from(data), segments, maps, blobs);
+          }
+          if (data instanceof Map) {
+            return this.serializeValue(Array.from(data.entries()), segments, maps, blobs);
+          }
+        }
+      }
+    }
+    const handlerEntries = this.handlerEntries;
+    if (handlerEntries) {
+      for (let i = 0; i < handlerEntries.length; i++) {
+        const handler = handlerEntries[i];
+        if (handler.condition(data)) {
+          const serialized = handler.serialize(data);
+          if (handler.isTerminal) {
+            if (serialized instanceof Blob) {
+              maps.push(segments.slice());
+              blobs.push(serialized);
+            }
+            return serialized;
+          }
+          return this.serializeValue(serialized, segments, maps, blobs);
         }
-        const result = this.serializeValue(serialized, segments, maps, blobs);
-        return result;
       }
     }
     if (data instanceof Blob) {
-      maps.push(segments);
+      maps.push(segments.slice());
       blobs.push(data);
-      return [data, maps, blobs];
+      return data;
     }
     if (Array.isArray(data)) {
-      const json = data.map((v, i) => {
-        return this.serializeValue(v, [...segments, i], maps, blobs)[0];
-      });
-      return [json, maps, blobs];
+      const json = [];
+      for (let i = 0; i < data.length; i++) {
+        segments.push(i);
+        json.push(this.serializeValue(data[i], segments, maps, blobs));
+        segments.pop();
+      }
+      return json;
     }
     if (isPlainObject(data)) {
-      const json = {};
+      const json = new NullProtoObj();
       for (const k in data) {
         const v = data[k];
         if (k === "toJSON" && typeof v === "function") {
@@ -130,27 +202,30 @@ class OpenAPIJsonSerializer {
         if (v === void 0 && this.omitUndefinedProperties) {
           continue;
         }
-        json[k] = this.serializeValue(v, [...segments, k], maps, blobs)[0];
+        segments.push(k);
+        json[k] = this.serializeValue(v, segments, maps, blobs);
+        segments.pop();
       }
-      return [json, maps, blobs];
+      return json;
     }
-    return [data, maps, blobs];
+    return data;
   }
   deserialize(serialized) {
     const ref = { data: serialized.json };
     if (serialized.blobs?.length) {
-      serialized.maps.forEach((segments, i) => {
+      for (let i = 0; i < serialized.maps.length; i++) {
+        const segments = serialized.maps[i];
         let currentRef = ref;
         let preSegment = "data";
-        segments.forEach((segment) => {
+        for (let j = 0; j < segments.length; j++) {
           currentRef = currentRef[preSegment];
-          preSegment = segment;
+          preSegment = segments[j];
           if (!Object.hasOwn(currentRef, preSegment)) {
             throw new Error(`Security error: Invalid serialized data. Segment "${preSegment}" does not exist.`);
           }
-        });
+        }
         currentRef[preSegment] = serialized.blobs[i];
-      });
+      }
     }
     return ref.data;
   }
@@ -166,34 +241,34 @@ class OpenAPISerializer {
     this.defaultSerializeOptions = serialize;
   }
   serialize(data, options = {}) {
-    const useFormDataForBlobFields = options.useFormDataForBlobFields ?? this.defaultSerializeOptions?.useFormDataForBlobFields ?? true;
-    const asFormData = options.asFormData ?? this.defaultSerializeOptions?.asFormData ?? false;
     if (!options.asFormData) {
       if (data === void 0 || data instanceof ReadableStream || data instanceof Blob) {
         return data;
       }
       if (isAsyncIteratorObject(data)) {
-        return wrapEventIteratorPreservingMeta(data, {
+        return wrapAsyncIteratorPreservingEventMeta(data, {
           mapResult: (result) => {
             if (result.value === void 0) {
               return result;
             }
-            return { done: result.done, value: this.serializeValue(result.value, { asFormData: false, useFormDataForBlobFields: false }) };
+            return { done: result.done, value: this.serializeValue(result.value, false, false) };
           },
           mapError: (e) => {
             return new ErrorEvent({
-              data: this.serializeValue(toORPCError(e).toJSON(), { asFormData: false, useFormDataForBlobFields: false }),
+              data: this.serializeValue(toORPCError(e).toJSON(), false, false),
               cause: e
             });
           }
         });
       }
     }
-    return this.serializeValue(data, { useFormDataForBlobFields, asFormData });
+    const useFormDataForBlobFields = options.useFormDataForBlobFields ?? this.defaultSerializeOptions?.useFormDataForBlobFields ?? true;
+    const asFormData = options.asFormData ?? this.defaultSerializeOptions?.asFormData ?? false;
+    return this.serializeValue(data, useFormDataForBlobFields, asFormData);
   }
-  serializeValue(value, options) {
+  serializeValue(value, useFormDataForBlobFields, asFormData) {
     const { json, blobs } = this.jsonSerializer.serialize(value);
-    if (!options.asFormData && (json instanceof Blob || json === void 0 || !blobs?.length || !options.useFormDataForBlobFields)) {
+    if (!asFormData && (json instanceof Blob || json === void 0 || !blobs?.length || !useFormDataForBlobFields)) {
       return json;
     }
     const form = new FormData();
@@ -211,7 +286,7 @@ class OpenAPISerializer {
       return data;
     }
     if (isAsyncIteratorObject(data)) {
-      return wrapEventIteratorPreservingMeta(data, {
+      return wrapAsyncIteratorPreservingEventMeta(data, {
         mapResult: (result) => {
           if (result.value === void 0) {
             return result;
@@ -236,6 +311,9 @@ class OpenAPISerializer {
   }
 }
 
+function isBodylessMethod(method) {
+  return method === "GET" || method === "HEAD";
+}
 const PARAMETER_NAME_REGEX = /^[\w-]+$/;
 function getDynamicPathParams(path) {
   if (!path.includes("{")) {
@@ -272,4 +350,4 @@ function getDynamicPathParams(path) {
   return params;
 }
 
-export { DEFAULT_OPENAPI_METHOD as D, OpenAPISerializer as O, DEFAULT_OPENAPI_INPUT_STRUCTURE as a, DEFAULT_OPENAPI_OUTPUT_STRUCTURE as b, DEFAULT_OPENAPI_SUCCESS_DESCRIPTION as c, OpenAPIJsonSerializer as d, getDynamicPathParams as g };
+export { DEFAULT_OPENAPI_METHOD as D, OpenAPISerializer as O, DEFAULT_OPENAPI_INPUT_STRUCTURE as a, DEFAULT_OPENAPI_OUTPUT_STRUCTURE as b, DEFAULT_OPENAPI_SUCCESS_DESCRIPTION as c, OpenAPIJsonSerializer as d, getDynamicPathParams as g, isBodylessMethod as i };

package/dist/shared/{openapi.DuDd2iQz.d.mts → openapi.9smDzQwj.d.mts}

@@ -1,10 +1,10 @@
 import { AnyORPCError } from '@orpc/client';
 import { AnyProcedure, AnyRouter, Context } from '@orpc/server';
-import { StandardHandlerHandleOptions, StandardHandlerCodec, StandardHandlerCodecResolvedProcedure } from '@orpc/server/standard';
+import { StandardHandlerCodec, StandardHandlerHandleOptions, StandardHandlerCodecResolvedProcedure } from '@orpc/server/standard';
 import { Value, Promisable } from '@orpc/shared';
 import { StandardLazyRequest, StandardResponse } from '@standardserver/core';
 import { AnyProcedureContract } from '@orpc/contract';
-import { O as OpenAPISerializer } from './openapi.C7m7NAmH.mjs';
+import { O as OpenAPISerializer } from './openapi.Dz-JaXHo.mjs';
 
 interface OpenAPIMatcherOptions {
     /**
@@ -18,7 +18,7 @@ declare class OpenAPIMatcher {
     private readonly filter;
     private readonly rootRouter;
     private readonly tree;
-    private pendingLazyRouters;
+    private readonly pendingLazyRouters;
     constructor(router: AnyRouter, options?: OpenAPIMatcherOptions);
     private index;
     match(method: string, pathname: `/${string}`, prefix: `/${string}` | undefined): Promise<{
@@ -26,8 +26,10 @@ declare class OpenAPIMatcher {
         procedure: AnyProcedure;
         params?: Record<string, string> | undefined;
     } | undefined>;
-    private matchPathname;
     private resolvePendingLazyRouters;
+    private loadPendingLazyRouters;
+    private loadPendingLazyRouter;
+    private indexPendingLazyRouter;
     private resolveProcedure;
 }
 
@@ -38,8 +40,9 @@ interface OpenAPIHandlerCodecCoreOptions<_T extends Context> {
     serializer?: Pick<OpenAPISerializer, keyof OpenAPISerializer>;
     /**
      * Mapping ORPCError Code -> HTTP Status Code
+     * The status code should be in the `4xx` or `5xx` range (must be greater than or equal to `400`).
      *
-     * @default COMMON_ERROR_STATUS_MAP, DEFAULT_ERROR_STATUS
+     * @default COMMON_ERROR_STATUS_MAP
      */
     errorStatusMap?: Record<string, number> | undefined;
     /**
@@ -65,8 +68,8 @@ declare class OpenAPIHandlerCodecCore<T extends Context> {
     /**
      * @throws {TypeError} If `outputStructure` is "detailed" and the output doesn't match the expected structure.
      */
-    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], _options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-    encodeError(error: AnyORPCError, _procedure: AnyProcedure, _path: string[], _options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[]): Promisable<StandardResponse>;
+    encodeError(error: AnyORPCError): Promisable<StandardResponse>;
     private deserializeQuery;
     private deserializeParams;
 }

package/dist/shared/{openapi.B2SK0ZAr.mjs → openapi.B6jrmH-p.mjs}

@@ -1,14 +1,13 @@
-import { isORPCErrorJson, createORPCErrorFromJson, ORPCError } from '@orpc/client';
+import { createORPCErrorFromMalformedResponse, isORPCErrorJson, createORPCErrorFromJson } from '@orpc/client';
 import { getRouterContract, ProcedureContract } from '@orpc/contract';
 import { unlazy } from '@orpc/server';
 import { value, pathToHttpPath, mergeHttpPath, isTypescriptObject, stringifyJSON } from '@orpc/shared';
-import { mergeStandardHeaders, parseStandardUrl, isStandardHeaders } from '@standardserver/core';
+import { mergeStandardHeaders, parseStandardUrl } from '@standardserver/core';
 import { toStandardHeaders } from '@standardserver/fetch';
-import { O as OpenAPISerializer, D as DEFAULT_OPENAPI_METHOD, a as DEFAULT_OPENAPI_INPUT_STRUCTURE, g as getDynamicPathParams, b as DEFAULT_OPENAPI_OUTPUT_STRUCTURE } from './openapi.DmAa7YPO.mjs';
+import { O as OpenAPISerializer, D as DEFAULT_OPENAPI_METHOD, a as DEFAULT_OPENAPI_INPUT_STRUCTURE, g as getDynamicPathParams, i as isBodylessMethod, b as DEFAULT_OPENAPI_OUTPUT_STRUCTURE } from './openapi.0yE-t1W-.mjs';
 import { g as getOpenAPIMeta } from './openapi.B9PQzqBn.mjs';
+import { s as serializeHeaders } from './openapi.iEFYDEKB.mjs';
 
-class OpenAPILinkCodecError extends TypeError {
-}
 const END_SLASH_REGEX = /\/$/;
 class OpenAPILinkCodec {
   constructor(router, options = {}) {
@@ -42,7 +41,7 @@ class OpenAPILinkCodec {
       let data = input;
       if (dynamicParams?.length) {
         if (!isTypescriptObject(input)) {
-          throw new OpenAPILinkCodecError(
+          throw new TypeError(
             `Input must be an object with "compact" input structure when the path has dynamic params (${dynamicParams.map((p) => p.parameterName).join(", ")}) in call to procedure (${path.join(".")}).`
           );
         }
@@ -56,7 +55,7 @@ class OpenAPILinkCodec {
         data = Object.keys(remaining).length > 0 ? remaining : void 0;
       }
       pathname = `${basePathname.replace(END_SLASH_REGEX, "")}${pathname}`;
-      if (method === "GET") {
+      if (isBodylessMethod(method)) {
         const queryString2 = this.serializeQueryString(data, meta?.queryStyles);
         const search2 = combineSearch(baseSearch, queryString2);
         const url3 = `${pathname}${search2 ?? ""}${baseHash ?? ""}`;
@@ -78,12 +77,12 @@ class OpenAPILinkCodec {
       };
     }
     if (!isValidDetailedInput(input)) {
-      throw new OpenAPILinkCodecError(`
+      throw new TypeError(`
         Invalid "detailed" input structure in call to procedure (${path.join(".")}):
         \u2022 Expected an object or undefined with optional properties:
           - params (object, required when the path has dynamic params)
           - query (object)
-          - headers (Record<string, string | string[] | undefined>)
+          - headers (object)
           - body (any)
 
         Actual value:
@@ -92,7 +91,7 @@ class OpenAPILinkCodec {
     }
     if (dynamicParams?.length) {
       if (!input?.params) {
-        throw new OpenAPILinkCodecError(
+        throw new TypeError(
           `The "params" property is required for "detailed" input when the path has dynamic params (${dynamicParams.map((p) => p.parameterName).join(", ")}) in call to procedure (${path.join(".")}).`
         );
       }
@@ -104,13 +103,13 @@ class OpenAPILinkCodec {
       }
     }
     if (input?.headers) {
-      headers = mergeStandardHeaders(headers, input.headers);
+      headers = mergeStandardHeaders(headers, serializeHeaders(input.headers, this.serializer));
     }
     pathname = `${basePathname.replace(END_SLASH_REGEX, "")}${pathname}`;
     const queryString = this.serializeQueryString(input?.query, meta?.queryStyles);
     const search = combineSearch(baseSearch, queryString);
     const url = `${pathname}${search ?? ""}${baseHash ?? ""}`;
-    if (method === "GET") {
+    if (isBodylessMethod(method)) {
       return {
         body: void 0,
         method,
@@ -144,7 +143,7 @@ class OpenAPILinkCodec {
       }
     }
     if (!encoded) {
-      throw new OpenAPILinkCodecError(`Path param "${param.parameterName}" cannot be empty in call to procedure (${path.join(".")}).`);
+      throw new TypeError(`Path param "${param.parameterName}" cannot be empty in call to procedure (${path.join(".")}).`);
     }
     return encoded;
   }
@@ -243,22 +242,17 @@ class OpenAPILinkCodec {
     return query || void 0;
   }
   async decodeResponse(response, path, _options) {
-    const isOk = response.status >= 200 && response.status < 400;
+    const isOk = response.status < 400;
     const procedure = await this.resolveProcedure(path);
     const meta = getOpenAPIMeta(procedure);
+    const body = await response.resolveBody(meta?.responseBodyHint);
     const deserialized = await (async () => {
-      let isBodyOk = false;
       try {
-        const body = await response.resolveBody(meta?.responseBodyHint);
-        isBodyOk = true;
         return this.serializer.deserialize(body);
       } catch (error) {
-        if (!isBodyOk) {
-          throw new Error("Cannot parse response body, please check the response body and content-type.", {
-            cause: error
-          });
-        }
-        throw new Error("Invalid OpenAPI response format.", {
+        throw createORPCErrorFromMalformedResponse({
+          message: "Invalid OpenAPI response format.",
+          response: { status: response.status, headers: response.headers, body },
           cause: error
         });
       }
@@ -273,9 +267,7 @@ class OpenAPILinkCodec {
       }
       return {
         kind: "error",
-        error: new ORPCError("MALFORMED_ORPC_ERROR_RESPONSE", {
-          data: { headers: response.headers, status: response.status, body: deserialized }
-        })
+        error: createORPCErrorFromMalformedResponse({ response: { headers: response.headers, status: response.status, body } })
       };
     }
     const outputStructure = meta?.outputStructure ?? DEFAULT_OPENAPI_OUTPUT_STRUCTURE;
@@ -291,7 +283,7 @@ class OpenAPILinkCodec {
   async resolveProcedure(path) {
     const { default: maybeProcedure } = await unlazy(getRouterContract(this.router, path));
     if (!(maybeProcedure instanceof ProcedureContract)) {
-      throw new OpenAPILinkCodecError(`Expected a procedure or contract at path (${path.join(".")})`);
+      throw new TypeError(`Expected a procedure or contract at path (${path.join(".")})`);
     }
     return maybeProcedure;
   }
@@ -324,7 +316,7 @@ function isValidDetailedInput(input) {
   if (input.query !== void 0 && !isTypescriptObject(input.query)) {
     return false;
   }
-  if (input.headers !== void 0 && !isStandardHeaders(input.headers)) {
+  if (input.headers !== void 0 && !isTypescriptObject(input.headers)) {
     return false;
   }
   return true;
@@ -356,4 +348,4 @@ function encodeDelimitedObject(entries, encodedDelimiter) {
   ).join(encodedDelimiter);
 }
 
-export { OpenAPILinkCodec as O, OpenAPILinkCodecError as a };
+export { OpenAPILinkCodec as O };

package/dist/shared/openapi.Bd9icEUa.d.mts

@@ -0,0 +1,45 @@
+import { ClientContext, ClientOptions, AnyORPCError } from '@orpc/client';
+import { StandardLinkCodec, StandardLinkCodecDecodedResponse } from '@orpc/client/standard';
+import { RouterContract } from '@orpc/contract';
+import { Value, Promisable } from '@orpc/shared';
+import { StandardUrl, StandardHeaders, StandardLazyResponse, StandardRequest } from '@standardserver/core';
+import { O as OpenAPISerializer } from './openapi.Dz-JaXHo.mjs';
+
+interface OpenAPILinkCodecOptions<T extends ClientContext> {
+    /**
+     * Base URL for all requests, without origin. Should match the OpenAPI handler mount path.
+     *
+     * @example '/api'
+     * @default '/'
+     */
+    url?: Value<Promisable<StandardUrl>, [options: ClientOptions<T>, path: string[], input: unknown]>;
+    /**
+     * Inject headers into the request.
+     */
+    headers?: Value<Promisable<StandardHeaders | Headers>, [options: ClientOptions<T>, path: string[], input: unknown]>;
+    /**
+     * Override the default OpenAPI serializer.
+     */
+    serializer?: Pick<OpenAPISerializer, keyof OpenAPISerializer>;
+    /**
+     * Customize how an error response body is converted into an ORPC error.
+     * Return `null` or `undefined` to fall back to the default decoding behavior.
+     */
+    customErrorResponseBodyDecoder?: (deserializedBody: unknown, response: StandardLazyResponse) => AnyORPCError | null | undefined;
+}
+declare class OpenAPILinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
+    private readonly router;
+    private readonly baseUrl;
+    private readonly headers;
+    private readonly serializer;
+    private readonly customErrorResponseBodyDecoder;
+    constructor(router: RouterContract, options?: OpenAPILinkCodecOptions<T>);
+    encodeInput(input: unknown, path: string[], options: ClientOptions<T>): Promise<StandardRequest>;
+    private encodePathParam;
+    private serializeQueryString;
+    decodeResponse(response: StandardLazyResponse, path: string[], _options: ClientOptions<T>): Promise<StandardLinkCodecDecodedResponse>;
+    private resolveProcedure;
+}
+
+export { OpenAPILinkCodec as a };
+export type { OpenAPILinkCodecOptions as O };

package/dist/shared/openapi.D1CqEIRy.d.ts

@@ -0,0 +1,45 @@
+import { ClientContext, ClientOptions, AnyORPCError } from '@orpc/client';
+import { StandardLinkCodec, StandardLinkCodecDecodedResponse } from '@orpc/client/standard';
+import { RouterContract } from '@orpc/contract';
+import { Value, Promisable } from '@orpc/shared';
+import { StandardUrl, StandardHeaders, StandardLazyResponse, StandardRequest } from '@standardserver/core';
+import { O as OpenAPISerializer } from './openapi.Dz-JaXHo.js';
+
+interface OpenAPILinkCodecOptions<T extends ClientContext> {
+    /**
+     * Base URL for all requests, without origin. Should match the OpenAPI handler mount path.
+     *
+     * @example '/api'
+     * @default '/'
+     */
+    url?: Value<Promisable<StandardUrl>, [options: ClientOptions<T>, path: string[], input: unknown]>;
+    /**
+     * Inject headers into the request.
+     */
+    headers?: Value<Promisable<StandardHeaders | Headers>, [options: ClientOptions<T>, path: string[], input: unknown]>;
+    /**
+     * Override the default OpenAPI serializer.
+     */
+    serializer?: Pick<OpenAPISerializer, keyof OpenAPISerializer>;
+    /**
+     * Customize how an error response body is converted into an ORPC error.
+     * Return `null` or `undefined` to fall back to the default decoding behavior.
+     */
+    customErrorResponseBodyDecoder?: (deserializedBody: unknown, response: StandardLazyResponse) => AnyORPCError | null | undefined;
+}
+declare class OpenAPILinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
+    private readonly router;
+    private readonly baseUrl;
+    private readonly headers;
+    private readonly serializer;
+    private readonly customErrorResponseBodyDecoder;
+    constructor(router: RouterContract, options?: OpenAPILinkCodecOptions<T>);
+    encodeInput(input: unknown, path: string[], options: ClientOptions<T>): Promise<StandardRequest>;
+    private encodePathParam;
+    private serializeQueryString;
+    decodeResponse(response: StandardLazyResponse, path: string[], _options: ClientOptions<T>): Promise<StandardLinkCodecDecodedResponse>;
+    private resolveProcedure;
+}
+
+export { OpenAPILinkCodec as a };
+export type { OpenAPILinkCodecOptions as O };