@orpc/openapi 1.14.9 → 1.14.11

package/dist/shared/openapi.C-p_Q2lb.mjs

@@ -0,0 +1,359 @@
+import { isORPCErrorJson, createORPCErrorFromJson, ORPCError } from '@orpc/client';
+import { getRouterContract, ProcedureContract } from '@orpc/contract';
+import { unlazy } from '@orpc/server';
+import { value, pathToHttpPath, mergeHttpPath, isTypescriptObject, stringifyJSON } from '@orpc/shared';
+import { mergeStandardHeaders, parseStandardUrl, isStandardHeaders } from '@standardserver/core';
+import { 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 { g as getOpenAPIMeta } from './openapi.B9PQzqBn.mjs';
+
+class OpenAPILinkCodecError extends TypeError {
+}
+const END_SLASH_REGEX = /\/$/;
+class OpenAPILinkCodec {
+  constructor(router, options = {}) {
+    this.router = router;
+    this.baseUrl = options.url ?? "/";
+    this.headers = options.headers ?? {};
+    this.serializer = options.serializer ?? new OpenAPISerializer();
+    this.customErrorResponseBodyDecoder = options.customErrorResponseBodyDecoder;
+  }
+  baseUrl;
+  headers;
+  serializer;
+  customErrorResponseBodyDecoder;
+  async encodeInput(input, path, options) {
+    let headers = toResolvedStandardHeaders(await value(this.headers, options, path, input));
+    if (options.lastEventId !== void 0) {
+      headers = mergeStandardHeaders(headers, { "last-event-id": options.lastEventId });
+    }
+    const baseUrl = await value(this.baseUrl, options, path, input);
+    const procedure = await this.resolveProcedure(path);
+    const meta = getOpenAPIMeta(procedure);
+    const method = meta?.method ?? DEFAULT_OPENAPI_METHOD;
+    const inputStructure = meta?.inputStructure ?? DEFAULT_OPENAPI_INPUT_STRUCTURE;
+    let pathname = meta?.path ?? pathToHttpPath(path);
+    if (meta?.prefix) {
+      pathname = mergeHttpPath(meta.prefix, pathname);
+    }
+    const [basePathname, baseSearch, baseHash] = parseStandardUrl(baseUrl);
+    const dynamicParams = getDynamicPathParams(pathname);
+    if (inputStructure === "compact") {
+      let data = input;
+      if (dynamicParams?.length) {
+        if (!isTypescriptObject(input)) {
+          throw new OpenAPILinkCodecError(
+            `Input must be an object with "compact" input structure when the path has dynamic params (${dynamicParams.map((p) => p.parameterName).join(", ")}) in call to procedure (${path.join(".")}).`
+          );
+        }
+        const remaining = { ...input };
+        for (let i = dynamicParams.length - 1; i >= 0; i--) {
+          const param = dynamicParams[i];
+          const encoded = this.encodePathParam(input[param.parameterName], param, meta?.paramsStyles?.[param.parameterName], path);
+          pathname = `${pathname.slice(0, param.startIndex)}${encoded}${pathname.slice(param.startIndex + param.segment.length)}`;
+          delete remaining[param.parameterName];
+        }
+        data = Object.keys(remaining).length > 0 ? remaining : void 0;
+      }
+      pathname = `${basePathname.replace(END_SLASH_REGEX, "")}${pathname}`;
+      if (isBodylessMethod(method)) {
+        const queryString2 = this.serializeQueryString(data, meta?.queryStyles);
+        const search2 = combineSearch(baseSearch, queryString2);
+        const url3 = `${pathname}${search2 ?? ""}${baseHash ?? ""}`;
+        return {
+          body: void 0,
+          method,
+          headers,
+          url: url3,
+          signal: options.signal
+        };
+      }
+      const url2 = `${pathname}${baseSearch ?? ""}${baseHash ?? ""}`;
+      return {
+        url: url2,
+        method,
+        headers,
+        body: this.serializer.serialize(data),
+        signal: options.signal
+      };
+    }
+    if (!isValidDetailedInput(input)) {
+      throw new OpenAPILinkCodecError(`
+        Invalid "detailed" input structure in call to procedure (${path.join(".")}):
+        \u2022 Expected an object or undefined with optional properties:
+          - params (object, required when the path has dynamic params)
+          - query (object)
+          - headers (Record<string, string | string[] | undefined>)
+          - body (any)
+
+        Actual value:
+          ${stringifyJSON(input)}
+      `);
+    }
+    if (dynamicParams?.length) {
+      if (!input?.params) {
+        throw new OpenAPILinkCodecError(
+          `The "params" property is required for "detailed" input when the path has dynamic params (${dynamicParams.map((p) => p.parameterName).join(", ")}) in call to procedure (${path.join(".")}).`
+        );
+      }
+      for (let i = dynamicParams.length - 1; i >= 0; i--) {
+        const param = dynamicParams[i];
+        const val = input.params[param.parameterName];
+        const encoded = this.encodePathParam(val, param, meta?.paramsStyles?.[param.parameterName], path);
+        pathname = `${pathname.slice(0, param.startIndex)}${encoded}${pathname.slice(param.startIndex + param.segment.length)}`;
+      }
+    }
+    if (input?.headers) {
+      headers = mergeStandardHeaders(headers, input.headers);
+    }
+    pathname = `${basePathname.replace(END_SLASH_REGEX, "")}${pathname}`;
+    const queryString = this.serializeQueryString(input?.query, meta?.queryStyles);
+    const search = combineSearch(baseSearch, queryString);
+    const url = `${pathname}${search ?? ""}${baseHash ?? ""}`;
+    if (isBodylessMethod(method)) {
+      return {
+        body: void 0,
+        method,
+        headers,
+        url,
+        signal: options.signal
+      };
+    }
+    return {
+      url,
+      method,
+      headers,
+      body: this.serializer.serialize(input?.body),
+      signal: options.signal
+    };
+  }
+  encodePathParam(val, param, style, path) {
+    let encoded;
+    if (style === "comma-delimited-array" && Array.isArray(val)) {
+      encoded = val.map((val2) => this.serializer.serialize(val2)).filter((val2) => val2 !== void 0 && val2 !== null).map((val2) => encodeURIComponent(String(val2))).join(",");
+    } else if (style === "comma-delimited-object" && isTypescriptObject(val)) {
+      encoded = Object.entries(val).map(([key, val2]) => [key, this.serializer.serialize(val2)]).filter(([, val2]) => val2 !== void 0 && val2 !== null).map(([key, val2]) => `${encodeURIComponent(String(key))},${encodeURIComponent(String(val2))}`).join(",");
+    } else {
+      const serialized = this.serializer.serialize(val);
+      if (serialized !== void 0 && serialized !== null) {
+        if (param.allowsSlash) {
+          encoded = String(serialized).split("/").map(encodeURIComponent).join("/");
+        } else {
+          encoded = encodeURIComponent(String(serialized));
+        }
+      }
+    }
+    if (!encoded) {
+      throw new OpenAPILinkCodecError(`Path param "${param.parameterName}" cannot be empty in call to procedure (${path.join(".")}).`);
+    }
+    return encoded;
+  }
+  serializeQueryString(data, queryStyles) {
+    if (!queryStyles || !isTypescriptObject(data)) {
+      return toURLSearchParams(
+        this.serializer.serialize(data, { asFormData: true })
+      ).toString();
+    }
+    const remaining = { ...data };
+    let query = "";
+    Object.entries(queryStyles).forEach(([key, style]) => {
+      if (style === void 0) {
+        return;
+      }
+      const value2 = remaining[key];
+      delete remaining[key];
+      if (style === "primitive") {
+        const serialized = this.serializer.serialize(value2);
+        if (serialized !== void 0 && serialized !== null) {
+          query += `&${encodeURLSearchParamComponent(key)}=${encodeURLSearchParamComponent(String(serialized))}`;
+        }
+      } else if (style === "array" && Array.isArray(value2)) {
+        const encodedKey = encodeURLSearchParamComponent(key);
+        value2.forEach((v) => {
+          const s = this.serializer.serialize(v);
+          if (s !== void 0 && s !== null) {
+            query += `&${encodedKey}=${encodeURLSearchParamComponent(String(s))}`;
+          }
+        });
+      } else if (style === "json") {
+        const serialized = this.serializer.serialize(value2);
+        if (serialized !== void 0) {
+          query += `&${encodeURLSearchParamComponent(key)}=${encodeURLSearchParamComponent(stringifyJSON(serialized))}`;
+        }
+      } else if (style === "comma-delimited-array" && Array.isArray(value2)) {
+        const encodedValue = encodeDelimitedArray(
+          value2.map((v) => this.serializer.serialize(v)),
+          ","
+        );
+        if (encodedValue !== void 0) {
+          query += `&${encodeURLSearchParamComponent(key)}=${encodedValue}`;
+        }
+      } else if (style === "comma-delimited-object" && isTypescriptObject(value2)) {
+        const encodedValue = encodeDelimitedObject(
+          Object.entries(value2).map(([key2, value3]) => [key2, this.serializer.serialize(value3)]),
+          ","
+        );
+        if (encodedValue !== void 0) {
+          query += `&${encodeURLSearchParamComponent(key)}=${encodedValue}`;
+        }
+      } else if (style === "pipe-delimited-array" && Array.isArray(value2)) {
+        const encodedValue = encodeDelimitedArray(
+          value2.map((v) => this.serializer.serialize(v)),
+          "%7C"
+        );
+        if (encodedValue !== void 0) {
+          query += `&${encodeURLSearchParamComponent(key)}=${encodedValue}`;
+        }
+      } else if (style === "pipe-delimited-object" && isTypescriptObject(value2)) {
+        const encodedValue = encodeDelimitedObject(
+          Object.entries(value2).map(([key2, value3]) => [key2, this.serializer.serialize(value3)]),
+          "%7C"
+        );
+        if (encodedValue !== void 0) {
+          query += `&${encodeURLSearchParamComponent(key)}=${encodedValue}`;
+        }
+      } else if (style === "space-delimited-array" && Array.isArray(value2)) {
+        const encodedValue = encodeDelimitedArray(
+          value2.map((v) => this.serializer.serialize(v)),
+          "%20"
+        );
+        if (encodedValue !== void 0) {
+          query += `&${encodeURLSearchParamComponent(key)}=${encodedValue}`;
+        }
+      } else if (style === "space-delimited-object" && isTypescriptObject(value2)) {
+        const encodedValue = encodeDelimitedObject(
+          Object.entries(value2).map(([key2, value3]) => [key2, this.serializer.serialize(value3)]),
+          "%20"
+        );
+        if (encodedValue !== void 0) {
+          query += `&${encodeURLSearchParamComponent(key)}=${encodedValue}`;
+        }
+      } else {
+        const serialized = this.serializer.serialize(value2);
+        if (serialized !== void 0 && serialized !== null) {
+          query += `&${encodeURLSearchParamComponent(key)}=${encodeURLSearchParamComponent(String(serialized))}`;
+        }
+      }
+    });
+    const form = this.serializer.serialize(remaining, { asFormData: true });
+    query = `${toURLSearchParams(form).toString()}${query}`;
+    if (query.startsWith("&")) {
+      query = query.slice(1);
+    }
+    return query || void 0;
+  }
+  async decodeResponse(response, path, _options) {
+    const isOk = response.status < 400;
+    const procedure = await this.resolveProcedure(path);
+    const meta = getOpenAPIMeta(procedure);
+    const deserialized = await (async () => {
+      let isBodyOk = false;
+      try {
+        const body = await response.resolveBody(meta?.responseBodyHint);
+        isBodyOk = true;
+        return this.serializer.deserialize(body);
+      } catch (error) {
+        if (!isBodyOk) {
+          throw new Error("Cannot parse response body, please check the response body and content-type.", {
+            cause: error
+          });
+        }
+        throw new Error("Invalid OpenAPI response format.", {
+          cause: error
+        });
+      }
+    })();
+    if (!isOk) {
+      const customError = this.customErrorResponseBodyDecoder?.(deserialized, response);
+      if (customError !== void 0 && customError !== null) {
+        return { kind: "error", error: customError };
+      }
+      if (isORPCErrorJson(deserialized)) {
+        return { kind: "error", error: createORPCErrorFromJson(deserialized) };
+      }
+      return {
+        kind: "error",
+        error: new ORPCError("MALFORMED_ORPC_ERROR_RESPONSE", {
+          data: { headers: response.headers, status: response.status, body: deserialized }
+        })
+      };
+    }
+    const outputStructure = meta?.outputStructure ?? DEFAULT_OPENAPI_OUTPUT_STRUCTURE;
+    return outputStructure === "compact" ? { kind: "output", output: deserialized } : {
+      kind: "output",
+      output: {
+        status: response.status,
+        headers: response.headers,
+        body: deserialized
+      }
+    };
+  }
+  async resolveProcedure(path) {
+    const { default: maybeProcedure } = await unlazy(getRouterContract(this.router, path));
+    if (!(maybeProcedure instanceof ProcedureContract)) {
+      throw new OpenAPILinkCodecError(`Expected a procedure or contract at path (${path.join(".")})`);
+    }
+    return maybeProcedure;
+  }
+}
+function combineSearch(baseSearch, additionalSearch) {
+  if (!baseSearch && !additionalSearch) {
+    return void 0;
+  }
+  if (!additionalSearch) {
+    return baseSearch;
+  }
+  if (!baseSearch) {
+    return `?${additionalSearch}`;
+  }
+  return `${baseSearch}&${additionalSearch}`;
+}
+function toResolvedStandardHeaders(headers) {
+  if (typeof headers.forEach === "function") {
+    return toStandardHeaders(headers);
+  }
+  return headers;
+}
+function isValidDetailedInput(input) {
+  if (!isTypescriptObject(input)) {
+    return input === void 0;
+  }
+  if (input.params !== void 0 && !isTypescriptObject(input.params)) {
+    return false;
+  }
+  if (input.query !== void 0 && !isTypescriptObject(input.query)) {
+    return false;
+  }
+  if (input.headers !== void 0 && !isStandardHeaders(input.headers)) {
+    return false;
+  }
+  return true;
+}
+function encodeURLSearchParamComponent(value2) {
+  return new URLSearchParams({ "": value2 }).toString().slice(1);
+}
+function toURLSearchParams(form) {
+  const params = new URLSearchParams();
+  for (const [key, value2] of form) {
+    params.append(key, String(value2));
+  }
+  return params;
+}
+function encodeDelimitedArray(serializedValues, encodedDelimiter) {
+  const strings = serializedValues.filter((v) => v !== null && v !== void 0).map(String);
+  if (!strings.length) {
+    return void 0;
+  }
+  return strings.map(encodeURLSearchParamComponent).join(encodedDelimiter);
+}
+function encodeDelimitedObject(entries, encodedDelimiter) {
+  const strings = entries.filter(([v]) => v !== null && v !== void 0).map(([k, v]) => [k, String(v)]);
+  if (!strings.length) {
+    return void 0;
+  }
+  return strings.map(
+    ([key, value2]) => `${encodeURLSearchParamComponent(key)}${encodedDelimiter}${encodeURLSearchParamComponent(value2)}`
+  ).join(encodedDelimiter);
+}
+
+export { OpenAPILinkCodec as O, OpenAPILinkCodecError as a };

package/dist/shared/openapi.CVgUshDP.mjs

@@ -0,0 +1,318 @@
+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 { g as getOpenAPIMeta } from './openapi.B9PQzqBn.mjs';
+import { createRouter, addRoute, findRoute, routeToRegExp } from 'rou3';
+
+class OpenAPIMatcher {
+  filter;
+  rootRouter;
+  tree = createRouter();
+  pendingLazyRouters = [];
+  constructor(router, options = {}) {
+    this.filter = options.filter ?? true;
+    this.rootRouter = router;
+    this.index(router);
+  }
+  index(router, path = []) {
+    const lazyResults = walkProcedureContractsSync(router, (contract, path2) => {
+      if (!value(this.filter, contract, path2)) {
+        return;
+      }
+      const meta = getOpenAPIMeta(contract);
+      const method = meta?.method ?? DEFAULT_OPENAPI_METHOD;
+      const postHttpPath = meta?.path ?? pathToHttpPath(path2);
+      const openapiPath = meta?.prefix ? mergeHttpPath(meta.prefix, postHttpPath) : postHttpPath;
+      const rou3Path = toRou3Pattern(openapiPath);
+      addRoute(this.tree, method, rou3Path, {
+        path: path2,
+        contract,
+        procedure: contract instanceof Procedure ? contract : void 0
+      });
+    }, path);
+    this.pendingLazyRouters.push(...lazyResults.map((result) => {
+      const prefix = getOpenAPIMeta(result.router)?.prefix;
+      return {
+        ...result,
+        matcher: prefix ? toRou3PrefixMatcher(prefix) : void 0
+      };
+    }));
+  }
+  async match(method, pathname, prefix) {
+    if (prefix) {
+      if (!pathname.startsWith(prefix)) {
+        return void 0;
+      }
+      const charAfterPrefix = pathname[prefix.length];
+      if (charAfterPrefix === "/") {
+        pathname = pathname.slice(prefix.length);
+      } else if (charAfterPrefix === void 0) {
+        pathname = "/";
+      } else if (prefix[prefix.length - 1] === "/") {
+        pathname = pathname.slice(prefix.length - 1);
+      } else {
+        return void 0;
+      }
+    }
+    const result = await this.matchPathname(method, pathname);
+    if (!result && pathname.includes("%")) {
+      return this.matchPathname(method, normalizeHttpPath(pathname));
+    }
+    return result;
+  }
+  async matchPathname(method, pathname) {
+    await this.resolvePendingLazyRouters(pathname);
+    const match = findRoute(this.tree, method, pathname);
+    if (!match) {
+      return void 0;
+    }
+    const procedure = await this.resolveProcedure(match.data);
+    return {
+      path: match.data.path,
+      procedure,
+      params: match.params ? decodeParams(match.params) : void 0
+    };
+  }
+  async resolvePendingLazyRouters(pathname) {
+    if (!this.pendingLazyRouters.length) {
+      return;
+    }
+    const stillPending = [];
+    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);
+      }
+    }
+    this.pendingLazyRouters = stillPending;
+  }
+  async resolveProcedure(entry) {
+    if (entry.procedure) {
+      return entry.procedure;
+    }
+    const { default: maybeProcedure } = await unlazy(getRouter(this.rootRouter, entry.path));
+    if (!(maybeProcedure instanceof Procedure)) {
+      throw new TypeError(
+        `[Contract-First] Missing or invalid implementation for procedure at path: "${entry.path.join(".")}". Ensure the procedure is correctly implemented and matches its contract.`
+      );
+    }
+    entry.procedure = createContractProcedure(maybeProcedure, entry.contract);
+    return entry.procedure;
+  }
+}
+function toRou3Pattern(path) {
+  const params = getDynamicPathParams(path);
+  if (!params?.length) {
+    return path;
+  }
+  for (let i = params.length - 1; i >= 0; i--) {
+    const param = params[i];
+    const pattern = param.allowsSlash ? `**:${param.parameterName}` : `:${param.parameterName}`;
+    path = path.slice(0, param.startIndex) + pattern + path.slice(param.startIndex + param.segment.length);
+  }
+  return path;
+}
+function toRou3PrefixMatcher(path) {
+  const pattern = toRou3Pattern(path);
+  return routeToRegExp(pattern === "/" ? "/**" : `${pattern}/**`);
+}
+function decodeParams(params) {
+  return Object.fromEntries(Object.entries(params).map(([key, val]) => [key, tryDecodeURIComponent(val)]));
+}
+
+class OpenAPIHandlerCodecCore {
+  serializer;
+  errorStatusMap;
+  customErrorResponseBodySerializer;
+  constructor(options = {}) {
+    this.serializer = options.serializer ?? new OpenAPISerializer();
+    this.errorStatusMap = options.errorStatusMap ?? COMMON_ERROR_STATUS_MAP;
+    this.customErrorResponseBodySerializer = options.customErrorResponseBodyEncoder;
+  }
+  async decodeInput(matched, request) {
+    const [_, search] = parseStandardUrl(request.url);
+    const meta = getOpenAPIMeta(matched.procedure);
+    const inputStructure = meta?.inputStructure ?? DEFAULT_OPENAPI_INPUT_STRUCTURE;
+    const params = this.deserializeParams(matched.params, meta?.paramsStyles);
+    const query = this.deserializeQuery(search, meta?.queryStyles);
+    if (inputStructure === "compact") {
+      const data = isBodylessMethod(request.method) ? query : this.serializer.deserialize(await request.resolveBody(meta?.requestBodyHint));
+      if (data === void 0) {
+        return params;
+      }
+      if (!params || Object.keys(params).length < 1) {
+        return data;
+      }
+      if (isPlainObject(data)) {
+        return {
+          ...params,
+          ...data
+        };
+      }
+      return data;
+    }
+    return {
+      params,
+      query,
+      headers: request.headers,
+      body: this.serializer.deserialize(await request.resolveBody(meta?.requestBodyHint))
+    };
+  }
+  /**
+   * @throws {TypeError} If `outputStructure` is "detailed" and the output doesn't match the expected structure.
+   */
+  encodeOutput(output, procedure, path) {
+    const meta = getOpenAPIMeta(procedure);
+    const successStatus = meta?.successStatus ?? DEFAULT_SUCCESS_STATUS;
+    const outputStructure = meta?.outputStructure ?? DEFAULT_OPENAPI_OUTPUT_STRUCTURE;
+    if (outputStructure === "compact") {
+      return {
+        status: successStatus,
+        headers: {},
+        body: this.serializer.serialize(output)
+      };
+    }
+    if (!isValidDetailedOutput(output)) {
+      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>)
+          - body (any)
+        \u2022 No extra keys allowed.
+
+        Actual value:
+          ${stringifyJSON(output)}
+      `);
+    }
+    return {
+      status: output.status ?? successStatus,
+      headers: output.headers ?? {},
+      body: this.serializer.serialize(output.body)
+    };
+  }
+  encodeError(error) {
+    const status = this.errorStatusMap[error.code] ?? DEFAULT_ERROR_STATUS;
+    return {
+      status,
+      headers: {},
+      body: this.serializer.serialize(this.customErrorResponseBodySerializer?.(error) ?? error.toJSON())
+    };
+  }
+  deserializeQuery(search, styles) {
+    const searchParams = new URLSearchParams(search);
+    const parsed = this.serializer.deserialize(searchParams);
+    if (!styles || !isPlainObject(parsed)) {
+      return parsed;
+    }
+    Object.entries(styles).forEach(([key, hint]) => {
+      if (hint === void 0) {
+        return;
+      }
+      const values = searchParams.getAll(key);
+      let parsedValue;
+      if (hint === "primitive") {
+        parsedValue = values.at(-1);
+      } else if (hint === "array") {
+        parsedValue = values;
+      } else if (hint === "comma-delimited-array") {
+        parsedValue = decodeDelimitedArray(values.at(-1), ",");
+      } else if (hint === "comma-delimited-object") {
+        parsedValue = decodeDelimitedObject(values.at(-1), ",");
+      } else if (hint === "space-delimited-array") {
+        parsedValue = decodeDelimitedArray(values.at(-1), " ");
+      } else if (hint === "space-delimited-object") {
+        parsedValue = decodeDelimitedObject(values.at(-1), " ");
+      } else if (hint === "pipe-delimited-array") {
+        parsedValue = decodeDelimitedArray(values.at(-1), "|");
+      } else if (hint === "pipe-delimited-object") {
+        parsedValue = decodeDelimitedObject(values.at(-1), "|");
+      } else {
+        const last = values.at(-1);
+        try {
+          parsedValue = parseEmptyableJSON(last);
+        } catch {
+          parsedValue = last;
+        }
+      }
+      parsed[key] = this.serializer.deserialize(parsedValue);
+    });
+    return parsed;
+  }
+  deserializeParams(params, styles) {
+    if (!params || !styles) {
+      return params;
+    }
+    const parsed = { ...params };
+    Object.entries(styles).forEach(([key, hint]) => {
+      if (hint === void 0 || hint === "primitive") {
+        return;
+      }
+      const value = params[key];
+      if (hint === "comma-delimited-array") {
+        parsed[key] = decodeDelimitedArray(value, ",");
+      } else {
+        parsed[key] = decodeDelimitedObject(value, ",");
+      }
+    });
+    return parsed;
+  }
+}
+class OpenAPIHandlerCodec extends OpenAPIHandlerCodecCore {
+  matcher;
+  constructor(router, options = {}) {
+    super(options);
+    this.matcher = new OpenAPIMatcher(router, options);
+  }
+  async resolveProcedure(request, options) {
+    const [pathname] = parseStandardUrl(request.url);
+    const matched = await this.matcher.match(request.method, pathname, options.prefix);
+    if (!matched) {
+      return void 0;
+    }
+    return {
+      procedure: matched.procedure,
+      path: matched.path,
+      decodeInput: () => this.decodeInput(matched, request)
+    };
+  }
+}
+function isValidDetailedOutput(output) {
+  if (!isTypescriptObject(output)) {
+    return false;
+  }
+  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)) {
+    return false;
+  }
+  if (output.headers !== void 0 && !isStandardHeaders(output.headers)) {
+    return false;
+  }
+  return true;
+}
+function decodeDelimitedArray(value, delimiter) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return value.split(delimiter);
+}
+function decodeDelimitedObject(value, delimiter) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const obj = new NullProtoObj();
+  const parts = value.split(delimiter);
+  for (let i = 0; i < parts.length; i += 2) {
+    const key = parts[i];
+    obj[key] = parts[i + 1];
+  }
+  return obj;
+}
+
+export { OpenAPIHandlerCodec as O, OpenAPIHandlerCodecCore as a, OpenAPIMatcher as b };