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

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';
 
@@ -71,6 +71,15 @@ 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;

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';
 
@@ -71,6 +71,15 @@ 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;

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.B3H7yHQa.mjs → openapi.BaqI61Xi.mjs}

@@ -1,8 +1,8 @@
 import { COMMON_ERROR_STATUS_MAP } from '@orpc/client';
 import { walkProcedureContractsSync, Procedure, unlazy, getRouter, createContractProcedure, DEFAULT_SUCCESS_STATUS, DEFAULT_ERROR_STATUS } from '@orpc/server';
-import { value, pathToHttpPath, mergeHttpPath, normalizeHttpPath, tryDecodeURIComponent, isPlainObject, stringifyJSON, parseEmptyableJSON, isTypescriptObject, NullProtoObj } from '@orpc/shared';
-import { parseStandardUrl, isStandardHeaders } from '@standardserver/core';
-import { D as DEFAULT_OPENAPI_METHOD, g as getDynamicPathParams, O as OpenAPISerializer, a as DEFAULT_OPENAPI_INPUT_STRUCTURE, b as DEFAULT_OPENAPI_OUTPUT_STRUCTURE } from './openapi.DmAa7YPO.mjs';
+import { value, pathToHttpPath, mergeHttpPath, normalizeHttpPath, tryDecodeURIComponent, NullProtoObj, isTypescriptObject, isPlainObject, stringifyJSON, parseEmptyableJSON } from '@orpc/shared';
+import { parseStandardUrl } from '@standardserver/core';
+import { D as DEFAULT_OPENAPI_METHOD, g as getDynamicPathParams, O as OpenAPISerializer, a as DEFAULT_OPENAPI_INPUT_STRUCTURE, i as isBodylessMethod, b as DEFAULT_OPENAPI_OUTPUT_STRUCTURE } from './openapi.0yE-t1W-.mjs';
 import { g as getOpenAPIMeta } from './openapi.B9PQzqBn.mjs';
 import { createRouter, addRoute, findRoute, routeToRegExp } from 'rou3';
 
@@ -10,7 +10,7 @@ class OpenAPIMatcher {
   filter;
   rootRouter;
   tree = createRouter();
-  pendingLazyRouters = [];
+  pendingLazyRouters = /* @__PURE__ */ new Set();
   constructor(router, options = {}) {
     this.filter = options.filter ?? true;
     this.rootRouter = router;
@@ -32,13 +32,13 @@ class OpenAPIMatcher {
         procedure: contract instanceof Procedure ? contract : void 0
       });
     }, path);
-    this.pendingLazyRouters.push(...lazyResults.map((result) => {
+    for (const result of lazyResults) {
       const prefix = getOpenAPIMeta(result.router)?.prefix;
-      return {
+      this.pendingLazyRouters.add({
         ...result,
         matcher: prefix ? toRou3PrefixMatcher(prefix) : void 0
-      };
-    }));
+      });
+    }
   }
   async match(method, pathname, prefix) {
     if (prefix) {
@@ -56,44 +56,58 @@ class OpenAPIMatcher {
         return void 0;
       }
     }
-    const result = await this.matchPathname(method, pathname);
-    if (!result && pathname.includes("%")) {
-      return this.matchPathname(method, normalizeHttpPath(pathname));
+    const loading = this.resolvePendingLazyRouters(pathname);
+    if (loading !== void 0) {
+      await loading;
     }
-    return result;
-  }
-  async matchPathname(method, pathname) {
-    await this.resolvePendingLazyRouters(pathname);
-    const match = findRoute(this.tree, method, pathname);
-    if (!match) {
+    let match = findRoute(this.tree, method, pathname);
+    if (match === void 0 && pathname.includes("%")) {
+      const normalizedPathname = normalizeHttpPath(pathname);
+      const normalizedLoading = this.resolvePendingLazyRouters(normalizedPathname);
+      if (normalizedLoading !== void 0) {
+        await normalizedLoading;
+      }
+      match = findRoute(this.tree, method, normalizedPathname);
+    }
+    if (match === void 0) {
       return void 0;
     }
-    const procedure = await this.resolveProcedure(match.data);
+    const entry = match.data;
     return {
-      path: match.data.path,
-      procedure,
+      path: entry.path,
+      procedure: entry.procedure ?? await this.resolveProcedure(entry),
       params: match.params ? decodeParams(match.params) : void 0
     };
   }
-  async resolvePendingLazyRouters(pathname) {
-    if (!this.pendingLazyRouters.length) {
-      return;
+  resolvePendingLazyRouters(pathname) {
+    for (const pending of this.pendingLazyRouters) {
+      if (pending.matcher === void 0 || pending.matcher.test(pathname)) {
+        return this.loadPendingLazyRouters(pathname);
+      }
     }
-    const stillPending = [];
+  }
+  async loadPendingLazyRouters(pathname) {
     for (const pending of this.pendingLazyRouters) {
-      if (!pending.matcher || pending.matcher.test(pathname)) {
-        const { default: router } = await unlazy(pending.router);
-        this.index(router, pending.path);
-      } else {
-        stillPending.push(pending);
+      if (pending.matcher === void 0 || pending.matcher.test(pathname)) {
+        await this.loadPendingLazyRouter(pending);
       }
     }
-    this.pendingLazyRouters = stillPending;
   }
-  async resolveProcedure(entry) {
-    if (entry.procedure) {
-      return entry.procedure;
+  loadPendingLazyRouter(pending) {
+    if (pending.loading === void 0) {
+      pending.loading = this.indexPendingLazyRouter(pending).catch((error) => {
+        pending.loading = void 0;
+        throw error;
+      });
     }
+    return pending.loading;
+  }
+  async indexPendingLazyRouter(pending) {
+    const { default: router } = await unlazy(pending.router);
+    this.index(router, pending.path);
+    this.pendingLazyRouters.delete(pending);
+  }
+  async resolveProcedure(entry) {
     const { default: maybeProcedure } = await unlazy(getRouter(this.rootRouter, entry.path));
     if (!(maybeProcedure instanceof Procedure)) {
       throw new TypeError(
@@ -124,6 +138,41 @@ function decodeParams(params) {
   return Object.fromEntries(Object.entries(params).map(([key, val]) => [key, tryDecodeURIComponent(val)]));
 }
 
+function serializeHeaders(headers, serializer) {
+  const result = new NullProtoObj();
+  for (const [key, value] of Object.entries(headers)) {
+    if (Array.isArray(value)) {
+      const lines = [];
+      for (const item of value) {
+        const line2 = serializeHeaderValue(item, serializer);
+        if (line2 !== void 0) {
+          lines.push(line2);
+        }
+      }
+      result[key] = lines;
+      continue;
+    }
+    const line = serializeHeaderValue(value, serializer);
+    if (line !== void 0) {
+      result[key] = line;
+    }
+  }
+  return result;
+}
+function serializeHeaderValue(value, serializer) {
+  const serialized = serializer.serialize(value);
+  if (Array.isArray(serialized)) {
+    return serialized.filter((item) => item !== void 0 && item !== null).map(String).join(",");
+  }
+  if (isTypescriptObject(serialized)) {
+    return Object.entries(serialized).filter(([, val]) => val !== void 0 && val !== null).map(([key, val]) => `${String(key)},${String(val)}`).join(",");
+  }
+  if (serialized !== void 0 && serialized !== null) {
+    return String(serialized);
+  }
+  return void 0;
+}
+
 class OpenAPIHandlerCodecCore {
   serializer;
   errorStatusMap;
@@ -140,7 +189,7 @@ class OpenAPIHandlerCodecCore {
     const params = this.deserializeParams(matched.params, meta?.paramsStyles);
     const query = this.deserializeQuery(search, meta?.queryStyles);
     if (inputStructure === "compact") {
-      const data = request.method === "GET" ? query : this.serializer.deserialize(await request.resolveBody(meta?.requestBodyHint));
+      const data = isBodylessMethod(request.method) ? query : this.serializer.deserialize(await request.resolveBody(meta?.requestBodyHint));
       if (data === void 0) {
         return params;
       }
@@ -165,7 +214,7 @@ class OpenAPIHandlerCodecCore {
   /**
    * @throws {TypeError} If `outputStructure` is "detailed" and the output doesn't match the expected structure.
    */
-  encodeOutput(output, procedure, path, _options) {
+  encodeOutput(output, procedure, path) {
     const meta = getOpenAPIMeta(procedure);
     const successStatus = meta?.successStatus ?? DEFAULT_SUCCESS_STATUS;
     const outputStructure = meta?.outputStructure ?? DEFAULT_OPENAPI_OUTPUT_STRUCTURE;
@@ -180,8 +229,8 @@ class OpenAPIHandlerCodecCore {
       throw new TypeError(`
         Invalid "detailed" output structure returned by procedure (${path.join(".")}):
         \u2022 Expected an object with optional properties:
-          - status (number 200-399)
-          - headers (Record<string, string | string[] | undefined>)
+          - status (number <400)
+          - headers (object)
           - body (any)
         \u2022 No extra keys allowed.
 
@@ -191,11 +240,11 @@ class OpenAPIHandlerCodecCore {
     }
     return {
       status: output.status ?? successStatus,
-      headers: output.headers ?? {},
+      headers: output.headers !== void 0 ? serializeHeaders(output.headers, this.serializer) : {},
       body: this.serializer.serialize(output.body)
     };
   }
-  encodeError(error, _procedure, _path, _options) {
+  encodeError(error) {
     const status = this.errorStatusMap[error.code] ?? DEFAULT_ERROR_STATUS;
     return {
       status,
@@ -288,10 +337,10 @@ function isValidDetailedOutput(output) {
   if (Object.keys(output).some((key) => key !== "status" && key !== "headers" && key !== "body")) {
     return false;
   }
-  if (output.status !== void 0 && (typeof output.status !== "number" || !Number.isInteger(output.status) || output.status < 200 || output.status > 399)) {
+  if (output.status !== void 0 && (typeof output.status !== "number" || !Number.isInteger(output.status) || output.status > 399)) {
     return false;
   }
-  if (output.headers !== void 0 && !isStandardHeaders(output.headers)) {
+  if (output.headers !== void 0 && !isTypescriptObject(output.headers)) {
     return false;
   }
   return true;
@@ -315,4 +364,4 @@ function decodeDelimitedObject(value, delimiter) {
   return obj;
 }
 
-export { OpenAPIHandlerCodec as O, OpenAPIHandlerCodecCore as a, OpenAPIMatcher as b };
+export { OpenAPIHandlerCodec as O, OpenAPIHandlerCodecCore as a, OpenAPIMatcher as b, serializeHeaders as s };

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 };