@orpc/openapi 0.0.0-next.ee0aeaf → 0.0.0-next.fd1db03

package/dist/fetch.js

@@ -1,707 +1,661 @@
 import {
-  eachContractProcedureLeaf,
+  JSONSerializer,
+  forEachContractProcedure,
   standardizeHTTPPath
-} from "./chunk-7HD5IZWG.js";
+} from "./chunk-KNYXLM77.js";
 
-// src/fetch/base-handler.ts
-import { createProcedureCaller, isLazy, isProcedure, LAZY_LOADER_SYMBOL, LAZY_ROUTER_PREFIX_SYMBOL, ORPCError } from "@orpc/server";
-import { executeWithHooks, isPlainObject, mapValues, ORPC_PROTOCOL_HEADER, ORPC_PROTOCOL_VALUE, trim, value } from "@orpc/shared";
-import { OpenAPIDeserializer, OpenAPISerializer, zodCoerce } from "@orpc/transformer";
-function createOpenAPIHandler(createHonoRouter) {
-  const resolveRouter = createResolveRouter(createHonoRouter);
-  return async (options) => {
-    if (options.request.headers.get(ORPC_PROTOCOL_HEADER)?.includes(ORPC_PROTOCOL_VALUE)) {
-      return void 0;
-    }
-    const context = await value(options.context);
-    const accept = options.request.headers.get("Accept") || void 0;
-    const serializer = new OpenAPISerializer({ accept });
-    const handler = async () => {
-      const url = new URL(options.request.url);
-      const pathname = `/${trim(url.pathname.replace(options.prefix ?? "", ""), "/")}`;
-      const customMethod = options.request.method === "POST" ? url.searchParams.get("method")?.toUpperCase() : void 0;
-      const method = customMethod || options.request.method;
-      const match = await resolveRouter(options.router, method, pathname);
-      if (!match) {
-        throw new ORPCError({ code: "NOT_FOUND", message: "Not found" });
-      }
-      const procedure = isLazy(match.procedure) ? (await match.procedure[LAZY_LOADER_SYMBOL]()).default : match.procedure;
-      const path = match.path;
-      if (!isProcedure(procedure)) {
-        throw new ORPCError({
-          code: "NOT_FOUND",
-          message: "Not found"
-        });
-      }
-      const params = procedure.zz$p.contract["~orpc"].InputSchema ? zodCoerce(
-        procedure.zz$p.contract["~orpc"].InputSchema,
-        match.params,
-        { bracketNotation: true }
-      ) : match.params;
-      const input = await deserializeInput(options.request, procedure);
-      const mergedInput = mergeParamsAndInput(params, input);
-      const caller = createProcedureCaller({
-        context,
-        procedure,
-        path
-      });
-      const output = await caller(mergedInput, { signal: options.signal });
-      const { body, headers } = serializer.serialize(output);
-      return new Response(body, {
-        status: 200,
-        headers
-      });
-    };
-    try {
-      return await executeWithHooks({
-        context,
-        hooks: options,
-        execute: handler,
-        input: options.request,
-        meta: {
-          signal: options.signal
-        }
+// src/fetch/bracket-notation.ts
+import { isPlainObject } from "@orpc/shared";
+function serialize(payload, parentKey = "") {
+  if (!Array.isArray(payload) && !isPlainObject(payload))
+    return [["", payload]];
+  const result = [];
+  function helper(value, path) {
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        helper(item, [...path, String(index)]);
       });
-    } catch (e) {
-      const error = toORPCError(e);
-      try {
-        const { body, headers } = serializer.serialize(error.toJSON());
-        return new Response(body, {
-          status: error.status,
-          headers
-        });
-      } catch (e2) {
-        const error2 = toORPCError(e2);
-        const { body, headers } = new OpenAPISerializer().serialize(
-          error2.toJSON()
-        );
-        return new Response(body, {
-          status: error2.status,
-          headers
-        });
+    } else if (isPlainObject(value)) {
+      for (const [key, val] of Object.entries(value)) {
+        helper(val, [...path, key]);
       }
+    } else {
+      result.push([stringifyPath(path), value]);
     }
-  };
+  }
+  helper(payload, parentKey ? [parentKey] : []);
+  return result;
 }
-var routingCache = /* @__PURE__ */ new Map();
-var pendingCache = /* @__PURE__ */ new Map();
-function createResolveRouter(createHonoRouter) {
-  const addRoutes = (routing, pending, options) => {
-    const lazies = eachContractProcedureLeaf(options, ({ path, contract }) => {
-      const method = contract["~orpc"].route?.method ?? "POST";
-      const httpPath = contract["~orpc"].route?.path ? openAPIPathToRouterPath(contract["~orpc"].route?.path) : `/${path.map(encodeURIComponent).join("/")}`;
-      routing.add(method, httpPath, path);
-    });
-    pending.ref.push(...lazies);
-  };
-  return async (router, method, pathname) => {
-    const pending = (() => {
-      let pending2 = pendingCache.get(router);
-      if (!pending2) {
-        pending2 = { ref: [] };
-        pendingCache.set(router, pending2);
-      }
-      return pending2;
-    })();
-    const routing = (() => {
-      let routing2 = routingCache.get(router);
-      if (!routing2) {
-        routing2 = createHonoRouter();
-        routingCache.set(router, routing2);
-        addRoutes(routing2, pending, { router, path: [] });
-      }
-      return routing2;
-    })();
-    const newPending = [];
-    for (const item of pending.ref) {
-      if (LAZY_ROUTER_PREFIX_SYMBOL in item.lazy && item.lazy[LAZY_ROUTER_PREFIX_SYMBOL] && !pathname.startsWith(item.lazy[LAZY_ROUTER_PREFIX_SYMBOL]) && !pathname.startsWith(`/${item.path.map(encodeURIComponent).join("/")}`)) {
-        newPending.push(item);
-        continue;
-      }
-      const router2 = (await item.lazy[LAZY_LOADER_SYMBOL]()).default;
-      addRoutes(routing, pending, { path: item.path, router: router2 });
+function deserialize(entities) {
+  if (entities.length === 0) {
+    return void 0;
+  }
+  const isRootArray = entities.every(([path]) => path === "");
+  const result = isRootArray ? [] : {};
+  const arrayPushPaths = /* @__PURE__ */ new Set();
+  for (const [path, _] of entities) {
+    const segments = parsePath(path);
+    const base = segments.slice(0, -1).join(".");
+    const last = segments[segments.length - 1];
+    if (last === "") {
+      arrayPushPaths.add(base);
+    } else {
+      arrayPushPaths.delete(base);
     }
-    pending.ref = newPending;
-    const [matches, params_] = routing.match(method, pathname);
-    const [match] = matches.sort((a, b) => {
-      return Object.keys(a[1]).length - Object.keys(b[1]).length;
-    });
-    if (!match) {
-      return void 0;
+  }
+  function setValue(obj, segments, value, fullPath) {
+    const [first, ...rest_] = segments;
+    if (Array.isArray(obj) && first === "") {
+      ;
+      obj.push(value);
+      return;
     }
-    const path = match[0];
-    const params = params_ ? mapValues(
-      match[1],
-      (v) => params_[v]
-    ) : match[1];
-    let current = router;
-    for (const segment of path) {
-      if (typeof current !== "object" && typeof current !== "function" || !current) {
-        current = void 0;
-        break;
+    const objAsRecord = obj;
+    if (rest_.length === 0) {
+      objAsRecord[first] = value;
+      return;
+    }
+    const rest = rest_;
+    if (rest[0] === "") {
+      const pathToCheck = segments.slice(0, -1).join(".");
+      if (rest.length === 1 && arrayPushPaths.has(pathToCheck)) {
+        if (!(first in objAsRecord)) {
+          objAsRecord[first] = [];
+        }
+        if (Array.isArray(objAsRecord[first])) {
+          ;
+          objAsRecord[first].push(value);
+          return;
+        }
       }
-      current = current[segment];
+      if (!(first in objAsRecord)) {
+        objAsRecord[first] = {};
+      }
+      const target = objAsRecord[first];
+      target[""] = value;
+      return;
     }
-    return isProcedure(current) || isLazy(current) ? {
-      path,
-      procedure: current,
-      params: { ...params }
-      // params from hono not a normal object, so we need spread here
-    } : void 0;
-  };
-}
-function mergeParamsAndInput(coercedParams, input) {
-  if (Object.keys(coercedParams).length === 0) {
-    return input;
-  }
-  if (!isPlainObject(input)) {
-    return coercedParams;
+    if (!(first in objAsRecord)) {
+      objAsRecord[first] = {};
+    }
+    setValue(
+      objAsRecord[first],
+      rest,
+      value,
+      fullPath
+    );
   }
-  return {
-    ...coercedParams,
-    ...input
-  };
-}
-async function deserializeInput(request, procedure) {
-  const deserializer = new OpenAPIDeserializer({
-    schema: procedure.zz$p.contract["~orpc"].InputSchema
-  });
-  try {
-    return await deserializer.deserialize(request);
-  } catch (e) {
-    throw new ORPCError({
-      code: "BAD_REQUEST",
-      message: "Cannot parse request. Please check the request body and Content-Type header.",
-      cause: e
-    });
+  for (const [path, value] of entities) {
+    const segments = parsePath(path);
+    setValue(result, segments, value, path);
   }
+  return result;
 }
-function toORPCError(e) {
-  return e instanceof ORPCError ? e : new ORPCError({
-    code: "INTERNAL_SERVER_ERROR",
-    message: "Internal server error",
-    cause: e
+function escapeSegment(segment) {
+  return segment.replace(/[\\[\]]/g, (match) => {
+    switch (match) {
+      case "\\":
+        return "\\\\";
+      case "[":
+        return "\\[";
+      case "]":
+        return "\\]";
+      default:
+        return match;
+    }
   });
 }
-function openAPIPathToRouterPath(path) {
-  return standardizeHTTPPath(path).replace(/\{([^}]+)\}/g, ":$1");
+function stringifyPath(path) {
+  const [first, ...rest] = path;
+  const firstSegment = escapeSegment(first);
+  const base = first === "" ? "" : firstSegment;
+  return rest.reduce(
+    (result, segment) => `${result}[${escapeSegment(segment)}]`,
+    base
+  );
 }
-
-// ../../node_modules/.pnpm/hono@4.6.13/node_modules/hono/dist/router.js
-var METHOD_NAME_ALL = "ALL";
-var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
-var UnsupportedPathError = class extends Error {
-};
-
-// ../../node_modules/.pnpm/hono@4.6.13/node_modules/hono/dist/utils/url.js
-var checkOptionalParameter = (path) => {
-  if (!path.match(/\:.+\?$/)) {
-    return null;
-  }
-  const segments = path.split("/");
-  const results = [];
-  let basePath = "";
-  segments.forEach((segment) => {
-    if (segment !== "" && !/\:/.test(segment)) {
-      basePath += "/" + segment;
-    } else if (/\:/.test(segment)) {
-      if (/\?/.test(segment)) {
-        if (results.length === 0 && basePath === "") {
-          results.push("/");
+function parsePath(path) {
+  if (path === "")
+    return [""];
+  const result = [];
+  let currentSegment = "";
+  let inBracket = false;
+  let bracketContent = "";
+  let backslashCount = 0;
+  for (let i = 0; i < path.length; i++) {
+    const char = path[i];
+    if (char === "\\") {
+      backslashCount++;
+      continue;
+    }
+    if (backslashCount > 0) {
+      const literalBackslashes = "\\".repeat(Math.floor(backslashCount / 2));
+      if (char === "[" || char === "]") {
+        if (backslashCount % 2 === 1) {
+          if (inBracket) {
+            bracketContent += literalBackslashes + char;
+          } else {
+            currentSegment += literalBackslashes + char;
+          }
         } else {
-          results.push(basePath);
+          if (inBracket) {
+            bracketContent += literalBackslashes;
+          } else {
+            currentSegment += literalBackslashes;
+          }
+          if (char === "[" && !inBracket) {
+            if (currentSegment !== "" || result.length === 0) {
+              result.push(currentSegment);
+            }
+            inBracket = true;
+            bracketContent = "";
+            currentSegment = "";
+          } else if (char === "]" && inBracket) {
+            result.push(bracketContent);
+            inBracket = false;
+            bracketContent = "";
+          } else {
+            if (inBracket) {
+              bracketContent += char;
+            } else {
+              currentSegment += char;
+            }
+          }
         }
-        const optionalSegment = segment.replace("?", "");
-        basePath += "/" + optionalSegment;
-        results.push(basePath);
       } else {
-        basePath += "/" + segment;
+        const allBackslashes = "\\".repeat(backslashCount);
+        if (inBracket) {
+          bracketContent += allBackslashes + char;
+        } else {
+          currentSegment += allBackslashes + char;
+        }
       }
+      backslashCount = 0;
+      continue;
     }
-  });
-  return results.filter((v, i, a) => a.indexOf(v) === i);
-};
-
-// ../../node_modules/.pnpm/hono@4.6.13/node_modules/hono/dist/router/reg-exp-router/node.js
-var LABEL_REG_EXP_STR = "[^/]+";
-var ONLY_WILDCARD_REG_EXP_STR = ".*";
-var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
-var PATH_ERROR = Symbol();
-var regExpMetaChars = new Set(".\\+*[^]$()");
-function compareKey(a, b) {
-  if (a.length === 1) {
-    return b.length === 1 ? a < b ? -1 : 1 : -1;
-  }
-  if (b.length === 1) {
-    return 1;
-  }
-  if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
-    return 1;
-  } else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) {
-    return -1;
-  }
-  if (a === LABEL_REG_EXP_STR) {
-    return 1;
-  } else if (b === LABEL_REG_EXP_STR) {
-    return -1;
-  }
-  return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
-}
-var Node = class {
-  #index;
-  #varIndex;
-  #children = /* @__PURE__ */ Object.create(null);
-  insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
-    if (tokens.length === 0) {
-      if (this.#index !== void 0) {
-        throw PATH_ERROR;
-      }
-      if (pathErrorCheckOnly) {
-        return;
+    if (char === "[" && !inBracket) {
+      if (currentSegment !== "" || result.length === 0) {
+        result.push(currentSegment);
       }
-      this.#index = index;
-      return;
+      inBracket = true;
+      bracketContent = "";
+      currentSegment = "";
+      continue;
     }
-    const [token, ...restTokens] = tokens;
-    const pattern = token === "*" ? restTokens.length === 0 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
-    let node;
-    if (pattern) {
-      const name = pattern[1];
-      let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
-      if (name && pattern[2]) {
-        regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
-        if (/\((?!\?:)/.test(regexpStr)) {
-          throw PATH_ERROR;
-        }
-      }
-      node = this.#children[regexpStr];
-      if (!node) {
-        if (Object.keys(this.#children).some(
-          (k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
-        )) {
-          throw PATH_ERROR;
-        }
-        if (pathErrorCheckOnly) {
-          return;
-        }
-        node = this.#children[regexpStr] = new Node();
-        if (name !== "") {
-          node.#varIndex = context.varIndex++;
-        }
-      }
-      if (!pathErrorCheckOnly && name !== "") {
-        paramMap.push([name, node.#varIndex]);
-      }
+    if (char === "]" && inBracket) {
+      result.push(bracketContent);
+      inBracket = false;
+      bracketContent = "";
+      continue;
+    }
+    if (inBracket) {
+      bracketContent += char;
     } else {
-      node = this.#children[token];
-      if (!node) {
-        if (Object.keys(this.#children).some(
-          (k) => k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
-        )) {
-          throw PATH_ERROR;
-        }
-        if (pathErrorCheckOnly) {
-          return;
-        }
-        node = this.#children[token] = new Node();
-      }
+      currentSegment += char;
     }
-    node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
   }
-  buildRegExpStr() {
-    const childKeys = Object.keys(this.#children).sort(compareKey);
-    const strList = childKeys.map((k) => {
-      const c = this.#children[k];
-      return (typeof c.#varIndex === "number" ? `(${k})@${c.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
-    });
-    if (typeof this.#index === "number") {
-      strList.unshift(`#${this.#index}`);
+  if (backslashCount > 0) {
+    const remainingBackslashes = "\\".repeat(backslashCount);
+    if (inBracket) {
+      bracketContent += remainingBackslashes;
+    } else {
+      currentSegment += remainingBackslashes;
     }
-    if (strList.length === 0) {
-      return "";
+  }
+  if (inBracket) {
+    if (currentSegment !== "" || result.length === 0) {
+      result.push(currentSegment);
     }
-    if (strList.length === 1) {
-      return strList[0];
+    result.push(`[${bracketContent}`);
+  } else if (currentSegment !== "" || result.length === 0) {
+    result.push(currentSegment);
+  }
+  return result;
+}
+
+// src/fetch/input-structure-compact.ts
+import { isPlainObject as isPlainObject2 } from "@orpc/shared";
+var InputStructureCompact = class {
+  build(params, payload) {
+    if (Object.keys(params).length === 0) {
+      return payload;
     }
-    return "(?:" + strList.join("|") + ")";
+    if (!isPlainObject2(payload)) {
+      return params;
+    }
+    return {
+      ...params,
+      ...payload
+    };
   }
 };
 
-// ../../node_modules/.pnpm/hono@4.6.13/node_modules/hono/dist/router/reg-exp-router/trie.js
-var Trie = class {
-  #context = { varIndex: 0 };
-  #root = new Node();
-  insert(path, index, pathErrorCheckOnly) {
-    const paramAssoc = [];
-    const groups = [];
-    for (let i = 0; ; ) {
-      let replaced = false;
-      path = path.replace(/\{[^}]+\}/g, (m) => {
-        const mark = `@\\${i}`;
-        groups[i] = [mark, m];
-        i++;
-        replaced = true;
-        return mark;
-      });
-      if (!replaced) {
-        break;
+// src/fetch/input-structure-detailed.ts
+var InputStructureDetailed = class {
+  build(params, query, headers, body) {
+    return {
+      params,
+      query,
+      headers,
+      body
+    };
+  }
+};
+
+// src/fetch/openapi-handler.ts
+import { createProcedureClient, ORPCError as ORPCError2 } from "@orpc/server";
+import { executeWithHooks, isPlainObject as isPlainObject3, ORPC_HANDLER_HEADER, trim } from "@orpc/shared";
+
+// src/fetch/openapi-payload-codec.ts
+import { ORPCError } from "@orpc/server";
+import { findDeepMatches } from "@orpc/shared";
+import cd from "content-disposition";
+import { safeParse } from "fast-content-type-parse";
+import wcmatch from "wildcard-match";
+var OpenAPIPayloadCodec = class {
+  constructor(jsonSerializer) {
+    this.jsonSerializer = jsonSerializer;
+  }
+  encode(payload, accept) {
+    const typeMatchers = (accept?.split(",").map(safeParse) ?? [{ type: "*/*" }]).map(({ type }) => wcmatch(type));
+    if (payload instanceof Blob) {
+      const contentType = payload.type || "application/octet-stream";
+      if (typeMatchers.some((isMatch) => isMatch(contentType))) {
+        const headers = new Headers({
+          "Content-Type": contentType
+        });
+        if (payload instanceof File && payload.name) {
+          headers.append("Content-Disposition", cd(payload.name));
+        }
+        return {
+          body: payload,
+          headers
+        };
       }
     }
-    const tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
-    for (let i = groups.length - 1; i >= 0; i--) {
-      const [mark] = groups[i];
-      for (let j = tokens.length - 1; j >= 0; j--) {
-        if (tokens[j].indexOf(mark) !== -1) {
-          tokens[j] = tokens[j].replace(mark, groups[i][1]);
-          break;
-        }
+    const handledPayload = this.jsonSerializer.serialize(payload);
+    const hasBlobs = findDeepMatches((v) => v instanceof Blob, handledPayload).values.length > 0;
+    const isExpectedMultipartFormData = typeMatchers.some(
+      (isMatch) => isMatch("multipart/form-data")
+    );
+    if (hasBlobs && isExpectedMultipartFormData) {
+      return this.encodeAsFormData(handledPayload);
+    }
+    if (typeMatchers.some((isMatch) => isMatch("application/json"))) {
+      return this.encodeAsJSON(handledPayload);
+    }
+    if (typeMatchers.some(
+      (isMatch) => isMatch("application/x-www-form-urlencoded")
+    )) {
+      return this.encodeAsURLSearchParams(handledPayload);
+    }
+    if (isExpectedMultipartFormData) {
+      return this.encodeAsFormData(handledPayload);
+    }
+    throw new ORPCError({
+      code: "NOT_ACCEPTABLE",
+      message: `Unsupported content-type: ${accept}`
+    });
+  }
+  encodeAsJSON(payload) {
+    if (payload === void 0) {
+      return {
+        body: void 0,
+        headers: new Headers({
+          "content-type": "application/json"
+        })
+      };
+    }
+    return {
+      body: JSON.stringify(payload),
+      headers: new Headers({
+        "content-type": "application/json"
+      })
+    };
+  }
+  encodeAsFormData(payload) {
+    const form = new FormData();
+    for (const [path, value] of serialize(payload)) {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        form.append(path, value.toString());
+      } else if (value === null) {
+        form.append(path, "null");
+      } else if (value instanceof Date) {
+        form.append(
+          path,
+          Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString()
+        );
+      } else if (value instanceof Blob) {
+        form.append(path, value);
       }
     }
-    this.#root.insert(tokens, index, paramAssoc, this.#context, pathErrorCheckOnly);
-    return paramAssoc;
-  }
-  buildRegExp() {
-    let regexp = this.#root.buildRegExpStr();
-    if (regexp === "") {
-      return [/^$/, [], []];
-    }
-    let captureIndex = 0;
-    const indexReplacementMap = [];
-    const paramReplacementMap = [];
-    regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
-      if (handlerIndex !== void 0) {
-        indexReplacementMap[++captureIndex] = Number(handlerIndex);
-        return "$()";
+    return {
+      body: form
+    };
+  }
+  encodeAsURLSearchParams(payload) {
+    const params = new URLSearchParams();
+    for (const [path, value] of serialize(payload)) {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        params.append(path, value.toString());
+      } else if (value === null) {
+        params.append(path, "null");
+      } else if (value instanceof Date) {
+        params.append(
+          path,
+          Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString()
+        );
       }
-      if (paramIndex !== void 0) {
-        paramReplacementMap[Number(paramIndex)] = ++captureIndex;
-        return "";
+    }
+    return {
+      body: params.toString(),
+      headers: new Headers({
+        "content-type": "application/x-www-form-urlencoded"
+      })
+    };
+  }
+  async decode(re) {
+    if (re instanceof Headers || re instanceof URLSearchParams || re instanceof FormData) {
+      return deserialize([...re.entries()]);
+    }
+    const contentType = re.headers.get("content-type");
+    const contentDisposition = re.headers.get("content-disposition");
+    const fileName = contentDisposition ? cd.parse(contentDisposition).parameters.filename : void 0;
+    if (fileName) {
+      const blob2 = await re.blob();
+      const file = new File([blob2], fileName, {
+        type: blob2.type
+      });
+      return file;
+    }
+    if (!contentType || contentType.startsWith("application/json")) {
+      if (!re.body) {
+        return void 0;
       }
-      return "";
+      return await re.json();
+    }
+    if (contentType.startsWith("application/x-www-form-urlencoded")) {
+      const params = new URLSearchParams(await re.text());
+      return this.decode(params);
+    }
+    if (contentType.startsWith("text/")) {
+      const text = await re.text();
+      return text;
+    }
+    if (contentType.startsWith("multipart/form-data")) {
+      const form = await re.formData();
+      return this.decode(form);
+    }
+    const blob = await re.blob();
+    return new File([blob], "blob", {
+      type: blob.type
     });
-    return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
   }
 };
 
-// ../../node_modules/.pnpm/hono@4.6.13/node_modules/hono/dist/router/reg-exp-router/router.js
-var emptyParam = [];
-var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
-var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
-function buildWildcardRegExp(path) {
-  return wildcardRegExpCache[path] ??= new RegExp(
-    path === "*" ? "" : `^${path.replace(
-      /\/\*$|([.\\+*[^\]$()])/g,
-      (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
-    )}$`
-  );
-}
-function clearWildcardRegExpCache() {
-  wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
-}
-function buildMatcherFromPreprocessedRoutes(routes) {
-  const trie = new Trie();
-  const handlerData = [];
-  if (routes.length === 0) {
-    return nullMatcher;
-  }
-  const routesWithStaticPathFlag = routes.map(
-    (route) => [!/\*|\/:/.test(route[0]), ...route]
-  ).sort(
-    ([isStaticA, pathA], [isStaticB, pathB]) => isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length
-  );
-  const staticMap = /* @__PURE__ */ Object.create(null);
-  for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
-    const [pathErrorCheckOnly, path, handlers] = routesWithStaticPathFlag[i];
-    if (pathErrorCheckOnly) {
-      staticMap[path] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
-    } else {
-      j++;
-    }
-    let paramAssoc;
-    try {
-      paramAssoc = trie.insert(path, j, pathErrorCheckOnly);
-    } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path) : e;
+// src/fetch/openapi-procedure-matcher.ts
+import { getLazyRouterPrefix, getRouterChild, isProcedure, unlazy } from "@orpc/server";
+import { mapValues } from "@orpc/shared";
+var OpenAPIProcedureMatcher = class {
+  constructor(hono, router) {
+    this.hono = hono;
+    this.router = router;
+    this.pendingRouters = [{ path: [], router }];
+  }
+  pendingRouters;
+  async match(method, pathname) {
+    await this.handlePendingRouters(pathname);
+    const [matches, paramStash] = this.hono.match(method, pathname);
+    const [match] = matches.sort((a, b) => {
+      const slashCountA = a[0][0].split("/").length;
+      const slashCountB = b[0][0].split("/").length;
+      if (slashCountA !== slashCountB) {
+        return slashCountB - slashCountA;
+      }
+      const paramsCountA = Object.keys(a[1]).length;
+      const paramsCountB = Object.keys(b[1]).length;
+      return paramsCountA - paramsCountB;
+    });
+    if (!match) {
+      return void 0;
     }
-    if (pathErrorCheckOnly) {
-      continue;
+    const path = match[0][1];
+    const params = paramStash ? mapValues(
+      match[1],
+      // if paramStash is defined, then match[1] is ParamIndexMap
+      (v) => paramStash[v]
+    ) : match[1];
+    const { default: maybeProcedure } = await unlazy(getRouterChild(this.router, ...path));
+    if (!isProcedure(maybeProcedure)) {
+      return void 0;
     }
-    handlerData[j] = handlers.map(([h, paramCount]) => {
-      const paramIndexMap = /* @__PURE__ */ Object.create(null);
-      paramCount -= 1;
-      for (; paramCount >= 0; paramCount--) {
-        const [key, value2] = paramAssoc[paramCount];
-        paramIndexMap[key] = value2;
-      }
-      return [h, paramIndexMap];
+    return {
+      path,
+      procedure: maybeProcedure,
+      params: { ...params }
+      // normalize params from hono
+    };
+  }
+  add(path, router) {
+    const lazies = forEachContractProcedure({ path, router }, ({ path: path2, contract }) => {
+      const method = contract["~orpc"].route?.method ?? "POST";
+      const httpPath = contract["~orpc"].route?.path ? this.convertOpenAPIPathToRouterPath(contract["~orpc"].route?.path) : `/${path2.map(encodeURIComponent).join("/")}`;
+      this.hono.add(method, httpPath, [httpPath, path2]);
     });
+    this.pendingRouters.push(...lazies);
   }
-  const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
-  for (let i = 0, len = handlerData.length; i < len; i++) {
-    for (let j = 0, len2 = handlerData[i].length; j < len2; j++) {
-      const map = handlerData[i][j]?.[1];
-      if (!map) {
+  async handlePendingRouters(pathname) {
+    const newPendingLazyRouters = [];
+    for (const item of this.pendingRouters) {
+      const lazyPrefix = getLazyRouterPrefix(item.router);
+      if (lazyPrefix && !pathname.startsWith(lazyPrefix) && !pathname.startsWith(`/${item.path.map(encodeURIComponent).join("/")}`)) {
+        newPendingLazyRouters.push(item);
         continue;
       }
-      const keys = Object.keys(map);
-      for (let k = 0, len3 = keys.length; k < len3; k++) {
-        map[keys[k]] = paramReplacementMap[map[keys[k]]];
-      }
+      const { default: router } = await unlazy(item.router);
+      this.add(item.path, router);
     }
+    this.pendingRouters = newPendingLazyRouters;
   }
-  const handlerMap = [];
-  for (const i in indexReplacementMap) {
-    handlerMap[i] = handlerData[indexReplacementMap[i]];
+  convertOpenAPIPathToRouterPath(path) {
+    return standardizeHTTPPath(path).replace(/\{([^}]+)\}/g, ":$1");
   }
-  return [regexp, handlerMap, staticMap];
-}
-function findMiddleware(middleware, path) {
-  if (!middleware) {
-    return void 0;
+};
+
+// src/fetch/schema-coercer.ts
+var CompositeSchemaCoercer = class {
+  constructor(coercers) {
+    this.coercers = coercers;
   }
-  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
-    if (buildWildcardRegExp(k).test(path)) {
-      return [...middleware[k]];
+  coerce(schema, value) {
+    let current = value;
+    for (const coercer of this.coercers) {
+      current = coercer.coerce(schema, current);
     }
+    return current;
   }
-  return void 0;
-}
-var RegExpRouter = class {
-  name = "RegExpRouter";
-  #middleware;
-  #routes;
-  constructor() {
-    this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
-    this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
-  }
-  add(method, path, handler) {
-    const middleware = this.#middleware;
-    const routes = this.#routes;
-    if (!middleware || !routes) {
-      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
-    }
-    if (!middleware[method]) {
-      ;
-      [middleware, routes].forEach((handlerMap) => {
-        handlerMap[method] = /* @__PURE__ */ Object.create(null);
-        Object.keys(handlerMap[METHOD_NAME_ALL]).forEach((p) => {
-          handlerMap[method][p] = [...handlerMap[METHOD_NAME_ALL][p]];
-        });
-      });
-    }
-    if (path === "/*") {
-      path = "*";
-    }
-    const paramCount = (path.match(/\/:/g) || []).length;
-    if (/\*$/.test(path)) {
-      const re = buildWildcardRegExp(path);
-      if (method === METHOD_NAME_ALL) {
-        Object.keys(middleware).forEach((m) => {
-          middleware[m][path] ||= findMiddleware(middleware[m], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
-        });
-      } else {
-        middleware[method][path] ||= findMiddleware(middleware[method], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
+};
+
+// src/fetch/openapi-handler.ts
+var OpenAPIHandler = class {
+  constructor(hono, router, options) {
+    this.options = options;
+    const jsonSerializer = options?.jsonSerializer ?? new JSONSerializer();
+    this.procedureMatcher = options?.procedureMatcher ?? new OpenAPIProcedureMatcher(hono, router);
+    this.payloadCodec = options?.payloadCodec ?? new OpenAPIPayloadCodec(jsonSerializer);
+    this.inputStructureCompact = options?.inputBuilderSimple ?? new InputStructureCompact();
+    this.inputStructureDetailed = options?.inputBuilderFull ?? new InputStructureDetailed();
+    this.compositeSchemaCoercer = new CompositeSchemaCoercer(options?.schemaCoercers ?? []);
+  }
+  procedureMatcher;
+  payloadCodec;
+  inputStructureCompact;
+  inputStructureDetailed;
+  compositeSchemaCoercer;
+  condition(request) {
+    return request.headers.get(ORPC_HANDLER_HEADER) === null;
+  }
+  async fetch(request, ...[options]) {
+    const context = options?.context;
+    const headers = request.headers;
+    const accept = headers.get("Accept") || void 0;
+    const execute = async () => {
+      const url = new URL(request.url);
+      const pathname = `/${trim(url.pathname.replace(options?.prefix ?? "", ""), "/")}`;
+      const query = url.searchParams;
+      const customMethod = request.method === "POST" ? query.get("method")?.toUpperCase() : void 0;
+      const matchedMethod = customMethod || request.method;
+      const matched = await this.procedureMatcher.match(matchedMethod, pathname);
+      if (!matched) {
+        throw new ORPCError2({ code: "NOT_FOUND", message: "Not found" });
       }
-      Object.keys(middleware).forEach((m) => {
-        if (method === METHOD_NAME_ALL || method === m) {
-          Object.keys(middleware[m]).forEach((p) => {
-            re.test(p) && middleware[m][p].push([handler, paramCount]);
-          });
-        }
+      const contractDef = matched.procedure["~orpc"].contract["~orpc"];
+      const input = await this.decodeInput(matched.procedure, matched.params, request);
+      const coercedInput = this.compositeSchemaCoercer.coerce(contractDef.InputSchema, input);
+      const client = createProcedureClient({
+        context,
+        procedure: matched.procedure,
+        path: matched.path
       });
-      Object.keys(routes).forEach((m) => {
-        if (method === METHOD_NAME_ALL || method === m) {
-          Object.keys(routes[m]).forEach(
-            (p) => re.test(p) && routes[m][p].push([handler, paramCount])
-          );
-        }
+      const output = await client(coercedInput, { signal: options?.signal });
+      const { body, headers: resHeaders } = this.encodeOutput(matched.procedure, output, accept);
+      return new Response(body, {
+        headers: resHeaders,
+        status: contractDef.route?.successStatus ?? 200
       });
-      return;
-    }
-    const paths = checkOptionalParameter(path) || [path];
-    for (let i = 0, len = paths.length; i < len; i++) {
-      const path2 = paths[i];
-      Object.keys(routes).forEach((m) => {
-        if (method === METHOD_NAME_ALL || method === m) {
-          routes[m][path2] ||= [
-            ...findMiddleware(middleware[m], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || []
-          ];
-          routes[m][path2].push([handler, paramCount - len + i + 1]);
+    };
+    try {
+      return await executeWithHooks({
+        context,
+        execute,
+        input: request,
+        hooks: this.options,
+        meta: {
+          signal: options?.signal
         }
       });
+    } catch (e) {
+      const error = this.convertToORPCError(e);
+      try {
+        const { body, headers: headers2 } = this.payloadCodec.encode(error.toJSON(), accept);
+        return new Response(body, {
+          status: error.status,
+          headers: headers2
+        });
+      } catch (e2) {
+        const error2 = this.convertToORPCError(e2);
+        const { body, headers: headers2 } = this.payloadCodec.encode(error2.toJSON(), void 0);
+        return new Response(body, {
+          status: error2.status,
+          headers: headers2
+        });
+      }
+    }
+  }
+  async decodeInput(procedure, params, request) {
+    const inputStructure = procedure["~orpc"].contract["~orpc"].route?.inputStructure;
+    const url = new URL(request.url);
+    const query = url.searchParams;
+    const headers = request.headers;
+    if (!inputStructure || inputStructure === "compact") {
+      return this.inputStructureCompact.build(
+        params,
+        request.method === "GET" ? await this.payloadCodec.decode(query) : await this.payloadCodec.decode(request)
+      );
     }
+    const _expect = inputStructure;
+    const decodedQuery = await this.payloadCodec.decode(query);
+    const decodedHeaders = await this.payloadCodec.decode(headers);
+    const decodedBody = await this.payloadCodec.decode(request);
+    return this.inputStructureDetailed.build(params, decodedQuery, decodedHeaders, decodedBody);
   }
-  match(method, path) {
-    clearWildcardRegExpCache();
-    const matchers = this.#buildAllMatchers();
-    this.match = (method2, path2) => {
-      const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
-      const staticMatch = matcher[2][path2];
-      if (staticMatch) {
-        return staticMatch;
+  encodeOutput(procedure, output, accept) {
+    const outputStructure = procedure["~orpc"].contract["~orpc"].route?.outputStructure;
+    if (!outputStructure || outputStructure === "compact") {
+      return this.payloadCodec.encode(output, accept);
+    }
+    const _expect = outputStructure;
+    this.assertDetailedOutput(output);
+    const headers = new Headers();
+    if (output.headers) {
+      for (const [key, value] of Object.entries(output.headers)) {
+        headers.append(key, value);
       }
-      const match = path2.match(matcher[0]);
-      if (!match) {
-        return [[], emptyParam];
+    }
+    const { body, headers: encodedHeaders } = this.payloadCodec.encode(output.body, accept);
+    if (encodedHeaders) {
+      for (const [key, value] of encodedHeaders.entries()) {
+        headers.append(key, value);
       }
-      const index = match.indexOf("", 1);
-      return [matcher[1][index], match];
-    };
-    return this.match(method, path);
+    }
+    return { body, headers };
   }
-  #buildAllMatchers() {
-    const matchers = /* @__PURE__ */ Object.create(null);
-    Object.keys(this.#routes).concat(Object.keys(this.#middleware)).forEach((method) => {
-      matchers[method] ||= this.#buildMatcher(method);
-    });
-    this.#middleware = this.#routes = void 0;
-    return matchers;
-  }
-  #buildMatcher(method) {
-    const routes = [];
-    let hasOwnRoute = method === METHOD_NAME_ALL;
-    [this.#middleware, this.#routes].forEach((r) => {
-      const ownRoute = r[method] ? Object.keys(r[method]).map((path) => [path, r[method][path]]) : [];
-      if (ownRoute.length !== 0) {
-        hasOwnRoute ||= true;
-        routes.push(...ownRoute);
-      } else if (method !== METHOD_NAME_ALL) {
-        routes.push(
-          ...Object.keys(r[METHOD_NAME_ALL]).map((path) => [path, r[METHOD_NAME_ALL][path]])
-        );
+  assertDetailedOutput(output) {
+    const error = new Error(`
+      Invalid output structure for 'detailed' output. 
+      Expected format:
+      {
+        body?: unknown;       // The main response content (optional)
+        headers?: {           // Additional headers (optional)
+          [key: string]: string;
+        };
       }
-    });
-    if (!hasOwnRoute) {
-      return null;
-    } else {
-      return buildMatcherFromPreprocessedRoutes(routes);
+
+      Example:
+      {
+        body: { message: "Success" },
+        headers: { "X-Custom-Header": "Custom-Value" },
+      }
+
+      Fix: Ensure your output matches the expected structure.
+    `);
+    if (!isPlainObject3(output) || Object.keys(output).some((key) => key !== "body" && key !== "headers")) {
+      throw error;
+    }
+    if (output.headers !== void 0 && !isPlainObject3(output.headers)) {
+      throw error;
+    }
+    if (output.headers && Object.entries(output.headers).some(([key, value]) => typeof key !== "string" || typeof value !== "string")) {
+      throw error;
     }
   }
+  convertToORPCError(e) {
+    return e instanceof ORPCError2 ? e : new ORPCError2({
+      code: "INTERNAL_SERVER_ERROR",
+      message: "Internal server error",
+      cause: e
+    });
+  }
 };
 
-// src/fetch/server-handler.ts
-function createOpenAPIServerHandler() {
-  return createOpenAPIHandler(() => new RegExpRouter());
-}
-
-// ../../node_modules/.pnpm/hono@4.6.13/node_modules/hono/dist/router/linear-router/router.js
-var emptyParams = /* @__PURE__ */ Object.create(null);
-var splitPathRe = /\/(:\w+(?:{(?:(?:{[\d,]+})|[^}])+})?)|\/[^\/\?]+|(\?)/g;
-var splitByStarRe = /\*/;
-var LinearRouter = class {
-  name = "LinearRouter";
-  #routes = [];
-  add(method, path, handler) {
-    for (let i = 0, paths = checkOptionalParameter(path) || [path], len = paths.length; i < len; i++) {
-      this.#routes.push([method, paths[i], handler]);
-    }
-  }
-  match(method, path) {
-    const handlers = [];
-    ROUTES_LOOP:
-      for (let i = 0, len = this.#routes.length; i < len; i++) {
-        const [routeMethod, routePath, handler] = this.#routes[i];
-        if (routeMethod === method || routeMethod === METHOD_NAME_ALL) {
-          if (routePath === "*" || routePath === "/*") {
-            handlers.push([handler, emptyParams]);
-            continue;
-          }
-          const hasStar = routePath.indexOf("*") !== -1;
-          const hasLabel = routePath.indexOf(":") !== -1;
-          if (!hasStar && !hasLabel) {
-            if (routePath === path || routePath + "/" === path) {
-              handlers.push([handler, emptyParams]);
-            }
-          } else if (hasStar && !hasLabel) {
-            const endsWithStar = routePath.charCodeAt(routePath.length - 1) === 42;
-            const parts = (endsWithStar ? routePath.slice(0, -2) : routePath).split(splitByStarRe);
-            const lastIndex = parts.length - 1;
-            for (let j = 0, pos = 0, len2 = parts.length; j < len2; j++) {
-              const part = parts[j];
-              const index = path.indexOf(part, pos);
-              if (index !== pos) {
-                continue ROUTES_LOOP;
-              }
-              pos += part.length;
-              if (j === lastIndex) {
-                if (!endsWithStar && pos !== path.length && !(pos === path.length - 1 && path.charCodeAt(pos) === 47)) {
-                  continue ROUTES_LOOP;
-                }
-              } else {
-                const index2 = path.indexOf("/", pos);
-                if (index2 === -1) {
-                  continue ROUTES_LOOP;
-                }
-                pos = index2;
-              }
-            }
-            handlers.push([handler, emptyParams]);
-          } else if (hasLabel && !hasStar) {
-            const params = /* @__PURE__ */ Object.create(null);
-            const parts = routePath.match(splitPathRe);
-            const lastIndex = parts.length - 1;
-            for (let j = 0, pos = 0, len2 = parts.length; j < len2; j++) {
-              if (pos === -1 || pos >= path.length) {
-                continue ROUTES_LOOP;
-              }
-              const part = parts[j];
-              if (part.charCodeAt(1) === 58) {
-                let name = part.slice(2);
-                let value2;
-                if (name.charCodeAt(name.length - 1) === 125) {
-                  const openBracePos = name.indexOf("{");
-                  const pattern = name.slice(openBracePos + 1, -1);
-                  const restPath = path.slice(pos + 1);
-                  const match = new RegExp(pattern, "d").exec(restPath);
-                  if (!match || match.indices[0][0] !== 0 || match.indices[0][1] === 0) {
-                    continue ROUTES_LOOP;
-                  }
-                  name = name.slice(0, openBracePos);
-                  value2 = restPath.slice(...match.indices[0]);
-                  pos += match.indices[0][1] + 1;
-                } else {
-                  let endValuePos = path.indexOf("/", pos + 1);
-                  if (endValuePos === -1) {
-                    if (pos + 1 === path.length) {
-                      continue ROUTES_LOOP;
-                    }
-                    endValuePos = path.length;
-                  }
-                  value2 = path.slice(pos + 1, endValuePos);
-                  pos = endValuePos;
-                }
-                params[name] ||= value2;
-              } else {
-                const index = path.indexOf(part, pos);
-                if (index !== pos) {
-                  continue ROUTES_LOOP;
-                }
-                pos += part.length;
-              }
-              if (j === lastIndex) {
-                if (pos !== path.length && !(pos === path.length - 1 && path.charCodeAt(pos) === 47)) {
-                  continue ROUTES_LOOP;
-                }
-              }
-            }
-            handlers.push([handler, params]);
-          } else if (hasLabel && hasStar) {
-            throw new UnsupportedPathError();
-          }
-        }
-      }
-    return [handlers];
+// src/fetch/openapi-handler-server.ts
+import { TrieRouter } from "hono/router/trie-router";
+var OpenAPIServerHandler = class extends OpenAPIHandler {
+  constructor(router, options) {
+    super(new TrieRouter(), router, options);
   }
 };
 
-// src/fetch/serverless-handler.ts
-function createOpenAPIServerlessHandler() {
-  return createOpenAPIHandler(() => new LinearRouter());
-}
+// src/fetch/openapi-handler-serverless.ts
+import { LinearRouter } from "hono/router/linear-router";
+var OpenAPIServerlessHandler = class extends OpenAPIHandler {
+  constructor(router, options) {
+    super(new LinearRouter(), router, options);
+  }
+};
 export {
-  createOpenAPIHandler,
-  createOpenAPIServerHandler,
-  createOpenAPIServerlessHandler,
-  createResolveRouter
+  CompositeSchemaCoercer,
+  InputStructureCompact,
+  InputStructureDetailed,
+  OpenAPIHandler,
+  OpenAPIPayloadCodec,
+  OpenAPIProcedureMatcher,
+  OpenAPIServerHandler,
+  OpenAPIServerlessHandler,
+  deserialize,
+  escapeSegment,
+  parsePath,
+  serialize,
+  stringifyPath
 };
 //# sourceMappingURL=fetch.js.map