@orpc/openapi 0.0.0-next.9306271 → 0.0.0-next.93e7a4c

package/dist/index.js

@@ -1,26 +1,19 @@
 import {
-  eachContractProcedureLeaf
-} from "./chunk-KZIT2WCV.js";
+  OpenAPIPayloadCodec,
+  forEachContractProcedure,
+  standardizeHTTPPath
+} from "./chunk-UPDKQRQG.js";
 
 // src/generator.ts
 import { isContractProcedure } from "@orpc/contract";
-import { LAZY_LOADER_SYMBOL } from "@orpc/server";
+import { unlazy } from "@orpc/server";
 import { findDeepMatches, isPlainObject, omit } from "@orpc/shared";
-import { preSerialize } from "@orpc/transformer";
 import {
   OpenApiBuilder
 } from "openapi3-ts/oas31";
 
-// src/zod-to-json-schema.ts
-import {
-  getCustomJSONSchema,
-  getCustomZodFileMimeType,
-  getCustomZodType
-} from "@orpc/zod";
-import escapeStringRegexp from "escape-string-regexp";
-import {
-  Format
-} from "json-schema-typed/draft-2020-12";
+// ../zod/src/coercer.ts
+import { guard } from "@orpc/shared";
 
 // ../../node_modules/.pnpm/zod@3.24.1/node_modules/zod/lib/index.mjs
 var util;
@@ -3912,7 +3905,37 @@ var nullableType = ZodNullable.create;
 var preprocessType = ZodEffects.createWithPreprocess;
 var pipelineType = ZodPipeline.create;
 
+// ../zod/src/schemas.ts
+import wcmatch from "wildcard-match";
+var customZodTypeSymbol = Symbol("customZodTypeSymbol");
+var customZodFileMimeTypeSymbol = Symbol("customZodFileMimeTypeSymbol");
+var CUSTOM_JSON_SCHEMA_SYMBOL = Symbol("CUSTOM_JSON_SCHEMA");
+var CUSTOM_JSON_SCHEMA_INPUT_SYMBOL = Symbol("CUSTOM_JSON_SCHEMA_INPUT");
+var CUSTOM_JSON_SCHEMA_OUTPUT_SYMBOL = Symbol("CUSTOM_JSON_SCHEMA_OUTPUT");
+function getCustomZodType(def) {
+  return customZodTypeSymbol in def ? def[customZodTypeSymbol] : void 0;
+}
+function getCustomZodFileMimeType(def) {
+  return customZodFileMimeTypeSymbol in def ? def[customZodFileMimeTypeSymbol] : void 0;
+}
+function getCustomJSONSchema(def, options) {
+  if (options?.mode === "input" && CUSTOM_JSON_SCHEMA_INPUT_SYMBOL in def) {
+    return def[CUSTOM_JSON_SCHEMA_INPUT_SYMBOL];
+  }
+  if (options?.mode === "output" && CUSTOM_JSON_SCHEMA_OUTPUT_SYMBOL in def) {
+    return def[CUSTOM_JSON_SCHEMA_OUTPUT_SYMBOL];
+  }
+  if (CUSTOM_JSON_SCHEMA_SYMBOL in def) {
+    return def[CUSTOM_JSON_SCHEMA_SYMBOL];
+  }
+  return void 0;
+}
+
 // src/zod-to-json-schema.ts
+import escapeStringRegexp from "escape-string-regexp";
+import {
+  Format
+} from "json-schema-typed/draft-2020-12";
 var NON_LOGIC_KEYWORDS = [
   // Core Documentation Keywords
   "$anchor",
@@ -3943,10 +3966,15 @@ var NON_LOGIC_KEYWORDS = [
 var UNSUPPORTED_JSON_SCHEMA = { not: {} };
 var UNDEFINED_JSON_SCHEMA = { const: "undefined" };
 function zodToJsonSchema(schema, options) {
+  if (schema["~standard"].vendor !== "zod") {
+    console.warn(`Generate JSON schema not support ${schema["~standard"].vendor} yet`);
+    return {};
+  }
+  const schema__ = schema;
   if (!options?.isHandledCustomJSONSchema) {
-    const customJSONSchema = getCustomJSONSchema(schema._def, options);
+    const customJSONSchema = getCustomJSONSchema(schema__._def, options);
     if (customJSONSchema) {
-      const json = zodToJsonSchema(schema, {
+      const json = zodToJsonSchema(schema__, {
         ...options,
         isHandledCustomJSONSchema: true
       });
@@ -3957,13 +3985,13 @@ function zodToJsonSchema(schema, options) {
     }
   }
   const childOptions = { ...options, isHandledCustomJSONSchema: false };
-  const customType = getCustomZodType(schema._def);
+  const customType = getCustomZodType(schema__._def);
   switch (customType) {
     case "Blob": {
       return { type: "string", contentMediaType: "*/*" };
     }
     case "File": {
-      const mimeType = getCustomZodFileMimeType(schema._def) ?? "*/*";
+      const mimeType = getCustomZodFileMimeType(schema__._def) ?? "*/*";
       return { type: "string", contentMediaType: mimeType };
     }
     case "Invalid Date": {
@@ -3980,10 +4008,10 @@ function zodToJsonSchema(schema, options) {
     }
   }
   const _expectedCustomType = customType;
-  const typeName = schema._def.typeName;
+  const typeName = schema__._def.typeName;
   switch (typeName) {
     case ZodFirstPartyTypeKind.ZodString: {
-      const schema_ = schema;
+      const schema_ = schema__;
       const json = { type: "string" };
       for (const check of schema_._def.checks) {
         switch (check.kind) {
@@ -4065,7 +4093,7 @@ function zodToJsonSchema(schema, options) {
       return json;
     }
     case ZodFirstPartyTypeKind.ZodNumber: {
-      const schema_ = schema;
+      const schema_ = schema__;
       const json = { type: "number" };
       for (const check of schema_._def.checks) {
         switch (check.kind) {
@@ -4110,23 +4138,23 @@ function zodToJsonSchema(schema, options) {
       return UNDEFINED_JSON_SCHEMA;
     }
     case ZodFirstPartyTypeKind.ZodLiteral: {
-      const schema_ = schema;
+      const schema_ = schema__;
       return { const: schema_._def.value };
     }
     case ZodFirstPartyTypeKind.ZodEnum: {
-      const schema_ = schema;
+      const schema_ = schema__;
       return {
         enum: schema_._def.values
       };
     }
     case ZodFirstPartyTypeKind.ZodNativeEnum: {
-      const schema_ = schema;
+      const schema_ = schema__;
       return {
         enum: Object.values(schema_._def.values)
       };
     }
     case ZodFirstPartyTypeKind.ZodArray: {
-      const schema_ = schema;
+      const schema_ = schema__;
       const def = schema_._def;
       const json = { type: "array" };
       if (def.exactLength) {
@@ -4142,7 +4170,7 @@ function zodToJsonSchema(schema, options) {
       return json;
     }
     case ZodFirstPartyTypeKind.ZodTuple: {
-      const schema_ = schema;
+      const schema_ = schema__;
       const prefixItems = [];
       const json = { type: "array" };
       for (const item of schema_._def.items) {
@@ -4160,7 +4188,7 @@ function zodToJsonSchema(schema, options) {
       return json;
     }
     case ZodFirstPartyTypeKind.ZodObject: {
-      const schema_ = schema;
+      const schema_ = schema__;
       const json = { type: "object" };
       const properties = {};
       const required = [];
@@ -4196,7 +4224,7 @@ function zodToJsonSchema(schema, options) {
       return json;
     }
     case ZodFirstPartyTypeKind.ZodRecord: {
-      const schema_ = schema;
+      const schema_ = schema__;
       const json = { type: "object" };
       json.additionalProperties = zodToJsonSchema(
         schema_._def.valueType,
@@ -4205,14 +4233,14 @@ function zodToJsonSchema(schema, options) {
       return json;
     }
     case ZodFirstPartyTypeKind.ZodSet: {
-      const schema_ = schema;
+      const schema_ = schema__;
       return {
         type: "array",
         items: zodToJsonSchema(schema_._def.valueType, childOptions)
       };
     }
     case ZodFirstPartyTypeKind.ZodMap: {
-      const schema_ = schema;
+      const schema_ = schema__;
       return {
         type: "array",
         items: {
@@ -4228,7 +4256,7 @@ function zodToJsonSchema(schema, options) {
     }
     case ZodFirstPartyTypeKind.ZodUnion:
     case ZodFirstPartyTypeKind.ZodDiscriminatedUnion: {
-      const schema_ = schema;
+      const schema_ = schema__;
       const anyOf = [];
       for (const s of schema_._def.options) {
         anyOf.push(zodToJsonSchema(s, childOptions));
@@ -4236,7 +4264,7 @@ function zodToJsonSchema(schema, options) {
       return { anyOf };
     }
     case ZodFirstPartyTypeKind.ZodIntersection: {
-      const schema_ = schema;
+      const schema_ = schema__;
       const allOf = [];
       for (const s of [schema_._def.left, schema_._def.right]) {
         allOf.push(zodToJsonSchema(s, childOptions));
@@ -4244,7 +4272,7 @@ function zodToJsonSchema(schema, options) {
       return { allOf };
     }
     case ZodFirstPartyTypeKind.ZodLazy: {
-      const schema_ = schema;
+      const schema_ = schema__;
       const maxLazyDepth = childOptions?.maxLazyDepth ?? 5;
       const lazyDepth = childOptions?.lazyDepth ?? 0;
       if (lazyDepth > maxLazyDepth) {
@@ -4261,44 +4289,44 @@ function zodToJsonSchema(schema, options) {
       return {};
     }
     case ZodFirstPartyTypeKind.ZodOptional: {
-      const schema_ = schema;
+      const schema_ = schema__;
       const inner = zodToJsonSchema(schema_._def.innerType, childOptions);
       return {
         anyOf: [UNDEFINED_JSON_SCHEMA, inner]
       };
     }
     case ZodFirstPartyTypeKind.ZodReadonly: {
-      const schema_ = schema;
+      const schema_ = schema__;
       return zodToJsonSchema(schema_._def.innerType, childOptions);
     }
     case ZodFirstPartyTypeKind.ZodDefault: {
-      const schema_ = schema;
+      const schema_ = schema__;
       return zodToJsonSchema(schema_._def.innerType, childOptions);
     }
     case ZodFirstPartyTypeKind.ZodEffects: {
-      const schema_ = schema;
+      const schema_ = schema__;
       if (schema_._def.effect.type === "transform" && childOptions?.mode === "output") {
         return {};
       }
       return zodToJsonSchema(schema_._def.schema, childOptions);
     }
     case ZodFirstPartyTypeKind.ZodCatch: {
-      const schema_ = schema;
+      const schema_ = schema__;
       return zodToJsonSchema(schema_._def.innerType, childOptions);
     }
     case ZodFirstPartyTypeKind.ZodBranded: {
-      const schema_ = schema;
+      const schema_ = schema__;
       return zodToJsonSchema(schema_._def.type, childOptions);
     }
     case ZodFirstPartyTypeKind.ZodPipeline: {
-      const schema_ = schema;
+      const schema_ = schema__;
       return zodToJsonSchema(
         childOptions?.mode === "output" ? schema_._def.out : schema_._def.in,
         childOptions
       );
     }
     case ZodFirstPartyTypeKind.ZodNullable: {
-      const schema_ = schema;
+      const schema_ = schema__;
       const inner = zodToJsonSchema(schema_._def.innerType, childOptions);
       return {
         anyOf: [{ type: "null" }, inner]
@@ -4353,6 +4381,7 @@ function extractJSONSchema(schema, check, matches = []) {
 async function generateOpenAPI(opts, options) {
   const throwOnMissingTagDefinition = options?.throwOnMissingTagDefinition ?? false;
   const ignoreUndefinedPathProcedures = options?.ignoreUndefinedPathProcedures ?? false;
+  const payloadCodec = options?.payloadCodec ?? new OpenAPIPayloadCodec();
   const builder = new OpenApiBuilder({
     ...omit(opts, ["router"]),
     openapi: "3.1.0"
@@ -4363,16 +4392,16 @@ async function generateOpenAPI(opts, options) {
     router: opts.router
   }];
   for (const item of pending) {
-    const lazies = eachContractProcedureLeaf(item, ({ contract, path }) => {
+    const lazies = forEachContractProcedure(item, ({ contract, path }) => {
       if (!isContractProcedure(contract)) {
         return;
       }
-      const internal = contract.zz$cp;
-      if (ignoreUndefinedPathProcedures && internal.path === void 0) {
+      const internal = contract["~orpc"];
+      if (ignoreUndefinedPathProcedures && internal.route?.path === void 0) {
         return;
       }
-      const httpPath = internal.path ?? `/${path.map(encodeURIComponent).join("/")}`;
-      const method = internal.method ?? "POST";
+      const httpPath = internal.route?.path ? standardizeHTTPPath(internal.route?.path) : `/${path.map(encodeURIComponent).join("/")}`;
+      const method = internal.route?.method ?? "POST";
       let inputSchema = internal.InputSchema ? zodToJsonSchema(internal.InputSchema, { mode: "input" }) : {};
       const outputSchema = internal.OutputSchema ? zodToJsonSchema(internal.OutputSchema, { mode: "output" }) : {};
       const params = (() => {
@@ -4507,7 +4536,9 @@ async function generateOpenAPI(opts, options) {
           };
         }
         return {
-          required: Boolean(internal.InputSchema?.isOptional()),
+          required: Boolean(
+            internal.InputSchema && "isOptional" in internal.InputSchema && typeof internal.InputSchema.isOptional === "function" ? internal.InputSchema.isOptional() : false
+          ),
           content
         };
       })();
@@ -4532,8 +4563,8 @@ async function generateOpenAPI(opts, options) {
           content
         };
       })();
-      if (throwOnMissingTagDefinition && internal.tags) {
-        const missingTag = internal.tags.find((tag) => !rootTags.includes(tag));
+      if (throwOnMissingTagDefinition && internal.route?.tags) {
+        const missingTag = internal.route?.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(".")}]`
@@ -4541,10 +4572,10 @@ async function generateOpenAPI(opts, options) {
         }
       }
       const operation = {
-        summary: internal.summary,
-        description: internal.description,
-        deprecated: internal.deprecated,
-        tags: internal.tags,
+        summary: internal.route?.summary,
+        description: internal.route?.description,
+        deprecated: internal.route?.deprecated,
+        tags: internal.route?.tags ? [...internal.route.tags] : void 0,
         operationId: path.join("."),
         parameters: parameters.length ? parameters : void 0,
         requestBody,
@@ -4557,14 +4588,14 @@ async function generateOpenAPI(opts, options) {
       });
     });
     for (const lazy of lazies) {
-      const router = (await lazy.lazy[LAZY_LOADER_SYMBOL]()).default;
+      const { default: router } = await unlazy(lazy.router);
       pending.push({
         path: lazy.path,
         router
       });
     }
   }
-  return preSerialize(builder.getSpec());
+  return payloadCodec.serialize(builder.getSpec());
 }
 function isFileSchema(schema) {
   if (typeof schema !== "object" || schema === null)

package/dist/src/fetch/bracket-notation.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Serialize an object or array into a list of [key, value] pairs.
+ * The key will express by using bracket-notation.
+ *
+ * Notice: This way cannot express the empty object or array.
+ *
+ * @example
+ * ```ts
+ * const payload = {
+ *  name: 'John Doe',
+ *  pets: ['dog', 'cat'],
+ * }
+ *
+ * const entities = serialize(payload)
+ *
+ * expect(entities).toEqual([
+ *  ['name', 'John Doe'],
+ *  ['name[pets][0]', 'dog'],
+ *  ['name[pets][1]', 'cat'],
+ * ])
+ * ```
+ */
+export declare function serialize(payload: unknown, parentKey?: string): [string, unknown][];
+/**
+ * Deserialize a list of [key, value] pairs into an object or array.
+ * The key is expressed by using bracket-notation.
+ *
+ * @example
+ * ```ts
+ * const entities = [
+ *  ['name', 'John Doe'],
+ *  ['name[pets][0]', 'dog'],
+ *  ['name[pets][1]', 'cat'],
+ *  ['name[dogs][]', 'hello'],
+ *  ['name[dogs][]', 'kitty'],
+ * ]
+ *
+ * const payload = deserialize(entities)
+ *
+ * expect(payload).toEqual({
+ *  name: 'John Doe',
+ *  pets: { 0: 'dog', 1: 'cat' },
+ *  dogs: ['hello', 'kitty'],
+ * })
+ * ```
+ */
+export declare function deserialize(entities: readonly (readonly [string, unknown])[]): Record<string, unknown> | unknown[] | undefined;
+/**
+ * Escape the `[`, `]`, and `\` chars in a path segment.
+ *
+ * @example
+ * ```ts
+ * expect(escapeSegment('name[pets')).toEqual('name\\[pets')
+ * ```
+ */
+export declare function escapeSegment(segment: string): string;
+/**
+ * Convert an array of path segments into a path string using bracket-notation.
+ *
+ * For the special char `[`, `]`, and `\` will be escaped by adding `\` at start.
+ *
+ * @example
+ * ```ts
+ * expect(stringifyPath(['name', 'pets', '0'])).toEqual('name[pets][0]')
+ * ```
+ */
+export declare function stringifyPath(path: readonly [string, ...string[]]): string;
+/**
+ * Convert a path string using bracket-notation into an array of path segments.
+ *
+ * For the special char `[`, `]`, and `\` you should escape by adding `\` at start.
+ * It only treats a pair `[${string}]` as a path segment.
+ * If missing or escape it will bypass and treat as normal string.
+ *
+ * @example
+ * ```ts
+ * expect(parsePath('name[pets][0]')).toEqual(['name', 'pets', '0'])
+ * expect(parsePath('name[pets][0')).toEqual(['name', 'pets', '[0'])
+ * expect(parsePath('name[pets[0]')).toEqual(['name', 'pets[0')
+ * expect(parsePath('name\\[pets][0]')).toEqual(['name[pets]', '0'])
+ * ```
+ */
+export declare function parsePath(path: string): [string, ...string[]];
+//# sourceMappingURL=bracket-notation.d.ts.map

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

@@ -1,4 +1,10 @@
-export * from './base-handler';
-export * from './server-handler';
-export * from './serverless-handler';
+export * from './bracket-notation';
+export * from './input-builder-full';
+export * from './input-builder-simple';
+export * from './openapi-handler';
+export * from './openapi-handler-server';
+export * from './openapi-handler-serverless';
+export * from './openapi-payload-codec';
+export * from './openapi-procedure-matcher';
+export * from './schema-coercer';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/fetch/input-builder-full.d.ts

@@ -0,0 +1,11 @@
+import type { Params } from 'hono/router';
+export declare class InputBuilderFull {
+    build(params: Params, query: unknown, headers: unknown, body: unknown): {
+        params: Params;
+        query: unknown;
+        headers: unknown;
+        body: unknown;
+    };
+}
+export type PublicInputBuilderFull = Pick<InputBuilderFull, keyof InputBuilderFull>;
+//# sourceMappingURL=input-builder-full.d.ts.map

package/dist/src/fetch/input-builder-simple.d.ts

@@ -0,0 +1,6 @@
+import type { Params } from 'hono/router';
+export declare class InputBuilderSimple {
+    build(params: Params, payload: unknown): unknown;
+}
+export type PublicInputBuilderSimple = Pick<InputBuilderSimple, keyof InputBuilderSimple>;
+//# sourceMappingURL=input-builder-simple.d.ts.map

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

@@ -0,0 +1,7 @@
+import type { Context, Router } from '@orpc/server';
+import type { OpenAPIHandlerOptions } from './openapi-handler';
+import { OpenAPIHandler } from './openapi-handler';
+export declare class OpenAPIServerHandler<T extends Context> extends OpenAPIHandler<T> {
+    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
+}
+//# sourceMappingURL=openapi-handler-server.d.ts.map

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

@@ -0,0 +1,7 @@
+import type { Context, Router } from '@orpc/server';
+import type { OpenAPIHandlerOptions } from './openapi-handler';
+import { OpenAPIHandler } from './openapi-handler';
+export declare class OpenAPIServerlessHandler<T extends Context> extends OpenAPIHandler<T> {
+    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
+}
+//# sourceMappingURL=openapi-handler-serverless.d.ts.map

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

@@ -0,0 +1,28 @@
+import type { ConditionalFetchHandler, FetchOptions } from '@orpc/server/fetch';
+import type { PublicInputBuilderSimple } from './input-builder-simple';
+import { type Context, type Router, type WithSignal } from '@orpc/server';
+import { type Hooks } from '@orpc/shared';
+import { type PublicInputBuilderFull } from './input-builder-full';
+import { type PublicOpenAPIPayloadCodec } from './openapi-payload-codec';
+import { type Hono, type PublicOpenAPIProcedureMatcher } from './openapi-procedure-matcher';
+import { type SchemaCoercer } from './schema-coercer';
+export type OpenAPIHandlerOptions<T extends Context> = Hooks<Request, Response, T, WithSignal> & {
+    procedureMatcher?: PublicOpenAPIProcedureMatcher;
+    payloadCodec?: PublicOpenAPIPayloadCodec;
+    inputBuilderSimple?: PublicInputBuilderSimple;
+    inputBuilderFull?: PublicInputBuilderFull;
+    schemaCoercers?: SchemaCoercer[];
+};
+export declare class OpenAPIHandler<T extends Context> implements ConditionalFetchHandler<T> {
+    private readonly options?;
+    private readonly procedureMatcher;
+    private readonly payloadCodec;
+    private readonly inputBuilderSimple;
+    private readonly inputBuilderFull;
+    private readonly compositeSchemaCoercer;
+    constructor(hono: Hono, router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>> | undefined);
+    condition(request: Request): boolean;
+    fetch(request: Request, ...[options]: [options: FetchOptions<T>] | (undefined extends T ? [] : never)): Promise<Response>;
+    private convertToORPCError;
+}
+//# sourceMappingURL=openapi-handler.d.ts.map

package/dist/src/fetch/openapi-payload-codec.d.ts

@@ -0,0 +1,13 @@
+export declare class OpenAPIPayloadCodec {
+    encode(payload: unknown, accept?: string): {
+        body: FormData | Blob | string | undefined;
+        headers?: Headers;
+    };
+    private encodeAsJSON;
+    private encodeAsFormData;
+    private encodeAsURLSearchParams;
+    serialize(payload: unknown): unknown;
+    decode(re: Request | Response | Headers | URLSearchParams | FormData): Promise<unknown>;
+}
+export type PublicOpenAPIPayloadCodec = Pick<OpenAPIPayloadCodec, keyof OpenAPIPayloadCodec>;
+//# sourceMappingURL=openapi-payload-codec.d.ts.map

package/dist/src/fetch/openapi-procedure-matcher.d.ts

@@ -0,0 +1,19 @@
+import type { Router as BaseHono, Params } from 'hono/router';
+import { type ANY_PROCEDURE, type ANY_ROUTER } from '@orpc/server';
+export type Hono = BaseHono<[string, string[]]>;
+export declare class OpenAPIProcedureMatcher {
+    private readonly hono;
+    private readonly router;
+    private pendingRouters;
+    constructor(hono: Hono, router: ANY_ROUTER);
+    match(method: string, pathname: string): Promise<{
+        path: string[];
+        procedure: ANY_PROCEDURE;
+        params: Params;
+    } | undefined>;
+    private add;
+    private handlePendingRouters;
+    private convertOpenAPIPathToRouterPath;
+}
+export type PublicOpenAPIProcedureMatcher = Pick<OpenAPIProcedureMatcher, keyof OpenAPIProcedureMatcher>;
+//# sourceMappingURL=openapi-procedure-matcher.d.ts.map

package/dist/src/fetch/schema-coercer.d.ts

@@ -0,0 +1,10 @@
+import type { Schema } from '@orpc/contract';
+export interface SchemaCoercer {
+    coerce: (schema: Schema, value: unknown) => unknown;
+}
+export declare class CompositeSchemaCoercer implements SchemaCoercer {
+    private readonly coercers;
+    constructor(coercers: SchemaCoercer[]);
+    coerce(schema: Schema, value: unknown): unknown;
+}
+//# sourceMappingURL=schema-coercer.d.ts.map

package/dist/src/generator.d.ts

@@ -1,5 +1,6 @@
+import type { PublicOpenAPIPayloadCodec } from './fetch';
 import { type ContractRouter } from '@orpc/contract';
-import { type Router } from '@orpc/server';
+import { type ANY_ROUTER } from '@orpc/server';
 import { type OpenAPIObject } from 'openapi3-ts/oas31';
 export interface GenerateOpenAPIOptions {
     /**
@@ -17,8 +18,9 @@ export interface GenerateOpenAPIOptions {
      * @default false
      */
     ignoreUndefinedPathProcedures?: boolean;
+    payloadCodec?: PublicOpenAPIPayloadCodec;
 }
 export declare function generateOpenAPI(opts: {
-    router: ContractRouter | Router<any>;
+    router: ContractRouter | ANY_ROUTER;
 } & Omit<OpenAPIObject, 'openapi'>, options?: GenerateOpenAPIOptions): Promise<OpenAPIObject>;
 //# sourceMappingURL=generator.d.ts.map

package/dist/src/utils.d.ts

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

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

@@ -1,5 +1,5 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
 import { type JSONSchema } from 'json-schema-typed/draft-2020-12';
-import { type ZodTypeAny } from 'zod';
 export declare const NON_LOGIC_KEYWORDS: ("$anchor" | "$comment" | "$defs" | "$dynamicAnchor" | "$dynamicRef" | "$id" | "$schema" | "$vocabulary" | "contentEncoding" | "contentMediaType" | "default" | "definitions" | "deprecated" | "description" | "examples" | "format" | "readOnly" | "title" | "writeOnly")[];
 export declare const UNSUPPORTED_JSON_SCHEMA: {
     not: {};
@@ -35,7 +35,7 @@ export interface ZodToJsonSchemaOptions {
      */
     isHandledCustomJSONSchema?: boolean;
 }
-export declare function zodToJsonSchema(schema: ZodTypeAny, options?: ZodToJsonSchemaOptions): Exclude<JSONSchema, boolean>;
+export declare function zodToJsonSchema(schema: StandardSchemaV1, options?: ZodToJsonSchemaOptions): Exclude<JSONSchema, boolean>;
 export declare function extractJSONSchema(schema: JSONSchema, check: (schema: JSONSchema) => boolean, matches?: JSONSchema[]): {
     schema: JSONSchema | undefined;
     matches: JSONSchema[];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/openapi",
   "type": "module",
-  "version": "0.0.0-next.9306271",
+  "version": "0.0.0-next.93e7a4c",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -34,18 +34,21 @@
     "dist"
   ],
   "dependencies": {
+    "@standard-schema/spec": "1.0.0-beta.4",
+    "@types/content-disposition": "^0.5.8",
+    "content-disposition": "^0.5.4",
     "escape-string-regexp": "^5.0.0",
+    "fast-content-type-parse": "^2.0.0",
+    "hono": "^4.6.12",
     "json-schema-typed": "^8.0.1",
     "openapi3-ts": "^4.4.0",
-    "@orpc/contract": "0.0.0-next.9306271",
-    "@orpc/transformer": "0.0.0-next.9306271",
-    "@orpc/shared": "0.0.0-next.9306271",
-    "@orpc/zod": "0.0.0-next.9306271",
-    "@orpc/server": "0.0.0-next.9306271"
+    "wildcard-match": "^5.1.3",
+    "@orpc/contract": "0.0.0-next.93e7a4c",
+    "@orpc/shared": "0.0.0-next.93e7a4c",
+    "@orpc/server": "0.0.0-next.93e7a4c"
   },
   "devDependencies": {
     "@readme/openapi-parser": "^2.6.0",
-    "hono": "^4.6.12",
     "zod": "^3.24.1"
   },
   "scripts": {