@orpc/openapi 0.0.0-next.aa72097 → 0.0.0-next.ad0709a

package/dist/index.js

@@ -1,9 +1,7 @@
 import {
   JSONSerializer,
-  forEachAllContractProcedure,
-  forEachContractProcedure,
   standardizeHTTPPath
-} from "./chunk-KNYXLM77.js";
+} from "./chunk-BHJYKXQL.js";
 
 // src/openapi.ts
 import { OpenApiBuilder } from "openapi3-ts/oas31";
@@ -36,14 +34,16 @@ var OpenAPIContentBuilder = class {
 };
 
 // src/openapi-generator.ts
-import { fallbackToGlobalConfig as fallbackToGlobalConfig2 } from "@orpc/contract";
+import { fallbackContractConfig as fallbackContractConfig2, fallbackORPCErrorStatus } from "@orpc/contract";
+import { eachAllContractProcedure } from "@orpc/server";
+import { group } from "@orpc/shared";
 
 // src/openapi-error.ts
 var OpenAPIError = class extends Error {
 };
 
 // src/openapi-input-structure-parser.ts
-import { fallbackToGlobalConfig } from "@orpc/contract";
+import { fallbackContractConfig } from "@orpc/contract";
 var OpenAPIInputStructureParser = class {
   constructor(schemaConverter, schemaUtils, pathParser) {
     this.schemaConverter = schemaConverter;
@@ -51,8 +51,8 @@ var OpenAPIInputStructureParser = class {
     this.pathParser = pathParser;
   }
   parse(contract, structure) {
-    const inputSchema = this.schemaConverter.convert(contract["~orpc"].InputSchema, { strategy: "input" });
-    const method = fallbackToGlobalConfig("defaultMethod", contract["~orpc"].route?.method);
+    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)) {
       return {
@@ -144,7 +144,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,
@@ -293,14 +293,14 @@ var SchemaUtils = class {
     return typeof schema === "object" && schema.type === "object";
   }
   isAnySchema(schema) {
-    return schema === true || Object.keys(schema).length === 0;
+    return schema === true || Object.keys(schema).filter((key) => !NON_LOGIC_KEYWORDS.includes(key)).length === 0;
   }
   isUndefinableSchema(schema) {
     const [matches] = this.filterSchemaBranches(schema, (schema2) => {
       if (typeof schema2 === "boolean") {
         return schema2;
       }
-      return Object.keys(schema2).length === 0;
+      return Object.keys(schema2).filter((key) => !NON_LOGIC_KEYWORDS.includes(key)).length === 0;
     });
     return matches.length > 0;
   }
@@ -384,6 +384,7 @@ var OpenAPIGenerator = class {
   errorHandlerStrategy;
   ignoreUndefinedPathProcedures;
   considerMissingTagDefinitionAsError;
+  strictErrorResponses;
   constructor(options) {
     this.parametersBuilder = options?.parametersBuilder ?? new OpenAPIParametersBuilder();
     this.schemaConverter = new CompositeSchemaConverter(options?.schemaConverters ?? []);
@@ -396,6 +397,7 @@ var OpenAPIGenerator = class {
     this.errorHandlerStrategy = options?.errorHandlerStrategy ?? "throw";
     this.ignoreUndefinedPathProcedures = options?.ignoreUndefinedPathProcedures ?? false;
     this.considerMissingTagDefinitionAsError = options?.considerMissingTagDefinitionAsError ?? false;
+    this.strictErrorResponses = options?.strictErrorResponses ?? true;
   }
   async generate(router, doc) {
     const builder = new OpenApiBuilder({
@@ -403,16 +405,19 @@ 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 = fallbackToGlobalConfig2("defaultMethod", def.route?.method);
+        const method = fallbackContractConfig2("defaultMethod", def.route?.method);
         const httpPath = def.route?.path ? standardizeHTTPPath(def.route?.path) : `/${path.map(encodeURIComponent).join("/")}`;
-        const inputStructure = fallbackToGlobalConfig2("defaultInputStructure", def.route?.inputStructure);
-        const outputStructure = fallbackToGlobalConfig2("defaultOutputStructure", def.route?.outputStructure);
+        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, {
@@ -425,15 +430,64 @@ var OpenAPIGenerator = class {
           required: this.schemaUtils.isUndefinableSchema(bodySchema),
           content: this.contentBuilder.build(bodySchema)
         } : void 0;
-        const successResponse = {
-          description: fallbackToGlobalConfig2("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 responses = {};
+        responses[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
         };
+        const errors = group(Object.entries(def.errorMap ?? {}).filter(([_, config]) => config).map(([code, config]) => ({
+          ...config,
+          code,
+          status: fallbackORPCErrorStatus(code, config?.status)
+        })), (error) => error.status);
+        for (const status in errors) {
+          const configs = errors[status];
+          if (!configs || configs.length === 0) {
+            continue;
+          }
+          const schemas = configs.map(({ data, code, message }) => {
+            const json = {
+              type: "object",
+              properties: {
+                defined: { const: true },
+                code: { const: code },
+                status: { const: Number(status) },
+                message: { type: "string", default: message },
+                data: {}
+              },
+              required: ["defined", "code", "status", "message"]
+            };
+            if (data) {
+              const dataJson = this.schemaConverter.convert(data, { strategy: "output" });
+              json.properties.data = dataJson;
+              if (!this.schemaUtils.isUndefinableSchema(dataJson)) {
+                json.required.push("data");
+              }
+            }
+            return json;
+          });
+          if (this.strictErrorResponses) {
+            schemas.push({
+              type: "object",
+              properties: {
+                defined: { const: false },
+                code: { type: "string" },
+                status: { type: "number" },
+                message: { type: "string" },
+                data: {}
+              },
+              required: ["defined", "code", "status", "message"]
+            });
+          }
+          const contentSchema = schemas.length === 1 ? schemas[0] : {
+            oneOf: schemas
+          };
+          responses[status] = {
+            description: status,
+            content: this.contentBuilder.build(contentSchema)
+          };
+        }
         if (this.considerMissingTagDefinitionAsError && def.route?.tags) {
           const missingTag = def.route?.tags.find((tag) => !rootTags.includes(tag));
           if (missingTag !== void 0) {
@@ -450,9 +504,7 @@ var OpenAPIGenerator = class {
           operationId: path.join("."),
           parameters: parameters.length ? parameters : void 0,
           requestBody,
-          responses: {
-            [fallbackToGlobalConfig2("defaultSuccessStatus", def.route?.successStatus)]: successResponse
-          }
+          responses
         };
         builder.addPath(httpPath, {
           [method.toLocaleLowerCase()]: operation
@@ -489,8 +541,6 @@ export {
   OpenAPIPathParser,
   OpenApiBuilder,
   SchemaUtils,
-  forEachAllContractProcedure,
-  forEachContractProcedure,
   standardizeHTTPPath
 };
 //# sourceMappingURL=index.js.map

package/dist/next.js

@@ -0,0 +1,9 @@
+import {
+  OpenAPIHandler
+} from "./chunk-HQ34JZI7.js";
+import "./chunk-M5HOHBLW.js";
+import "./chunk-BHJYKXQL.js";
+export {
+  OpenAPIHandler
+};
+//# sourceMappingURL=next.js.map

package/dist/node.js

@@ -1,46 +1,30 @@
 import {
-  OpenAPIHandler
-} from "./chunk-XYIZDXKB.js";
-import "./chunk-KNYXLM77.js";
+  OpenAPICodec,
+  OpenAPIMatcher
+} from "./chunk-M5HOHBLW.js";
+import "./chunk-BHJYKXQL.js";
 
 // src/adapters/node/openapi-handler.ts
-import { createRequest, sendResponse } from "@orpc/server/node";
-var OpenAPIHandler2 = class {
-  openapiFetchHandler;
-  constructor(hono, router, options) {
-    this.openapiFetchHandler = new OpenAPIHandler(hono, router, options);
+import { nodeHttpResponseSendStandardResponse, nodeHttpToStandardRequest } from "@orpc/server/node";
+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(req, res, ...[options]) {
-    const request = createRequest(req, res);
-    const castedOptions = options ?? {};
-    const result = await this.openapiFetchHandler.handle(request, castedOptions);
-    if (result.matched === false) {
+  async handle(req, res, ...rest) {
+    const standardRequest = nodeHttpToStandardRequest(req, res);
+    const result = await this.standardHandler.handle(standardRequest, ...rest);
+    if (!result.matched) {
       return { matched: false };
     }
-    await options?.beforeSend?.(result.response, castedOptions.context);
-    await sendResponse(res, result.response);
+    await nodeHttpResponseSendStandardResponse(res, result.response);
     return { matched: true };
   }
 };
-
-// src/adapters/node/openapi-handler-server.ts
-import { TrieRouter } from "hono/router/trie-router";
-var OpenAPIServerHandler = class extends OpenAPIHandler2 {
-  constructor(router, options) {
-    super(new TrieRouter(), router, options);
-  }
-};
-
-// src/adapters/node/openapi-handler-serverless.ts
-import { LinearRouter } from "hono/router/linear-router";
-var OpenAPIServerlessHandler = class extends OpenAPIHandler2 {
-  constructor(router, options) {
-    super(new LinearRouter(), router, options);
-  }
-};
 export {
-  OpenAPIHandler2 as OpenAPIHandler,
-  OpenAPIServerHandler,
-  OpenAPIServerlessHandler
+  OpenAPIHandler
 };
 //# sourceMappingURL=node.js.map

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

@@ -1,10 +1,2 @@
-export * from './bracket-notation';
-export * from './input-structure-compact';
-export * from './input-structure-detailed';
 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/adapters/fetch/openapi-handler.d.ts

@@ -1,32 +1,10 @@
-import type { Context, Router, WithSignal } from '@orpc/server';
-import type { FetchHandler, FetchHandleRest, FetchHandleResult } from '@orpc/server/fetch';
-import type { PublicInputStructureCompact } from './input-structure-compact';
-import { type Hooks } from '@orpc/shared';
-import { type PublicJSONSerializer } from '../../json-serializer';
-import { type PublicInputStructureDetailed } from './input-structure-detailed';
-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, FetchHandleResult, T, WithSignal> & {
-    jsonSerializer?: PublicJSONSerializer;
-    procedureMatcher?: PublicOpenAPIProcedureMatcher;
-    payloadCodec?: PublicOpenAPIPayloadCodec;
-    inputBuilderSimple?: PublicInputStructureCompact;
-    inputBuilderFull?: PublicInputStructureDetailed;
-    schemaCoercers?: SchemaCoercer[];
-};
+import type { Context, Router } from '@orpc/server';
+import type { FetchHandler, FetchHandleResult } from '@orpc/server/fetch';
+import type { StandardHandleRest } from '@orpc/server/standard';
+import type { OpenAPIHandlerOptions } from '../standard';
 export declare class OpenAPIHandler<T extends Context> implements FetchHandler<T> {
-    private readonly options?;
-    private readonly procedureMatcher;
-    private readonly payloadCodec;
-    private readonly inputStructureCompact;
-    private readonly inputStructureDetailed;
-    private readonly compositeSchemaCoercer;
-    constructor(hono: Hono, router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>> | undefined);
-    handle(request: Request, ...[options]: FetchHandleRest<T>): Promise<FetchHandleResult>;
-    private decodeInput;
-    private encodeOutput;
-    private assertDetailedOutput;
-    private convertToORPCError;
+    private readonly standardHandler;
+    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
+    handle(request: Request, ...rest: StandardHandleRest<T>): Promise<FetchHandleResult>;
 }
 //# sourceMappingURL=openapi-handler.d.ts.map

package/dist/src/adapters/next/index.d.ts

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

package/dist/src/adapters/node/index.d.ts

@@ -1,5 +1,2 @@
 export * from './openapi-handler';
-export * from './openapi-handler-server';
-export * from './openapi-handler-serverless';
-export * from './types';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/node/openapi-handler.d.ts

@@ -1,11 +1,10 @@
 import type { Context, Router } from '@orpc/server';
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { OpenAPIHandlerOptions } from '../fetch/openapi-handler';
-import type { Hono } from '../fetch/openapi-procedure-matcher';
-import { type RequestHandler, type RequestHandleRest, type RequestHandleResult } from '@orpc/server/node';
-export declare class OpenAPIHandler<T extends Context> implements RequestHandler<T> {
-    private readonly openapiFetchHandler;
-    constructor(hono: Hono, router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
-    handle(req: IncomingMessage, res: ServerResponse, ...[options]: RequestHandleRest<T>): Promise<RequestHandleResult>;
+import type { NodeHttpHandler, NodeHttpHandleResult, NodeHttpRequest, NodeHttpResponse } from '@orpc/server/node';
+import type { StandardHandleRest } from '@orpc/server/standard';
+import type { OpenAPIHandlerOptions } from '../standard';
+export declare class OpenAPIHandler<T extends Context> implements NodeHttpHandler<T> {
+    private readonly standardHandler;
+    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
+    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: StandardHandleRest<T>): Promise<NodeHttpHandleResult>;
 }
 //# sourceMappingURL=openapi-handler.d.ts.map

package/dist/src/adapters/standard/index.d.ts

@@ -0,0 +1,7 @@
+export * as BracketNotation from './bracket-notation';
+export * from './openapi-codec';
+export * from './openapi-handler';
+export * from './openapi-matcher';
+export * from './openapi-serializer';
+export * from './schema-coercer';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/standard/openapi-codec.d.ts

@@ -0,0 +1,18 @@
+import type { AnyProcedure } from '@orpc/server';
+import type { StandardCodec, StandardParams, StandardRequest, StandardResponse } from '@orpc/server/standard';
+import { type ORPCError } from '@orpc/contract';
+import { OpenAPISerializer } from './openapi-serializer';
+import { type SchemaCoercer } from './schema-coercer';
+export interface OpenAPICodecOptions {
+    serializer?: OpenAPISerializer;
+    schemaCoercers?: SchemaCoercer[];
+}
+export declare class OpenAPICodec implements StandardCodec {
+    private readonly serializer;
+    private readonly compositeSchemaCoercer;
+    constructor(options?: OpenAPICodecOptions);
+    decode(request: StandardRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+}
+//# sourceMappingURL=openapi-codec.d.ts.map

package/dist/src/adapters/standard/openapi-handler.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from '@orpc/server';
+import type { RPCHandlerOptions } from '@orpc/server/standard';
+import type { OpenAPICodecOptions } from './openapi-codec';
+import type { OpenAPIMatcherOptions } from './openapi-matcher';
+export interface OpenAPIHandlerOptions<T extends Context> extends RPCHandlerOptions<T>, OpenAPIMatcherOptions, OpenAPICodecOptions {
+}
+//# sourceMappingURL=openapi-handler.d.ts.map

package/dist/src/adapters/standard/openapi-matcher.d.ts

@@ -0,0 +1,20 @@
+import type { AnyRouter } from '@orpc/server';
+import type { StandardMatcher, StandardMatchResult } from '@orpc/server/standard';
+import { type HTTPPath } from '@orpc/contract';
+export interface OpenAPIMatcherOptions {
+    /**
+     * Ignore procedure that does not have a method defined in the contract.
+     *
+     * @default false
+     */
+    ignoreUndefinedMethod?: boolean;
+}
+export declare class OpenAPIMatcher implements StandardMatcher {
+    private readonly tree;
+    private readonly ignoreUndefinedMethod;
+    constructor(options?: OpenAPIMatcherOptions);
+    private pendingRouters;
+    init(router: AnyRouter, path?: string[]): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+//# sourceMappingURL=openapi-matcher.d.ts.map

package/dist/src/adapters/standard/openapi-serializer.d.ts

@@ -0,0 +1,11 @@
+import type { PublicJSONSerializer } from '../../json-serializer';
+export interface OpenAPISerializerOptions {
+    jsonSerializer?: PublicJSONSerializer;
+}
+export declare class OpenAPISerializer {
+    private readonly jsonSerializer;
+    constructor(options?: OpenAPISerializerOptions);
+    serialize(data: unknown): unknown;
+    deserialize(serialized: unknown): unknown;
+}
+//# sourceMappingURL=openapi-serializer.d.ts.map

package/dist/src/adapters/{fetch → standard}/schema-coercer.d.ts

@@ -1,6 +1,6 @@
 import type { Schema } from '@orpc/contract';
 export interface SchemaCoercer {
-    coerce: (schema: Schema, value: unknown) => unknown;
+    coerce(schema: Schema, value: unknown): unknown;
 }
 export declare class CompositeSchemaCoercer implements SchemaCoercer {
     private readonly coercers;

package/dist/src/openapi-generator.d.ts

@@ -1,9 +1,9 @@
-import type { ANY_ROUTER } from '@orpc/server';
 import type { PublicOpenAPIInputStructureParser } from './openapi-input-structure-parser';
 import type { PublicOpenAPIOutputStructureParser } from './openapi-output-structure-parser';
 import type { PublicOpenAPIPathParser } from './openapi-path-parser';
 import type { SchemaConverter } from './schema-converter';
 import { type ContractRouter } from '@orpc/contract';
+import { type AnyRouter } from '@orpc/server';
 import { type PublicJSONSerializer } from './json-serializer';
 import { type OpenAPI } from './openapi';
 import { type PublicOpenAPIContentBuilder } from './openapi-content-builder';
@@ -40,6 +40,12 @@ export interface OpenAPIGeneratorOptions {
      * @default 'throw'
      */
     errorHandlerStrategy?: ErrorHandlerStrategy;
+    /**
+     * Strict error response
+     *
+     * @default true
+     */
+    strictErrorResponses?: boolean;
 }
 export declare class OpenAPIGenerator {
     private readonly contentBuilder;
@@ -53,8 +59,9 @@ export declare class OpenAPIGenerator {
     private readonly errorHandlerStrategy;
     private readonly ignoreUndefinedPathProcedures;
     private readonly considerMissingTagDefinitionAsError;
+    private readonly strictErrorResponses;
     constructor(options?: OpenAPIGeneratorOptions);
-    generate(router: ContractRouter | ANY_ROUTER, doc: Omit<OpenAPI.OpenAPIObject, 'openapi'>): Promise<OpenAPI.OpenAPIObject>;
+    generate(router: ContractRouter<any> | AnyRouter, doc: Omit<OpenAPI.OpenAPIObject, 'openapi'>): Promise<OpenAPI.OpenAPIObject>;
 }
 export {};
 //# sourceMappingURL=openapi-generator.d.ts.map

package/dist/src/openapi-input-structure-parser.d.ts

@@ -1,8 +1,8 @@
+import type { AnyContractProcedure } from '@orpc/contract';
 import type { PublicOpenAPIPathParser } from './openapi-path-parser';
 import type { JSONSchema, ObjectSchema } from './schema';
 import type { SchemaConverter } from './schema-converter';
 import type { PublicSchemaUtils } from './schema-utils';
-import { type ANY_CONTRACT_PROCEDURE } from '@orpc/contract';
 export interface OpenAPIInputStructureParseResult {
     paramsSchema: ObjectSchema | undefined;
     querySchema: ObjectSchema | undefined;
@@ -14,7 +14,7 @@ export declare class OpenAPIInputStructureParser {
     private readonly schemaUtils;
     private readonly pathParser;
     constructor(schemaConverter: SchemaConverter, schemaUtils: PublicSchemaUtils, pathParser: PublicOpenAPIPathParser);
-    parse(contract: ANY_CONTRACT_PROCEDURE, structure: 'compact' | 'detailed'): OpenAPIInputStructureParseResult;
+    parse(contract: AnyContractProcedure, structure: 'compact' | 'detailed'): OpenAPIInputStructureParseResult;
     private parseDetailedSchema;
     private parseCompactSchema;
 }

package/dist/src/openapi-output-structure-parser.d.ts

@@ -1,4 +1,4 @@
-import type { ANY_CONTRACT_PROCEDURE } from '@orpc/contract';
+import type { AnyContractProcedure } from '@orpc/contract';
 import type { JSONSchema, ObjectSchema } from './schema';
 import type { SchemaConverter } from './schema-converter';
 import type { PublicSchemaUtils } from './schema-utils';
@@ -10,7 +10,7 @@ export declare class OpenAPIOutputStructureParser {
     private readonly schemaConverter;
     private readonly schemaUtils;
     constructor(schemaConverter: SchemaConverter, schemaUtils: PublicSchemaUtils);
-    parse(contract: ANY_CONTRACT_PROCEDURE, structure: 'compact' | 'detailed'): OpenAPIOutputStructureParseResult;
+    parse(contract: AnyContractProcedure, structure: 'compact' | 'detailed'): OpenAPIOutputStructureParseResult;
     private parseDetailedSchema;
     private parseCompactSchema;
 }

package/dist/src/schema-converter.d.ts

@@ -4,8 +4,8 @@ export interface SchemaConvertOptions {
     strategy: 'input' | 'output';
 }
 export interface SchemaConverter {
-    condition: (schema: Schema, options: SchemaConvertOptions) => boolean;
-    convert: (schema: Schema, options: SchemaConvertOptions) => JSONSchema.JSONSchema;
+    condition(schema: Schema, options: SchemaConvertOptions): boolean;
+    convert(schema: Schema, options: SchemaConvertOptions): JSONSchema.JSONSchema;
 }
 export declare class CompositeSchemaConverter implements SchemaConverter {
     private readonly converters;

package/dist/src/schema.d.ts

@@ -8,5 +8,5 @@ export type FileSchema = JSONSchema.JSONSchema & {
     type: 'string';
     contentMediaType: string;
 } & object;
-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 NON_LOGIC_KEYWORDS: string[];
 //# sourceMappingURL=schema.d.ts.map

package/dist/src/utils.d.ts

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

package/dist/standard.js

@@ -0,0 +1,16 @@
+import {
+  CompositeSchemaCoercer,
+  OpenAPICodec,
+  OpenAPIMatcher,
+  OpenAPISerializer,
+  bracket_notation_exports
+} from "./chunk-M5HOHBLW.js";
+import "./chunk-BHJYKXQL.js";
+export {
+  bracket_notation_exports as BracketNotation,
+  CompositeSchemaCoercer,
+  OpenAPICodec,
+  OpenAPIMatcher,
+  OpenAPISerializer
+};
+//# sourceMappingURL=standard.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/openapi",
   "type": "module",
-  "version": "0.0.0-next.aa72097",
+  "version": "0.0.0-next.ad0709a",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -19,6 +19,11 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./standard": {
+      "types": "./dist/src/adapters/standard/index.d.ts",
+      "import": "./dist/standard.js",
+      "default": "./dist/standard.js"
+    },
     "./fetch": {
       "types": "./dist/src/adapters/fetch/index.d.ts",
       "import": "./dist/fetch.js",
@@ -29,6 +34,11 @@
       "import": "./dist/hono.js",
       "default": "./dist/hono.js"
     },
+    "./next": {
+      "types": "./dist/src/adapters/next/index.d.ts",
+      "import": "./dist/next.js",
+      "default": "./dist/next.js"
+    },
     "./node": {
       "types": "./dist/src/adapters/node/index.d.ts",
       "import": "./dist/node.js",
@@ -49,13 +59,13 @@
     "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",
+    "rou3": "^0.5.1",
     "wildcard-match": "^5.1.3",
-    "@orpc/contract": "0.0.0-next.aa72097",
-    "@orpc/shared": "0.0.0-next.aa72097",
-    "@orpc/server": "0.0.0-next.aa72097"
+    "@orpc/shared": "0.0.0-next.ad0709a",
+    "@orpc/server": "0.0.0-next.ad0709a",
+    "@orpc/contract": "0.0.0-next.ad0709a"
   },
   "devDependencies": {
     "@readme/openapi-parser": "^2.6.0",