@orpc/openapi 0.12.0 → 0.14.0

package/dist/chunk-KZIT2WCV.js

@@ -0,0 +1,49 @@
+// src/utils.ts
+import { isContractProcedure } from "@orpc/contract";
+import { isLazy, isProcedure, ROUTER_CONTRACT_SYMBOL } from "@orpc/server";
+function eachContractProcedureLeaf(options, callback, result = [], isCurrentRouterContract = false) {
+  if (!isCurrentRouterContract && ROUTER_CONTRACT_SYMBOL in options.router && options.router[ROUTER_CONTRACT_SYMBOL]) {
+    return eachContractProcedureLeaf(
+      {
+        path: options.path,
+        router: options.router[ROUTER_CONTRACT_SYMBOL]
+      },
+      callback,
+      result,
+      true
+    );
+  }
+  if (isLazy(options.router)) {
+    result.push({
+      lazy: options.router,
+      path: options.path
+    });
+  } else if (isProcedure(options.router)) {
+    callback({
+      contract: options.router.zz$p.contract,
+      path: options.path
+    });
+  } else if (isContractProcedure(options.router)) {
+    callback({
+      contract: options.router,
+      path: options.path
+    });
+  } else {
+    for (const key in options.router) {
+      eachContractProcedureLeaf(
+        {
+          router: options.router[key],
+          path: [...options.path, key]
+        },
+        callback,
+        result
+      );
+    }
+  }
+  return result;
+}
+
+export {
+  eachContractProcedureLeaf
+};
+//# sourceMappingURL=chunk-KZIT2WCV.js.map

package/dist/fetch.js

@@ -1,7 +1,11 @@
+import {
+  eachContractProcedureLeaf
+} from "./chunk-KZIT2WCV.js";
+
 // src/fetch/base-handler.ts
 import { ORPC_HEADER, standardizeHTTPPath } from "@orpc/contract";
-import { createProcedureCaller, isProcedure, ORPCError } from "@orpc/server";
-import { isPlainObject, mapValues, trim, value } from "@orpc/shared";
+import { createProcedureCaller, isLazy, isProcedure, LAZY_LOADER_SYMBOL, LAZY_ROUTER_PREFIX_SYMBOL, ORPCError } from "@orpc/server";
+import { executeWithHooks, isPlainObject, mapValues, trim, value } from "@orpc/shared";
 import { OpenAPIDeserializer, OpenAPISerializer, zodCoerce } from "@orpc/transformer";
 function createOpenAPIHandler(createHonoRouter) {
   const resolveRouter = createResolveRouter(createHonoRouter);
@@ -17,12 +21,18 @@ function createOpenAPIHandler(createHonoRouter) {
       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 = resolveRouter(options.router, method, pathname);
+      const match = await resolveRouter(options.router, method, pathname);
       if (!match) {
         throw new ORPCError({ code: "NOT_FOUND", message: "Not found" });
       }
-      const procedure = match.procedure;
+      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.zz$cp.InputSchema ? zodCoerce(
         procedure.zz$p.contract.zz$cp.InputSchema,
         match.params,
@@ -43,10 +53,13 @@ function createOpenAPIHandler(createHonoRouter) {
       });
     };
     try {
-      return await options.hooks?.(context, {
-        next: handler,
-        response: (response) => response
-      }) ?? await handler();
+      return await executeWithHooks({
+        context,
+        hooks: options,
+        execute: handler,
+        input: options.request,
+        meta: void 0
+      });
     } catch (e) {
       const error = toORPCError(e);
       try {
@@ -69,27 +82,44 @@ function createOpenAPIHandler(createHonoRouter) {
   };
 }
 var routingCache = /* @__PURE__ */ new Map();
+var pendingCache = /* @__PURE__ */ new Map();
 function createResolveRouter(createHonoRouter) {
-  return (router, method, pathname) => {
-    let routing = routingCache.get(router);
-    if (!routing) {
-      routing = createHonoRouter();
-      const addRouteRecursively = (routing2, router2, basePath) => {
-        for (const key in router2) {
-          const currentPath = [...basePath, key];
-          const item = router2[key];
-          if (isProcedure(item)) {
-            const method2 = item.zz$p.contract.zz$cp.method ?? "POST";
-            const path2 = item.zz$p.contract.zz$cp.path ? openAPIPathToRouterPath(item.zz$p.contract.zz$cp.path) : `/${currentPath.map(encodeURIComponent).join("/")}`;
-            routing2.add(method2, path2, [currentPath, item]);
-          } else {
-            addRouteRecursively(routing2, item, currentPath);
-          }
-        }
-      };
-      addRouteRecursively(routing, router, []);
-      routingCache.set(router, routing);
+  const addRoutes = (routing, pending, options) => {
+    const lazies = eachContractProcedureLeaf(options, ({ path, contract }) => {
+      const method = contract.zz$cp.method ?? "POST";
+      const httpPath = contract.zz$cp.path ? openAPIPathToRouterPath(contract.zz$cp.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 });
     }
+    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;
@@ -97,18 +127,25 @@ function createResolveRouter(createHonoRouter) {
     if (!match) {
       return void 0;
     }
-    const path = match[0][0];
-    const procedure = match[0][1];
+    const path = match[0];
     const params = params_ ? mapValues(
       match[1],
       (v) => params_[v]
     ) : match[1];
-    return {
+    let current = router;
+    for (const segment of path) {
+      if (typeof current !== "object" && typeof current !== "function" || !current) {
+        current = void 0;
+        break;
+      }
+      current = current[segment];
+    }
+    return isProcedure(current) || isLazy(current) ? {
       path,
-      procedure,
+      procedure: current,
       params: { ...params }
       // params from hono not a normal object, so we need spread here
-    };
+    } : void 0;
   };
 }
 function mergeParamsAndInput(coercedParams, input) {
@@ -666,3 +703,4 @@ export {
   createResolveRouter,
   openAPIPathToRouterPath
 };
+//# sourceMappingURL=fetch.js.map

package/dist/index.js

@@ -1,6 +1,10 @@
+import {
+  eachContractProcedureLeaf
+} from "./chunk-KZIT2WCV.js";
+
 // src/generator.ts
-import { eachContractRouterLeaf } from "@orpc/contract";
-import { toContractRouter } from "@orpc/server";
+import { isContractProcedure } from "@orpc/contract";
+import { LAZY_LOADER_SYMBOL } from "@orpc/server";
 import { findDeepMatches, isPlainObject, omit } from "@orpc/shared";
 import { preSerialize } from "@orpc/transformer";
 import {
@@ -4210,7 +4214,7 @@ function extractJSONSchema(schema, check, matches = []) {
 }
 
 // src/generator.ts
-function generateOpenAPI(opts, options) {
+async function generateOpenAPI(opts, options) {
   const throwOnMissingTagDefinition = options?.throwOnMissingTagDefinition ?? false;
   const ignoreUndefinedPathProcedures = options?.ignoreUndefinedPathProcedures ?? false;
   const builder = new OpenApiBuilder({
@@ -4218,197 +4222,212 @@ function generateOpenAPI(opts, options) {
     openapi: "3.1.0"
   });
   const rootTags = opts.tags?.map((tag) => tag.name) ?? [];
-  const router = toContractRouter(opts.router);
-  eachContractRouterLeaf(router, (procedure, path_) => {
-    const internal = procedure.zz$cp;
-    if (ignoreUndefinedPathProcedures && internal.path === void 0) {
-      return;
-    }
-    const path = internal.path ?? `/${path_.map(encodeURIComponent).join("/")}`;
-    const method = internal.method ?? "POST";
-    let inputSchema = internal.InputSchema ? zodToJsonSchema(internal.InputSchema, { mode: "input" }) : {};
-    const outputSchema = internal.OutputSchema ? zodToJsonSchema(internal.OutputSchema, { mode: "output" }) : {};
-    const params = (() => {
-      const names = path.match(/\{([^}]+)\}/g);
-      if (!names || !names.length) {
-        return void 0;
+  const pending = [{
+    path: [],
+    router: opts.router
+  }];
+  for (const item of pending) {
+    const lazies = eachContractProcedureLeaf(item, ({ contract, path }) => {
+      if (!isContractProcedure(contract)) {
+        return;
       }
-      if (typeof inputSchema !== "object" || inputSchema.type !== "object") {
-        throw new Error(
-          `When path has parameters, input schema must be an object [${path_.join(".")}]`
-        );
+      const internal = contract.zz$cp;
+      if (ignoreUndefinedPathProcedures && internal.path === void 0) {
+        return;
       }
-      return names.map((raw) => raw.slice(1, -1)).map((name) => {
-        let schema = inputSchema.properties?.[name];
-        const required = inputSchema.required?.includes(name);
-        if (schema === void 0) {
-          throw new Error(
-            `Parameter ${name} is missing in input schema [${path_.join(".")}]`
-          );
+      const httpPath = internal.path ?? `/${path.map(encodeURIComponent).join("/")}`;
+      const method = internal.method ?? "POST";
+      let inputSchema = internal.InputSchema ? zodToJsonSchema(internal.InputSchema, { mode: "input" }) : {};
+      const outputSchema = internal.OutputSchema ? zodToJsonSchema(internal.OutputSchema, { mode: "output" }) : {};
+      const params = (() => {
+        const names = httpPath.match(/\{([^}]+)\}/g);
+        if (!names || !names.length) {
+          return void 0;
         }
-        if (!required) {
+        if (typeof inputSchema !== "object" || inputSchema.type !== "object") {
           throw new Error(
-            `Parameter ${name} must be required in input schema [${path_.join(".")}]`
+            `When path has parameters, input schema must be an object [${path.join(".")}]`
           );
         }
-        const examples = inputSchema.examples?.filter((example) => {
-          return isPlainObject(example) && name in example;
-        }).map((example) => {
-          return example[name];
-        });
-        schema = {
-          examples: examples?.length ? examples : void 0,
-          ...schema === true ? {} : schema === false ? UNSUPPORTED_JSON_SCHEMA : schema
-        };
-        inputSchema = {
-          ...inputSchema,
-          properties: inputSchema.properties ? Object.entries(inputSchema.properties).reduce(
-            (acc, [key, value]) => {
-              if (key !== name) {
-                acc[key] = value;
-              }
-              return acc;
-            },
-            {}
-          ) : void 0,
-          required: inputSchema.required?.filter((v) => v !== name),
-          examples: inputSchema.examples?.map((example) => {
-            if (!isPlainObject(example))
-              return example;
-            return Object.entries(example).reduce(
-              (acc, [key, value]) => {
-                if (key !== name) {
-                  acc[key] = value;
-                }
-                return acc;
-              },
-              {}
+        return names.map((raw) => raw.slice(1, -1)).map((name) => {
+          let schema = inputSchema.properties?.[name];
+          const required = inputSchema.required?.includes(name);
+          if (schema === void 0) {
+            throw new Error(
+              `Parameter ${name} is missing in input schema [${path.join(".")}]`
             );
-          })
-        };
-        return {
-          name,
-          in: "path",
-          required: true,
-          schema,
-          example: internal.inputExample?.[name]
-        };
-      });
-    })();
-    const query = (() => {
-      if (method !== "GET" || Object.keys(inputSchema).length === 0) {
-        return void 0;
-      }
-      if (typeof inputSchema !== "object" || inputSchema.type !== "object") {
-        throw new Error(
-          `When method is GET, input schema must be an object [${path_.join(".")}]`
-        );
-      }
-      return Object.entries(inputSchema.properties ?? {}).map(
-        ([name, schema]) => {
+          }
+          if (!required) {
+            throw new Error(
+              `Parameter ${name} must be required in input schema [${path.join(".")}]`
+            );
+          }
           const examples = inputSchema.examples?.filter((example) => {
             return isPlainObject(example) && name in example;
           }).map((example) => {
             return example[name];
           });
-          const schema_ = {
+          schema = {
             examples: examples?.length ? examples : void 0,
             ...schema === true ? {} : schema === false ? UNSUPPORTED_JSON_SCHEMA : schema
           };
+          inputSchema = {
+            ...inputSchema,
+            properties: inputSchema.properties ? Object.entries(inputSchema.properties).reduce(
+              (acc, [key, value]) => {
+                if (key !== name) {
+                  acc[key] = value;
+                }
+                return acc;
+              },
+              {}
+            ) : void 0,
+            required: inputSchema.required?.filter((v) => v !== name),
+            examples: inputSchema.examples?.map((example) => {
+              if (!isPlainObject(example))
+                return example;
+              return Object.entries(example).reduce(
+                (acc, [key, value]) => {
+                  if (key !== name) {
+                    acc[key] = value;
+                  }
+                  return acc;
+                },
+                {}
+              );
+            })
+          };
           return {
             name,
-            in: "query",
-            style: "deepObject",
-            required: inputSchema?.required?.includes(name) ?? false,
-            schema: schema_,
+            in: "path",
+            required: true,
+            schema,
             example: internal.inputExample?.[name]
           };
+        });
+      })();
+      const query = (() => {
+        if (method !== "GET" || Object.keys(inputSchema).length === 0) {
+          return void 0;
         }
-      );
-    })();
-    const parameters = [...params ?? [], ...query ?? []];
-    const requestBody = (() => {
-      if (method === "GET") {
-        return void 0;
-      }
-      const { schema, matches } = extractJSONSchema(inputSchema, isFileSchema);
-      const files = matches;
-      const isStillHasFileSchema = findDeepMatches(isFileSchema, schema).values.length > 0;
-      if (files.length) {
-        parameters.push({
-          name: "content-disposition",
-          in: "header",
-          required: schema === void 0,
-          schema: {
-            type: "string",
-            pattern: "filename",
-            example: 'filename="file.png"',
-            description: "To define the file name. Required when the request body is a file."
+        if (typeof inputSchema !== "object" || inputSchema.type !== "object") {
+          throw new Error(
+            `When method is GET, input schema must be an object [${path.join(".")}]`
+          );
+        }
+        return Object.entries(inputSchema.properties ?? {}).map(
+          ([name, schema]) => {
+            const examples = inputSchema.examples?.filter((example) => {
+              return isPlainObject(example) && name in example;
+            }).map((example) => {
+              return example[name];
+            });
+            const schema_ = {
+              examples: examples?.length ? examples : void 0,
+              ...schema === true ? {} : schema === false ? UNSUPPORTED_JSON_SCHEMA : schema
+            };
+            return {
+              name,
+              in: "query",
+              style: "deepObject",
+              required: inputSchema?.required?.includes(name) ?? false,
+              schema: schema_,
+              example: internal.inputExample?.[name]
+            };
           }
-        });
-      }
-      const content = {};
-      for (const file of files) {
-        content[file.contentMediaType] = {
-          schema: file
-        };
-      }
-      if (schema !== void 0) {
-        content[isStillHasFileSchema ? "multipart/form-data" : "application/json"] = {
-          schema,
-          example: internal.inputExample
-        };
-      }
-      return {
-        required: Boolean(internal.InputSchema?.isOptional()),
-        content
-      };
-    })();
-    const successResponse = (() => {
-      const { schema, matches } = extractJSONSchema(outputSchema, isFileSchema);
-      const files = matches;
-      const isStillHasFileSchema = findDeepMatches(isFileSchema, schema).values.length > 0;
-      const content = {};
-      for (const file of files) {
-        content[file.contentMediaType] = {
-          schema: file
+        );
+      })();
+      const parameters = [...params ?? [], ...query ?? []];
+      const requestBody = (() => {
+        if (method === "GET") {
+          return void 0;
+        }
+        const { schema, matches } = extractJSONSchema(inputSchema, isFileSchema);
+        const files = matches;
+        const isStillHasFileSchema = findDeepMatches(isFileSchema, schema).values.length > 0;
+        if (files.length) {
+          parameters.push({
+            name: "content-disposition",
+            in: "header",
+            required: schema === void 0,
+            schema: {
+              type: "string",
+              pattern: "filename",
+              example: 'filename="file.png"',
+              description: "To define the file name. Required when the request body is a file."
+            }
+          });
+        }
+        const content = {};
+        for (const file of files) {
+          content[file.contentMediaType] = {
+            schema: file
+          };
+        }
+        if (schema !== void 0) {
+          content[isStillHasFileSchema ? "multipart/form-data" : "application/json"] = {
+            schema,
+            example: internal.inputExample
+          };
+        }
+        return {
+          required: Boolean(internal.InputSchema?.isOptional()),
+          content
         };
-      }
-      if (schema !== void 0) {
-        content[isStillHasFileSchema ? "multipart/form-data" : "application/json"] = {
-          schema,
-          example: internal.outputExample
+      })();
+      const successResponse = (() => {
+        const { schema, matches } = extractJSONSchema(outputSchema, isFileSchema);
+        const files = matches;
+        const isStillHasFileSchema = findDeepMatches(isFileSchema, schema).values.length > 0;
+        const content = {};
+        for (const file of files) {
+          content[file.contentMediaType] = {
+            schema: file
+          };
+        }
+        if (schema !== void 0) {
+          content[isStillHasFileSchema ? "multipart/form-data" : "application/json"] = {
+            schema,
+            example: internal.outputExample
+          };
+        }
+        return {
+          description: "OK",
+          content
         };
+      })();
+      if (throwOnMissingTagDefinition && internal.tags) {
+        const missingTag = internal.tags.find((tag) => !rootTags.includes(tag));
+        if (missingTag !== void 0) {
+          throw new Error(
+            `Tag "${missingTag}" is missing definition. Please define it in OpenAPI root tags object. [${path.join(".")}]`
+          );
+        }
       }
-      return {
-        description: "OK",
-        content
+      const operation = {
+        summary: internal.summary,
+        description: internal.description,
+        deprecated: internal.deprecated,
+        tags: internal.tags,
+        operationId: path.join("."),
+        parameters: parameters.length ? parameters : void 0,
+        requestBody,
+        responses: {
+          200: successResponse
+        }
       };
-    })();
-    if (throwOnMissingTagDefinition && internal.tags) {
-      const missingTag = internal.tags.find((tag) => !rootTags.includes(tag));
-      if (missingTag !== void 0) {
-        throw new Error(
-          `Tag "${missingTag}" is missing definition. Please define it in OpenAPI root tags object. [${path_.join(".")}]`
-        );
-      }
-    }
-    const operation = {
-      summary: internal.summary,
-      description: internal.description,
-      deprecated: internal.deprecated,
-      tags: internal.tags,
-      operationId: path_.join("."),
-      parameters: parameters.length ? parameters : void 0,
-      requestBody,
-      responses: {
-        200: successResponse
-      }
-    };
-    builder.addPath(path, {
-      [method.toLocaleLowerCase()]: operation
+      builder.addPath(httpPath, {
+        [method.toLocaleLowerCase()]: operation
+      });
     });
-  });
+    for (const lazy of lazies) {
+      const router = (await lazy.lazy[LAZY_LOADER_SYMBOL]()).default;
+      pending.push({
+        path: lazy.path,
+        router
+      });
+    }
+  }
   return preSerialize(builder.getSpec());
 }
 function isFileSchema(schema) {
@@ -4419,3 +4438,4 @@ function isFileSchema(schema) {
 export {
   generateOpenAPI
 };
+//# sourceMappingURL=index.js.map

package/dist/src/fetch/base-handler.d.ts

@@ -1,14 +1,15 @@
 import type { HTTPPath } from '@orpc/contract';
+import type { ANY_LAZY_PROCEDURE, ANY_PROCEDURE, Router } from '@orpc/server';
 import type { FetchHandler } from '@orpc/server/fetch';
 import type { Router as HonoRouter } from 'hono/router';
-import { type Procedure, type Router } from '@orpc/server';
-export type ResolveRouter = (router: Router<any>, method: string, pathname: string) => {
+export type ResolveRouter = (router: Router<any>, method: string, pathname: string) => Promise<{
     path: string[];
-    procedure: Procedure<any, any, any, any, any>;
+    procedure: ANY_PROCEDURE | ANY_LAZY_PROCEDURE;
     params: Record<string, string>;
-} | undefined;
-type Routing = HonoRouter<[string[], Procedure<any, any, any, any, any>]>;
+} | undefined>;
+type Routing = HonoRouter<string[]>;
 export declare function createOpenAPIHandler(createHonoRouter: () => Routing): FetchHandler;
 export declare function createResolveRouter(createHonoRouter: () => Routing): ResolveRouter;
 export declare function openAPIPathToRouterPath(path: HTTPPath): string;
 export {};
+//# sourceMappingURL=base-handler.d.ts.map

package/dist/src/fetch/index.d.ts

@@ -1,3 +1,4 @@
 export * from './base-handler';
 export * from './server-handler';
 export * from './serverless-handler';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/fetch/server-handler.d.ts

@@ -1,2 +1,3 @@
 import type { FetchHandler } from '@orpc/server/fetch';
 export declare function createOpenAPIServerHandler(): FetchHandler;
+//# sourceMappingURL=server-handler.d.ts.map

package/dist/src/fetch/serverless-handler.d.ts

@@ -1,2 +1,3 @@
 import type { FetchHandler } from '@orpc/server/fetch';
 export declare function createOpenAPIServerlessHandler(): FetchHandler;
+//# sourceMappingURL=serverless-handler.d.ts.map

package/dist/src/generator.d.ts

@@ -20,4 +20,5 @@ export interface GenerateOpenAPIOptions {
 }
 export declare function generateOpenAPI(opts: {
     router: ContractRouter | Router<any>;
-} & Omit<OpenAPIObject, 'openapi'>, options?: GenerateOpenAPIOptions): OpenAPIObject;
+} & Omit<OpenAPIObject, 'openapi'>, options?: GenerateOpenAPIOptions): Promise<OpenAPIObject>;
+//# sourceMappingURL=generator.d.ts.map

package/dist/src/index.d.ts

@@ -1,2 +1,3 @@
 /** unnoq */
 export * from './generator';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/utils.d.ts

@@ -0,0 +1,16 @@
+import type { ContractProcedure, ContractRouter, WELL_CONTRACT_PROCEDURE } from '@orpc/contract';
+import type { ANY_LAZY_PROCEDURE, ANY_PROCEDURE, Lazy, Router } from '@orpc/server';
+export interface EachLeafOptions {
+    router: ANY_PROCEDURE | Router<any> | ContractRouter | ContractProcedure<any, any>;
+    path: string[];
+}
+export interface EachLeafCallbackOptions {
+    contract: WELL_CONTRACT_PROCEDURE;
+    path: string[];
+}
+export interface EachContractLeafResultItem {
+    lazy: ANY_LAZY_PROCEDURE | Lazy<Router<any>>;
+    path: string[];
+}
+export declare function eachContractProcedureLeaf(options: EachLeafOptions, callback: (options: EachLeafCallbackOptions) => void, result?: EachContractLeafResultItem[], isCurrentRouterContract?: boolean): EachContractLeafResultItem[];
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/zod-to-json-schema.d.ts

@@ -40,3 +40,4 @@ export declare function extractJSONSchema(schema: JSONSchema, check: (schema: JS
     schema: JSONSchema | undefined;
     matches: JSONSchema[];
 };
+//# sourceMappingURL=zod-to-json-schema.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/openapi",
   "type": "module",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -29,18 +29,19 @@
     }
   },
   "files": [
-    "!dist/*.tsbuildinfo",
+    "!**/*.map",
+    "!**/*.tsbuildinfo",
     "dist"
   ],
   "dependencies": {
     "escape-string-regexp": "^5.0.0",
     "json-schema-typed": "^8.0.1",
     "openapi3-ts": "^4.4.0",
-    "@orpc/contract": "0.12.0",
-    "@orpc/transformer": "0.12.0",
-    "@orpc/server": "0.12.0",
-    "@orpc/shared": "0.12.0",
-    "@orpc/zod": "0.12.0"
+    "@orpc/contract": "0.14.0",
+    "@orpc/server": "0.14.0",
+    "@orpc/shared": "0.14.0",
+    "@orpc/transformer": "0.14.0",
+    "@orpc/zod": "0.14.0"
   },
   "devDependencies": {
     "@readme/openapi-parser": "^2.6.0",
@@ -48,7 +49,7 @@
     "zod": "^3.23.8"
   },
   "scripts": {
-    "build": "tsup --clean --entry.index=src/index.ts --entry.fetch=src/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.fetch=src/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }