@orpc/server 0.0.0-next.db1f26d → 0.0.0-next.ee0aeaf

package/dist/{chunk-FL4ZAGNE.js → chunk-VARUID7X.js}

@@ -45,9 +45,8 @@ function decorateMiddleware(middleware) {
 }
 
 // src/procedure-caller.ts
-import { trim, value } from "@orpc/shared";
+import { executeWithHooks, trim, value } from "@orpc/shared";
 import { ORPCError } from "@orpc/shared/error";
-import { OpenAPIDeserializer } from "@orpc/transformer";
 
 // src/procedure.ts
 import {
@@ -109,96 +108,102 @@ function isProcedure(item) {
 
 // src/procedure-caller.ts
 function createProcedureCaller(options) {
-  const loadProcedure = async () => {
-    let procedure;
-    if (isLazy(options.procedure)) {
-      procedure = (await loadLazy(options.procedure)).default;
-    } else {
-      procedure = options.procedure;
-    }
-    if (!isProcedure(procedure)) {
-      throw new ORPCError({
-        code: "NOT_FOUND",
-        message: "Not found",
-        cause: new Error(trim(`
-          This error should be caught by the typescript compiler.
-          But if you still see this error, it means that you trying to call a lazy router (expected to be a lazy procedure).
-        `))
-      });
-    }
-    return procedure;
-  };
-  const caller = async (input) => {
+  const caller = async (...args) => {
+    const [input, callerOptions] = args;
     const path = options.path ?? [];
-    const procedure = await loadProcedure();
-    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 procedure = await loadProcedure(options.procedure);
+    const context = await value(options.context);
+    const execute = async () => {
+      const validInput = await (async () => {
+        const schema = procedure.zz$p.contract["~orpc"].InputSchema;
+        if (!schema) {
+          return input;
+        }
+        const result = await schema["~standard"].validate(input);
+        if (result.issues) {
+          throw new ORPCError({
+            message: "Validation input failed",
+            code: "BAD_REQUEST",
+            issues: result.issues
+          });
+        }
+        return result.value;
+      })();
+      const meta = {
+        path,
+        procedure,
+        signal: callerOptions?.signal
+      };
+      const middlewares = procedure.zz$p.middlewares ?? [];
+      let currentMidIndex = 0;
+      let currentContext = context;
+      const next = async (nextOptions) => {
+        const mid = middlewares[currentMidIndex];
+        currentMidIndex += 1;
+        currentContext = mergeContext(currentContext, nextOptions.context);
+        if (mid) {
+          return await mid(validInput, currentContext, {
+            ...meta,
+            next,
+            output: (output3) => ({ output: output3, context: void 0 })
+          });
+        } else {
+          return {
+            output: await await procedure.zz$p.func(validInput, currentContext, meta),
+            context: currentContext
+          };
+        }
+      };
+      const output2 = (await next({})).output;
+      const validOutput = await (async () => {
+        const schema = procedure.zz$p.contract["~orpc"].OutputSchema;
+        if (!schema) {
+          return output2;
+        }
+        const result = await schema["~standard"].validate(output2);
+        if (result.issues) {
+          throw new ORPCError({
+            message: "Validation output failed",
+            code: "INTERNAL_SERVER_ERROR"
+          });
+        }
+        return result.value;
+      })();
+      return validOutput;
     };
-    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;
+    const output = await executeWithHooks({
+      hooks: options,
+      input,
+      context,
+      meta: {
+        path,
+        procedure
+      },
+      execute
+    });
+    return output;
   };
   return caller;
 }
+async function loadProcedure(procedure) {
+  let loadedProcedure;
+  if (isLazy(procedure)) {
+    loadedProcedure = (await loadLazy(procedure)).default;
+  } else {
+    loadedProcedure = procedure;
+  }
+  if (!isProcedure(loadedProcedure)) {
+    throw new ORPCError({
+      code: "NOT_FOUND",
+      message: "Not found",
+      cause: new Error(trim(`
+          This error should be caught by the typescript compiler.
+          But if you still see this error, it means that you trying to call a lazy router (expected to be a lazy procedure).
+        `))
+    });
+  }
+  return loadedProcedure;
+}
 
 // src/lazy.ts
 var LAZY_LOADER_SYMBOL = Symbol("ORPC_LAZY_LOADER");
@@ -260,8 +265,9 @@ export {
   createFlattenLazy,
   decorateLazy,
   createProcedureCaller,
+  loadProcedure,
   Procedure,
   decorateProcedure,
   isProcedure
 };
-//# sourceMappingURL=chunk-FL4ZAGNE.js.map
+//# sourceMappingURL=chunk-VARUID7X.js.map

package/dist/fetch.js

@@ -2,7 +2,7 @@ import {
   createProcedureCaller,
   isLazy,
   isProcedure
-} from "./chunk-FL4ZAGNE.js";
+} from "./chunk-VARUID7X.js";
 
 // src/fetch/handle.ts
 import { ORPCError } from "@orpc/shared/error";
@@ -23,15 +23,14 @@ async function handleFetchRequest(options) {
 }
 
 // src/fetch/handler.ts
-import { ORPC_HEADER, ORPC_HEADER_VALUE } from "@orpc/contract";
-import { trim, value } from "@orpc/shared";
+import { executeWithHooks, ORPC_PROTOCOL_HEADER, ORPC_PROTOCOL_VALUE, trim, value } from "@orpc/shared";
 import { ORPCError as ORPCError2 } from "@orpc/shared/error";
 import { ORPCDeserializer, ORPCSerializer } from "@orpc/transformer";
 var serializer = new ORPCSerializer();
 var deserializer = new ORPCDeserializer();
 function createORPCHandler() {
   return async (options) => {
-    if (options.request.headers.get(ORPC_HEADER) !== ORPC_HEADER_VALUE) {
+    if (!options.request.headers.get(ORPC_PROTOCOL_HEADER)?.includes(ORPC_PROTOCOL_VALUE)) {
       return void 0;
     }
     const context = await value(options.context);
@@ -48,7 +47,7 @@ function createORPCHandler() {
         procedure: match.procedure,
         path: match.path
       });
-      const output = await caller(input);
+      const output = await caller(input, { signal: options.signal });
       const { body, headers } = serializer.serialize(output);
       return new Response(body, {
         status: 200,
@@ -56,10 +55,15 @@ function createORPCHandler() {
       });
     };
     try {
-      return await options.hooks?.(
+      return await executeWithHooks({
+        hooks: options,
         context,
-        { next: handler, response: (response) => response }
-      ) ?? await handler();
+        execute: handler,
+        input: options.request,
+        meta: {
+          signal: options.signal
+        }
+      });
     } catch (e) {
       const error = e instanceof ORPCError2 ? e : new ORPCError2({
         code: "INTERNAL_SERVER_ERROR",

package/dist/index.js

@@ -10,8 +10,9 @@ import {
   isLazy,
   isProcedure,
   loadLazy,
+  loadProcedure,
   mergeContext
-} from "./chunk-FL4ZAGNE.js";
+} from "./chunk-VARUID7X.js";
 
 // src/builder.ts
 import {
@@ -25,7 +26,7 @@ import {
 } from "@orpc/contract";
 
 // src/router-builder.ts
-import { DecoratedContractProcedure, prefixHTTPPath } from "@orpc/contract";
+import { DecoratedContractProcedure } from "@orpc/contract";
 var LAZY_ROUTER_PREFIX_SYMBOL = Symbol("ORPC_LAZY_ROUTER_PREFIX");
 var RouterBuilder = class _RouterBuilder {
   constructor(zz$rb) {
@@ -108,7 +109,7 @@ function adaptLazyRouter(options) {
   };
   let lazyRouterPrefix = options.prefix;
   if (LAZY_ROUTER_PREFIX_SYMBOL in options.current && typeof options.current[LAZY_ROUTER_PREFIX_SYMBOL] === "string") {
-    lazyRouterPrefix = lazyRouterPrefix ? prefixHTTPPath(options.current[LAZY_ROUTER_PREFIX_SYMBOL], lazyRouterPrefix) : options.current[LAZY_ROUTER_PREFIX_SYMBOL];
+    lazyRouterPrefix = `${options.current[LAZY_ROUTER_PREFIX_SYMBOL]}${lazyRouterPrefix ?? ""}`;
   }
   const decoratedLazy = Object.assign(decorateLazy(createLazy(loader)), {
     [LAZY_ROUTER_PREFIX_SYMBOL]: lazyRouterPrefix
@@ -140,7 +141,7 @@ function adaptProcedure(options) {
   ];
   let contract = DecoratedContractProcedure.decorate(
     options.procedure.zz$p.contract
-  ).addTags(...options.tags ?? []);
+  ).pushTag(...options.tags ?? []);
   if (options.prefix) {
     contract = contract.prefix(options.prefix);
   }
@@ -297,11 +298,11 @@ var Builder = class _Builder {
   /**
    * Convert to ContractProcedureBuilder
    */
-  route(opts) {
+  route(route) {
     return new ProcedureBuilder({
       middlewares: this.zz$b.middlewares,
       contract: new ContractProcedure({
-        ...opts,
+        route,
         InputSchema: void 0,
         OutputSchema: void 0
       })
@@ -388,49 +389,27 @@ var Builder = class _Builder {
   }
 };
 
-// src/router.ts
-import {
-  isContractProcedure as isContractProcedure3
-} from "@orpc/contract";
-function toContractRouter(router) {
-  const contract = {};
-  for (const key in router) {
-    const item = router[key];
-    if (isContractProcedure3(item)) {
-      contract[key] = item;
-    } else if (isProcedure(item)) {
-      contract[key] = item.zz$p.contract;
-    } else {
-      contract[key] = toContractRouter(item);
-    }
-  }
-  return contract;
-}
-
 // src/router-caller.ts
 function createRouterCaller(options) {
-  return createRouterCallerInternal({
-    current: options.router,
-    context: options.context,
-    path: options.basePath ?? []
-  });
+  return createRouterCallerInternal(options);
 }
 function createRouterCallerInternal(options) {
-  const procedureCaller = isLazy(options.current) || isProcedure(options.current) ? createProcedureCaller({
-    procedure: options.current,
+  const procedureCaller = isLazy(options.router) || isProcedure(options.router) ? createProcedureCaller({
+    ...options,
+    procedure: options.router,
     context: options.context,
-    path: options.path
+    path: options.basePath
   }) : {};
   const recursive = new Proxy(procedureCaller, {
     get(target, key) {
       if (typeof key !== "string") {
         return Reflect.get(target, key);
       }
-      const next = options.current[key];
+      const next = options.router[key];
       return createRouterCallerInternal({
-        current: next,
-        context: options.context,
-        path: [...options.path, key]
+        ...options,
+        router: next,
+        basePath: [...options.basePath ?? [], key]
       });
     }
   });
@@ -461,8 +440,8 @@ export {
   isLazy,
   isProcedure,
   loadLazy,
+  loadProcedure,
   mergeContext,
-  os,
-  toContractRouter
+  os
 };
 //# sourceMappingURL=index.js.map

package/dist/src/builder.d.ts

@@ -1,9 +1,10 @@
+import type { ANY_CONTRACT_PROCEDURE, ContractRouter, HTTPPath, RouteOptions, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { IsEqual } from '@orpc/shared';
 import type { DecoratedLazy } from './lazy';
 import type { DecoratedProcedure, Procedure, ProcedureFunc } from './procedure';
 import type { HandledRouter, Router } from './router';
 import type { Context, MergeContext } from './types';
-import { ContractProcedure, type ContractRouter, type HTTPPath, type RouteOptions, type Schema, type SchemaInput, type SchemaOutput } from '@orpc/contract';
+import { ContractProcedure } from '@orpc/contract';
 import { type DecoratedMiddleware, type MapInputMiddleware, type Middleware } from './middleware';
 import { ProcedureBuilder } from './procedure-builder';
 import { ProcedureImplementer } from './procedure-implementer';
@@ -25,7 +26,7 @@ export declare class Builder<TContext extends Context, TExtraContext extends Con
     /**
      * Convert to ContractProcedureBuilder
      */
-    route(opts: RouteOptions): ProcedureBuilder<TContext, TExtraContext, undefined, undefined>;
+    route(route: RouteOptions): ProcedureBuilder<TContext, TExtraContext, undefined, undefined>;
     input<USchema extends Schema = undefined>(schema: USchema, example?: SchemaInput<USchema>): ProcedureBuilder<TContext, TExtraContext, USchema, undefined>;
     output<USchema extends Schema = undefined>(schema: USchema, example?: SchemaOutput<USchema>): ProcedureBuilder<TContext, TExtraContext, undefined, USchema>;
     /**
@@ -35,7 +36,7 @@ export declare class Builder<TContext extends Context, TExtraContext extends Con
     /**
      * Convert to ProcedureImplementer | RouterBuilder
      */
-    contract<UContract extends ContractProcedure<any, any> | ContractRouter>(contract: UContract): UContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? ProcedureImplementer<TContext, TExtraContext, UInputSchema, UOutputSchema> : UContract extends ContractRouter ? ChainedRouterImplementer<TContext, UContract, TExtraContext> : never;
+    contract<UContract extends ANY_CONTRACT_PROCEDURE | ContractRouter>(contract: UContract): UContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? ProcedureImplementer<TContext, TExtraContext, UInputSchema, UOutputSchema> : UContract extends ContractRouter ? ChainedRouterImplementer<TContext, UContract, TExtraContext> : never;
     /**
      * Create ExtendedMiddleware
      */

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

@@ -1,9 +1,6 @@
-import type { PartialOnUndefinedDeep, Promisable, Value } from '@orpc/shared';
+import type { Hooks, PartialOnUndefinedDeep, Value } from '@orpc/shared';
 import type { Router } from '../router';
-export interface FetchHandlerHooks {
-    next: () => Promise<Response>;
-    response: (response: Response) => Response;
-}
+import type { CallerOptions } from '../types';
 export type FetchHandlerOptions<TRouter extends Router<any>> = {
     /**
      * The `router` used for handling the request and routing,
@@ -21,15 +18,11 @@ export type FetchHandlerOptions<TRouter extends Router<any>> = {
      * @example /api
      */
     prefix?: string;
-    /**
-     * Hooks for executing logics on lifecycle events.
-     */
-    hooks?: (context: TRouter extends Router<infer UContext> ? UContext : never, hooks: FetchHandlerHooks) => Promisable<Response>;
 } & PartialOnUndefinedDeep<{
     /**
      * The context used to handle the request.
      */
     context: Value<TRouter extends Router<infer UContext> ? UContext : never>;
-}>;
+}> & CallerOptions & Hooks<Request, Response, TRouter extends Router<infer UContext> ? UContext : never, CallerOptions>;
 export type FetchHandler = <TRouter extends Router<any>>(options: FetchHandlerOptions<TRouter>) => Promise<Response | undefined>;
 //# sourceMappingURL=types.d.ts.map

package/dist/src/procedure-caller.d.ts

@@ -1,20 +1,26 @@
 import type { SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { Hooks, PartialOnUndefinedDeep, Value } from '@orpc/shared';
 import type { Lazy } from './lazy';
-import { type Value } from '@orpc/shared';
-import { type ANY_LAZY_PROCEDURE, type ANY_PROCEDURE, type Procedure } from './procedure';
-export interface CreateProcedureCallerOptions<TProcedure extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE> {
-    procedure: TProcedure;
-    /**
-     * The context used when calling the procedure.
-     */
-    context: Value<TProcedure extends Procedure<infer UContext, any, any, any, any> | Lazy<Procedure<infer UContext, any, any, any, any>> ? UContext : never>;
+import type { ANY_LAZY_PROCEDURE, ANY_PROCEDURE, Procedure } from './procedure';
+import type { Caller } from './types';
+export type CreateProcedureCallerOptions<T extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE> = T extends Procedure<infer UContext, any, any, infer UOutputSchema, infer UFuncOutput> | Lazy<Procedure<infer UContext, any, any, infer UOutputSchema, infer UFuncOutput>> ? {
+    procedure: T;
     /**
      * This is helpful for logging and analytics.
      *
      * @internal
      */
     path?: string[];
-}
-export type ProcedureCaller<TProcedure extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE> = TProcedure extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> | Lazy<Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput>> ? (...input: [input: SchemaInput<UInputSchema> | FormData] | (undefined extends SchemaInput<UInputSchema> ? [] : never)) => Promise<SchemaOutput<UOutputSchema, UFuncOutput>> : never;
+} & PartialOnUndefinedDeep<{
+    /**
+     * The context used when calling the procedure.
+     */
+    context: Value<UContext>;
+}> & Hooks<unknown, SchemaOutput<UOutputSchema, UFuncOutput>, UContext, {
+    path: string[];
+    procedure: ANY_PROCEDURE;
+}> : never;
+export type ProcedureCaller<TProcedure extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE> = TProcedure extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> | Lazy<Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput>> ? Caller<SchemaInput<UInputSchema>, SchemaOutput<UOutputSchema, UFuncOutput>> : never;
 export declare function createProcedureCaller<TProcedure extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE>(options: CreateProcedureCallerOptions<TProcedure>): ProcedureCaller<TProcedure>;
+export declare function loadProcedure(procedure: ANY_PROCEDURE | ANY_LAZY_PROCEDURE): Promise<ANY_PROCEDURE>;
 //# sourceMappingURL=procedure-caller.d.ts.map

package/dist/src/router-caller.d.ts

@@ -1,8 +1,11 @@
-import type { Value } from '@orpc/shared';
+import type { Hooks, Value } from '@orpc/shared';
 import type { ANY_LAZY_PROCEDURE, ANY_PROCEDURE } from './procedure';
 import type { Router } from './router';
 import { type ProcedureCaller } from './procedure-caller';
-export interface CreateRouterCallerOptions<TRouter extends Router<any>> {
+export interface CreateRouterCallerOptions<TRouter extends Router<any>> extends Hooks<unknown, unknown, TRouter extends Router<infer UContext> ? UContext : never, {
+    path: string[];
+    procedure: ANY_PROCEDURE;
+}> {
     router: TRouter;
     /**
      * The context used when calling the procedure.

package/dist/src/router-implementer.d.ts

@@ -12,10 +12,10 @@ export declare class RouterImplementer<TContext extends Context, TContract exten
     constructor(zz$ri: {
         contract: TContract;
     });
-    router(router: RouterWithContract<TContext, TContract>): HandledRouter<RouterWithContract<TContext, TContract>>;
-    lazy(loader: () => Promise<{
-        default: RouterWithContract<TContext, TContract>;
-    }>): DecoratedLazy<RouterWithContract<TContext, TContract>>;
+    router<U extends RouterWithContract<TContext, TContract>>(router: U): HandledRouter<U>;
+    lazy<U extends RouterWithContract<TContext, TContract>>(loader: () => Promise<{
+        default: U;
+    }>): DecoratedLazy<U>;
 }
 export type ChainedRouterImplementer<TContext extends Context, TContract extends ContractRouter, TExtraContext extends Context> = {
     [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? ProcedureImplementer<TContext, TExtraContext, UInputSchema, UOutputSchema> : TContract[K] extends ContractRouter ? ChainedRouterImplementer<TContext, TContract[K], TExtraContext> : never;

package/dist/src/router.d.ts

@@ -1,7 +1,7 @@
 import type { ContractProcedure, ContractRouter, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { ANY_LAZY, DecoratedLazy, Lazy } from './lazy';
+import type { DecoratedProcedure, Procedure } from './procedure';
 import type { Context } from './types';
-import { type DecoratedProcedure, type Procedure } from './procedure';
 export interface Router<TContext extends Context> {
     [k: string]: Procedure<TContext, any, any, any, any> | Lazy<Procedure<TContext, any, any, any, any>> | Router<TContext> | Lazy<Router<TContext>>;
 }
@@ -9,13 +9,12 @@ export type HandledRouter<TRouter extends Router<any>> = {
     [K in keyof TRouter]: TRouter[K] extends Procedure<infer UContext, infer UExtraContext, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> ? DecoratedProcedure<UContext, UExtraContext, UInputSchema, UOutputSchema, UFuncOutput> : TRouter[K] extends ANY_LAZY ? DecoratedLazy<TRouter[K]> : TRouter[K] extends Router<any> ? HandledRouter<TRouter[K]> : never;
 };
 export type RouterWithContract<TContext extends Context, TContract extends ContractRouter> = {
-    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? Procedure<TContext, any, UInputSchema, UOutputSchema, any> | Lazy<Procedure<TContext, any, UInputSchema, UOutputSchema, any>> : TContract[K] extends ContractRouter ? RouterWithContract<TContext, TContract[K]> | Lazy<RouterWithContract<TContext, TContract[K]>> : never;
+    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? Procedure<TContext, any, UInputSchema, UOutputSchema, any> | Lazy<Procedure<TContext, any, UInputSchema, UOutputSchema, any>> : TContract[K] extends ContractRouter ? RouterWithContract<TContext, TContract[K]> : never;
 };
-export declare function toContractRouter(router: ContractRouter | Router<any>): ContractRouter;
 export type InferRouterInputs<T extends Router<any>> = {
-    [K in keyof T]: T[K] extends Procedure<any, any, infer UInputSchema, any, any> ? SchemaInput<UInputSchema> : T[K] extends Router<any> ? InferRouterInputs<T[K]> : never;
+    [K in keyof T]: T[K] extends Procedure<any, any, infer UInputSchema, any, any> | Lazy<Procedure<any, any, infer UInputSchema, any, any>> ? SchemaInput<UInputSchema> : T[K] extends Router<any> ? InferRouterInputs<T[K]> : never;
 };
 export type InferRouterOutputs<T extends Router<any>> = {
-    [K in keyof T]: T[K] extends Procedure<any, any, any, infer UOutputSchema, infer UFuncOutput> ? SchemaOutput<UOutputSchema, UFuncOutput> : T[K] extends Router<any> ? InferRouterOutputs<T[K]> : never;
+    [K in keyof T]: T[K] extends Procedure<any, any, any, infer UOutputSchema, infer UFuncOutput> | Lazy<Procedure<any, any, any, infer UOutputSchema, infer UFuncOutput>> ? SchemaOutput<UOutputSchema, UFuncOutput> : T[K] extends Router<any> ? InferRouterOutputs<T[K]> : never;
 };
 //# sourceMappingURL=router.d.ts.map

package/dist/src/types.d.ts

@@ -1,7 +1,13 @@
 import type { WELL_DEFINED_PROCEDURE } from './procedure';
 export type Context = Record<string, unknown> | undefined;
 export type MergeContext<TA extends Context, TB extends Context> = TA extends undefined ? TB : TB extends undefined ? TA : TA & TB;
-export interface Meta {
+export interface CallerOptions {
+    signal?: AbortSignal;
+}
+export interface Caller<TInput, TOutput> {
+    (...opts: [input: TInput, options?: CallerOptions] | (undefined extends TInput ? [] : never)): Promise<TOutput>;
+}
+export interface Meta extends CallerOptions {
     path: string[];
     procedure: WELL_DEFINED_PROCEDURE;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.0.0-next.db1f26d",
+  "version": "0.0.0-next.ee0aeaf",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -34,16 +34,15 @@
     "dist"
   ],
   "peerDependencies": {
-    "zod": ">=3.23.0",
-    "@orpc/zod": "0.0.0-next.db1f26d"
+    "@orpc/zod": "0.0.0-next.ee0aeaf"
   },
   "dependencies": {
-    "@orpc/contract": "0.0.0-next.db1f26d",
-    "@orpc/shared": "0.0.0-next.db1f26d",
-    "@orpc/transformer": "0.0.0-next.db1f26d"
+    "@orpc/shared": "0.0.0-next.ee0aeaf",
+    "@orpc/transformer": "0.0.0-next.ee0aeaf",
+    "@orpc/contract": "0.0.0-next.ee0aeaf"
   },
   "devDependencies": {
-    "@orpc/openapi": "0.0.0-next.db1f26d"
+    "@orpc/openapi": "0.0.0-next.ee0aeaf"
   },
   "scripts": {
     "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.fetch=src/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",