@orpc/openapi 0.0.0-next.4e27480 → 0.0.0-next.4f63ec1

package/dist/chunk-LPBZEW4B.js

@@ -0,0 +1,165 @@
+import {
+  standardizeHTTPPath
+} from "./chunk-XGHV4TH3.js";
+
+// src/adapters/standard/openapi-codec.ts
+import { OpenAPISerializer } from "@orpc/client/openapi";
+import { fallbackContractConfig } from "@orpc/contract";
+import { isObject } from "@orpc/shared";
+var OpenAPICodec = class {
+  serializer;
+  constructor(options) {
+    this.serializer = options?.serializer ?? new OpenAPISerializer();
+  }
+  async decode(request, params, procedure) {
+    const inputStructure = fallbackContractConfig("defaultInputStructure", procedure["~orpc"].route.inputStructure);
+    if (inputStructure === "compact") {
+      const data = request.method === "GET" ? this.serializer.deserialize(request.url.searchParams) : this.serializer.deserialize(await request.body());
+      if (data === void 0) {
+        return params;
+      }
+      if (isObject(data)) {
+        return {
+          ...params,
+          ...data
+        };
+      }
+      return data;
+    }
+    const deserializeSearchParams = () => {
+      return this.serializer.deserialize(request.url.searchParams);
+    };
+    return {
+      params,
+      get query() {
+        const value = deserializeSearchParams();
+        Object.defineProperty(this, "query", { value, writable: true });
+        return value;
+      },
+      set query(value) {
+        Object.defineProperty(this, "query", { value, writable: true });
+      },
+      headers: request.headers,
+      body: this.serializer.deserialize(await request.body())
+    };
+  }
+  encode(output, procedure) {
+    const successStatus = fallbackContractConfig("defaultSuccessStatus", procedure["~orpc"].route.successStatus);
+    const outputStructure = fallbackContractConfig("defaultOutputStructure", procedure["~orpc"].route.outputStructure);
+    if (outputStructure === "compact") {
+      return {
+        status: successStatus,
+        headers: {},
+        body: this.serializer.serialize(output)
+      };
+    }
+    if (!isObject(output)) {
+      throw new Error(
+        'Invalid output structure for "detailed" output. Expected format: { body: any, headers?: Record<string, string | string[] | undefined> }'
+      );
+    }
+    return {
+      status: successStatus,
+      headers: output.headers ?? {},
+      body: this.serializer.serialize(output.body)
+    };
+  }
+  encodeError(error) {
+    return {
+      status: error.status,
+      headers: {},
+      body: this.serializer.serialize(error.toJSON())
+    };
+  }
+};
+
+// src/adapters/standard/openapi-matcher.ts
+import { fallbackContractConfig as fallbackContractConfig2 } from "@orpc/contract";
+import { convertPathToHttpPath, createContractedProcedure, eachContractProcedure, getLazyRouterPrefix, getRouterChild, isProcedure, unlazy } from "@orpc/server";
+import { addRoute, createRouter, findRoute } from "rou3";
+var OpenAPIMatcher = class {
+  tree = createRouter();
+  ignoreUndefinedMethod;
+  constructor(options) {
+    this.ignoreUndefinedMethod = options?.ignoreUndefinedMethod ?? false;
+  }
+  pendingRouters = [];
+  init(router, path = []) {
+    const laziedOptions = eachContractProcedure({
+      router,
+      path
+    }, ({ path: path2, contract }) => {
+      if (!contract["~orpc"].route.method && this.ignoreUndefinedMethod) {
+        return;
+      }
+      const method = fallbackContractConfig2("defaultMethod", contract["~orpc"].route.method);
+      const httpPath = contract["~orpc"].route.path ? toRou3Pattern(contract["~orpc"].route.path) : convertPathToHttpPath(path2);
+      if (isProcedure(contract)) {
+        addRoute(this.tree, method, httpPath, {
+          path: path2,
+          contract,
+          procedure: contract,
+          // this mean dev not used contract-first so we can used contract as procedure directly
+          router
+        });
+      } else {
+        addRoute(this.tree, method, httpPath, {
+          path: path2,
+          contract,
+          procedure: void 0,
+          router
+        });
+      }
+    });
+    this.pendingRouters.push(...laziedOptions.map((option) => ({
+      ...option,
+      httpPathPrefix: convertPathToHttpPath(option.path),
+      laziedPrefix: getLazyRouterPrefix(option.lazied)
+    })));
+  }
+  async match(method, pathname) {
+    if (this.pendingRouters.length) {
+      const newPendingRouters = [];
+      for (const pendingRouter of this.pendingRouters) {
+        if (!pendingRouter.laziedPrefix || pathname.startsWith(pendingRouter.laziedPrefix) || pathname.startsWith(pendingRouter.httpPathPrefix)) {
+          const { default: router } = await unlazy(pendingRouter.lazied);
+          this.init(router, pendingRouter.path);
+        } else {
+          newPendingRouters.push(pendingRouter);
+        }
+      }
+      this.pendingRouters = newPendingRouters;
+    }
+    const match = findRoute(this.tree, method, pathname);
+    if (!match) {
+      return void 0;
+    }
+    if (!match.data.procedure) {
+      const { default: maybeProcedure } = await unlazy(getRouterChild(match.data.router, ...match.data.path));
+      if (!isProcedure(maybeProcedure)) {
+        throw new Error(`
+          [Contract-First] Missing or invalid implementation for procedure at path: ${convertPathToHttpPath(match.data.path)}.
+          Ensure that the procedure is correctly defined and matches the expected contract.
+        `);
+      }
+      match.data.procedure = createContractedProcedure(match.data.contract, maybeProcedure);
+    }
+    return {
+      path: match.data.path,
+      procedure: match.data.procedure,
+      params: match.params ? decodeParams(match.params) : void 0
+    };
+  }
+};
+function toRou3Pattern(path) {
+  return standardizeHTTPPath(path).replace(/\{\+([^}]+)\}/g, "**:$1").replace(/\{([^}]+)\}/g, ":$1");
+}
+function decodeParams(params) {
+  return Object.fromEntries(Object.entries(params).map(([key, value]) => [key, decodeURIComponent(value)]));
+}
+
+export {
+  OpenAPICodec,
+  OpenAPIMatcher
+};
+//# sourceMappingURL=chunk-LPBZEW4B.js.map

package/dist/chunk-UU2TTVB2.js

@@ -0,0 +1,32 @@
+import {
+  OpenAPICodec,
+  OpenAPIMatcher
+} from "./chunk-LPBZEW4B.js";
+
+// src/adapters/fetch/openapi-handler.ts
+import { toFetchResponse, toStandardRequest } from "@orpc/server-standard-fetch";
+import { StandardHandler } from "@orpc/server/standard";
+var OpenAPIHandler = class {
+  standardHandler;
+  constructor(router, options) {
+    const matcher = options?.matcher ?? new OpenAPIMatcher(options);
+    const codec = options?.codec ?? new OpenAPICodec(options);
+    this.standardHandler = new StandardHandler(router, matcher, codec, options);
+  }
+  async handle(request, ...rest) {
+    const standardRequest = toStandardRequest(request);
+    const result = await this.standardHandler.handle(standardRequest, ...rest);
+    if (!result.matched) {
+      return result;
+    }
+    return {
+      matched: true,
+      response: toFetchResponse(result.response)
+    };
+  }
+};
+
+export {
+  OpenAPIHandler
+};
+//# sourceMappingURL=chunk-UU2TTVB2.js.map

package/dist/chunk-XGHV4TH3.js

@@ -0,0 +1,13 @@
+// src/utils.ts
+function standardizeHTTPPath(path) {
+  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
+}
+function toOpenAPI31RoutePattern(path) {
+  return standardizeHTTPPath(path).replace(/\{\+([^}]+)\}/g, "{$1}");
+}
+
+export {
+  standardizeHTTPPath,
+  toOpenAPI31RoutePattern
+};
+//# sourceMappingURL=chunk-XGHV4TH3.js.map

package/dist/fetch.js

@@ -1,34 +1,9 @@
 import {
-  OpenAPIServerHandler,
-  OpenAPIServerlessHandler
-} from "./chunk-GEDPF5HA.js";
-import {
-  CompositeSchemaCoercer,
-  InputStructureCompact,
-  InputStructureDetailed,
-  OpenAPIHandler,
-  OpenAPIPayloadCodec,
-  OpenAPIProcedureMatcher,
-  deserialize,
-  escapeSegment,
-  parsePath,
-  serialize,
-  stringifyPath
-} from "./chunk-UG6W4GSA.js";
-import "./chunk-V4HFPIEN.js";
+  OpenAPIHandler
+} from "./chunk-UU2TTVB2.js";
+import "./chunk-LPBZEW4B.js";
+import "./chunk-XGHV4TH3.js";
 export {
-  CompositeSchemaCoercer,
-  InputStructureCompact,
-  InputStructureDetailed,
-  OpenAPIHandler,
-  OpenAPIPayloadCodec,
-  OpenAPIProcedureMatcher,
-  OpenAPIServerHandler,
-  OpenAPIServerlessHandler,
-  deserialize,
-  escapeSegment,
-  parsePath,
-  serialize,
-  stringifyPath
+  OpenAPIHandler
 };
 //# sourceMappingURL=fetch.js.map

package/dist/hono.js

@@ -1,34 +1,9 @@
 import {
-  OpenAPIServerHandler,
-  OpenAPIServerlessHandler
-} from "./chunk-GEDPF5HA.js";
-import {
-  CompositeSchemaCoercer,
-  InputStructureCompact,
-  InputStructureDetailed,
-  OpenAPIHandler,
-  OpenAPIPayloadCodec,
-  OpenAPIProcedureMatcher,
-  deserialize,
-  escapeSegment,
-  parsePath,
-  serialize,
-  stringifyPath
-} from "./chunk-UG6W4GSA.js";
-import "./chunk-V4HFPIEN.js";
+  OpenAPIHandler
+} from "./chunk-UU2TTVB2.js";
+import "./chunk-LPBZEW4B.js";
+import "./chunk-XGHV4TH3.js";
 export {
-  CompositeSchemaCoercer,
-  InputStructureCompact,
-  InputStructureDetailed,
-  OpenAPIHandler,
-  OpenAPIPayloadCodec,
-  OpenAPIProcedureMatcher,
-  OpenAPIServerHandler,
-  OpenAPIServerlessHandler,
-  deserialize,
-  escapeSegment,
-  parsePath,
-  serialize,
-  stringifyPath
+  OpenAPIHandler
 };
 //# sourceMappingURL=hono.js.map

package/dist/index.js

@@ -1,9 +1,53 @@
 import {
-  JSONSerializer,
-  forEachAllContractProcedure,
-  forEachContractProcedure,
-  standardizeHTTPPath
-} from "./chunk-V4HFPIEN.js";
+  standardizeHTTPPath,
+  toOpenAPI31RoutePattern
+} from "./chunk-XGHV4TH3.js";
+
+// src/openapi-operation-extender.ts
+import { isProcedure } from "@orpc/server";
+var OPERATION_EXTENDER_SYMBOL = Symbol("ORPC_OPERATION_EXTENDER");
+function setOperationExtender(o, extend) {
+  return new Proxy(o, {
+    get(target, prop, receiver) {
+      if (prop === OPERATION_EXTENDER_SYMBOL) {
+        return extend;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function getOperationExtender(o) {
+  return o[OPERATION_EXTENDER_SYMBOL];
+}
+function extendOperation(operation, procedure) {
+  const operationExtenders = [];
+  for (const errorItem of Object.values(procedure["~orpc"].errorMap)) {
+    const maybeExtender = getOperationExtender(errorItem);
+    if (maybeExtender) {
+      operationExtenders.push(maybeExtender);
+    }
+  }
+  if (isProcedure(procedure)) {
+    for (const middleware of procedure["~orpc"].middlewares) {
+      const maybeExtender = getOperationExtender(middleware);
+      if (maybeExtender) {
+        operationExtenders.push(maybeExtender);
+      }
+    }
+  }
+  let currentOperation = operation;
+  for (const extender of operationExtenders) {
+    if (typeof extender === "function") {
+      currentOperation = extender(currentOperation, procedure);
+    } else {
+      currentOperation = {
+        ...currentOperation,
+        ...extender
+      };
+    }
+  }
+  return currentOperation;
+}
 
 // src/openapi.ts
 import { OpenApiBuilder } from "openapi3-ts/oas31";
@@ -36,7 +80,10 @@ var OpenAPIContentBuilder = class {
 };
 
 // src/openapi-generator.ts
-import { fallbackContractConfig as fallbackContractConfig2, fallbackORPCErrorStatus } from "@orpc/contract";
+import { fallbackORPCErrorStatus } from "@orpc/client";
+import { OpenAPIJsonSerializer } from "@orpc/client/openapi";
+import { fallbackContractConfig as fallbackContractConfig2, getEventIteratorSchemaDetails } from "@orpc/contract";
+import { eachAllContractProcedure } from "@orpc/server";
 import { group } from "@orpc/shared";
 
 // src/openapi-error.ts
@@ -52,7 +99,7 @@ var OpenAPIInputStructureParser = class {
     this.pathParser = pathParser;
   }
   parse(contract, structure) {
-    const inputSchema = this.schemaConverter.convert(contract["~orpc"].InputSchema, { strategy: "input" });
+    const inputSchema = this.schemaConverter.convert(contract["~orpc"].inputSchema, { strategy: "input" });
     const method = fallbackContractConfig("defaultMethod", contract["~orpc"].route?.method);
     const httpPath = contract["~orpc"].route?.path;
     if (this.schemaUtils.isAnySchema(inputSchema)) {
@@ -145,7 +192,7 @@ var OpenAPIOutputStructureParser = class {
     this.schemaUtils = schemaUtils;
   }
   parse(contract, structure) {
-    const outputSchema = this.schemaConverter.convert(contract["~orpc"].OutputSchema, { strategy: "output" });
+    const outputSchema = this.schemaConverter.convert(contract["~orpc"].outputSchema, { strategy: "output" });
     if (this.schemaUtils.isAnySchema(outputSchema)) {
       return {
         headersSchema: void 0,
@@ -184,14 +231,14 @@ var OpenAPIOutputStructureParser = class {
 };
 
 // src/openapi-parameters-builder.ts
-import { get, isPlainObject, omit } from "@orpc/shared";
+import { get, isObject, omit } from "@orpc/shared";
 var OpenAPIParametersBuilder = class {
   build(paramIn, jsonSchema, options) {
     const parameters = [];
     for (const name in jsonSchema.properties) {
       const schema = jsonSchema.properties[name];
       const paramExamples = jsonSchema.examples?.filter((example) => {
-        return isPlainObject(example) && name in example;
+        return isObject(example) && name in example;
       }).map((example) => {
         return example[name];
       });
@@ -252,7 +299,7 @@ var CompositeSchemaConverter = class {
 };
 
 // src/schema-utils.ts
-import { isPlainObject as isPlainObject2 } from "@orpc/shared";
+import { isObject as isObject2 } from "@orpc/shared";
 
 // src/schema.ts
 import * as JSONSchema from "json-schema-typed/draft-2020-12";
@@ -314,7 +361,7 @@ var SchemaUtils = class {
     }, {});
     matched.required = schema.required?.filter((key) => separatedProperties.includes(key));
     matched.examples = schema.examples?.map((example) => {
-      if (!isPlainObject2(example)) {
+      if (!isObject2(example)) {
         return example;
       }
       return Object.entries(example).reduce((acc, [key, value]) => {
@@ -330,7 +377,7 @@ var SchemaUtils = class {
     }, {});
     rest.required = schema.required?.filter((key) => !separatedProperties.includes(key));
     rest.examples = schema.examples?.map((example) => {
-      if (!isPlainObject2(example)) {
+      if (!isObject2(example)) {
         return example;
       }
       return Object.entries(example).reduce((acc, [key, value]) => {
@@ -390,7 +437,7 @@ var OpenAPIGenerator = class {
     this.parametersBuilder = options?.parametersBuilder ?? new OpenAPIParametersBuilder();
     this.schemaConverter = new CompositeSchemaConverter(options?.schemaConverters ?? []);
     this.schemaUtils = options?.schemaUtils ?? new SchemaUtils();
-    this.jsonSerializer = options?.jsonSerializer ?? new JSONSerializer();
+    this.jsonSerializer = options?.jsonSerializer ?? new OpenAPIJsonSerializer();
     this.contentBuilder = options?.contentBuilder ?? new OpenAPIContentBuilder(this.schemaUtils);
     this.pathParser = new OpenAPIPathParser();
     this.inputStructureParser = options?.inputStructureParser ?? new OpenAPIInputStructureParser(this.schemaConverter, this.schemaUtils, this.pathParser);
@@ -406,38 +453,134 @@ var OpenAPIGenerator = class {
       openapi: "3.1.1"
     });
     const rootTags = doc.tags?.map((tag) => tag.name) ?? [];
-    await forEachAllContractProcedure(router, ({ contract, path }) => {
+    await eachAllContractProcedure({
+      path: [],
+      router
+    }, ({ contract, path }) => {
       try {
         const def = contract["~orpc"];
         if (this.ignoreUndefinedPathProcedures && def.route?.path === void 0) {
           return;
         }
         const method = fallbackContractConfig2("defaultMethod", def.route?.method);
-        const httpPath = def.route?.path ? standardizeHTTPPath(def.route?.path) : `/${path.map(encodeURIComponent).join("/")}`;
-        const inputStructure = fallbackContractConfig2("defaultInputStructure", def.route?.inputStructure);
-        const outputStructure = fallbackContractConfig2("defaultOutputStructure", def.route?.outputStructure);
-        const { paramsSchema, querySchema, headersSchema, bodySchema } = this.inputStructureParser.parse(contract, inputStructure);
-        const { headersSchema: resHeadersSchema, bodySchema: resBodySchema } = this.outputStructureParser.parse(contract, outputStructure);
-        const params = paramsSchema ? this.parametersBuilder.build("path", paramsSchema, {
-          required: true
-        }) : [];
-        const query = querySchema ? this.parametersBuilder.build("query", querySchema) : [];
-        const headers = headersSchema ? this.parametersBuilder.build("header", headersSchema) : [];
-        const parameters = [...params, ...query, ...headers];
-        const requestBody = bodySchema !== void 0 ? {
-          required: this.schemaUtils.isUndefinableSchema(bodySchema),
-          content: this.contentBuilder.build(bodySchema)
-        } : void 0;
-        const responses = {};
-        responses[fallbackContractConfig2("defaultSuccessStatus", def.route?.successStatus)] = {
-          description: fallbackContractConfig2("defaultSuccessDescription", def.route?.successDescription),
-          content: resBodySchema !== void 0 ? this.contentBuilder.build(resBodySchema, {
-            example: def.outputExample
-          }) : void 0,
-          headers: resHeadersSchema !== void 0 ? this.parametersBuilder.buildHeadersObject(resHeadersSchema, {
-            example: def.outputExample
-          }) : void 0
-        };
+        const httpPath = def.route?.path ? toOpenAPI31RoutePattern(def.route?.path) : `/${path.map(encodeURIComponent).join("/")}`;
+        const { parameters, requestBody } = (() => {
+          const eventIteratorSchemaDetails = getEventIteratorSchemaDetails(def.inputSchema);
+          if (eventIteratorSchemaDetails) {
+            const requestBody3 = {
+              required: true,
+              content: {
+                "text/event-stream": {
+                  schema: {
+                    oneOf: [
+                      {
+                        type: "object",
+                        properties: {
+                          event: { type: "string", const: "message" },
+                          data: this.schemaConverter.convert(eventIteratorSchemaDetails.yields, { strategy: "input" }),
+                          id: { type: "string" },
+                          retry: { type: "number" }
+                        },
+                        required: ["event", "data"]
+                      },
+                      {
+                        type: "object",
+                        properties: {
+                          event: { type: "string", const: "done" },
+                          data: this.schemaConverter.convert(eventIteratorSchemaDetails.returns, { strategy: "input" }),
+                          id: { type: "string" },
+                          retry: { type: "number" }
+                        },
+                        required: ["event", "data"]
+                      },
+                      {
+                        type: "object",
+                        properties: {
+                          event: { type: "string", const: "error" },
+                          data: {},
+                          id: { type: "string" },
+                          retry: { type: "number" }
+                        },
+                        required: ["event", "data"]
+                      }
+                    ]
+                  }
+                }
+              }
+            };
+            return { requestBody: requestBody3, parameters: [] };
+          }
+          const inputStructure = fallbackContractConfig2("defaultInputStructure", def.route?.inputStructure);
+          const { paramsSchema, querySchema, headersSchema, bodySchema } = this.inputStructureParser.parse(contract, inputStructure);
+          const params = paramsSchema ? this.parametersBuilder.build("path", paramsSchema, {
+            required: true
+          }) : [];
+          const query = querySchema ? this.parametersBuilder.build("query", querySchema) : [];
+          const headers = headersSchema ? this.parametersBuilder.build("header", headersSchema) : [];
+          const parameters2 = [...params, ...query, ...headers];
+          const requestBody2 = bodySchema !== void 0 ? {
+            required: this.schemaUtils.isUndefinableSchema(bodySchema),
+            content: this.contentBuilder.build(bodySchema)
+          } : void 0;
+          return { parameters: parameters2, requestBody: requestBody2 };
+        })();
+        const { responses } = (() => {
+          const eventIteratorSchemaDetails = getEventIteratorSchemaDetails(def.outputSchema);
+          if (eventIteratorSchemaDetails) {
+            const responses3 = {};
+            responses3[fallbackContractConfig2("defaultSuccessStatus", def.route?.successStatus)] = {
+              description: fallbackContractConfig2("defaultSuccessDescription", def.route?.successDescription),
+              content: {
+                "text/event-stream": {
+                  schema: {
+                    oneOf: [
+                      {
+                        type: "object",
+                        properties: {
+                          event: { type: "string", const: "message" },
+                          data: this.schemaConverter.convert(eventIteratorSchemaDetails.yields, { strategy: "input" }),
+                          id: { type: "string" },
+                          retry: { type: "number" }
+                        },
+                        required: ["event", "data"]
+                      },
+                      {
+                        type: "object",
+                        properties: {
+                          event: { type: "string", const: "done" },
+                          data: this.schemaConverter.convert(eventIteratorSchemaDetails.returns, { strategy: "input" }),
+                          id: { type: "string" },
+                          retry: { type: "number" }
+                        },
+                        required: ["event", "data"]
+                      },
+                      {
+                        type: "object",
+                        properties: {
+                          event: { type: "string", const: "error" },
+                          data: {},
+                          id: { type: "string" },
+                          retry: { type: "number" }
+                        },
+                        required: ["event", "data"]
+                      }
+                    ]
+                  }
+                }
+              }
+            };
+            return { responses: responses3 };
+          }
+          const outputStructure = fallbackContractConfig2("defaultOutputStructure", def.route?.outputStructure);
+          const { headersSchema: resHeadersSchema, bodySchema: resBodySchema } = this.outputStructureParser.parse(contract, outputStructure);
+          const responses2 = {};
+          responses2[fallbackContractConfig2("defaultSuccessStatus", def.route?.successStatus)] = {
+            description: fallbackContractConfig2("defaultSuccessDescription", def.route?.successDescription),
+            content: resBodySchema !== void 0 ? this.contentBuilder.build(resBodySchema) : void 0,
+            headers: resHeadersSchema !== void 0 ? this.parametersBuilder.buildHeadersObject(resHeadersSchema) : void 0
+          };
+          return { responses: responses2 };
+        })();
         const errors = group(Object.entries(def.errorMap ?? {}).filter(([_, config]) => config).map(([code, config]) => ({
           ...config,
           code,
@@ -508,8 +651,9 @@ var OpenAPIGenerator = class {
           requestBody,
           responses
         };
+        const extendedOperation = extendOperation(operation, contract);
         builder.addPath(httpPath, {
-          [method.toLocaleLowerCase()]: operation
+          [method.toLocaleLowerCase()]: extendedOperation
         });
       } catch (e) {
         if (e instanceof OpenAPIError) {
@@ -531,11 +675,15 @@ var OpenAPIGenerator = class {
     return this.jsonSerializer.serialize(builder.getSpec());
   }
 };
+
+// src/index.ts
+var oo = {
+  spec: setOperationExtender
+};
 export {
   CompositeSchemaConverter,
   JSONSchema,
   Format as JSONSchemaFormat,
-  JSONSerializer,
   NON_LOGIC_KEYWORDS,
   OpenAPIContentBuilder,
   OpenAPIGenerator,
@@ -543,8 +691,11 @@ export {
   OpenAPIPathParser,
   OpenApiBuilder,
   SchemaUtils,
-  forEachAllContractProcedure,
-  forEachContractProcedure,
-  standardizeHTTPPath
+  extendOperation,
+  getOperationExtender,
+  oo,
+  setOperationExtender,
+  standardizeHTTPPath,
+  toOpenAPI31RoutePattern
 };
 //# sourceMappingURL=index.js.map

package/dist/next.js

@@ -1,34 +1,9 @@
 import {
-  OpenAPIServerHandler,
-  OpenAPIServerlessHandler
-} from "./chunk-GEDPF5HA.js";
-import {
-  CompositeSchemaCoercer,
-  InputStructureCompact,
-  InputStructureDetailed,
-  OpenAPIHandler,
-  OpenAPIPayloadCodec,
-  OpenAPIProcedureMatcher,
-  deserialize,
-  escapeSegment,
-  parsePath,
-  serialize,
-  stringifyPath
-} from "./chunk-UG6W4GSA.js";
-import "./chunk-V4HFPIEN.js";
+  OpenAPIHandler
+} from "./chunk-UU2TTVB2.js";
+import "./chunk-LPBZEW4B.js";
+import "./chunk-XGHV4TH3.js";
 export {
-  CompositeSchemaCoercer,
-  InputStructureCompact,
-  InputStructureDetailed,
-  OpenAPIHandler,
-  OpenAPIPayloadCodec,
-  OpenAPIProcedureMatcher,
-  OpenAPIServerHandler,
-  OpenAPIServerlessHandler,
-  deserialize,
-  escapeSegment,
-  parsePath,
-  serialize,
-  stringifyPath
+  OpenAPIHandler
 };
 //# sourceMappingURL=next.js.map