@orpc/openapi 2.0.0-beta.20 → 2.0.0-beta.22

package/dist/index.mjs

@@ -1,13 +1,13 @@
-export { B as BracketNotationSerializer } from './shared/openapi.Bt87OzTt.mjs';
+export { B as BracketNotationSerializer } from './shared/openapi.s_p5sN-P.mjs';
 import { createContractClientFactory, getAsyncIteratorObjectSchemaDetails, ProcedureContract, resolveMetaPlugins } from '@orpc/contract';
-import { D as DEFAULT_OPENAPI_METHOD, a as DEFAULT_OPENAPI_INPUT_STRUCTURE, c as DEFAULT_OPENAPI_SUCCESS_DESCRIPTION, b as DEFAULT_OPENAPI_OUTPUT_STRUCTURE, i as isBodylessMethod, O as OpenAPISerializer, g as getDynamicPathParams } from './shared/openapi.zZH_UksW.mjs';
-export { d as OpenAPIJsonSerializer } from './shared/openapi.zZH_UksW.mjs';
+import { D as DEFAULT_OPENAPI_METHOD, a as DEFAULT_OPENAPI_INPUT_STRUCTURE, c as DEFAULT_OPENAPI_SUCCESS_DESCRIPTION, b as DEFAULT_OPENAPI_OUTPUT_STRUCTURE, i as isBodylessMethod, O as OpenAPISerializer, g as getDynamicPathParams } from './shared/openapi.0yE-t1W-.mjs';
+export { d as OpenAPIJsonSerializer } from './shared/openapi.0yE-t1W-.mjs';
 import { g as getOpenAPIMeta, o as openapi } from './shared/openapi.B9PQzqBn.mjs';
 import { COMMON_ERROR_STATUS_MAP } from '@orpc/client';
 export { COMMON_ERROR_STATUS_MAP } from '@orpc/client';
-import { encodeJsonPointerSegment, ensureJsonSchemaObject, mapJsonSchemaRefs, visitJsonSchemaRefs, decodeJsonPointerSegment, isUnconstrainedSchema, combineJsonSchemasWithComposition, extractJsonObjectSchemaEntries, combineJsonObjectSchemaEntries, flattenJsonUnionSchema, isJsonPrimitiveSchema, matchArrayableJsonSchema, isJsonFileSchema, DelegatingJsonSchemaConverter, StandardJsonSchemaConverter } from '@orpc/json-schema';
+import { encodeJsonPointerSegment, ensureJsonSchemaObject, mapJsonSchemaRefs, decodeJsonPointerSegment, isUnconstrainedSchema, combineJsonSchemasWithComposition, extractJsonObjectSchemaEntries, combineJsonObjectSchemaEntries, flattenJsonUnionSchema, isJsonPrimitiveSchema, matchArrayableJsonSchema, isJsonFileSchema, DelegatingJsonSchemaConverter, StandardJsonSchemaConverter } from '@orpc/json-schema';
 import { DEFAULT_SUCCESS_STATUS, DEFAULT_ERROR_STATUS, walkProcedureContractsAsync } from '@orpc/server';
-import { value, isDeepEqual, findDeepMatches, isPlainObject, stringifyJSON, toArray, clone, pathToHttpPath, mergeHttpPath, isTypescriptObject } from '@orpc/shared';
+import { isDeepEqual, value, findDeepMatches, isPlainObject, stringifyJSON, toArray, clone, pathToHttpPath, mergeHttpPath, isTypescriptObject } from '@orpc/shared';
 import '@standardserver/core';
 
 function createContractJsonifiedClientFactory(link, options = {}) {
@@ -15,14 +15,13 @@ function createContractJsonifiedClientFactory(link, options = {}) {
 }
 
 class OpenAPIComponentRegistry {
-  constructor(doc, shouldHoistDef) {
+  constructor(doc, customComponentName) {
     this.doc = doc;
-    this.shouldHoistDef = shouldHoistDef;
+    this.customComponentName = customComponentName;
   }
   /**
    * Registers `schema` as a component under `preferredName` (or an equivalent/postfixed name)
-   * and returns a `$ref` to it. When hoisting is declined via `shouldHoistDef`, the schema is
-   * returned in its local `$defs` form instead.
+   * and returns a `$ref` to it.
    */
   register(preferredName, schema) {
     const { $defs, ...body } = schema;
@@ -39,59 +38,53 @@ class OpenAPIComponentRegistry {
   }
   /**
    * Moves a schema's root-level `$defs` into `doc.components.schemas` and rewrites
-   * its refs accordingly. Defs declined by `shouldHoistDef` stay local unless a
-   * hoisted def references them.
+   * its refs accordingly.
    */
   hoistDefs(schema, direction) {
     if (typeof schema !== "object" || !schema.$defs) {
       return schema;
     }
     const { $defs, ...rest } = schema;
-    const localDefs = {};
-    const hoistedDefs = {};
+    const defs = {};
+    const preferredNames = {};
     for (const defName of Object.keys($defs)) {
       const defSchema = $defs[defName];
       if (defSchema === void 0) {
         continue;
       }
       const normalized = ensureJsonSchemaObject(defSchema);
-      if (value(this.shouldHoistDef, defName, normalized) !== false) {
-        hoistedDefs[defName] = normalized;
-      } else {
-        localDefs[defName] = normalized;
-      }
+      defs[defName] = normalized;
+      preferredNames[defName] = this.customComponentName?.(defName, normalized) ?? defName;
     }
-    hoistReferencedLocalDefs(hoistedDefs, localDefs);
-    if (Object.keys(hoistedDefs).length === 0) {
+    const defNames = Object.keys(defs);
+    if (defNames.length === 0) {
       return schema;
     }
     this.doc.components ??= {};
     this.doc.components.schemas ??= {};
     const componentsSchemas = this.doc.components.schemas;
     const identityRenameMap = Object.fromEntries(
-      Object.keys(hoistedDefs).map((defName) => [defName, defName])
+      defNames.map((defName) => [defName, preferredNames[defName]])
     );
     const renameMap = {};
     const pendingSchemas = [];
-    for (const defName of Object.keys(hoistedDefs)) {
-      const cleanSchema = hoistedDefs[defName];
+    for (const defName of defNames) {
+      const cleanSchema = defs[defName];
       const candidateSchemas = Object.fromEntries(
-        Object.keys(hoistedDefs).map((currentDefName) => [
-          currentDefName,
-          rewriteComponentSchemaRefs(
-            withReferencedLocalDefs(hoistedDefs[currentDefName], localDefs),
-            {
-              ...identityRenameMap,
-              ...renameMap
-            }
-          )
+        defNames.map((currentDefName) => [
+          preferredNames[currentDefName],
+          rewriteComponentSchemaRefs(defs[currentDefName], {
+            ...identityRenameMap,
+            ...renameMap
+          })
         ])
       );
-      const prelimSchema = candidateSchemas[defName];
+      const preferredName = preferredNames[defName];
+      const prelimSchema = candidateSchemas[preferredName];
       const [componentName, reuseExisting] = resolveComponentName(
         componentsSchemas,
         new Set(Object.values(renameMap)),
-        defName,
+        preferredName,
         prelimSchema,
         candidateSchemas,
         direction
@@ -103,77 +96,20 @@ class OpenAPIComponentRegistry {
     }
     for (const { cleanSchema, componentName } of pendingSchemas) {
       componentsSchemas[componentName] = rewriteComponentSchemaRefs(
-        withReferencedLocalDefs(cleanSchema, localDefs),
+        cleanSchema,
         renameMap
       );
     }
-    return rewriteComponentSchemaRefs(withReferencedLocalDefs(rest, localDefs), renameMap);
+    return rewriteComponentSchemaRefs(rest, renameMap);
   }
   toOpenAPISchema(schema, direction) {
     return ensureJsonSchemaObject(this.hoistDefs(schema, direction));
   }
 }
-function visitLocalDefRefs(schema, onRef) {
-  visitJsonSchemaRefs(schema, (ref) => {
-    const refName = parseLocalDefRefName(ref);
-    if (refName !== void 0) {
-      onRef(refName);
-    }
-  });
-}
-function hoistReferencedLocalDefs(hoistedDefs, localDefs) {
-  const queue = Object.values(hoistedDefs);
-  while (queue.length > 0) {
-    const current = queue.shift();
-    visitLocalDefRefs(current, (refName) => {
-      const referenced = localDefs[refName];
-      if (referenced === void 0) {
-        return;
-      }
-      hoistedDefs[refName] = referenced;
-      delete localDefs[refName];
-      queue.push(referenced);
-    });
-  }
-}
-function withReferencedLocalDefs(schema, localDefs) {
-  const referencedLocalDefs = collectReferencedLocalDefNames(schema, localDefs);
-  if (referencedLocalDefs.length === 0) {
-    return schema;
-  }
-  const mergedDefs = {
-    ...schema.$defs
-  };
-  for (const defName of referencedLocalDefs) {
-    mergedDefs[defName] = localDefs[defName];
-  }
-  return {
-    ...schema,
-    $defs: mergedDefs
-  };
-}
-function collectReferencedLocalDefNames(schema, localDefs) {
-  if (Object.keys(localDefs).length === 0) {
-    return [];
-  }
-  const referenced = /* @__PURE__ */ new Set();
-  const queue = [schema];
-  while (queue.length > 0) {
-    const current = queue.shift();
-    visitLocalDefRefs(current, (refName) => {
-      if (localDefs[refName] === void 0 || referenced.has(refName)) {
-        return;
-      }
-      referenced.add(refName);
-      queue.push(localDefs[refName]);
-    });
-  }
-  return [...referenced];
-}
-function resolveComponentName(componentsSchemas, claimedNames, defName, schema, candidateSchemas, direction) {
+function resolveComponentName(componentsSchemas, claimedNames, preferredName, schema, candidateSchemas, direction) {
   let mintName;
   for (let i = 1; ; i++) {
-    const [componentName, mintable, tail] = componentNameCandidate(defName, direction, i);
+    const [componentName, mintable, tail] = componentNameCandidate(preferredName, direction, i);
     const existingSchema = componentsSchemas[componentName];
     if (existingSchema === void 0) {
       if (mintable && !claimedNames.has(componentName)) {
@@ -191,27 +127,27 @@ function resolveComponentName(componentsSchemas, claimedNames, defName, schema,
       existingSchema,
       candidateSchemas,
       componentsSchemas,
-      /* @__PURE__ */ new Map([[defName, componentName]]),
-      /* @__PURE__ */ new Map([[componentName, defName]])
+      /* @__PURE__ */ new Map([[preferredName, componentName]]),
+      /* @__PURE__ */ new Map([[componentName, preferredName]])
     )) {
       return [componentName, true];
     }
   }
 }
-function componentNameCandidate(defName, direction, attempt) {
+function componentNameCandidate(preferredName, direction, attempt) {
   if (attempt === 1) {
-    return [defName, true, false];
+    return [preferredName, true, false];
   }
   if (direction !== void 0) {
     if (attempt === 2) {
-      return [`${defName}${direction === "input" ? "Input" : "Output"}`, true, false];
+      return [`${preferredName}${direction === "input" ? "Input" : "Output"}`, true, false];
     }
     if (attempt === 3) {
-      return [`${defName}${direction === "input" ? "Output" : "Input"}`, false, false];
+      return [`${preferredName}${direction === "input" ? "Output" : "Input"}`, false, false];
     }
-    return [`${defName}${attempt - 2}`, true, true];
+    return [`${preferredName}${attempt - 2}`, true, true];
   }
-  return [`${defName}${attempt}`, true, true];
+  return [`${preferredName}${attempt}`, true, true];
 }
 function definedKeysOf(object) {
   return Object.keys(object).filter((key) => object[key] !== void 0).sort();
@@ -678,13 +614,14 @@ function buildErrorResponse(ctx, operation, def) {
       status
     );
     const responseSchema = customBodySchema ?? combineJsonSchemasWithComposition("oneOf", [
-      ...definitions.map(({ code, dataJsonSchema, dataOptional, defaultMessage }) => {
+      ...definitions.map(({ code, dataJsonSchema, dataOptional }) => {
         return ctx.registry.register(toErrorComponentName(code), combineJsonObjectSchemaEntries([
           ["defined", { const: true }, false],
           ["inferable", { type: "boolean" }, false],
           ["code", { const: code }, false],
           ["status", { const: status }, false],
-          ["message", { type: "string", default: defaultMessage }, false],
+          // avoid using the defaultMessage here to improve component reusability
+          ["message", { type: "string" }, false],
           ["data", ctx.registry.hoistDefs(dataJsonSchema, "output"), dataOptional]
         ]));
       }),
@@ -811,7 +748,7 @@ class OpenAPIGenerator {
       info: options.base?.info ?? { title: "API Reference", version: "0.0.0" }
     };
     const ctx = {
-      registry: new OpenAPIComponentRegistry(doc, options.shouldHoistDef),
+      registry: new OpenAPIComponentRegistry(doc, options.customComponentName),
       convertSchemas: (schemas, direction) => this.convertSchemas(schemas, direction),
       errorStatusMap: options.errorStatusMap ?? COMMON_ERROR_STATUS_MAP,
       customErrorResponseBodySchema: options.customErrorResponseBodySchema

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.ByT4oUeY.mjs';
+import { O as OpenAPIDocument } from '../shared/openapi.Bsz7d8xx.mjs';
 import '@hey-api/spec-types';
 import '@orpc/client';
 

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.ByT4oUeY.js';
+import { O as OpenAPIDocument } from '../shared/openapi.Bsz7d8xx.js';
 import '@hey-api/spec-types';
 import '@orpc/client';
 

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

@@ -1,7 +1,7 @@
 import { wrapAsyncIteratorPreservingEventMeta, toORPCError, isORPCErrorJson, createORPCErrorFromJson } from '@orpc/client';
-import { isPlainObject, isAsyncIteratorObject } from '@orpc/shared';
+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,8 +241,6 @@ 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;
@@ -178,22 +251,24 @@ class OpenAPISerializer {
             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();

package/dist/shared/{openapi.C-p_Q2lb.mjs → openapi.B48raJ3F.mjs}

@@ -2,10 +2,11 @@ import { isORPCErrorJson, createORPCErrorFromJson, ORPCError } from '@orpc/clien
 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, i as isBodylessMethod, b as DEFAULT_OPENAPI_OUTPUT_STRUCTURE } from './openapi.zZH_UksW.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.BaqI61Xi.mjs';
 
 class OpenAPILinkCodecError extends TypeError {
 }
@@ -83,7 +84,7 @@ class OpenAPILinkCodec {
         \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:
@@ -104,7 +105,7 @@ 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);
@@ -324,7 +325,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;

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

@@ -0,0 +1,47 @@
+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.DBFXInk5.js';
+
+declare class OpenAPILinkCodecError extends TypeError {
+}
+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, OpenAPILinkCodecError as b };
+export type { OpenAPILinkCodecOptions as O };