@orpc/server 0.0.0-next.c59d67c → 0.0.0-next.c72b962

package/dist/shared/server.DLt5njUb.d.mts

@@ -0,0 +1,143 @@
+import { ORPCErrorCode, ORPCErrorOptions, ORPCError, HTTPPath, ClientContext, Client } from '@orpc/client';
+import { MaybeOptionalOptions, Promisable, Interceptor, Value } from '@orpc/shared';
+import { ErrorMap, ErrorMapItem, InferSchemaInput, AnySchema, Meta, ContractProcedureDef, InferSchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure } from '@orpc/contract';
+
+type Context = Record<PropertyKey, any>;
+type MergedInitialContext<TInitial extends Context, TAdditional extends Context, TCurrent extends Context> = TInitial & Omit<TAdditional, keyof TCurrent>;
+type MergedCurrentContext<T extends Context, U extends Context> = Omit<T, keyof U> & U;
+declare function mergeCurrentContext<T extends Context, U extends Context>(context: T, other: U): MergedCurrentContext<T, U>;
+
+type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'defined' | 'status'>;
+type ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> = (...rest: MaybeOptionalOptions<ORPCErrorConstructorMapItemOptions<TInData>>) => ORPCError<TCode, TInData>;
+type ORPCErrorConstructorMap<T extends ErrorMap> = {
+    [K in keyof T]: K extends ORPCErrorCode ? T[K] extends ErrorMapItem<infer UInputSchema> ? ORPCErrorConstructorMapItem<K, InferSchemaInput<UInputSchema>> : never : never;
+};
+declare function createORPCErrorConstructorMap<T extends ErrorMap>(errors: T): ORPCErrorConstructorMap<T>;
+declare function validateORPCError(map: ErrorMap, error: ORPCError<any, any>): Promise<ORPCError<string, unknown>>;
+
+declare const LAZY_SYMBOL: unique symbol;
+interface LazyMeta {
+    prefix?: HTTPPath;
+}
+interface Lazy<T> {
+    [LAZY_SYMBOL]: {
+        loader: () => Promise<{
+            default: T;
+        }>;
+        meta: LazyMeta;
+    };
+}
+type Lazyable<T> = T | Lazy<T>;
+declare function lazy<T>(loader: () => Promise<{
+    default: T;
+}>, meta?: LazyMeta): Lazy<T>;
+declare function isLazy(item: unknown): item is Lazy<any>;
+declare function getLazyMeta(lazied: Lazy<any>): LazyMeta;
+declare function unlazy<T extends Lazyable<any>>(lazied: T): Promise<{
+    default: T extends Lazy<infer U> ? U : T;
+}>;
+
+interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    context: TCurrentContext;
+    input: TInput;
+    path: readonly string[];
+    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+    errors: TErrorConstructorMap;
+}
+interface ProcedureHandler<TCurrentContext extends Context, TInput, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    (opt: ProcedureHandlerOptions<TCurrentContext, TInput, ORPCErrorConstructorMap<TErrorMap>, TMeta>): Promisable<THandlerOutput>;
+}
+interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    __initialContext?: (type: TInitialContext) => unknown;
+    middlewares: readonly AnyMiddleware[];
+    inputValidationIndex: number;
+    outputValidationIndex: number;
+    handler: ProcedureHandler<TCurrentContext, any, any, any, any>;
+}
+declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    constructor(def: ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>);
+}
+type AnyProcedure = Procedure<any, any, any, any, any, any>;
+declare function isProcedure(item: unknown): item is AnyProcedure;
+
+type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
+    output: TOutput;
+    context: TOutContext;
+}>;
+type MiddlewareNextFnOptions<TOutContext extends Context> = Record<never, never> extends TOutContext ? {
+    context?: TOutContext;
+} : {
+    context: TOutContext;
+};
+interface MiddlewareNextFn<TOutput> {
+    <U extends Context = Record<never, never>>(...rest: MaybeOptionalOptions<MiddlewareNextFnOptions<U>>): MiddlewareResult<U, TOutput>;
+}
+interface MiddlewareOutputFn<TOutput> {
+    (output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+}
+interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    context: TInContext;
+    path: readonly string[];
+    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+    next: MiddlewareNextFn<TOutput>;
+    errors: TErrorConstructorMap;
+}
+interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    (options: MiddlewareOptions<TInContext, TOutput, TErrorConstructorMap, TMeta>, input: TInput, output: MiddlewareOutputFn<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
+}
+type AnyMiddleware = Middleware<any, any, any, any, any, any>;
+interface MapInputMiddleware<TInput, TMappedInput> {
+    (input: TInput): TMappedInput;
+}
+declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+
+type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
+interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    context: TInitialContext;
+    input: unknown;
+    errors: ORPCErrorConstructorMap<TErrorMap>;
+    path: readonly string[];
+    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+}
+/**
+ * Options for creating a procedure caller with comprehensive type safety
+ */
+type CreateProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
+    /**
+     * This is helpful for logging and analytics.
+     */
+    path?: readonly string[];
+    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap, TMeta>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>[];
+} & (Record<never, never> extends TInitialContext ? {
+    context?: Value<TInitialContext, [clientContext: TClientContext]>;
+} : {
+    context: Value<TInitialContext, [clientContext: TClientContext]>;
+});
+declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>, ...[options]: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
+
+type Router<T extends AnyContractRouter, TInitialContext extends Context> = T extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, any, UInputSchema, UOutputSchema, UErrorMap, UMeta> : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? Lazyable<Router<T[K], TInitialContext>> : never;
+};
+type AnyRouter = Router<any, any>;
+type InferRouterInitialContext<T extends AnyRouter> = T extends Router<any, infer UInitialContext> ? UInitialContext : never;
+type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any, any> ? UInitialContext : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : never;
+};
+type InferRouterCurrentContexts<T extends AnyRouter> = T extends Procedure<any, infer UCurrentContext, any, any, any, any> ? UCurrentContext : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterCurrentContexts<U> : never;
+};
+type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any, any> ? InferSchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
+};
+type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, any, any> ? InferSchemaOutput<UOutputSchema> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
+};
+
+export { type AnyProcedure as A, middlewareOutputFn as B, type Context as C, type ProcedureHandlerOptions as D, type ProcedureDef as E, isProcedure as F, createProcedureClient as G, type InferRouterInitialContexts as H, type InferRouterInitialContext as I, type InferRouterCurrentContexts as J, type InferRouterInputs as K, type Lazyable as L, type Middleware as M, type InferRouterOutputs as N, type ORPCErrorConstructorMap as O, type ProcedureClientInterceptorOptions as P, type Router as R, type AnyRouter as a, Procedure as b, type MergedInitialContext as c, type MergedCurrentContext as d, type MapInputMiddleware as e, type CreateProcedureClientOptions as f, type ProcedureClient as g, type AnyMiddleware as h, type Lazy as i, type ProcedureHandler as j, type ORPCErrorConstructorMapItemOptions as k, type ORPCErrorConstructorMapItem as l, mergeCurrentContext as m, createORPCErrorConstructorMap as n, LAZY_SYMBOL as o, type LazyMeta as p, lazy as q, isLazy as r, getLazyMeta as s, type MiddlewareResult as t, unlazy as u, validateORPCError as v, type MiddlewareNextFnOptions as w, type MiddlewareNextFn as x, type MiddlewareOutputFn as y, type MiddlewareOptions as z };

package/dist/shared/server.DLt5njUb.d.ts

@@ -0,0 +1,143 @@
+import { ORPCErrorCode, ORPCErrorOptions, ORPCError, HTTPPath, ClientContext, Client } from '@orpc/client';
+import { MaybeOptionalOptions, Promisable, Interceptor, Value } from '@orpc/shared';
+import { ErrorMap, ErrorMapItem, InferSchemaInput, AnySchema, Meta, ContractProcedureDef, InferSchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure } from '@orpc/contract';
+
+type Context = Record<PropertyKey, any>;
+type MergedInitialContext<TInitial extends Context, TAdditional extends Context, TCurrent extends Context> = TInitial & Omit<TAdditional, keyof TCurrent>;
+type MergedCurrentContext<T extends Context, U extends Context> = Omit<T, keyof U> & U;
+declare function mergeCurrentContext<T extends Context, U extends Context>(context: T, other: U): MergedCurrentContext<T, U>;
+
+type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'defined' | 'status'>;
+type ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> = (...rest: MaybeOptionalOptions<ORPCErrorConstructorMapItemOptions<TInData>>) => ORPCError<TCode, TInData>;
+type ORPCErrorConstructorMap<T extends ErrorMap> = {
+    [K in keyof T]: K extends ORPCErrorCode ? T[K] extends ErrorMapItem<infer UInputSchema> ? ORPCErrorConstructorMapItem<K, InferSchemaInput<UInputSchema>> : never : never;
+};
+declare function createORPCErrorConstructorMap<T extends ErrorMap>(errors: T): ORPCErrorConstructorMap<T>;
+declare function validateORPCError(map: ErrorMap, error: ORPCError<any, any>): Promise<ORPCError<string, unknown>>;
+
+declare const LAZY_SYMBOL: unique symbol;
+interface LazyMeta {
+    prefix?: HTTPPath;
+}
+interface Lazy<T> {
+    [LAZY_SYMBOL]: {
+        loader: () => Promise<{
+            default: T;
+        }>;
+        meta: LazyMeta;
+    };
+}
+type Lazyable<T> = T | Lazy<T>;
+declare function lazy<T>(loader: () => Promise<{
+    default: T;
+}>, meta?: LazyMeta): Lazy<T>;
+declare function isLazy(item: unknown): item is Lazy<any>;
+declare function getLazyMeta(lazied: Lazy<any>): LazyMeta;
+declare function unlazy<T extends Lazyable<any>>(lazied: T): Promise<{
+    default: T extends Lazy<infer U> ? U : T;
+}>;
+
+interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    context: TCurrentContext;
+    input: TInput;
+    path: readonly string[];
+    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+    errors: TErrorConstructorMap;
+}
+interface ProcedureHandler<TCurrentContext extends Context, TInput, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    (opt: ProcedureHandlerOptions<TCurrentContext, TInput, ORPCErrorConstructorMap<TErrorMap>, TMeta>): Promisable<THandlerOutput>;
+}
+interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    __initialContext?: (type: TInitialContext) => unknown;
+    middlewares: readonly AnyMiddleware[];
+    inputValidationIndex: number;
+    outputValidationIndex: number;
+    handler: ProcedureHandler<TCurrentContext, any, any, any, any>;
+}
+declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    constructor(def: ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>);
+}
+type AnyProcedure = Procedure<any, any, any, any, any, any>;
+declare function isProcedure(item: unknown): item is AnyProcedure;
+
+type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
+    output: TOutput;
+    context: TOutContext;
+}>;
+type MiddlewareNextFnOptions<TOutContext extends Context> = Record<never, never> extends TOutContext ? {
+    context?: TOutContext;
+} : {
+    context: TOutContext;
+};
+interface MiddlewareNextFn<TOutput> {
+    <U extends Context = Record<never, never>>(...rest: MaybeOptionalOptions<MiddlewareNextFnOptions<U>>): MiddlewareResult<U, TOutput>;
+}
+interface MiddlewareOutputFn<TOutput> {
+    (output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+}
+interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    context: TInContext;
+    path: readonly string[];
+    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+    next: MiddlewareNextFn<TOutput>;
+    errors: TErrorConstructorMap;
+}
+interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    (options: MiddlewareOptions<TInContext, TOutput, TErrorConstructorMap, TMeta>, input: TInput, output: MiddlewareOutputFn<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
+}
+type AnyMiddleware = Middleware<any, any, any, any, any, any>;
+interface MapInputMiddleware<TInput, TMappedInput> {
+    (input: TInput): TMappedInput;
+}
+declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+
+type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
+interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    context: TInitialContext;
+    input: unknown;
+    errors: ORPCErrorConstructorMap<TErrorMap>;
+    path: readonly string[];
+    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+}
+/**
+ * Options for creating a procedure caller with comprehensive type safety
+ */
+type CreateProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
+    /**
+     * This is helpful for logging and analytics.
+     */
+    path?: readonly string[];
+    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap, TMeta>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>[];
+} & (Record<never, never> extends TInitialContext ? {
+    context?: Value<TInitialContext, [clientContext: TClientContext]>;
+} : {
+    context: Value<TInitialContext, [clientContext: TClientContext]>;
+});
+declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>, ...[options]: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
+
+type Router<T extends AnyContractRouter, TInitialContext extends Context> = T extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, any, UInputSchema, UOutputSchema, UErrorMap, UMeta> : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? Lazyable<Router<T[K], TInitialContext>> : never;
+};
+type AnyRouter = Router<any, any>;
+type InferRouterInitialContext<T extends AnyRouter> = T extends Router<any, infer UInitialContext> ? UInitialContext : never;
+type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any, any> ? UInitialContext : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : never;
+};
+type InferRouterCurrentContexts<T extends AnyRouter> = T extends Procedure<any, infer UCurrentContext, any, any, any, any> ? UCurrentContext : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterCurrentContexts<U> : never;
+};
+type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any, any> ? InferSchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
+};
+type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, any, any> ? InferSchemaOutput<UOutputSchema> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
+};
+
+export { type AnyProcedure as A, middlewareOutputFn as B, type Context as C, type ProcedureHandlerOptions as D, type ProcedureDef as E, isProcedure as F, createProcedureClient as G, type InferRouterInitialContexts as H, type InferRouterInitialContext as I, type InferRouterCurrentContexts as J, type InferRouterInputs as K, type Lazyable as L, type Middleware as M, type InferRouterOutputs as N, type ORPCErrorConstructorMap as O, type ProcedureClientInterceptorOptions as P, type Router as R, type AnyRouter as a, Procedure as b, type MergedInitialContext as c, type MergedCurrentContext as d, type MapInputMiddleware as e, type CreateProcedureClientOptions as f, type ProcedureClient as g, type AnyMiddleware as h, type Lazy as i, type ProcedureHandler as j, type ORPCErrorConstructorMapItemOptions as k, type ORPCErrorConstructorMapItem as l, mergeCurrentContext as m, createORPCErrorConstructorMap as n, LAZY_SYMBOL as o, type LazyMeta as p, lazy as q, isLazy as r, getLazyMeta as s, type MiddlewareResult as t, unlazy as u, validateORPCError as v, type MiddlewareNextFnOptions as w, type MiddlewareNextFn as x, type MiddlewareOutputFn as y, type MiddlewareOptions as z };

package/dist/shared/server.DOYDVeMX.d.mts

@@ -0,0 +1,73 @@
+import { HTTPPath, ORPCError } from '@orpc/client';
+import { Meta, InferSchemaOutput, AnySchema, ErrorFromErrorMap } from '@orpc/contract';
+import { Interceptor, ThrowableError } from '@orpc/shared';
+import { StandardResponse, StandardLazyRequest } from '@orpc/standard-server';
+import { a as AnyRouter, A as AnyProcedure, C as Context, P as ProcedureClientInterceptorOptions, R as Router } from './server.DLt5njUb.mjs';
+
+type StandardParams = Record<string, string>;
+type StandardMatchResult = {
+    path: readonly string[];
+    procedure: AnyProcedure;
+    params?: StandardParams;
+} | undefined;
+interface StandardMatcher {
+    init(router: AnyRouter): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+interface StandardCodec {
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+    decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
+}
+
+interface StandardHandlerPlugin<TContext extends Context> {
+    order?: number;
+    init?(options: StandardHandlerOptions<TContext>): void;
+}
+declare class CompositeStandardHandlerPlugin<T extends Context, TPlugin extends StandardHandlerPlugin<T>> implements StandardHandlerPlugin<T> {
+    protected readonly plugins: TPlugin[];
+    constructor(plugins?: readonly TPlugin[]);
+    init(options: StandardHandlerOptions<T>): void;
+}
+
+interface StandardHandleOptions<T extends Context> {
+    prefix?: HTTPPath;
+    context: T;
+}
+type StandardHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response: undefined;
+};
+interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
+    request: StandardLazyRequest;
+}
+interface StandardHandlerOptions<TContext extends Context> {
+    plugins?: StandardHandlerPlugin<TContext>[];
+    /**
+     * Interceptors at the request level, helpful when you want catch errors
+     */
+    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, ThrowableError>[];
+    /**
+     * Interceptors at the root level, helpful when you want override the request/response
+     */
+    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, ThrowableError>[];
+    /**
+     *
+     * Interceptors for procedure client.
+     */
+    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Record<never, never>, Meta>, InferSchemaOutput<AnySchema>, ErrorFromErrorMap<Record<never, never>>>[];
+}
+declare class StandardHandler<T extends Context> {
+    private readonly matcher;
+    private readonly codec;
+    private readonly interceptors;
+    private readonly clientInterceptors;
+    private readonly rootInterceptors;
+    constructor(router: Router<any, T>, matcher: StandardMatcher, codec: StandardCodec, options: NoInfer<StandardHandlerOptions<T>>);
+    handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
+}
+
+export { CompositeStandardHandlerPlugin as C, type StandardHandleOptions as S, type StandardHandlerOptions as a, StandardHandler as b, type StandardCodec as c, type StandardParams as d, type StandardMatcher as e, type StandardMatchResult as f, type StandardHandleResult as g, type StandardHandlerInterceptorOptions as h, type StandardHandlerPlugin as i };

package/dist/shared/server._2UufoXA.d.ts

@@ -0,0 +1,10 @@
+import { C as Context } from './server.DLt5njUb.js';
+import { S as StandardHandleOptions } from './server.DFFT_EZo.js';
+
+type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+
+export type { FriendlyStandardHandleOptions as F };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.0.0-next.c59d67c",
+  "version": "0.0.0-next.c72b962",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -15,38 +15,61 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./plugins": {
+      "types": "./dist/plugins/index.d.mts",
+      "import": "./dist/plugins/index.mjs",
+      "default": "./dist/plugins/index.mjs"
+    },
+    "./standard": {
+      "types": "./dist/adapters/standard/index.d.mts",
+      "import": "./dist/adapters/standard/index.mjs",
+      "default": "./dist/adapters/standard/index.mjs"
     },
     "./fetch": {
-      "types": "./dist/src/fetch/index.d.ts",
-      "import": "./dist/fetch.js",
-      "default": "./dist/fetch.js"
+      "types": "./dist/adapters/fetch/index.d.mts",
+      "import": "./dist/adapters/fetch/index.mjs",
+      "default": "./dist/adapters/fetch/index.mjs"
+    },
+    "./hono": {
+      "types": "./dist/adapters/hono/index.d.mts",
+      "import": "./dist/adapters/hono/index.mjs",
+      "default": "./dist/adapters/hono/index.mjs"
+    },
+    "./next": {
+      "types": "./dist/adapters/next/index.d.mts",
+      "import": "./dist/adapters/next/index.mjs",
+      "default": "./dist/adapters/next/index.mjs"
     },
-    "./🔒/*": {
-      "types": "./dist/src/*.d.ts"
+    "./node": {
+      "types": "./dist/adapters/node/index.d.mts",
+      "import": "./dist/adapters/node/index.mjs",
+      "default": "./dist/adapters/node/index.mjs"
     }
   },
   "files": [
-    "!**/*.map",
-    "!**/*.tsbuildinfo",
     "dist"
   ],
   "peerDependencies": {
-    "zod": ">=3.23.0",
-    "@orpc/zod": "0.0.0-next.c59d67c"
+    "hono": ">=4.6.0",
+    "next": ">=14.0.0"
   },
   "dependencies": {
-    "@orpc/contract": "0.0.0-next.c59d67c",
-    "@orpc/shared": "0.0.0-next.c59d67c",
-    "@orpc/transformer": "0.0.0-next.c59d67c"
+    "@orpc/client": "0.0.0-next.c72b962",
+    "@orpc/shared": "0.0.0-next.c72b962",
+    "@orpc/contract": "0.0.0-next.c72b962",
+    "@orpc/standard-server": "0.0.0-next.c72b962",
+    "@orpc/standard-server-fetch": "0.0.0-next.c72b962",
+    "@orpc/standard-server-node": "0.0.0-next.c72b962"
   },
   "devDependencies": {
-    "@orpc/openapi": "0.0.0-next.c59d67c"
+    "supertest": "^7.0.0"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.fetch=src/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "unbuild",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/chunk-TDFYNRZV.js

@@ -1,190 +0,0 @@
-// src/utils.ts
-function mergeContext(a, b) {
-  if (!a)
-    return b;
-  if (!b)
-    return a;
-  return {
-    ...a,
-    ...b
-  };
-}
-
-// src/middleware.ts
-var decoratedMiddlewareSymbol = Symbol("\u{1F512}decoratedMiddleware");
-function decorateMiddleware(middleware) {
-  if (Reflect.get(middleware, decoratedMiddlewareSymbol)) {
-    return middleware;
-  }
-  const concat = (concatMiddleware, mapInput2) => {
-    const concatMiddleware_ = mapInput2 ? decorateMiddleware(concatMiddleware).mapInput(mapInput2) : concatMiddleware;
-    return decorateMiddleware(async (input, context, meta, ...rest) => {
-      const input_ = input;
-      const context_ = context;
-      const meta_ = meta;
-      const next = async (options) => {
-        return concatMiddleware_(input_, mergeContext(context_, options.context), meta_, ...rest);
-      };
-      const m1 = await middleware(input_, context_, {
-        ...meta_,
-        next
-      }, ...rest);
-      return m1;
-    });
-  };
-  const mapInput = (map) => {
-    return decorateMiddleware(
-      (input, ...rest) => middleware(map(input), ...rest)
-    );
-  };
-  return Object.assign(middleware, {
-    [decoratedMiddlewareSymbol]: true,
-    concat,
-    mapInput
-  });
-}
-
-// src/procedure-caller.ts
-import { value } from "@orpc/shared";
-import { ORPCError } from "@orpc/shared/error";
-import { OpenAPIDeserializer } from "@orpc/transformer";
-function createProcedureCaller(options) {
-  const path = options.path ?? [];
-  const procedure = options.procedure;
-  const caller = async (input) => {
-    const input_ = (() => {
-      if (!(input instanceof FormData)) {
-        return input;
-      }
-      const transformer = new OpenAPIDeserializer({
-        schema: procedure.zz$p.contract.zz$cp.InputSchema
-      });
-      return transformer.deserializeAsFormData(input);
-    })();
-    const validInput = (() => {
-      const schema = procedure.zz$p.contract.zz$cp.InputSchema;
-      if (!schema) {
-        return input_;
-      }
-      try {
-        return schema.parse(input_);
-      } catch (e) {
-        throw new ORPCError({
-          message: "Validation input failed",
-          code: "BAD_REQUEST",
-          cause: e
-        });
-      }
-    })();
-    const middlewares = procedure.zz$p.middlewares ?? [];
-    let currentMidIndex = 0;
-    let currentContext = await value(options.context);
-    const next = async (nextOptions) => {
-      const mid = middlewares[currentMidIndex];
-      currentMidIndex += 1;
-      currentContext = mergeContext(currentContext, nextOptions.context);
-      if (mid) {
-        return await mid(validInput, currentContext, {
-          path,
-          procedure,
-          next,
-          output: (output2) => ({ output: output2, context: void 0 })
-        });
-      } else {
-        return {
-          output: await await procedure.zz$p.func(validInput, currentContext, {
-            path,
-            procedure
-          }),
-          context: currentContext
-        };
-      }
-    };
-    const output = (await next({})).output;
-    const validOutput = await (async () => {
-      const schema = procedure.zz$p.contract.zz$cp.OutputSchema;
-      if (!schema) {
-        return output;
-      }
-      const result = await schema.safeParseAsync(output);
-      if (result.error) {
-        throw new ORPCError({
-          message: "Validation output failed",
-          code: "INTERNAL_SERVER_ERROR",
-          cause: result.error
-        });
-      }
-      return result.data;
-    })();
-    return validOutput;
-  };
-  return caller;
-}
-
-// src/procedure.ts
-import {
-  DecoratedContractProcedure,
-  isContractProcedure
-} from "@orpc/contract";
-var Procedure = class {
-  constructor(zz$p) {
-    this.zz$p = zz$p;
-  }
-};
-var DECORATED_PROCEDURE_SYMBOL = Symbol("DECORATED_PROCEDURE");
-function decorateProcedure(procedure) {
-  if (DECORATED_PROCEDURE_SYMBOL in procedure) {
-    return procedure;
-  }
-  return Object.assign(createProcedureCaller({
-    procedure,
-    context: void 0
-  }), {
-    [DECORATED_PROCEDURE_SYMBOL]: true,
-    zz$p: procedure.zz$p,
-    prefix(prefix) {
-      return decorateProcedure({
-        zz$p: {
-          ...procedure.zz$p,
-          contract: DecoratedContractProcedure.decorate(
-            procedure.zz$p.contract
-          ).prefix(prefix)
-        }
-      });
-    },
-    route(opts) {
-      return decorateProcedure({
-        zz$p: {
-          ...procedure.zz$p,
-          contract: DecoratedContractProcedure.decorate(
-            procedure.zz$p.contract
-          ).route(opts)
-        }
-      });
-    },
-    use(middleware, mapInput) {
-      const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-      return decorateProcedure({
-        zz$p: {
-          ...procedure.zz$p,
-          middlewares: [middleware_, ...procedure.zz$p.middlewares ?? []]
-        }
-      });
-    }
-  });
-}
-function isProcedure(item) {
-  if (item instanceof Procedure)
-    return true;
-  return (typeof item === "object" || typeof item === "function") && item !== null && "zz$p" in item && typeof item.zz$p === "object" && item.zz$p !== null && "contract" in item.zz$p && isContractProcedure(item.zz$p.contract) && "func" in item.zz$p && typeof item.zz$p.func === "function";
-}
-
-export {
-  mergeContext,
-  decorateMiddleware,
-  createProcedureCaller,
-  Procedure,
-  decorateProcedure,
-  isProcedure
-};
-//# sourceMappingURL=chunk-TDFYNRZV.js.map