@orpc/server 2.0.0-beta.5 → 2.0.0-beta.50

package/dist/index.d.mts

@@ -1,196 +0,0 @@
-import { AnyORPCError, ClientOptions, ClientContext } from '@orpc/client';
-export { AnyORPCError, AnyORPCErrorJSON, COMMON_ERROR_STATUS_MAP, Client, ClientContext, ClientOptions, ClientRest, FriendlyClientOptions, ORPCError, ORPCErrorCode, ORPCErrorJSON, ORPCErrorOptions, RPCJsonSerialization, RPCJsonSerializationMeta, RPCJsonSerializer, RPCJsonSerializerHandler, RPCJsonSerializerOptions, RPCSerializer, RPCSerializerOptions, RPCSerializerSerializeOptions, SafeResult, cloneORPCError, isDefinedError, isInferableError, safe, toORPCError } from '@orpc/client';
-import { ErrorMap, MergedErrorMap, AnySchema, MetaPlugin, InferSchemaOutput, InferSchemaInput, AugmentContractRouterOptions, RouterContract, AnyProcedureContract, InitialInputSchema, InitialOutputSchema, MergedSchema, Schema, ProcedureContractDefinition, ProcedureContract, InferRouterContractErrorMap, ORPCErrorFromErrorMap } from '@orpc/contract';
-export { AnyMetaPlugin, AnySchema, ErrorMap, ErrorMapItem, InferSchemaInput, InferSchemaOutput, MergedErrorMap, Meta, MetaPlugin, MetaPluginDefinition, ORPCErrorFromErrorMap, ProcedureContract, ProcedureContractDefinition, RouterContract, Schema, ValidationError, defineMeta, eventIterator, reconcileORPCError, type } from '@orpc/contract';
-import { IntersectPick, Promisable, Public, PromiseWithError, ThrowableError, MaybeOptionalOptions } from '@orpc/shared';
-export { AsyncCleanupFn, AsyncIteratorClass, AsyncIteratorClassNextFn, MaybeOptionalOptions, PromiseWithError, Registry, ThrowableError, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
-import { C as Context, d as Middleware, M as MergedContext, e as MergedInitialContext, a as Procedure, f as AnyMiddleware, g as Lazy, A as AnyProcedure, L as Lazyable, h as ProcedureHandler, O as ORPCErrorConstructorMap, i as OrderedMiddleware, P as ProcedureClientOptions, b as ProcedureClient } from './shared/server.BL22TloH.mjs';
-export { j as LazyDefinition, k as MiddlewareDefinition, l as MiddlewareDone, m as MiddlewareDoneOptions, n as MiddlewareNext, o as MiddlewareNextOptions, p as MiddlewareOptions, q as MiddlewareResult, r as ORPCErrorConstructorMapItem, s as ORPCErrorConstructorMapItemOptions, c as ProcedureClientInterceptor, t as ProcedureClientInterceptorOptions, u as ProcedureDefinition, v as ProcedureHandlerOptions, w as createORPCErrorConstructorMap, x as createProcedureClient, y as unlazy } from './shared/server.BL22TloH.mjs';
-import { A as AnyRouter, R as Router, C as ContractedRouter, I as InferRouterInitialContext } from './shared/server.BsNNjG5J.mjs';
-export { a as InferRouterError, b as InferRouterErrors, c as InferRouterFinalContexts, d as InferRouterInitialContexts, e as InferRouterInputs, f as InferRouterOutputs } from './shared/server.BsNNjG5J.mjs';
-export { ErrorEvent, EventMeta, getEventMeta, unwrapEvent, withEventMeta } from '@standardserver/core';
-
-interface DecoratedMiddleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorMap extends ErrorMap> extends Middleware<TInContext, TOutContext, TInput, TOutput, TErrorMap> {
-    adaptInput<T>(adapt: (input: T) => TInput): DecoratedMiddleware<TInContext, TOutContext, T, TOutput, TErrorMap>;
-    errors<T extends ErrorMap>(errors: T): DecoratedMiddleware<TInContext, TOutContext, TInput, TOutput, MergedErrorMap<TErrorMap, T>>;
-    use<$OutContext extends IntersectPick<MergedContext<TInContext, TOutContext>, $OutContext>, $Input extends TInput, $InContext extends Context = MergedContext<TInContext, TOutContext>, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | MergedContext<TInContext, TOutContext>, $OutContext, $Input, TOutput, $ErrorMap>): DecoratedMiddleware<MergedInitialContext<TInContext, TOutContext, $InContext>, MergedContext<TOutContext, $OutContext>, $Input, TOutput, MergedErrorMap<$ErrorMap, TErrorMap>>;
-}
-declare function decorateMiddleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorMap extends ErrorMap>(middleware: Middleware<TInContext, TOutContext, TInput, TOutput, TErrorMap>): DecoratedMiddleware<TInContext, TOutContext, TInput, TOutput, TErrorMap>;
-
-declare class DecoratedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> extends Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError> {
-    meta(...plugins: MetaPlugin<TInputSchema, TOutputSchema, TErrorMap>[]): DecoratedProcedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
-    errors<T extends ErrorMap>(errors: T): DecoratedProcedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, T>, TReturnedError>;
-    use<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, InferSchemaOutput<TInputSchema>, InferSchemaInput<TOutputSchema>, $ErrorMap>): DecoratedProcedure<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, TInputSchema, TOutputSchema, MergedErrorMap<$ErrorMap, TErrorMap>, TReturnedError>;
-}
-
-type AugmentedRouter<T extends AnyRouter, TErrorMap extends ErrorMap> = T extends Procedure<infer $InitialContext, infer $CurrentContext, infer $InputSchema, infer $OutputSchema, infer $ErrorMap, infer $ReturnedORPCError> ? Procedure<$InitialContext, $CurrentContext, $InputSchema, $OutputSchema, MergedErrorMap<TErrorMap, $ErrorMap>, $ReturnedORPCError> : {
-    [K in keyof T]: T[K] extends Lazy<infer $ extends AnyRouter> ? Lazy<AugmentedRouter<$, TErrorMap>> : T[K] extends AnyRouter ? AugmentedRouter<T[K], TErrorMap> : never;
-};
-type AugmentedRouterWithMiddlewares<T extends AnyRouter, TInitialContext extends Context, TInjectedContext extends Context, TErrorMap extends ErrorMap> = T extends Procedure<infer $InitialContext, infer $CurrentContext, infer $InputSchema, infer $OutputSchema, infer $ErrorMap, infer $ReturnedORPCError> ? Procedure<MergedInitialContext<TInitialContext, TInjectedContext, $InitialContext>, $CurrentContext, $InputSchema, $OutputSchema, MergedErrorMap<TErrorMap, $ErrorMap>, $ReturnedORPCError> : {
-    [K in keyof T]: T[K] extends Lazy<infer $ extends AnyRouter> ? Lazy<AugmentedRouterWithMiddlewares<$, TInitialContext, TInjectedContext, TErrorMap>> : T[K] extends AnyRouter ? AugmentedRouterWithMiddlewares<T[K], TInitialContext, TInjectedContext, TErrorMap> : never;
-};
-interface AugmentRouterOptions<TErrorMap extends ErrorMap> extends AugmentContractRouterOptions<TErrorMap> {
-    middlewares: AnyMiddleware[];
-}
-declare function augmentRouter<T extends AnyRouter, TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap>(router: T, options: AugmentRouterOptions<TErrorMap>): AugmentedRouter<T, TErrorMap> | AugmentedRouterWithMiddlewares<T, TInitialContext, TCurrentContext, TErrorMap>;
-interface AugmentImplementedRouterOptions {
-    middlewares: AnyMiddleware[];
-}
-declare function augmentImplementedRouter<T extends AnyRouter, TInitialContext extends Context, TCurrentContext extends Context>(router: T, options: AugmentImplementedRouterOptions): AugmentedRouter<T, object> | AugmentedRouterWithMiddlewares<T, TInitialContext, TCurrentContext, object>;
-declare function getRouter<T extends Lazyable<AnyRouter | undefined>>(router: T, path: readonly string[]): T extends Lazy<any> ? Lazy<AnyRouter | undefined> : Lazyable<AnyRouter | undefined>;
-interface WalkProcedureContractsLazyResult {
-    router: Lazy<AnyRouter>;
-    path: string[];
-}
-declare function walkProcedureContractsSync(router: RouterContract | AnyRouter, callback: (contract: AnyProcedureContract | AnyProcedure, path: string[]) => void, path?: string[]): WalkProcedureContractsLazyResult[];
-declare function walkProcedureContractsAsync(router: RouterContract | AnyRouter, callback: (contract: AnyProcedureContract | AnyProcedure, path: string[]) => Promisable<void>, path?: string[]): Promise<void>;
-type UnlaziedRouter<T extends AnyRouter> = T extends AnyProcedure ? T : {
-    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? UnlaziedRouter<U> : never;
-};
-declare function unlazyRouter<T extends AnyRouter>(router: T): Promise<UnlaziedRouter<T>>;
-
-interface BuilderWithMiddlewares<TInitialContext extends Context, TInjectedContext extends Context, TErrorMap extends ErrorMap> {
-    '~orpc': BuilderDefinition<InitialInputSchema, InitialOutputSchema, TErrorMap>;
-    'meta'(...plugins: MetaPlugin<InitialInputSchema, InitialOutputSchema, TErrorMap>[]): BuilderWithMiddlewares<TInitialContext, TInjectedContext, TErrorMap>;
-    'errors'<T extends ErrorMap>(errors: T): BuilderWithMiddlewares<TInitialContext, TInjectedContext, MergedErrorMap<TErrorMap, T>>;
-    'use'<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, InferSchemaOutput<InitialInputSchema>, InferSchemaInput<InitialOutputSchema>, $ErrorMap>): BuilderWithMiddlewares<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, MergedErrorMap<$ErrorMap, TErrorMap>>;
-    'middleware'<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $Input, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $Output = any>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, $Input, $Output, TErrorMap>): DecoratedMiddleware<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, $Input, $Output, TErrorMap>;
-    'input'<T extends AnySchema>(schema: T): BuilderWithInput<TInitialContext, TInjectedContext, T, TErrorMap>;
-    'output'<T extends AnySchema>(schema: T): BuilderWithOutput<TInitialContext, TInjectedContext, T, TErrorMap>;
-    'handler'<T>(handler: ProcedureHandler<MergedContext<TInitialContext, TInjectedContext>, InferSchemaOutput<InitialInputSchema>, T, ORPCErrorConstructorMap<TErrorMap>>): DecoratedProcedure<TInitialContext, TInjectedContext, InitialInputSchema, Schema<Exclude<T, AnyORPCError>>, TErrorMap, Extract<T, AnyORPCError>>;
-    'router'<T extends Router<MergedContext<TInitialContext, TInjectedContext>>>(router: T): AugmentedRouterWithMiddlewares<T, TInitialContext, TInjectedContext, TErrorMap>;
-    'lazy'<T extends Router<MergedContext<TInitialContext, TInjectedContext>>>(loader: () => Promise<{
-        default: T;
-    }>): Lazy<AugmentedRouterWithMiddlewares<T, TInitialContext, TInjectedContext, TErrorMap>>;
-}
-interface BuilderWithInput<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-    '~orpc': BuilderDefinition<TInputSchema, InitialOutputSchema, TErrorMap>;
-    'meta'(...plugins: MetaPlugin<TInputSchema, InitialOutputSchema, TErrorMap>[]): BuilderWithInput<TInitialContext, TInjectedContext, TInputSchema, TErrorMap>;
-    'errors'<T extends ErrorMap>(errors: T): BuilderWithInput<TInitialContext, TInjectedContext, TInputSchema, MergedErrorMap<TErrorMap, T>>;
-    'use'<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, InferSchemaOutput<TInputSchema>, InferSchemaInput<InitialOutputSchema>, $ErrorMap>): BuilderWithInput<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, TInputSchema, MergedErrorMap<$ErrorMap, TErrorMap>>;
-    'input'<T extends AnySchema>(schema: T): BuilderWithInput<TInitialContext, TInjectedContext, MergedSchema<T, TInputSchema>, TErrorMap>;
-    'output'<T extends AnySchema>(schema: T): BuilderWithInputOutput<TInitialContext, TInjectedContext, TInputSchema, T, TErrorMap>;
-    'handler'<T>(handler: ProcedureHandler<MergedContext<TInitialContext, TInjectedContext>, InferSchemaOutput<TInputSchema>, T, ORPCErrorConstructorMap<TErrorMap>>): DecoratedProcedure<TInitialContext, TInjectedContext, TInputSchema, Schema<Exclude<T, AnyORPCError>>, TErrorMap, Extract<T, AnyORPCError>>;
-}
-interface BuilderWithOutput<TInitialContext extends Context, TInjectedContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-    '~orpc': BuilderDefinition<InitialInputSchema, TOutputSchema, TErrorMap>;
-    'meta'(...plugins: MetaPlugin<InitialInputSchema, TOutputSchema, TErrorMap>[]): BuilderWithOutput<TInitialContext, TInjectedContext, TOutputSchema, TErrorMap>;
-    'errors'<T extends ErrorMap>(errors: T): BuilderWithOutput<TInitialContext, TInjectedContext, TOutputSchema, MergedErrorMap<TErrorMap, T>>;
-    'use'<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, InferSchemaOutput<InitialInputSchema>, InferSchemaInput<TOutputSchema>, $ErrorMap>): BuilderWithOutput<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, TOutputSchema, MergedErrorMap<$ErrorMap, TErrorMap>>;
-    'input'<T extends AnySchema>(schema: T): BuilderWithInputOutput<TInitialContext, TInjectedContext, T, TOutputSchema, TErrorMap>;
-    'output'<T extends AnySchema>(schema: T): BuilderWithOutput<TInitialContext, TInjectedContext, MergedSchema<T, TOutputSchema>, TErrorMap>;
-    'handler'<T extends InferSchemaInput<TOutputSchema> | AnyORPCError>(handler: ProcedureHandler<MergedContext<TInitialContext, TInjectedContext>, InferSchemaOutput<InitialInputSchema>, T, ORPCErrorConstructorMap<TErrorMap>>): DecoratedProcedure<TInitialContext, TInjectedContext, InitialInputSchema, TOutputSchema, TErrorMap, Extract<T, AnyORPCError>>;
-}
-interface BuilderWithInputOutput<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-    '~orpc': BuilderDefinition<TInputSchema, TOutputSchema, TErrorMap>;
-    'meta'(...plugins: MetaPlugin<TInputSchema, TOutputSchema, TErrorMap>[]): BuilderWithInputOutput<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
-    'errors'<T extends ErrorMap>(errors: T): BuilderWithInputOutput<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, T>>;
-    'use'<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, InferSchemaOutput<TInputSchema>, InferSchemaInput<TOutputSchema>, $ErrorMap>): BuilderWithInputOutput<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, TInputSchema, TOutputSchema, MergedErrorMap<$ErrorMap, TErrorMap>>;
-    'input'<T extends AnySchema>(schema: T): BuilderWithInputOutput<TInitialContext, TInjectedContext, MergedSchema<T, TInputSchema>, TOutputSchema, TErrorMap>;
-    'output'<T extends AnySchema>(schema: T): BuilderWithInputOutput<TInitialContext, TInjectedContext, TInputSchema, MergedSchema<T, TOutputSchema>, TErrorMap>;
-    'handler'<T extends InferSchemaInput<TOutputSchema> | AnyORPCError>(handler: ProcedureHandler<MergedContext<TInitialContext, TInjectedContext>, InferSchemaOutput<TInputSchema>, T, ORPCErrorConstructorMap<TErrorMap>>): DecoratedProcedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, Extract<T, AnyORPCError>>;
-}
-
-interface DefaultInitialContext {
-}
-interface BuilderDefinition<TInputSchema extends AnySchema, TInjectedContext extends AnySchema, TErrorMap extends ErrorMap> extends ProcedureContractDefinition<TInputSchema, TInjectedContext, TErrorMap> {
-    orderedMiddlewares: OrderedMiddleware[];
-}
-declare class Builder<TInitialContext extends Context, TErrorMap extends ErrorMap> {
-    '~orpc': BuilderDefinition<InitialInputSchema, InitialOutputSchema, TErrorMap>;
-    private constructor();
-    static create<T extends Context = DefaultInitialContext>(): Builder<T & object, Record<never, never>>;
-    $context<T extends Context = DefaultInitialContext>(): Builder<T & object, TErrorMap>;
-    meta(...plugins: MetaPlugin<InitialInputSchema, InitialOutputSchema, TErrorMap>[]): Builder<TInitialContext, TErrorMap>;
-    errors<U extends ErrorMap>(errors: U): Builder<TInitialContext, MergedErrorMap<TErrorMap, U>>;
-    use<$OutContext extends IntersectPick<TInitialContext, $OutContext>, $InContext extends Context = TInitialContext, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | TInitialContext, $OutContext, InferSchemaOutput<InitialInputSchema>, InferSchemaInput<InitialOutputSchema>, $ErrorMap>): BuilderWithMiddlewares<MergedInitialContext<TInitialContext, object, $InContext>, $OutContext, MergedErrorMap<$ErrorMap, TErrorMap>>;
-    middleware<$OutContext extends IntersectPick<TInitialContext, $OutContext>, $Input, $Output = any>(middleware: Middleware<TInitialContext, $OutContext, $Input, $Output, TErrorMap>): DecoratedMiddleware<TInitialContext, $OutContext, $Input, $Output, TErrorMap>;
-    input<$ extends AnySchema>(schema: $): BuilderWithInput<TInitialContext, object, $, TErrorMap>;
-    output<$ extends AnySchema>(schema: $): BuilderWithOutput<TInitialContext, object, $, TErrorMap>;
-    handler<T>(handler: ProcedureHandler<TInitialContext, InferSchemaOutput<InitialInputSchema>, T, ORPCErrorConstructorMap<TErrorMap>>): DecoratedProcedure<TInitialContext, object, InitialInputSchema, Schema<Exclude<T, AnyORPCError>>, TErrorMap, Extract<T, AnyORPCError>>;
-    router<T extends AnyRouter>(router: T): AugmentedRouter<T, TErrorMap>;
-    lazy<T extends AnyRouter>(loader: () => Promise<{
-        default: T;
-    }>): Lazy<AugmentedRouter<T, TErrorMap>>;
-}
-declare const os: Builder<DefaultInitialContext & object, Record<never, never>>;
-
-declare const DEFAULT_SUCCESS_STATUS = 200;
-declare const DEFAULT_ERROR_STATUS = 500;
-
-declare class ProcedureImplementer<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-    '~orpc': BuilderDefinition<TInputSchema, TOutputSchema, TErrorMap>;
-    constructor(definition: BuilderDefinition<TInputSchema, TOutputSchema, TErrorMap>);
-    'use'<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, InferSchemaOutput<TInputSchema>, InferSchemaInput<TOutputSchema>, $ErrorMap>): ProcedureImplementer<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, TInputSchema, TOutputSchema, TErrorMap>;
-    'handler'(handler: ProcedureHandler<MergedContext<TInitialContext, TInjectedContext>, InferSchemaOutput<TInputSchema>, AnyORPCError | InferSchemaInput<TOutputSchema>, ORPCErrorConstructorMap<TErrorMap>>): ImplementedProcedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
-}
-declare class ImplementedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> extends Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, never> {
-    use<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, InferSchemaOutput<TInputSchema>, InferSchemaInput<TOutputSchema>, $ErrorMap>): ImplementedProcedure<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, TInputSchema, TOutputSchema, TErrorMap>;
-}
-
-declare class SharedRouterImplementer<TContract extends RouterContract, TInitialContext extends Context> {
-    private readonly contract;
-    private readonly middlewares;
-    private constructor();
-    static create<TContract extends RouterContract, TInitialContext extends Context>(contract: TContract): SharedRouterImplementer<TContract, TInitialContext>;
-    static create<TContract extends RouterContract, TInitialContext extends Context, TInjectedContext extends Context>(contract: TContract, middlewares: AnyMiddleware[]): SharedRouterImplementerWithMiddlewares<TContract, TInitialContext, TInjectedContext>;
-    use<$OutContext extends IntersectPick<TInitialContext, $OutContext>, $InContext extends Context = TInitialContext, $ErrorMap extends ErrorMap = InferRouterContractErrorMap<TContract>>(middleware: Middleware<$InContext | TInitialContext, $OutContext, unknown, unknown, $ErrorMap>): RouterImplementerWithMiddlewares<TContract, MergedInitialContext<TInitialContext, object, $InContext>, $OutContext>;
-    middleware<$OutContext extends IntersectPick<TInitialContext, $OutContext>, $Input, $InContext extends Context = TInitialContext, $Output = any>(middleware: Middleware<$InContext | TInitialContext, $OutContext, $Input, $Output, InferRouterContractErrorMap<TContract>>): DecoratedMiddleware<MergedInitialContext<TInitialContext, object, $InContext>, $OutContext, $Input, $Output, object>;
-    router<T extends ContractedRouter<TContract, any>>(router: T): T;
-    lazy<T extends ContractedRouter<TContract, any>>(loader: () => Promise<{
-        default: T;
-    }>): Lazy<T>;
-}
-interface SharedRouterImplementerWithMiddlewares<TContract extends RouterContract, TInitialContext extends Context, TInjectedContext extends Context> {
-    use<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $ErrorMap extends ErrorMap = InferRouterContractErrorMap<TContract>>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, unknown, unknown, $ErrorMap>): RouterImplementerWithMiddlewares<TContract, MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>>;
-    middleware<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $Input, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $Output = any>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, $Input, $Output, InferRouterContractErrorMap<TContract>>): DecoratedMiddleware<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, $Input, $Output, object>;
-    router<T extends ContractedRouter<TContract, MergedContext<TInitialContext, TInjectedContext>>>(router: T): AugmentedRouterWithMiddlewares<T, TInitialContext, TInjectedContext, object>;
-    lazy<T extends ContractedRouter<TContract, any>>(loader: () => Promise<{
-        default: T;
-    }>): Lazy<AugmentedRouterWithMiddlewares<T, TInitialContext, TInjectedContext, object>>;
-}
-type RouterImplementer<TContract extends RouterContract, TInitialContext extends Context> = TContract extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? ProcedureImplementer<TInitialContext, object, $InputSchema, $OutputSchema, $ErrorMap> : Public<SharedRouterImplementer<TContract, TInitialContext>> & {
-    [K in keyof TContract]: TContract[K] extends RouterContract ? RouterImplementer<TContract[K], TInitialContext> : never;
-};
-type RouterImplementerWithMiddlewares<TContract extends RouterContract, TInitialContext extends Context, TInjectedContext extends Context> = TContract extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? ProcedureImplementer<TInitialContext, TInjectedContext, $InputSchema, $OutputSchema, $ErrorMap> : SharedRouterImplementerWithMiddlewares<TContract, TInitialContext, TInjectedContext> & {
-    [K in keyof TContract]: TContract[K] extends RouterContract ? RouterImplementerWithMiddlewares<TContract[K], TInitialContext, TInjectedContext> : never;
-};
-declare function createRouterImplementer<TContract extends RouterContract, TInitialContext extends Context>(contract: TContract): RouterImplementer<TContract, TInitialContext>;
-
-type Implementer<TContract extends RouterContract, TInitialContext extends Context> = {
-    $context<T extends Context = DefaultInitialContext>(): Implementer<TContract, T & object>;
-} & RouterImplementer<TContract, TInitialContext>;
-declare function implement<TContract extends RouterContract, TInitialContext extends Context = DefaultInitialContext>(contract: TContract): Implementer<TContract, TInitialContext & object>;
-
-declare function createGuardedProcedureLazy(lazy: Lazy<unknown>): Lazy<AnyProcedure>;
-/**
- * Create a new procedure that ensure the contract is applied to the procedure.
- *
- * .input/.output/.handler mismatches are already caught by the `implementer.router`,
- * but .errors (in case implemented procedure error map is more than enough) and .meta cannot be
- * validated that way - so they must be overridden here to ensure the client always sees what the contract defines.
- */
-declare function createContractProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap>(procedure: Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, any, any>, contract: ProcedureContract<any, any, TErrorMap>): Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, never>;
-type CallOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> = ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError, object> & Omit<ClientOptions<object>, 'context'>;
-type CallRest<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> = object extends CallOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError> ? undefined extends InferSchemaInput<TInputSchema> ? [input?: InferSchemaInput<TInputSchema>, options?: CallOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError>] : [input: InferSchemaInput<TInputSchema>, options?: CallOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError>] : [input: InferSchemaInput<TInputSchema>, options: CallOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError>];
-/**
- * Quickly call a procedure without creating a client.
- *
- * @example
- * ```ts
- * const output = await call(getting, 'input')
- * const output = await call(getting, 'input', { context: { db: 'postgres' } })
- * ```
- */
-declare function call<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>>, ...[input, options,]: CallRest<TInitialContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>): PromiseWithError<InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | TReturnedError | ThrowableError>;
-
-type RouterClient<TRouter extends AnyRouter, TClientContext extends ClientContext = object> = TRouter extends Procedure<any, any, infer $InputSchema, infer $OutputSchema, infer $ErrorMap, infer $ReturnedError> ? ProcedureClient<TClientContext, $InputSchema, $OutputSchema, $ErrorMap, $ReturnedError> : {
-    [K in keyof TRouter]: TRouter[K] extends Lazyable<infer U extends AnyRouter> ? RouterClient<U, TClientContext> : never;
-};
-declare function createRouterClient<T extends AnyRouter, TClientContext extends ClientContext = object>(router: Lazyable<T | undefined>, ...rest: MaybeOptionalOptions<ProcedureClientOptions<InferRouterInitialContext<T>, Schema<unknown>, ErrorMap, any, TClientContext>>): RouterClient<T, TClientContext>;
-
-declare function withHiddenRouterContract<T extends Lazyable<AnyRouter>>(router: T, contract: RouterContract): T;
-declare function getHiddenRouterContract(router: Lazyable<AnyRouter | RouterContract>): RouterContract | undefined;
-
-export { AnyMiddleware, AnyProcedure, AnyRouter, Builder, Context, ContractedRouter, DEFAULT_ERROR_STATUS, DEFAULT_SUCCESS_STATUS, DecoratedProcedure, ImplementedProcedure, InferRouterInitialContext, Lazy, Lazyable, MergedContext, MergedInitialContext, Middleware, ORPCErrorConstructorMap, OrderedMiddleware, Procedure, ProcedureClient, ProcedureClientOptions, ProcedureHandler, ProcedureImplementer, Router, SharedRouterImplementer, augmentImplementedRouter, augmentRouter, call, createContractProcedure, createGuardedProcedureLazy, createRouterClient, createRouterImplementer, decorateMiddleware, getHiddenRouterContract, getRouter, implement, os, unlazyRouter, walkProcedureContractsAsync, walkProcedureContractsSync, withHiddenRouterContract };
-export type { AugmentImplementedRouterOptions, AugmentRouterOptions, AugmentedRouter, AugmentedRouterWithMiddlewares, BuilderDefinition, BuilderWithInput, BuilderWithInputOutput, BuilderWithMiddlewares, BuilderWithOutput, CallOptions, CallRest, DecoratedMiddleware, DefaultInitialContext, Implementer, RouterClient, RouterImplementer, RouterImplementerWithMiddlewares, SharedRouterImplementerWithMiddlewares, UnlaziedRouter, WalkProcedureContractsLazyResult };

package/dist/index.mjs

@@ -1,385 +0,0 @@
-import { mergeErrorMap, resolveMetaPlugins, getHiddenMetaPlugins, ProcedureContract } from '@orpc/contract';
-export { ValidationError, defineMeta, eventIterator, reconcileORPCError, type } from '@orpc/contract';
-import { toArray, bindMethods, getOrBind, isTypescriptObject, resolveMaybeOptionalOptions } from '@orpc/shared';
-export { AsyncIteratorClass, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
-import { L as Lazy, P as Procedure, c as createProcedureClient } from './shared/server.CrlKQucM.mjs';
-export { a as createORPCErrorConstructorMap, u as unlazy } from './shared/server.CrlKQucM.mjs';
-import { D as DecoratedProcedure } from './shared/server.CjOb6ItT.mjs';
-import { b as augmentRouter, d as augmentImplementedRouter, e as withHiddenRouterContract, f as createGuardedProcedureLazy, g as getRouter } from './shared/server.BwHnWUuN.mjs';
-export { a as DEFAULT_ERROR_STATUS, D as DEFAULT_SUCCESS_STATUS, h as call, c as createContractProcedure, i as getHiddenRouterContract, u as unlazyRouter, j as walkProcedureContractsAsync, w as walkProcedureContractsSync } from './shared/server.BwHnWUuN.mjs';
-import { RECURSIVE_CLIENT_UNWRAP_KEYS } from '@orpc/client';
-export { COMMON_ERROR_STATUS_MAP, ORPCError, RPCJsonSerializer, RPCSerializer, cloneORPCError, isDefinedError, isInferableError, safe, toORPCError } from '@orpc/client';
-export { ErrorEvent, getEventMeta, unwrapEvent, withEventMeta } from '@standardserver/core';
-
-function decorateMiddleware(middleware) {
-  const decorated = ((...args) => middleware(...args));
-  decorated["~orpc"] = middleware["~orpc"];
-  Object.defineProperty(decorated, "name", {
-    value: middleware.name
-  });
-  decorated.adaptInput = (adapt) => {
-    const mapped = decorateMiddleware(
-      (opts, input, ...args) => {
-        return middleware(opts, adapt(input), ...args);
-      }
-    );
-    mapped["~orpc"] = middleware["~orpc"];
-    Object.defineProperty(mapped, "name", {
-      value: middleware.name
-    });
-    return mapped;
-  };
-  decorated.errors = (errors) => {
-    const newMiddleware = decorateMiddleware(decorated);
-    newMiddleware["~orpc"] = {
-      ...decorated["~orpc"],
-      errorMap: mergeErrorMap(decorated["~orpc"]?.errorMap, errors)
-    };
-    return newMiddleware;
-  };
-  decorated.use = (usedMiddleware) => {
-    const merged = decorateMiddleware((opts, ...args) => {
-      return middleware(
-        {
-          ...opts,
-          async next(nextOpts1) {
-            const result = await usedMiddleware({
-              ...opts,
-              context: { ...opts.context, ...nextOpts1?.context },
-              next(nextOpts2, ...args2) {
-                return opts.next({
-                  ...opts,
-                  context: {
-                    ...nextOpts1?.context,
-                    ...nextOpts2?.context
-                  }
-                }, ...args2);
-              }
-            }, ...args);
-            return {
-              ...result,
-              context: {
-                ...nextOpts1?.context,
-                ...result.context
-              }
-            };
-          }
-        },
-        ...args
-      );
-    });
-    merged["~orpc"] = {
-      ...decorated["~orpc"],
-      errorMap: mergeErrorMap(usedMiddleware["~orpc"]?.errorMap, decorated["~orpc"]?.errorMap),
-      metaPlugins: [
-        ...toArray(middleware["~orpc"]?.metaPlugins),
-        ...toArray(usedMiddleware["~orpc"]?.metaPlugins)
-      ]
-    };
-    Object.defineProperty(merged, "name", {
-      value: `${middleware.name} + ${usedMiddleware.name}`
-    });
-    return merged;
-  };
-  return decorated;
-}
-
-class Builder {
-  "~orpc";
-  constructor(definition) {
-    this["~orpc"] = definition;
-  }
-  static create() {
-    return new Builder({
-      errorMap: {},
-      meta: {},
-      orderedMiddlewares: []
-    });
-  }
-  $context() {
-    return this;
-  }
-  meta(...plugins) {
-    const [meta, metaPlugins] = resolveMetaPlugins(
-      this["~orpc"].meta,
-      this["~orpc"].metaPlugins,
-      plugins
-    );
-    return new Builder({
-      ...this["~orpc"],
-      meta,
-      metaPlugins
-    });
-  }
-  errors(errors) {
-    let builder = new Builder({
-      ...this["~orpc"],
-      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
-    });
-    const plugins = getHiddenMetaPlugins(errors);
-    if (plugins) {
-      builder = builder.meta(...plugins);
-    }
-    return builder;
-  }
-  use(middleware) {
-    let builder = new Builder({
-      ...this["~orpc"],
-      errorMap: mergeErrorMap(middleware["~orpc"]?.errorMap ?? {}, this["~orpc"].errorMap),
-      orderedMiddlewares: [...this["~orpc"].orderedMiddlewares, {
-        middleware,
-        inputSchemasLengthAtUse: this["~orpc"].inputSchemas?.length,
-        outputSchemasLengthAtUse: this["~orpc"].outputSchemas?.length
-      }]
-    });
-    if (middleware["~orpc"]?.metaPlugins) {
-      builder = builder.meta(...middleware["~orpc"]?.metaPlugins);
-    }
-    return builder;
-  }
-  middleware(middleware) {
-    const allMiddlewares = [
-      ...this["~orpc"].orderedMiddlewares.map(({ middleware: middleware2 }) => middleware2),
-      middleware
-    ];
-    let current = decorateMiddleware(allMiddlewares.shift());
-    for (const mid of allMiddlewares) {
-      current = current.use(mid);
-    }
-    current["~orpc"] = {
-      ...current["~orpc"],
-      errorMap: this["~orpc"].errorMap,
-      metaPlugins: [
-        ...toArray(this["~orpc"].metaPlugins),
-        ...toArray(middleware["~orpc"]?.metaPlugins)
-      ]
-    };
-    return current;
-  }
-  input(schema) {
-    let builder = new Builder({
-      ...this["~orpc"],
-      inputSchemas: [...toArray(this["~orpc"].inputSchemas), schema]
-    });
-    const plugins = getHiddenMetaPlugins(schema);
-    if (plugins) {
-      builder = builder.meta(...plugins);
-    }
-    return builder;
-  }
-  output(schema) {
-    let builder = new Builder({
-      ...this["~orpc"],
-      outputSchemas: [...toArray(this["~orpc"].outputSchemas), schema]
-    });
-    const plugins = getHiddenMetaPlugins(schema);
-    if (plugins) {
-      builder = builder.meta(...plugins);
-    }
-    return builder;
-  }
-  handler(handler) {
-    let procedure = new DecoratedProcedure({
-      ...this["~orpc"],
-      handler
-    });
-    const plugins = getHiddenMetaPlugins(handler);
-    if (plugins) {
-      procedure = procedure.meta(...plugins);
-    }
-    return procedure;
-  }
-  router(router) {
-    return augmentRouter(router, {
-      middlewares: this["~orpc"].orderedMiddlewares.map(({ middleware }) => middleware),
-      meta: this["~orpc"].meta,
-      metaPlugins: this["~orpc"].metaPlugins,
-      errorMap: this["~orpc"].errorMap
-    });
-  }
-  lazy(loader) {
-    return new Lazy({
-      loader: async () => {
-        const { default: router } = await loader();
-        return {
-          default: this.router(router)
-        };
-      },
-      meta: this["~orpc"].meta,
-      metaPlugins: this["~orpc"].metaPlugins
-    });
-  }
-}
-const os = Builder.create();
-
-class ProcedureImplementer {
-  "~orpc";
-  constructor(definition) {
-    this["~orpc"] = definition;
-  }
-  "use"(middleware) {
-    return new ProcedureImplementer({
-      ...this["~orpc"],
-      orderedMiddlewares: [...this["~orpc"].orderedMiddlewares, {
-        middleware,
-        inputSchemasLengthAtUse: this["~orpc"].inputSchemas?.length,
-        outputSchemasLengthAtUse: this["~orpc"].outputSchemas?.length
-      }]
-    });
-  }
-  "handler"(handler) {
-    return new ImplementedProcedure({
-      ...this["~orpc"],
-      handler,
-      /**
-       * When enabled, errors returned (not thrown) by the handler are passed through as-is,
-       * rather than being transformed into inferrable errors.
-       *
-       * This is intended for the contract-first approach, where the procedure adheres to an
-       * external contract and returned errors should not affect the inferred contract types.
-       */
-      opaqueReturnedErrors: true
-    });
-  }
-}
-class ImplementedProcedure extends Procedure {
-  use(middleware) {
-    return new ImplementedProcedure({
-      ...this["~orpc"],
-      orderedMiddlewares: [...this["~orpc"].orderedMiddlewares, {
-        middleware,
-        inputSchemasLengthAtUse: this["~orpc"].inputSchemas?.length,
-        outputSchemasLengthAtUse: this["~orpc"].outputSchemas?.length
-      }]
-    });
-  }
-}
-
-class SharedRouterImplementer {
-  constructor(contract, middlewares) {
-    this.contract = contract;
-    this.middlewares = middlewares;
-  }
-  static create(contract, middlewares = []) {
-    return new SharedRouterImplementer(contract, middlewares);
-  }
-  use(middleware) {
-    return createRouterImplementerInternal(this.contract, [...this.middlewares, middleware]);
-  }
-  middleware(middleware) {
-    const allMiddlewares = [
-      ...this.middlewares,
-      middleware
-    ];
-    let current = decorateMiddleware(allMiddlewares.shift());
-    for (const mid of allMiddlewares) {
-      current = current.use(mid);
-    }
-    return current;
-  }
-  router(router) {
-    if (this.middlewares.length) {
-      router = augmentImplementedRouter(router, {
-        middlewares: this.middlewares
-      });
-    }
-    return withHiddenRouterContract(router, this.contract);
-  }
-  lazy(loader) {
-    if (this.middlewares.length) {
-      const originalLoader = loader;
-      loader = async () => {
-        const { default: router } = await originalLoader();
-        return {
-          default: augmentImplementedRouter(router, {
-            middlewares: this.middlewares
-          })
-        };
-      };
-    }
-    return new Lazy({ loader, meta: {} });
-  }
-}
-function createRouterImplementer(contract) {
-  return createRouterImplementerInternal(contract, []);
-}
-function createRouterImplementerInternal(contract, middlewares) {
-  if (contract instanceof ProcedureContract) {
-    return new ProcedureImplementer({
-      ...contract["~orpc"],
-      orderedMiddlewares: middlewares.map((middleware) => ({ middleware }))
-    });
-  }
-  const implementer = {};
-  for (const key in contract) {
-    const child = contract[key];
-    implementer[key] = createRouterImplementerInternal(child, middlewares);
-  }
-  const shared = bindMethods(SharedRouterImplementer.create(contract, middlewares));
-  for (const key in shared) {
-    const method = shared[key];
-    if (key in implementer) {
-      const child = implementer[key];
-      implementer[key] = new Proxy(method, {
-        get(_, p) {
-          return getOrBind(child, p);
-        }
-      });
-    } else {
-      implementer[key] = method;
-    }
-  }
-  return implementer;
-}
-
-function implement(contract) {
-  const routerImplementer = createRouterImplementer(contract);
-  const implementer = new Proxy(routerImplementer, {
-    get(_, p) {
-      let method;
-      if (p === "$context") {
-        method = () => implementer;
-      }
-      const value = getOrBind(routerImplementer, p);
-      if (method) {
-        if (!isTypescriptObject(value)) {
-          return method;
-        }
-        return new Proxy(method, {
-          get(_2, p2) {
-            return getOrBind(value, p2);
-          }
-        });
-      }
-      return value;
-    }
-  });
-  return implementer;
-}
-
-function createRouterClient(router, ...rest) {
-  const options = resolveMaybeOptionalOptions(rest);
-  if (router instanceof Procedure) {
-    return createProcedureClient(router, options);
-  }
-  const procedureCaller = router instanceof Lazy ? createProcedureClient(createGuardedProcedureLazy(router), options) : {};
-  const recursive = new Proxy(procedureCaller, {
-    get(target, key) {
-      if (typeof key !== "string" || router instanceof Lazy && RECURSIVE_CLIENT_UNWRAP_KEYS.has(key)) {
-        return getOrBind(target, key);
-      }
-      const next = getRouter(router, [key]);
-      if (!next) {
-        return getOrBind(target, key);
-      }
-      const nextClient = createRouterClient(next, {
-        ...options,
-        path: [...toArray(options.path), key]
-      });
-      return nextClient;
-    }
-  });
-  return recursive;
-}
-
-export { Builder, DecoratedProcedure, ImplementedProcedure, Lazy, Procedure, ProcedureImplementer, SharedRouterImplementer, augmentImplementedRouter, augmentRouter, createGuardedProcedureLazy, createProcedureClient, createRouterClient, createRouterImplementer, decorateMiddleware, getRouter, implement, os, withHiddenRouterContract };