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

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

package/dist/shared/{openapi.CVgUshDP.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, i as isBodylessMethod, b as DEFAULT_OPENAPI_OUTPUT_STRUCTURE } from './openapi.zZH_UksW.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;
@@ -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,7 +240,7 @@ 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)
     };
   }
@@ -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.ByT4oUeY.d.mts → openapi.Bsz7d8xx.d.mts}

@@ -15,4 +15,4 @@ type JsonifiedClient<T extends AnyNestedClient> = T extends Client<infer UClient
     [K in keyof T]: T[K] extends AnyNestedClient ? JsonifiedClient<T[K]> : T[K];
 };
 
-export type { JsonifiedClient as J, OpenAPIOperationObject as O, OpenAPIDocument as a, JsonifiedArray as b, JsonifiedClientError as c, JsonifiedValue as d };
+export type { JsonifiedClient as J, OpenAPIDocument as O, JsonifiedArray as a, JsonifiedClientError as b, JsonifiedValue as c, OpenAPIOperationObject as d };

package/dist/shared/{openapi.ByT4oUeY.d.ts → openapi.Bsz7d8xx.d.ts}

@@ -15,4 +15,4 @@ type JsonifiedClient<T extends AnyNestedClient> = T extends Client<infer UClient
     [K in keyof T]: T[K] extends AnyNestedClient ? JsonifiedClient<T[K]> : T[K];
 };
 
-export type { JsonifiedClient as J, OpenAPIOperationObject as O, OpenAPIDocument as a, JsonifiedArray as b, JsonifiedClientError as c, JsonifiedValue as d };
+export type { JsonifiedClient as J, OpenAPIDocument as O, JsonifiedArray as a, JsonifiedClientError as b, JsonifiedValue as c, OpenAPIOperationObject as d };

package/dist/shared/{openapi.hg_rhZ4x.d.mts → openapi.COG_72WY.d.mts}

@@ -2,7 +2,7 @@ import { AnySchema, ErrorMap, MetaPlugin, AnyProcedureContract } from '@orpc/con
 import { Lazy } from '@orpc/server';
 import { Value } from '@orpc/shared';
 import { StandardBodyHint } from '@standardserver/core';
-import { O as OpenAPIOperationObject } from './openapi.ByT4oUeY.mjs';
+import { d as OpenAPIOperationObject } from './openapi.Bsz7d8xx.mjs';
 
 interface OpenAPIMeta {
     /**

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

@@ -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.mjs';
+
+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 };

package/dist/shared/{openapi.B6hEbRyF.d.ts → openapi.D7Fpk6aV.d.ts}

@@ -4,7 +4,7 @@ import { StandardHandlerCodec, StandardHandlerHandleOptions, StandardHandlerCode
 import { Value, Promisable } from '@orpc/shared';
 import { StandardLazyRequest, StandardResponse } from '@standardserver/core';
 import { AnyProcedureContract } from '@orpc/contract';
-import { O as OpenAPISerializer } from './openapi.BOOA-bde.js';
+import { O as OpenAPISerializer } from './openapi.DBFXInk5.js';
 
 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;
 }
 

package/dist/shared/{openapi.BOOA-bde.d.mts → openapi.DBFXInk5.d.mts}

@@ -95,10 +95,15 @@ interface OpenAPIJsonSerializerOptions {
     omitUndefinedProperties?: boolean | undefined;
 }
 declare class OpenAPIJsonSerializer {
-    private readonly handlers;
+    private readonly inlineBuiltInHandlers;
+    private readonly handlerEntries;
     private readonly omitUndefinedProperties;
     constructor(options?: OpenAPIJsonSerializerOptions);
     serialize(data: unknown): OpenAPIJsonSerialization;
+    /**
+     * `segments` is a shared mutable stack (push/pop while walking),
+     * so it must be copied before being stored in `maps`.
+     */
     private serializeValue;
     deserialize(serialized: OpenAPIJsonSerialization): unknown;
 }

package/dist/shared/{openapi.BOOA-bde.d.ts → openapi.DBFXInk5.d.ts}

@@ -95,10 +95,15 @@ interface OpenAPIJsonSerializerOptions {
     omitUndefinedProperties?: boolean | undefined;
 }
 declare class OpenAPIJsonSerializer {
-    private readonly handlers;
+    private readonly inlineBuiltInHandlers;
+    private readonly handlerEntries;
     private readonly omitUndefinedProperties;
     constructor(options?: OpenAPIJsonSerializerOptions);
     serialize(data: unknown): OpenAPIJsonSerialization;
+    /**
+     * `segments` is a shared mutable stack (push/pop while walking),
+     * so it must be copied before being stored in `maps`.
+     */
     private serializeValue;
     deserialize(serialized: OpenAPIJsonSerialization): unknown;
 }