@orpc/server 0.28.0 → 0.29.0

package/dist/{chunk-V3I7RIRY.js → chunk-VY6NXNQT.js}

@@ -4,7 +4,7 @@ import {
   getRouterChild,
   isProcedure,
   unlazy
-} from "./chunk-DNG2IB3R.js";
+} from "./chunk-XDC42C3C.js";
 
 // src/adapters/fetch/super-json.ts
 var super_json_exports = {};
@@ -238,7 +238,7 @@ var ORPCProcedureMatcher = class {
 // src/adapters/fetch/orpc-handler.ts
 import { ORPCError as ORPCError2 } from "@orpc/contract";
 import { executeWithHooks, trim as trim2 } from "@orpc/shared";
-var ORPCHandler = class {
+var RPCHandler = class {
   constructor(router, options) {
     this.options = options;
     this.procedureMatcher = options?.procedureMatcher ?? new ORPCProcedureMatcher(router);
@@ -256,9 +256,8 @@ var ORPCHandler = class {
         return { matched: false, response: void 0 };
       }
       const input = await this.payloadCodec.decode(request);
-      const client = createProcedureClient({
+      const client = createProcedureClient(match.procedure, {
         context,
-        procedure: match.procedure,
         path: match.path
       });
       const output = await client(input, { signal: request.signal });
@@ -297,6 +296,6 @@ export {
   super_json_exports,
   ORPCPayloadCodec,
   ORPCProcedureMatcher,
-  ORPCHandler
+  RPCHandler
 };
-//# sourceMappingURL=chunk-V3I7RIRY.js.map
+//# sourceMappingURL=chunk-VY6NXNQT.js.map

package/dist/{chunk-DNG2IB3R.js → chunk-XDC42C3C.js}

@@ -89,11 +89,11 @@ function flatLazy(lazied) {
 // src/procedure-client.ts
 import { ORPCError as ORPCError2, validateORPCError, ValidationError } from "@orpc/contract";
 import { executeWithHooks, toError, value } from "@orpc/shared";
-function createProcedureClient(options) {
+function createProcedureClient(lazyableProcedure, ...[options]) {
   return async (...[input, callerOptions]) => {
-    const path = options.path ?? [];
-    const { default: procedure } = await unlazy(options.procedure);
-    const context = await value(options.context);
+    const path = options?.path ?? [];
+    const { default: procedure } = await unlazy(lazyableProcedure);
+    const context = await value(options?.context, callerOptions?.context);
     const meta = {
       path,
       procedure,
@@ -224,4 +224,4 @@ export {
   createProcedureClient,
   getRouterChild
 };
-//# sourceMappingURL=chunk-DNG2IB3R.js.map
+//# sourceMappingURL=chunk-XDC42C3C.js.map

package/dist/fetch.js

@@ -1,15 +1,15 @@
 import "./chunk-WUOGVGWG.js";
 import {
-  ORPCHandler,
   ORPCPayloadCodec,
   ORPCProcedureMatcher,
+  RPCHandler,
   super_json_exports
-} from "./chunk-V3I7RIRY.js";
-import "./chunk-DNG2IB3R.js";
+} from "./chunk-VY6NXNQT.js";
+import "./chunk-XDC42C3C.js";
 export {
-  ORPCHandler,
   ORPCPayloadCodec,
   ORPCProcedureMatcher,
+  RPCHandler,
   super_json_exports as SuperJSON
 };
 //# sourceMappingURL=fetch.js.map

package/dist/hono.js

@@ -1,11 +1,11 @@
 import "./chunk-WUOGVGWG.js";
 import {
-  ORPCHandler,
   ORPCPayloadCodec,
   ORPCProcedureMatcher,
+  RPCHandler,
   super_json_exports
-} from "./chunk-V3I7RIRY.js";
-import "./chunk-DNG2IB3R.js";
+} from "./chunk-VY6NXNQT.js";
+import "./chunk-XDC42C3C.js";
 
 // src/adapters/hono/middleware.ts
 import { value } from "@orpc/shared";
@@ -21,9 +21,9 @@ function createMiddleware(handler, ...[options]) {
   };
 }
 export {
-  ORPCHandler,
   ORPCPayloadCodec,
   ORPCProcedureMatcher,
+  RPCHandler,
   super_json_exports as SuperJSON,
   createMiddleware
 };

package/dist/index.js

@@ -10,14 +10,14 @@ import {
   lazy,
   mergeContext,
   unlazy
-} from "./chunk-DNG2IB3R.js";
+} from "./chunk-XDC42C3C.js";
 
 // src/builder.ts
 import { ContractProcedure } from "@orpc/contract";
 
 // src/implementer-chainable.ts
 import { isContractProcedure } from "@orpc/contract";
-import { createCallableObject } from "@orpc/shared";
+import { createCallableObject as createCallableObject2 } from "@orpc/shared";
 
 // src/middleware-decorated.ts
 function decorateMiddleware(middleware) {
@@ -44,58 +44,72 @@ function decorateMiddleware(middleware) {
 
 // src/procedure-decorated.ts
 import { DecoratedContractProcedure } from "@orpc/contract";
-function decorateProcedure(procedure) {
-  const caller = createProcedureClient({
-    procedure,
-    context: void 0
-  });
-  const decorated = caller;
-  decorated["~type"] = procedure["~type"];
-  decorated["~orpc"] = procedure["~orpc"];
-  decorated.prefix = (prefix) => {
-    return decorateProcedure(new Procedure({
-      ...procedure["~orpc"],
-      contract: DecoratedContractProcedure.decorate(procedure["~orpc"].contract).prefix(prefix)
-    }));
-  };
-  decorated.route = (route) => {
-    return decorateProcedure(new Procedure({
-      ...procedure["~orpc"],
-      contract: DecoratedContractProcedure.decorate(procedure["~orpc"].contract).route(route)
-    }));
-  };
-  decorated.use = (middleware, mapInput) => {
+import { createCallableObject } from "@orpc/shared";
+var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
+  static decorate(procedure) {
+    if (procedure instanceof _DecoratedProcedure) {
+      return procedure;
+    }
+    return new _DecoratedProcedure(procedure["~orpc"]);
+  }
+  prefix(prefix) {
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).prefix(prefix)
+    });
+  }
+  route(route) {
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).route(route)
+    });
+  }
+  use(middleware, mapInput) {
     const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return decorateProcedure(new Procedure({
-      ...procedure["~orpc"],
-      middlewares: [...procedure["~orpc"].middlewares ?? [], middleware_]
-    }));
-  };
-  decorated.unshiftTag = (...tags) => {
-    return decorateProcedure(new Procedure({
-      ...procedure["~orpc"],
-      contract: DecoratedContractProcedure.decorate(procedure["~orpc"].contract).unshiftTag(...tags)
-    }));
-  };
-  decorated.unshiftMiddleware = (...middlewares) => {
-    if (procedure["~orpc"].middlewares?.length) {
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      middlewares: [...this["~orpc"].middlewares ?? [], middleware_]
+    });
+  }
+  unshiftTag(...tags) {
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).unshiftTag(...tags)
+    });
+  }
+  unshiftMiddleware(...middlewares) {
+    const castedMiddlewares = middlewares;
+    if (this["~orpc"].middlewares?.length) {
       let min = 0;
-      for (let i = 0; i < procedure["~orpc"].middlewares.length; i++) {
-        const index = middlewares.indexOf(procedure["~orpc"].middlewares[i], min);
+      for (let i = 0; i < this["~orpc"].middlewares.length; i++) {
+        const index = castedMiddlewares.indexOf(this["~orpc"].middlewares[i], min);
         if (index === -1) {
-          middlewares.push(...procedure["~orpc"].middlewares.slice(i));
+          castedMiddlewares.push(...this["~orpc"].middlewares.slice(i));
           break;
         }
         min = index + 1;
       }
     }
-    return decorateProcedure(new Procedure({
-      ...procedure["~orpc"],
-      middlewares
-    }));
-  };
-  return decorated;
-}
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      middlewares: castedMiddlewares
+    });
+  }
+  /**
+   * Make this procedure callable (works like a function while still being a procedure).
+   * **Note**: this only takes effect when this method is called at the end of the chain.
+   */
+  callable(...rest) {
+    return createCallableObject(this, createProcedureClient(this, ...rest));
+  }
+  /**
+   * Make this procedure compatible with server action (the same as .callable, but the type is compatible with server action).
+   * **Note**: this only takes effect when this method is called at the end of the chain.
+   */
+  actionable(...rest) {
+    return this.callable(...rest);
+  }
+};
 
 // src/procedure-implementer.ts
 var ProcedureImplementer = class _ProcedureImplementer {
@@ -112,11 +126,11 @@ var ProcedureImplementer = class _ProcedureImplementer {
     });
   }
   handler(handler) {
-    return decorateProcedure(new Procedure({
+    return new DecoratedProcedure({
       middlewares: this["~orpc"].middlewares,
       contract: this["~orpc"].contract,
       handler
-    }));
+    });
   }
 };
 
@@ -154,31 +168,10 @@ function getLazyRouterPrefix(obj) {
   return obj[LAZY_ROUTER_PREFIX_SYMBOL];
 }
 
-// src/lazy-utils.ts
-function createLazyProcedureFormAnyLazy(lazied) {
-  const lazyProcedure = lazy(async () => {
-    const { default: maybeProcedure } = await unlazy(flatLazy(lazied));
-    if (!isProcedure(maybeProcedure)) {
-      throw new Error(`
-            Expected a lazy<procedure> but got lazy<unknown>.
-            This should be caught by TypeScript compilation.
-            Please report this issue if this makes you feel uncomfortable.
-        `);
-    }
-    return { default: maybeProcedure };
-  });
-  return lazyProcedure;
-}
-
 // src/lazy-decorated.ts
 function decorateLazy(lazied) {
   const flattenLazy = flatLazy(lazied);
-  const procedureProcedureClient = createProcedureClient({
-    procedure: createLazyProcedureFormAnyLazy(flattenLazy),
-    context: void 0
-  });
-  Object.assign(procedureProcedureClient, flattenLazy);
-  const recursive = new Proxy(procedureProcedureClient, {
+  const recursive = new Proxy(flattenLazy, {
     get(target, key) {
       if (typeof key !== "string") {
         return Reflect.get(target, key);
@@ -245,7 +238,7 @@ function adapt(item, options) {
     return adaptedLazy;
   }
   if (isProcedure(item)) {
-    let decorated = decorateProcedure(item);
+    let decorated = DecoratedProcedure.decorate(item);
     if (options.tags?.length) {
       decorated = decorated.unshiftTag(...options.tags);
     }
@@ -313,7 +306,7 @@ function createChainableImplementer(contract, middlewares) {
       if (!next) {
         return method.bind(routerImplementer);
       }
-      return createCallableObject(next, method.bind(routerImplementer));
+      return createCallableObject2(next, method.bind(routerImplementer));
     }
   });
   return merged;
@@ -366,11 +359,11 @@ var ProcedureBuilder = class _ProcedureBuilder {
     }).use(middleware, mapInput);
   }
   handler(handler) {
-    return decorateProcedure(new Procedure({
+    return new DecoratedProcedure({
       middlewares: this["~orpc"].middlewares,
       contract: this["~orpc"].contract,
       handler
-    }));
+    });
   }
 };
 
@@ -437,7 +430,7 @@ var Builder = class _Builder {
     });
   }
   handler(handler) {
-    return decorateProcedure(new Procedure({
+    return new DecoratedProcedure({
       middlewares: this["~orpc"].middlewares,
       contract: new ContractProcedure({
         InputSchema: void 0,
@@ -445,7 +438,7 @@ var Builder = class _Builder {
         errorMap: void 0
       }),
       handler
-    }));
+    });
   }
   prefix(prefix) {
     return new RouterBuilder({
@@ -470,36 +463,47 @@ var Builder = class _Builder {
   }
 };
 
+// src/procedure-utils.ts
+function call(procedure, input, ...rest) {
+  return createProcedureClient(procedure, ...rest)(input);
+}
+
+// src/lazy-utils.ts
+function createLazyProcedureFormAnyLazy(lazied) {
+  const lazyProcedure = lazy(async () => {
+    const { default: maybeProcedure } = await unlazy(flatLazy(lazied));
+    if (!isProcedure(maybeProcedure)) {
+      throw new Error(`
+            Expected a lazy<procedure> but got lazy<unknown>.
+            This should be caught by TypeScript compilation.
+            Please report this issue if this makes you feel uncomfortable.
+        `);
+    }
+    return { default: maybeProcedure };
+  });
+  return lazyProcedure;
+}
+
 // src/router-client.ts
-function createRouterClient(options) {
-  if (isProcedure(options.router)) {
-    const caller = createProcedureClient({
-      ...options,
-      procedure: options.router,
-      context: options.context,
-      path: options.path
-    });
+function createRouterClient(router, ...rest) {
+  if (isProcedure(router)) {
+    const caller = createProcedureClient(router, ...rest);
     return caller;
   }
-  const procedureCaller = isLazy(options.router) ? createProcedureClient({
-    ...options,
-    procedure: createLazyProcedureFormAnyLazy(options.router),
-    context: options.context,
-    path: options.path
-  }) : {};
+  const procedureCaller = isLazy(router) ? createProcedureClient(createLazyProcedureFormAnyLazy(router), ...rest) : {};
   const recursive = new Proxy(procedureCaller, {
     get(target, key) {
       if (typeof key !== "string") {
         return Reflect.get(target, key);
       }
-      const next = getRouterChild(options.router, key);
+      const next = getRouterChild(router, key);
       if (!next) {
         return Reflect.get(target, key);
       }
-      return createRouterClient({
+      const [options] = rest;
+      return createRouterClient(next, {
         ...options,
-        router: next,
-        path: [...options.path ?? [], key]
+        path: [...options?.path ?? [], key]
       });
     }
   });
@@ -511,6 +515,7 @@ import { configGlobal, fallbackToGlobalConfig, isDefinedError, ORPCError, safe }
 var os = new Builder({});
 export {
   Builder,
+  DecoratedProcedure,
   LAZY_LOADER_SYMBOL,
   ORPCError,
   Procedure,
@@ -518,6 +523,7 @@ export {
   ProcedureImplementer,
   RouterBuilder,
   RouterImplementer,
+  call,
   configGlobal,
   createChainableImplementer,
   createORPCErrorConstructorMap,
@@ -525,7 +531,6 @@ export {
   createRouterClient,
   decorateLazy,
   decorateMiddleware,
-  decorateProcedure,
   deepSetLazyRouterPrefix,
   fallbackToGlobalConfig,
   flatLazy,

package/dist/next.js

@@ -1,11 +1,11 @@
 import "./chunk-WUOGVGWG.js";
 import {
-  ORPCHandler,
   ORPCPayloadCodec,
   ORPCProcedureMatcher,
+  RPCHandler,
   super_json_exports
-} from "./chunk-V3I7RIRY.js";
-import "./chunk-DNG2IB3R.js";
+} from "./chunk-VY6NXNQT.js";
+import "./chunk-XDC42C3C.js";
 
 // src/adapters/next/serve.ts
 import { value } from "@orpc/shared";
@@ -27,9 +27,9 @@ function serve(handler, ...[options]) {
   };
 }
 export {
-  ORPCHandler,
   ORPCPayloadCodec,
   ORPCProcedureMatcher,
+  RPCHandler,
   super_json_exports as SuperJSON,
   serve
 };

package/dist/node.js

@@ -1,7 +1,7 @@
 import {
-  ORPCHandler
-} from "./chunk-V3I7RIRY.js";
-import "./chunk-DNG2IB3R.js";
+  RPCHandler
+} from "./chunk-VY6NXNQT.js";
+import "./chunk-XDC42C3C.js";
 
 // src/adapters/node/request-listener.ts
 function createRequest(req, res) {
@@ -61,10 +61,10 @@ async function sendResponse(res, response) {
 }
 
 // src/adapters/node/orpc-handler.ts
-var ORPCHandler2 = class {
+var RPCHandler2 = class {
   orpcFetchHandler;
   constructor(router, options) {
-    this.orpcFetchHandler = new ORPCHandler(router, options);
+    this.orpcFetchHandler = new RPCHandler(router, options);
   }
   async handle(req, res, ...[options]) {
     const request = createRequest(req, res);
@@ -79,7 +79,7 @@ var ORPCHandler2 = class {
   }
 };
 export {
-  ORPCHandler2 as ORPCHandler,
+  RPCHandler2 as RPCHandler,
   createHeaders,
   createRequest,
   sendResponse

package/dist/src/adapters/fetch/orpc-handler.d.ts

@@ -4,17 +4,17 @@ import type { Context } from '../../types';
 import type { FetchHandler, FetchHandleRest, FetchHandleResult } from './types';
 import { type PublicORPCPayloadCodec } from './orpc-payload-codec';
 import { type PublicORPCProcedureMatcher } from './orpc-procedure-matcher';
-export type ORPCHandlerOptions<T extends Context> = Hooks<Request, FetchHandleResult, T, {
+export type RPCHandlerOptions<T extends Context> = Hooks<Request, FetchHandleResult, T, {
     signal?: AbortSignal;
 }> & {
     procedureMatcher?: PublicORPCProcedureMatcher;
     payloadCodec?: PublicORPCPayloadCodec;
 };
-export declare class ORPCHandler<T extends Context> implements FetchHandler<T> {
+export declare class RPCHandler<T extends Context> implements FetchHandler<T> {
     private readonly options?;
     private readonly procedureMatcher;
     private readonly payloadCodec;
-    constructor(router: Router<T, any>, options?: NoInfer<ORPCHandlerOptions<T>> | undefined);
+    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>> | undefined);
     handle(request: Request, ...[options]: FetchHandleRest<T>): Promise<FetchHandleResult>;
 }
 //# sourceMappingURL=orpc-handler.d.ts.map

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

@@ -1,12 +1,12 @@
 import type { ServerResponse } from 'node:http';
 import type { Router } from '../../router';
 import type { Context } from '../../types';
-import type { ORPCHandlerOptions } from '../fetch/orpc-handler';
+import type { RPCHandlerOptions } from '../fetch/orpc-handler';
 import type { RequestHandler, RequestHandleRest, RequestHandleResult } from './types';
 import { type ExpressableIncomingMessage } from './request-listener';
-export declare class ORPCHandler<T extends Context> implements RequestHandler<T> {
+export declare class RPCHandler<T extends Context> implements RequestHandler<T> {
     private readonly orpcFetchHandler;
-    constructor(router: Router<T, any>, options?: NoInfer<ORPCHandlerOptions<T>>);
+    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>);
     handle(req: ExpressableIncomingMessage, res: ServerResponse, ...[options]: RequestHandleRest<T>): Promise<RequestHandleResult>;
 }
 //# sourceMappingURL=orpc-handler.d.ts.map

package/dist/src/builder.d.ts

@@ -2,13 +2,13 @@ import type { ANY_CONTRACT_PROCEDURE, ContractRouter, ErrorMap, HTTPPath, RouteO
 import type { FlattenLazy } from './lazy';
 import type { Middleware } from './middleware';
 import type { DecoratedMiddleware } from './middleware-decorated';
+import type { ProcedureHandler } from './procedure';
 import type { Router } from './router';
 import type { AdaptedRouter } from './router-builder';
 import type { Context, MergeContext, WELL_CONTEXT } from './types';
 import { type ChainableImplementer } from './implementer-chainable';
-import { type ProcedureHandler } from './procedure';
 import { ProcedureBuilder } from './procedure-builder';
-import { type DecoratedProcedure } from './procedure-decorated';
+import { DecoratedProcedure } from './procedure-decorated';
 import { RouterBuilder } from './router-builder';
 export interface BuilderDef<TContext extends Context, TExtraContext extends Context> {
     middlewares?: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<string, unknown>>[];

package/dist/src/index.d.ts

@@ -13,6 +13,7 @@ export * from './procedure-builder';
 export * from './procedure-client';
 export * from './procedure-decorated';
 export * from './procedure-implementer';
+export * from './procedure-utils';
 export * from './router';
 export * from './router-builder';
 export * from './router-client';

package/dist/src/lazy-decorated.d.ts

@@ -1,10 +1,7 @@
-import type { ErrorFromErrorMap, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { Lazy } from './lazy';
-import type { Procedure } from './procedure';
-import type { ProcedureClient } from './procedure-client';
 import { type ANY_ROUTER } from './router';
-export type DecoratedLazy<T> = T extends Lazy<infer U> ? DecoratedLazy<U> : Lazy<T> & (T extends Procedure<infer UContext, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput, infer UErrorMap> ? undefined extends UContext ? ProcedureClient<unknown, SchemaInput<UInputSchema>, SchemaOutput<UOutputSchema, UFuncOutput>, ErrorFromErrorMap<UErrorMap>> : unknown : {
-    [K in keyof T]: T[K] extends object ? DecoratedLazy<T[K]> : never;
-});
+export type DecoratedLazy<T> = T extends Lazy<infer U> ? DecoratedLazy<U> : Lazy<T> & (T extends ANY_ROUTER ? {
+    [K in keyof T]: DecoratedLazy<T[K]>;
+} : unknown);
 export declare function decorateLazy<T extends Lazy<ANY_ROUTER | undefined>>(lazied: T): DecoratedLazy<T>;
 //# sourceMappingURL=lazy-decorated.d.ts.map

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

@@ -1,9 +1,9 @@
 import type { ContractProcedure, ErrorMap, RouteOptions, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { ORPCErrorConstructorMap } from './error';
 import type { MapInputMiddleware, Middleware } from './middleware';
-import type { DecoratedProcedure } from './procedure-decorated';
+import type { ProcedureHandler } from './procedure';
 import type { Context, MergeContext } from './types';
-import { type ProcedureHandler } from './procedure';
+import { DecoratedProcedure } from './procedure-decorated';
 import { ProcedureImplementer } from './procedure-implementer';
 export interface ProcedureBuilderDef<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> {
     contract: ContractProcedure<TInputSchema, TOutputSchema, TErrorMap>;

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

@@ -2,33 +2,21 @@ import type { Client, ErrorFromErrorMap, ErrorMap, Schema, SchemaInput, SchemaOu
 import type { Hooks, Value } from '@orpc/shared';
 import type { Lazyable } from './lazy';
 import type { Procedure } from './procedure';
-import type { AbortSignal, Context, Meta } from './types';
-export type ProcedureClientOptions<TClientContext> = {
-    signal?: AbortSignal;
-} & (undefined extends TClientContext ? {
-    context?: TClientContext;
-} : {
-    context: TClientContext;
-});
-export type ProcedureClient<TClientContext, TInput, TOutput, TError extends Error> = Client<TClientContext, TInput, TOutput, TError>;
+import type { Context, Meta } from './types';
+export type ProcedureClient<TClientContext, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap> = Client<TClientContext, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>;
 /**
  * Options for creating a procedure caller with comprehensive type safety
  */
-export type CreateProcedureClientOptions<TContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap> = {
-    procedure: Lazyable<Procedure<TContext, any, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>>;
+export type CreateProcedureClientOptions<TContext extends Context, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TClientContext> = {
     /**
      * This is helpful for logging and analytics.
-     *
-     * @internal
      */
     path?: string[];
 } & ({
-    /**
-     * The context used when calling the procedure.
-     */
-    context: Value<TContext>;
+    context: Value<TContext, [clientContext: TClientContext]>;
 } | (undefined extends TContext ? {
-    context?: undefined;
+    context?: Value<TContext, [clientContext: TClientContext]>;
 } : never)) & Hooks<unknown, SchemaOutput<TOutputSchema, THandlerOutput>, TContext, Meta>;
-export declare function createProcedureClient<TContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap>(options: CreateProcedureClientOptions<TContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>): ProcedureClient<unknown, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>;
+export type CreateProcedureClientRest<TContext extends Context, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TClientContext> = [options: CreateProcedureClientOptions<TContext, TOutputSchema, THandlerOutput, TClientContext>] | (undefined extends TContext ? [] : never);
+export declare function createProcedureClient<TContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap, TClientContext>(lazyableProcedure: Lazyable<Procedure<TContext, any, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>>, ...[options]: CreateProcedureClientRest<TContext, TOutputSchema, THandlerOutput, TClientContext>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
 //# sourceMappingURL=procedure-client.d.ts.map

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

@@ -1,15 +1,26 @@
-import type { ErrorFromErrorMap, ErrorMap, HTTPPath, RouteOptions, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ClientRest, ErrorMap, HTTPPath, RouteOptions, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { ORPCErrorConstructorMap } from './error';
 import type { MapInputMiddleware, Middleware } from './middleware';
-import type { ProcedureClient } from './procedure-client';
+import type { CreateProcedureClientRest, ProcedureClient } from './procedure-client';
 import type { Context, MergeContext } from './types';
 import { Procedure } from './procedure';
-export type DecoratedProcedure<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap> = Procedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap> & {
-    prefix: (prefix: HTTPPath) => DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
-    route: (route: RouteOptions) => DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
-    use: (<U extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, U, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema, THandlerOutput>, ORPCErrorConstructorMap<TErrorMap>>) => DecoratedProcedure<TContext, MergeContext<TExtraContext, U>, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>) & (<UExtra extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined, UInput = unknown>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtra, UInput, SchemaInput<TOutputSchema, THandlerOutput>, ORPCErrorConstructorMap<TErrorMap>>, mapInput: MapInputMiddleware<SchemaOutput<TInputSchema, THandlerOutput>, UInput>) => DecoratedProcedure<TContext, MergeContext<TExtraContext, UExtra>, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>);
-    unshiftTag: (...tags: string[]) => DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
-    unshiftMiddleware: <U extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined>(...middlewares: Middleware<TContext, U, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema, THandlerOutput>, ORPCErrorConstructorMap<TErrorMap>>[]) => DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
-} & (undefined extends TContext ? ProcedureClient<unknown, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>> : unknown);
-export declare function decorateProcedure<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap>(procedure: Procedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
+export declare class DecoratedProcedure<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap> extends Procedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap> {
+    static decorate<UContext extends Context, UExtraContext extends Context, UInputSchema extends Schema, UOutputSchema extends Schema, UHandlerOutput extends SchemaInput<UOutputSchema>, UErrorMap extends ErrorMap>(procedure: Procedure<UContext, UExtraContext, UInputSchema, UOutputSchema, UHandlerOutput, UErrorMap>): DecoratedProcedure<any, any, any, any, any, any> | DecoratedProcedure<UContext, UExtraContext, UInputSchema, UOutputSchema, UHandlerOutput, UErrorMap>;
+    prefix(prefix: HTTPPath): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
+    route(route: RouteOptions): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
+    use<U extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, U, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema, THandlerOutput>, ORPCErrorConstructorMap<TErrorMap>>): DecoratedProcedure<TContext, MergeContext<TExtraContext, U>, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
+    use<UExtra extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined, UInput = unknown>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtra, UInput, SchemaInput<TOutputSchema, THandlerOutput>, ORPCErrorConstructorMap<TErrorMap>>, mapInput: MapInputMiddleware<SchemaOutput<TInputSchema, THandlerOutput>, UInput>): DecoratedProcedure<TContext, MergeContext<TExtraContext, UExtra>, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
+    unshiftTag(...tags: string[]): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
+    unshiftMiddleware<U extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined>(...middlewares: Middleware<TContext, U, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema, THandlerOutput>, ORPCErrorConstructorMap<TErrorMap>>[]): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
+    /**
+     * Make this procedure callable (works like a function while still being a procedure).
+     * **Note**: this only takes effect when this method is called at the end of the chain.
+     */
+    callable<TClientContext>(...rest: CreateProcedureClientRest<TContext, TOutputSchema, THandlerOutput, TClientContext>): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
+    /**
+     * Make this procedure compatible with server action (the same as .callable, but the type is compatible with server action).
+     * **Note**: this only takes effect when this method is called at the end of the chain.
+     */
+    actionable<TClientContext>(...rest: CreateProcedureClientRest<TContext, TOutputSchema, THandlerOutput, TClientContext>): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap> & ((...rest: ClientRest<TClientContext, SchemaInput<TInputSchema>>) => Promise<SchemaOutput<TOutputSchema, THandlerOutput>>);
+}
 //# sourceMappingURL=procedure-decorated.d.ts.map

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

@@ -2,8 +2,8 @@ import type { ContractProcedure, ErrorMap, Schema, SchemaInput, SchemaOutput } f
 import type { ORPCErrorConstructorMap } from './error';
 import type { MapInputMiddleware, Middleware } from './middleware';
 import type { ProcedureHandler } from './procedure';
-import type { DecoratedProcedure } from './procedure-decorated';
 import type { Context, MergeContext } from './types';
+import { DecoratedProcedure } from './procedure-decorated';
 export type ProcedureImplementerDef<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> = {
     contract: ContractProcedure<TInputSchema, TOutputSchema, TErrorMap>;
     middlewares?: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema>, ORPCErrorConstructorMap<TErrorMap>>[];

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

@@ -0,0 +1,17 @@
+import type { ClientPromiseResult, ErrorFromErrorMap, ErrorMap, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { Lazyable } from './lazy';
+import type { Procedure } from './procedure';
+import type { Context } from './types';
+import { type CreateProcedureClientRest } from './procedure-client';
+/**
+ * Directly call a procedure without creating a client.
+ *
+ * @example
+ * ```ts
+ * const output = await call(getting, 'input')
+ * const output = await call(getting, 'input', { context: { db: 'postgres' } })
+ * ```
+ *
+ */
+export declare function call<TContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap>(procedure: Lazyable<Procedure<TContext, any, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>>, input: SchemaInput<TInputSchema>, ...rest: CreateProcedureClientRest<TContext, TOutputSchema, THandlerOutput, unknown>): ClientPromiseResult<SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>;
+//# sourceMappingURL=procedure-utils.d.ts.map

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

@@ -5,7 +5,7 @@ import type { Procedure } from './procedure';
 import type { ANY_ROUTER, Router } from './router';
 import type { Context, MergeContext } from './types';
 import { type DecoratedLazy } from './lazy-decorated';
-import { type DecoratedProcedure } from './procedure-decorated';
+import { DecoratedProcedure } from './procedure-decorated';
 export type AdaptedRouter<TContext extends Context, TRouter extends ANY_ROUTER> = TRouter extends Lazy<infer U extends ANY_ROUTER> ? DecoratedLazy<AdaptedRouter<TContext, U>> : TRouter extends Procedure<any, infer UExtraContext, infer UInputSchema, infer UOutputSchema, infer UFuncOutput, infer UErrorMap> ? DecoratedProcedure<TContext, UExtraContext, UInputSchema, UOutputSchema, UFuncOutput, UErrorMap> : {
     [K in keyof TRouter]: TRouter[K] extends ANY_ROUTER ? AdaptedRouter<TContext, TRouter[K]> : never;
 };

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

@@ -1,15 +1,16 @@
-import type { ContractProcedure, ContractRouter, ErrorFromErrorMap, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { Hooks, Value } from '@orpc/shared';
 import type { Lazy } from './lazy';
 import type { Procedure } from './procedure';
-import type { ProcedureClient } from './procedure-client';
+import type { CreateProcedureClientRest, ProcedureClient } from './procedure-client';
 import type { Meta } from './types';
 import { type ANY_ROUTER, type Router } from './router';
-export type RouterClient<TRouter extends ANY_ROUTER | ContractRouter, TClientContext> = TRouter extends Lazy<infer U extends ANY_ROUTER | ContractRouter> ? RouterClient<U, TClientContext> : TRouter extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap> | Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput, infer UErrorMap> ? ProcedureClient<TClientContext, SchemaInput<UInputSchema>, SchemaOutput<UOutputSchema, UFuncOutput>, ErrorFromErrorMap<UErrorMap>> : {
-    [K in keyof TRouter]: TRouter[K] extends ANY_ROUTER | ContractRouter ? RouterClient<TRouter[K], TClientContext> : never;
+/**
+ * FIXME: separate RouterClient and ContractRouterClient, don't mix them
+ */
+export type RouterClient<TRouter extends ANY_ROUTER, TClientContext> = TRouter extends Lazy<infer U extends ANY_ROUTER> ? RouterClient<U, TClientContext> : TRouter extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput, infer UErrorMap> ? ProcedureClient<TClientContext, UInputSchema, UOutputSchema, UFuncOutput, UErrorMap> : {
+    [K in keyof TRouter]: TRouter[K] extends ANY_ROUTER ? RouterClient<TRouter[K], TClientContext> : never;
 };
 export type CreateRouterClientOptions<TRouter extends ANY_ROUTER> = {
-    router: TRouter | Lazy<undefined>;
     /**
      * This is helpful for logging and analytics.
      *
@@ -21,5 +22,5 @@ export type CreateRouterClientOptions<TRouter extends ANY_ROUTER> = {
 } : {
     context: Value<UContext>;
 } : never) & Hooks<unknown, unknown, TRouter extends Router<infer UContext, any> ? UContext : never, Meta>;
-export declare function createRouterClient<TRouter extends ANY_ROUTER>(options: CreateRouterClientOptions<TRouter>): RouterClient<TRouter, unknown>;
+export declare function createRouterClient<TRouter extends ANY_ROUTER, TClientContext>(router: TRouter | Lazy<undefined>, ...rest: CreateProcedureClientRest<TRouter extends Router<infer UContext, any> ? UContext : never, undefined, unknown, TClientContext>): RouterClient<TRouter, TClientContext>;
 //# sourceMappingURL=router-client.d.ts.map

package/dist/src/router.d.ts

@@ -12,5 +12,5 @@ export type InferRouterInputs<T extends ANY_ROUTER> = T extends Lazy<infer U ext
 export type InferRouterOutputs<T extends ANY_ROUTER> = T extends Lazy<infer U extends ANY_ROUTER> ? InferRouterOutputs<U> : T extends Procedure<any, any, any, infer UOutputSchema, infer UFuncOutput, any> ? SchemaOutput<UOutputSchema, UFuncOutput> : {
     [K in keyof T]: T[K] extends ANY_ROUTER ? InferRouterOutputs<T[K]> : never;
 };
-export declare function getRouterChild<T extends ANY_ROUTER | Lazy<undefined>>(router: T, ...path: string[]): T extends ANY_LAZY ? Lazy<ANY_PROCEDURE | Record<string, ANY_ROUTER> | undefined> : ANY_ROUTER | Lazy<undefined> | undefined;
+export declare function getRouterChild<T extends ANY_ROUTER | Lazy<undefined>>(router: T, ...path: string[]): T extends ANY_LAZY ? Lazy<ANY_PROCEDURE> | Lazy<Record<string, ANY_ROUTER>> | Lazy<undefined> : ANY_ROUTER | Lazy<undefined> | undefined;
 //# sourceMappingURL=router.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -53,8 +53,8 @@
     "next": ">=14.0.0"
   },
   "dependencies": {
-    "@orpc/contract": "0.28.0",
-    "@orpc/shared": "0.28.0"
+    "@orpc/contract": "0.29.0",
+    "@orpc/shared": "0.29.0"
   },
   "scripts": {
     "build": "tsup --onSuccess='tsc -b --noCheck'",