@orpc/server 1.14.6 → 2.0.0-beta.10

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

@@ -0,0 +1,184 @@
+import { ORPCErrorCode, ORPCErrorOptions, ORPCError, AnyORPCError, ClientContext, Client } from '@orpc/client';
+import { ErrorMap, ErrorMapItem, InferSchemaInput, AnyMetaPlugin, AnySchema, ProcedureContractDefinition, Meta, InferSchemaOutput, ORPCErrorFromErrorMap } from '@orpc/contract';
+import { MaybeOptionalOptions, Promisable, Interceptor, PromiseWithError, ThrowableError, Value } from '@orpc/shared';
+
+interface Context {
+    [key: PropertyKey]: any;
+}
+type MergedInitialContext<TInitial extends Context, TOutContext extends Context, TInContext extends Context> = Exclude<keyof TInContext, keyof TInitial | keyof TOutContext> extends never ? TInitial : TInitial & Omit<TInContext, keyof TInitial | keyof TOutContext>;
+type MergedContext<TCurrent extends Context, TOutContext extends Context> = keyof TOutContext extends never ? TCurrent : Omit<TCurrent, keyof TOutContext> & TOutContext;
+
+type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'status'>;
+interface 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;
+};
+/**
+ * Creates a map of ORPC error constructors.
+ *
+ * The returned object is a `Proxy` that allows access to arbitrary error codes:
+ * - If the code exists in the provided `errorMap`, the corresponding constructor
+ *   will create a **defined** `ORPCError`.
+ * - If the code does not exist, a fallback `ORPCError` constructor is returned.
+ *
+ * The `in` operator can be used to check whether an error code is explicitly
+ * defined in the map.
+ *
+ * @example
+ * ```ts
+ * const errorMap = createORPCErrorConstructorMap({
+ *   NOT_FOUND: {
+ *     status: 404,
+ *     message: 'Not Found',
+ *   },
+ * })
+ *
+ * if ('NOT_FOUND' in errorMap) {
+ *   const error = errorMap.NOT_FOUND()
+ * }
+ * ```
+ */
+declare function createORPCErrorConstructorMap<T extends ErrorMap>(errorMap: T): ORPCErrorConstructorMap<T>;
+
+type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
+    output: TOutput;
+    context: TOutContext;
+}>;
+type MiddlewareNextOptions<TOutContext extends Context> = object extends TOutContext ? {
+    context?: TOutContext;
+} : {
+    context: TOutContext;
+};
+interface MiddlewareNext<TOutput> {
+    <T extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareNextOptions<T>>): MiddlewareResult<T, TOutput>;
+}
+type MiddlewareDoneOptions<TOutContext, TOutput> = (object extends TOutContext ? {
+    context?: TOutContext;
+} : {
+    context: TOutContext;
+}) & {
+    output: TOutput;
+};
+interface MiddlewareDone<TOutput> {
+    /**
+     * Create a successful result and terminate the middleware chain early.
+     */
+    <TOutContext extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareDoneOptions<TOutContext, TOutput>>): MiddlewareResult<TOutContext, TOutput>;
+}
+interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
+    context: TInContext;
+    path: string[];
+    procedure: AnyProcedure;
+    signal?: AbortSignal | undefined;
+    lastEventId: string | undefined;
+    /**
+     * Invoke to continue the middleware chain.
+     */
+    next: MiddlewareNext<TOutput>;
+    errors: TErrorConstructorMap;
+}
+interface MiddlewareDefinition<TErrorMap extends ErrorMap> {
+    errorMap?: TErrorMap | undefined;
+    metaPlugins?: AnyMetaPlugin[] | undefined;
+}
+interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorMap extends ErrorMap> {
+    /** this property should be optional to support inline middleware */
+    '~orpc'?: MiddlewareDefinition<TErrorMap> | undefined;
+    (opts: MiddlewareOptions<TInContext, TOutput, ORPCErrorConstructorMap<TErrorMap>>, input: TInput, done: MiddlewareDone<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
+}
+type AnyMiddleware = Middleware<any, any, any, any, any>;
+
+interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
+    context: TCurrentContext;
+    input: TInput;
+    path: string[];
+    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, any>;
+    signal?: AbortSignal | undefined;
+    lastEventId?: string | undefined;
+    errors: TErrorConstructorMap;
+}
+interface ProcedureHandler<TCurrentContext extends Context, TInput, THandlerOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
+    (opts: ProcedureHandlerOptions<TCurrentContext, TInput, TErrorConstructorMap>, input: TInput): Promisable<THandlerOutput>;
+}
+interface OrderedMiddleware {
+    /**
+     * Snapshot of `inputSchemas.length`
+     * at the time this middleware was used.
+     *
+     * @default 0
+     */
+    inputSchemasLengthAtUse?: number | undefined;
+    /**
+     * Snapshot of `outputSchemas.length`
+     * at the time this middleware was used.
+     *
+     * @default 0
+     */
+    outputSchemasLengthAtUse?: number | undefined;
+    middleware: AnyMiddleware;
+}
+interface ProcedureDefinition<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> extends ProcedureContractDefinition<TInputSchema, TOutputSchema, TErrorMap> {
+    __TInitialContext?: (type: TInitialContext) => unknown;
+    __TInjectedContext?: (type: TInjectedContext) => unknown;
+    __TReturnedError?: () => TReturnedError;
+    /**
+     * 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.
+     *
+     * @default false
+     */
+    opaqueReturnedErrors?: boolean | undefined;
+    orderedMiddlewares: OrderedMiddleware[];
+    handler: ProcedureHandler<any, any, any, any>;
+}
+declare class Procedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> {
+    '~orpc': ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
+    constructor(def: ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>);
+    /**
+     * Checks if the given instance satisfies the {@see Procedure} class/interface.
+     */
+    static [Symbol.hasInstance](instance: unknown): boolean;
+}
+type AnyProcedure = Procedure<any, any, any, any, any, any>;
+
+interface LazyDefinition<T> {
+    meta: Meta;
+    metaPlugins?: AnyMetaPlugin[] | undefined;
+    loader: () => Promise<{
+        default: T;
+    }>;
+}
+declare class Lazy<T> {
+    '~orpc': LazyDefinition<T>;
+    constructor(def: LazyDefinition<T>);
+    /**
+     * Checks if the given instance satisfies the {@see Lazy} class/interface.
+     */
+    static [Symbol.hasInstance](instance: unknown): boolean;
+}
+type Lazyable<T> = T | Lazy<T>;
+declare function unlazy<T extends Lazyable<any>>(maybeLazy: T): Promise<{
+    default: T extends Lazy<infer U> ? U : T;
+}>;
+
+type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedORPCError extends AnyORPCError> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | TReturnedORPCError | ThrowableError>;
+interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap> extends ProcedureHandlerOptions<TInitialContext, unknown, ORPCErrorConstructorMap<TErrorMap>> {
+}
+type ProcedureClientInterceptor<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> = Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap>, PromiseWithError<InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | TReturnedError | ThrowableError>>;
+type ProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError, TClientContext extends ClientContext> = {
+    path?: string[];
+    interceptors?: ProcedureClientInterceptor<TInitialContext, TOutputSchema, TErrorMap, TReturnedError>[];
+} & (object extends TInitialContext ? {
+    context?: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
+} : {
+    context: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
+});
+declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError, TClientContext extends ClientContext = object>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>>, ...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
+
+export { Procedure as a, Lazy as g, createORPCErrorConstructorMap as w, createProcedureClient as x, unlazy as y };
+export type { AnyProcedure as A, Context as C, Lazyable as L, MergedContext as M, ORPCErrorConstructorMap as O, ProcedureClientOptions as P, ProcedureClient as b, ProcedureClientInterceptor as c, Middleware as d, MergedInitialContext as e, AnyMiddleware as f, ProcedureHandler as h, OrderedMiddleware as i, LazyDefinition as j, MiddlewareDefinition as k, MiddlewareDone as l, MiddlewareDoneOptions as m, MiddlewareNext as n, MiddlewareNextOptions as o, MiddlewareOptions as p, MiddlewareResult as q, ORPCErrorConstructorMapItem as r, ORPCErrorConstructorMapItemOptions as s, ProcedureClientInterceptorOptions as t, ProcedureDefinition as u, ProcedureHandlerOptions as v };

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

@@ -0,0 +1,184 @@
+import { ORPCErrorCode, ORPCErrorOptions, ORPCError, AnyORPCError, ClientContext, Client } from '@orpc/client';
+import { ErrorMap, ErrorMapItem, InferSchemaInput, AnyMetaPlugin, AnySchema, ProcedureContractDefinition, Meta, InferSchemaOutput, ORPCErrorFromErrorMap } from '@orpc/contract';
+import { MaybeOptionalOptions, Promisable, Interceptor, PromiseWithError, ThrowableError, Value } from '@orpc/shared';
+
+interface Context {
+    [key: PropertyKey]: any;
+}
+type MergedInitialContext<TInitial extends Context, TOutContext extends Context, TInContext extends Context> = Exclude<keyof TInContext, keyof TInitial | keyof TOutContext> extends never ? TInitial : TInitial & Omit<TInContext, keyof TInitial | keyof TOutContext>;
+type MergedContext<TCurrent extends Context, TOutContext extends Context> = keyof TOutContext extends never ? TCurrent : Omit<TCurrent, keyof TOutContext> & TOutContext;
+
+type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'status'>;
+interface 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;
+};
+/**
+ * Creates a map of ORPC error constructors.
+ *
+ * The returned object is a `Proxy` that allows access to arbitrary error codes:
+ * - If the code exists in the provided `errorMap`, the corresponding constructor
+ *   will create a **defined** `ORPCError`.
+ * - If the code does not exist, a fallback `ORPCError` constructor is returned.
+ *
+ * The `in` operator can be used to check whether an error code is explicitly
+ * defined in the map.
+ *
+ * @example
+ * ```ts
+ * const errorMap = createORPCErrorConstructorMap({
+ *   NOT_FOUND: {
+ *     status: 404,
+ *     message: 'Not Found',
+ *   },
+ * })
+ *
+ * if ('NOT_FOUND' in errorMap) {
+ *   const error = errorMap.NOT_FOUND()
+ * }
+ * ```
+ */
+declare function createORPCErrorConstructorMap<T extends ErrorMap>(errorMap: T): ORPCErrorConstructorMap<T>;
+
+type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
+    output: TOutput;
+    context: TOutContext;
+}>;
+type MiddlewareNextOptions<TOutContext extends Context> = object extends TOutContext ? {
+    context?: TOutContext;
+} : {
+    context: TOutContext;
+};
+interface MiddlewareNext<TOutput> {
+    <T extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareNextOptions<T>>): MiddlewareResult<T, TOutput>;
+}
+type MiddlewareDoneOptions<TOutContext, TOutput> = (object extends TOutContext ? {
+    context?: TOutContext;
+} : {
+    context: TOutContext;
+}) & {
+    output: TOutput;
+};
+interface MiddlewareDone<TOutput> {
+    /**
+     * Create a successful result and terminate the middleware chain early.
+     */
+    <TOutContext extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareDoneOptions<TOutContext, TOutput>>): MiddlewareResult<TOutContext, TOutput>;
+}
+interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
+    context: TInContext;
+    path: string[];
+    procedure: AnyProcedure;
+    signal?: AbortSignal | undefined;
+    lastEventId: string | undefined;
+    /**
+     * Invoke to continue the middleware chain.
+     */
+    next: MiddlewareNext<TOutput>;
+    errors: TErrorConstructorMap;
+}
+interface MiddlewareDefinition<TErrorMap extends ErrorMap> {
+    errorMap?: TErrorMap | undefined;
+    metaPlugins?: AnyMetaPlugin[] | undefined;
+}
+interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorMap extends ErrorMap> {
+    /** this property should be optional to support inline middleware */
+    '~orpc'?: MiddlewareDefinition<TErrorMap> | undefined;
+    (opts: MiddlewareOptions<TInContext, TOutput, ORPCErrorConstructorMap<TErrorMap>>, input: TInput, done: MiddlewareDone<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
+}
+type AnyMiddleware = Middleware<any, any, any, any, any>;
+
+interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
+    context: TCurrentContext;
+    input: TInput;
+    path: string[];
+    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, any>;
+    signal?: AbortSignal | undefined;
+    lastEventId?: string | undefined;
+    errors: TErrorConstructorMap;
+}
+interface ProcedureHandler<TCurrentContext extends Context, TInput, THandlerOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
+    (opts: ProcedureHandlerOptions<TCurrentContext, TInput, TErrorConstructorMap>, input: TInput): Promisable<THandlerOutput>;
+}
+interface OrderedMiddleware {
+    /**
+     * Snapshot of `inputSchemas.length`
+     * at the time this middleware was used.
+     *
+     * @default 0
+     */
+    inputSchemasLengthAtUse?: number | undefined;
+    /**
+     * Snapshot of `outputSchemas.length`
+     * at the time this middleware was used.
+     *
+     * @default 0
+     */
+    outputSchemasLengthAtUse?: number | undefined;
+    middleware: AnyMiddleware;
+}
+interface ProcedureDefinition<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> extends ProcedureContractDefinition<TInputSchema, TOutputSchema, TErrorMap> {
+    __TInitialContext?: (type: TInitialContext) => unknown;
+    __TInjectedContext?: (type: TInjectedContext) => unknown;
+    __TReturnedError?: () => TReturnedError;
+    /**
+     * 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.
+     *
+     * @default false
+     */
+    opaqueReturnedErrors?: boolean | undefined;
+    orderedMiddlewares: OrderedMiddleware[];
+    handler: ProcedureHandler<any, any, any, any>;
+}
+declare class Procedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> {
+    '~orpc': ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
+    constructor(def: ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>);
+    /**
+     * Checks if the given instance satisfies the {@see Procedure} class/interface.
+     */
+    static [Symbol.hasInstance](instance: unknown): boolean;
+}
+type AnyProcedure = Procedure<any, any, any, any, any, any>;
+
+interface LazyDefinition<T> {
+    meta: Meta;
+    metaPlugins?: AnyMetaPlugin[] | undefined;
+    loader: () => Promise<{
+        default: T;
+    }>;
+}
+declare class Lazy<T> {
+    '~orpc': LazyDefinition<T>;
+    constructor(def: LazyDefinition<T>);
+    /**
+     * Checks if the given instance satisfies the {@see Lazy} class/interface.
+     */
+    static [Symbol.hasInstance](instance: unknown): boolean;
+}
+type Lazyable<T> = T | Lazy<T>;
+declare function unlazy<T extends Lazyable<any>>(maybeLazy: T): Promise<{
+    default: T extends Lazy<infer U> ? U : T;
+}>;
+
+type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedORPCError extends AnyORPCError> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | TReturnedORPCError | ThrowableError>;
+interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap> extends ProcedureHandlerOptions<TInitialContext, unknown, ORPCErrorConstructorMap<TErrorMap>> {
+}
+type ProcedureClientInterceptor<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> = Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap>, PromiseWithError<InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | TReturnedError | ThrowableError>>;
+type ProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError, TClientContext extends ClientContext> = {
+    path?: string[];
+    interceptors?: ProcedureClientInterceptor<TInitialContext, TOutputSchema, TErrorMap, TReturnedError>[];
+} & (object extends TInitialContext ? {
+    context?: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
+} : {
+    context: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
+});
+declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError, TClientContext extends ClientContext = object>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>>, ...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
+
+export { Procedure as a, Lazy as g, createORPCErrorConstructorMap as w, createProcedureClient as x, unlazy as y };
+export type { AnyProcedure as A, Context as C, Lazyable as L, MergedContext as M, ORPCErrorConstructorMap as O, ProcedureClientOptions as P, ProcedureClient as b, ProcedureClientInterceptor as c, Middleware as d, MergedInitialContext as e, AnyMiddleware as f, ProcedureHandler as h, OrderedMiddleware as i, LazyDefinition as j, MiddlewareDefinition as k, MiddlewareDone as l, MiddlewareDoneOptions as m, MiddlewareNext as n, MiddlewareNextOptions as o, MiddlewareOptions as p, MiddlewareResult as q, ORPCErrorConstructorMapItem as r, ORPCErrorConstructorMapItemOptions as s, ProcedureClientInterceptorOptions as t, ProcedureDefinition as u, ProcedureHandlerOptions as v };

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

@@ -0,0 +1,61 @@
+import { RouterContract, ProcedureContract, ORPCErrorFromErrorMap, ThrowableError, InferSchemaInput, InferSchemaOutput } from '@orpc/contract';
+import { C as Context, a as Procedure, L as Lazyable, M as MergedContext } from './server.BL22TloH.mjs';
+
+type Router<TInitialContext extends Context> = Procedure<TInitialContext, any, any, any, any, any> | {
+    [k: string]: Lazyable<Router<TInitialContext>>;
+};
+type ContractedRouter<T extends RouterContract, TInitialContext extends Context> = T extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? Procedure<TInitialContext, any, $InputSchema, $OutputSchema, $ErrorMap, never> : {
+    [K in keyof T]: T[K] extends RouterContract ? Lazyable<ContractedRouter<T[K], TInitialContext>> : never;
+};
+type AnyRouter = Router<any>;
+type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer $> ? $ : never;
+/**
+ * Infer all initial context of the router.
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ */
+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;
+};
+/**
+ * Infer all current context of the router.
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ */
+type InferRouterFinalContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, infer UInjectedContext, any, any, any, any> ? MergedContext<UInitialContext, UInjectedContext> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterFinalContexts<U> : never;
+};
+/**
+ * Infer all router inputs
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ */
+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;
+};
+/**
+ * Infer all router outputs
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ */
+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;
+};
+/**
+ * Infer the union of throwable errors for entire router.
+ */
+type InferRouterError<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap, infer UReturnedError> ? ORPCErrorFromErrorMap<UErrorMap> | UReturnedError | ThrowableError : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterError<U> : never;
+}[keyof T];
+/**
+ * Infer throwable errors for each procedure, preserving the router shape.
+ */
+type InferRouterErrors<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap, infer UReturnedError> ? ORPCErrorFromErrorMap<UErrorMap> | UReturnedError | ThrowableError : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterErrors<U> : never;
+};
+
+export type { AnyRouter as A, ContractedRouter as C, InferRouterInitialContext as I, Router as R, InferRouterError as a, InferRouterErrors as b, InferRouterFinalContexts as c, InferRouterInitialContexts as d, InferRouterInputs as e, InferRouterOutputs as f };

package/dist/shared/server.BwHnWUuN.mjs

@@ -0,0 +1,222 @@
+import { c as createProcedureClient, P as Procedure, L as Lazy, u as unlazy } from './server.CrlKQucM.mjs';
+import { resolveMetaPlugins, mergeErrorMap, ProcedureContract } from '@orpc/contract';
+import { getOrBind, isTypescriptObject } from '@orpc/shared';
+
+const DEFAULT_SUCCESS_STATUS = 200;
+const DEFAULT_ERROR_STATUS = 500;
+
+function createGuardedProcedureLazy(lazy) {
+  const guarded = new Lazy({
+    ...lazy["~orpc"],
+    async loader() {
+      const { default: maybeProcedure } = await unlazy(lazy);
+      if (!(maybeProcedure instanceof Procedure)) {
+        throw new TypeError(`
+          Expected a lazy<procedure> but got lazy<unknown>.
+          This should be caught by TypeScript compilation.
+          Please report this issue if you think this is a bug.
+        `);
+      }
+      return { default: maybeProcedure };
+    }
+  });
+  return guarded;
+}
+function createContractProcedure(procedure, contract) {
+  return new Procedure({
+    ...procedure["~orpc"],
+    errorMap: contract["~orpc"].errorMap,
+    meta: contract["~orpc"].meta,
+    metaPlugins: contract["~orpc"].metaPlugins
+  });
+}
+function call(lazyableProcedure, ...[
+  input = void 0,
+  options = {}
+]) {
+  return createProcedureClient(lazyableProcedure, options)(input, options);
+}
+
+const HIDDEN_ROUTER_CONTRACT_SYMBOL = Symbol.for("ORPC_HIDDEN_ROUTER_CONTRACT");
+function withHiddenRouterContract(router, contract) {
+  return new Proxy(router, {
+    get(target, key) {
+      if (key === HIDDEN_ROUTER_CONTRACT_SYMBOL) {
+        return contract;
+      }
+      return getOrBind(target, key);
+    }
+  });
+}
+function getHiddenRouterContract(router) {
+  return router[HIDDEN_ROUTER_CONTRACT_SYMBOL];
+}
+
+function augmentRouter(router, options) {
+  if (router instanceof Lazy) {
+    const [meta, metaPlugins] = resolveMetaPlugins(
+      options.meta,
+      options.metaPlugins,
+      router["~orpc"].metaPlugins
+    );
+    const enhanced2 = new Lazy({
+      meta,
+      metaPlugins,
+      async loader() {
+        const { default: unlaziedRouter } = await unlazy(router);
+        const enhanced3 = augmentRouter(unlaziedRouter, options);
+        return unlazy(enhanced3);
+      }
+    });
+    return enhanced2;
+  }
+  if (router instanceof Procedure) {
+    const [meta, metaPlugins] = resolveMetaPlugins(
+      options.meta,
+      options.metaPlugins,
+      router["~orpc"].metaPlugins
+    );
+    const enhanced2 = new Procedure({
+      ...router["~orpc"],
+      meta,
+      metaPlugins,
+      errorMap: mergeErrorMap(options.errorMap, router["~orpc"].errorMap),
+      orderedMiddlewares: [
+        ...options.middlewares.map((middleware) => ({ middleware, inputSchemasLengthAtUse: 0, outputSchemasLengthAtUse: 0 })),
+        ...router["~orpc"].orderedMiddlewares
+      ]
+    });
+    return enhanced2;
+  }
+  if (!isTypescriptObject(router)) {
+    return router;
+  }
+  const enhanced = {};
+  for (const key in router) {
+    enhanced[key] = augmentRouter(router[key], options);
+  }
+  return enhanced;
+}
+function augmentImplementedRouter(router, options) {
+  if (router instanceof Lazy) {
+    const enhanced2 = new Lazy({
+      ...router["~orpc"],
+      async loader() {
+        const { default: unlaziedRouter } = await unlazy(router);
+        const enhanced3 = augmentImplementedRouter(unlaziedRouter, options);
+        return unlazy(enhanced3);
+      }
+    });
+    return enhanced2;
+  }
+  if (router instanceof Procedure) {
+    const enhanced2 = new Procedure({
+      ...router["~orpc"],
+      orderedMiddlewares: [
+        ...options.middlewares.map((middleware) => ({ middleware, inputSchemasLengthAtUse: 0, outputSchemasLengthAtUse: 0 })),
+        ...router["~orpc"].orderedMiddlewares
+      ]
+    });
+    return enhanced2;
+  }
+  if (!isTypescriptObject(router)) {
+    return router;
+  }
+  const enhanced = {};
+  for (const key in router) {
+    enhanced[key] = augmentImplementedRouter(router[key], options);
+  }
+  return enhanced;
+}
+function getRouter(router, path) {
+  let current = router;
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+    if (!isTypescriptObject(current)) {
+      return void 0;
+    }
+    if (current instanceof Procedure) {
+      return void 0;
+    }
+    if (!(current instanceof Lazy)) {
+      current = current[segment];
+      continue;
+    }
+    const lazied = current;
+    const rest = path.slice(i);
+    return new Lazy({
+      ...lazied["~orpc"],
+      async loader() {
+        const unwrapped = await unlazy(lazied);
+        const next = getRouter(unwrapped.default, rest);
+        return await unlazy(next);
+      }
+    });
+  }
+  if (!isTypescriptObject(current)) {
+    return void 0;
+  }
+  return current;
+}
+function walkProcedureContractsSync(router, callback, path = []) {
+  const hiddenContract = getHiddenRouterContract(router);
+  if (hiddenContract !== void 0) {
+    router = hiddenContract;
+  }
+  if (router instanceof ProcedureContract) {
+    callback(router, path);
+    return [];
+  }
+  if (!isTypescriptObject(router)) {
+    return [];
+  }
+  const lazyResults = [];
+  for (const key in router) {
+    const value = router[key];
+    if (value instanceof Lazy) {
+      lazyResults.push({ router: value, path: [...path, key] });
+    } else {
+      lazyResults.push(...walkProcedureContractsSync(value, callback, [...path, key]));
+    }
+  }
+  return lazyResults;
+}
+async function walkProcedureContractsAsync(router, callback, path = []) {
+  const hiddenContract = getHiddenRouterContract(router);
+  if (hiddenContract !== void 0) {
+    router = hiddenContract;
+  }
+  if (router instanceof ProcedureContract) {
+    await callback(router, path);
+    return;
+  }
+  if (!isTypescriptObject(router)) {
+    return;
+  }
+  for (const key in router) {
+    const value = router[key];
+    if (value instanceof Lazy) {
+      const { default: router2 } = await unlazy(value);
+      await walkProcedureContractsAsync(router2, callback, [...path, key]);
+    } else {
+      await walkProcedureContractsAsync(value, callback, [...path, key]);
+    }
+  }
+}
+async function unlazyRouter(router) {
+  if (router instanceof Procedure) {
+    return router;
+  }
+  if (!isTypescriptObject(router)) {
+    return router;
+  }
+  const unlazied = {};
+  for (const key in router) {
+    const item = router[key];
+    const { default: unlaziedRouter } = await unlazy(item);
+    unlazied[key] = await unlazyRouter(unlaziedRouter);
+  }
+  return unlazied;
+}
+
+export { DEFAULT_SUCCESS_STATUS as D, DEFAULT_ERROR_STATUS as a, augmentRouter as b, createContractProcedure as c, augmentImplementedRouter as d, withHiddenRouterContract as e, createGuardedProcedureLazy as f, getRouter as g, call as h, getHiddenRouterContract as i, walkProcedureContractsAsync as j, unlazyRouter as u, walkProcedureContractsSync as w };

package/dist/shared/server.CX4vUnDk.mjs

@@ -0,0 +1,11 @@
+import { value } from '@orpc/shared';
+
+function createStandardPeerRequestHandler(handler, options) {
+  return async (request) => {
+    const context = await value(options.context ?? {}, request);
+    const { response } = await handler.handle(request, { ...options, context });
+    return response ?? { status: 404, headers: {}, body: "No procedure matched" };
+  };
+}
+
+export { createStandardPeerRequestHandler as c };