@orpc/server 0.35.1 → 0.36.1

package/dist/{chunk-SUGWQSMQ.js → chunk-F75AQ6KO.js}

@@ -6,10 +6,10 @@ import {
   getRouterChild,
   isProcedure,
   unlazy
-} from "./chunk-NOA3GBJQ.js";
+} from "./chunk-SV6DBVXJ.js";
 import {
   CompositePlugin
-} from "./chunk-OWMUECGT.js";
+} from "./chunk-XFBAK67J.js";
 
 // src/adapters/standard/handler.ts
 import { toORPCError } from "@orpc/contract";
@@ -25,30 +25,35 @@ var StandardHandler = class {
   }
   plugin;
   handle(request, ...[options]) {
-    const handleOptions = options ?? {};
-    handleOptions.context ??= {};
     return intercept(
       this.options.interceptorsRoot ?? [],
-      { request, ...handleOptions },
-      async (interceptorRootOptions) => {
+      {
+        request,
+        ...options,
+        context: options?.context ?? {}
+        // context is optional only when all fields are optional so we can safely force it to have a context
+      },
+      async (interceptorOptions) => {
         try {
           return await intercept(
             this.options.interceptors ?? [],
-            interceptorRootOptions,
-            async ({ request: request2, context }) => {
-              const method = request2.method;
-              const url = request2.url;
-              const pathname = `/${trim(url.pathname.replace(options?.prefix ?? "", ""), "/")}`;
+            interceptorOptions,
+            async (interceptorOptions2) => {
+              const method = interceptorOptions2.request.method;
+              const url = interceptorOptions2.request.url;
+              const pathname = `/${trim(url.pathname.replace(interceptorOptions2.prefix ?? "", ""), "/")}`;
               const match = await this.matcher.match(method, pathname);
               if (!match) {
                 return { matched: false, response: void 0 };
               }
-              const client = createProcedureClient(match.procedure, {
-                context,
+              const clientOptions = {
+                context: interceptorOptions2.context,
                 path: match.path
-              });
-              const input = await this.codec.decode(request2, match.params, match.procedure);
-              const output = await client(input, { signal: request2.signal });
+              };
+              this.plugin.beforeCreateProcedureClient(clientOptions, interceptorOptions2);
+              const client = createProcedureClient(match.procedure, clientOptions);
+              const input = await this.codec.decode(request, match.params, match.procedure);
+              const output = await client(input, { signal: request.signal });
               const response = this.codec.encode(output, match.procedure);
               return {
                 matched: true,
@@ -305,4 +310,4 @@ export {
   RPCCodec,
   RPCMatcher
 };
-//# sourceMappingURL=chunk-SUGWQSMQ.js.map
+//# sourceMappingURL=chunk-F75AQ6KO.js.map

package/dist/{chunk-JBPBLCBJ.js → chunk-GQ4376GR.js}

@@ -2,11 +2,11 @@ import {
   RPCCodec,
   RPCMatcher,
   StandardHandler
-} from "./chunk-SUGWQSMQ.js";
+} from "./chunk-F75AQ6KO.js";
 
 // src/adapters/fetch/utils.ts
 import { once } from "@orpc/shared";
-import cd from "content-disposition";
+import { contentDisposition, parse as parseContentDisposition } from "@tinyhttp/content-disposition";
 function fetchHeadersToStandardHeaders(headers) {
   const standardHeaders = {};
   for (const [key, value] of headers) {
@@ -24,9 +24,9 @@ async function fetchReToStandardBody(re) {
   if (!re.body) {
     return void 0;
   }
-  const contentDisposition = re.headers.get("content-disposition");
-  const fileName = contentDisposition ? cd.parse(contentDisposition).parameters.filename : void 0;
-  if (fileName) {
+  const contentDisposition2 = re.headers.get("content-disposition");
+  const fileName = contentDisposition2 ? parseContentDisposition(contentDisposition2).parameters.filename : void 0;
+  if (typeof fileName === "string") {
     const blob2 = await re.blob();
     return new File([blob2], fileName, {
       type: blob2.type
@@ -86,7 +86,7 @@ function standardResponseToFetchHeaders(response) {
     }
   }
   if (response.body instanceof Blob && !fetchHeaders.has("content-disposition")) {
-    fetchHeaders.set("content-disposition", cd(response.body instanceof File ? response.body.name : "blob"));
+    fetchHeaders.set("content-disposition", contentDisposition(response.body instanceof File ? response.body.name : "blob"));
   } else if (!(response.body instanceof Blob) && !(response.body instanceof URLSearchParams) && !(response.body instanceof FormData) && response.body !== void 0 && !fetchHeaders.has("content-type")) {
     fetchHeaders.set("content-type", "application/json");
   }
@@ -133,4 +133,4 @@ export {
   standardResponseToFetchResponse,
   RPCHandler
 };
-//# sourceMappingURL=chunk-JBPBLCBJ.js.map
+//# sourceMappingURL=chunk-GQ4376GR.js.map

package/dist/{chunk-NOA3GBJQ.js → chunk-SV6DBVXJ.js}

@@ -63,30 +63,27 @@ function middlewareOutputFn(output) {
 
 // src/procedure-client.ts
 import { createORPCErrorConstructorMap, ORPCError, validateORPCError, ValidationError } from "@orpc/contract";
-import { executeWithHooks, toError, value } from "@orpc/shared";
+import { intercept, toError, value } from "@orpc/shared";
 function createProcedureClient(lazyableProcedure, ...[options]) {
   return async (...[input, callerOptions]) => {
     const path = options?.path ?? [];
     const { default: procedure } = await unlazy(lazyableProcedure);
     const context = await value(options?.context ?? {}, callerOptions?.context);
     const errors = createORPCErrorConstructorMap(procedure["~orpc"].errorMap);
-    const executeOptions = {
-      input,
-      context,
-      errors,
-      path,
-      procedure,
-      signal: callerOptions?.signal
-    };
     try {
-      const output = await executeWithHooks({
-        hooks: options,
-        input,
-        context,
-        meta: executeOptions,
-        execute: () => executeProcedureInternal(procedure, executeOptions)
-      });
-      return output;
+      return await intercept(
+        options?.interceptors ?? [],
+        {
+          context,
+          input,
+          // input only optional when it undefinable so we can safely cast it
+          errors,
+          path,
+          procedure,
+          signal: callerOptions?.signal
+        },
+        (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions)
+      );
     } catch (e) {
       if (!(e instanceof ORPCError)) {
         throw toError(e);
@@ -377,4 +374,4 @@ export {
   convertPathToHttpPath,
   createContractedProcedure
 };
-//# sourceMappingURL=chunk-NOA3GBJQ.js.map
+//# sourceMappingURL=chunk-SV6DBVXJ.js.map

package/dist/{chunk-OWMUECGT.js → chunk-XFBAK67J.js}

@@ -8,6 +8,11 @@ var CompositePlugin = class {
       plugin.init?.(options);
     }
   }
+  beforeCreateProcedureClient(clientOptions, interceptorOptions) {
+    for (const plugin of this.plugins) {
+      plugin.beforeCreateProcedureClient?.(clientOptions, interceptorOptions);
+    }
+  }
 };
 
 // src/plugins/cors.ts
@@ -19,6 +24,9 @@ var CORSPlugin = class {
       origin: "*",
       allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"]
     };
+    if (options?.credentials) {
+      defaults.origin = (origin) => origin;
+    }
     this.options = {
       ...defaults,
       ...options
@@ -60,12 +68,21 @@ var CORSPlugin = class {
       const origin = Array.isArray(interceptorOptions.request.headers.origin) ? interceptorOptions.request.headers.origin.join(",") : interceptorOptions.request.headers.origin || "";
       const allowedOrigin = await value(this.options.origin, origin, interceptorOptions);
       const allowedOriginArr = Array.isArray(allowedOrigin) ? allowedOrigin : [allowedOrigin];
-      if (allowedOriginArr.includes(origin) || allowedOriginArr.includes("*")) {
-        result.response.headers["access-control-allow-origin"] = origin;
-      }
-      if (!allowedOriginArr.includes("*")) {
+      if (allowedOriginArr.includes("*")) {
+        result.response.headers["access-control-allow-origin"] = "*";
+      } else {
+        if (allowedOriginArr.includes(origin)) {
+          result.response.headers["access-control-allow-origin"] = origin;
+        }
         result.response.headers.vary = interceptorOptions.request.headers.vary ?? "origin";
       }
+      const allowedTimingOrigin = await value(this.options.timingOrigin, origin, interceptorOptions);
+      const allowedTimingOriginArr = Array.isArray(allowedTimingOrigin) ? allowedTimingOrigin : [allowedTimingOrigin];
+      if (allowedTimingOriginArr.includes("*")) {
+        result.response.headers["timing-allow-origin"] = "*";
+      } else if (allowedTimingOriginArr.includes(origin)) {
+        result.response.headers["timing-allow-origin"] = origin;
+      }
       if (this.options.credentials) {
         result.response.headers["access-control-allow-credentials"] = "true";
       }
@@ -108,4 +125,4 @@ export {
   CORSPlugin,
   ResponseHeadersPlugin
 };
-//# sourceMappingURL=chunk-OWMUECGT.js.map
+//# sourceMappingURL=chunk-XFBAK67J.js.map

package/dist/fetch.js

@@ -4,10 +4,10 @@ import {
   fetchRequestToStandardRequest,
   standardBodyToFetchBody,
   standardResponseToFetchResponse
-} from "./chunk-JBPBLCBJ.js";
-import "./chunk-SUGWQSMQ.js";
-import "./chunk-NOA3GBJQ.js";
-import "./chunk-OWMUECGT.js";
+} from "./chunk-GQ4376GR.js";
+import "./chunk-F75AQ6KO.js";
+import "./chunk-SV6DBVXJ.js";
+import "./chunk-XFBAK67J.js";
 export {
   RPCHandler,
   fetchReToStandardBody,

package/dist/hono.js

@@ -4,10 +4,10 @@ import {
   fetchRequestToStandardRequest,
   standardBodyToFetchBody,
   standardResponseToFetchResponse
-} from "./chunk-JBPBLCBJ.js";
-import "./chunk-SUGWQSMQ.js";
-import "./chunk-NOA3GBJQ.js";
-import "./chunk-OWMUECGT.js";
+} from "./chunk-GQ4376GR.js";
+import "./chunk-F75AQ6KO.js";
+import "./chunk-SV6DBVXJ.js";
+import "./chunk-XFBAK67J.js";
 
 // src/adapters/hono/middleware.ts
 import { value } from "@orpc/shared";
@@ -26,7 +26,7 @@ function createMiddleware(handler, ...[options]) {
     const context = await value(options?.context ?? {}, c);
     const { matched, response } = await handler.handle(request, { ...options, context });
     if (matched) {
-      return c.body(response.body, response);
+      return c.newResponse(response.body, response);
     }
     await next();
   };

package/dist/index.js

@@ -21,7 +21,7 @@ import {
   middlewareOutputFn,
   setRouterContract,
   unlazy
-} from "./chunk-NOA3GBJQ.js";
+} from "./chunk-SV6DBVXJ.js";
 
 // src/builder.ts
 import { mergeErrorMap as mergeErrorMap2, mergeMeta as mergeMeta2, mergePrefix, mergeRoute as mergeRoute2, mergeTags } from "@orpc/contract";

package/dist/next.js

@@ -4,10 +4,10 @@ import {
   fetchRequestToStandardRequest,
   standardBodyToFetchBody,
   standardResponseToFetchResponse
-} from "./chunk-JBPBLCBJ.js";
-import "./chunk-SUGWQSMQ.js";
-import "./chunk-NOA3GBJQ.js";
-import "./chunk-OWMUECGT.js";
+} from "./chunk-GQ4376GR.js";
+import "./chunk-F75AQ6KO.js";
+import "./chunk-SV6DBVXJ.js";
+import "./chunk-XFBAK67J.js";
 
 // src/adapters/next/serve.ts
 import { value } from "@orpc/shared";

package/dist/node.js

@@ -2,15 +2,15 @@ import {
   RPCCodec,
   RPCMatcher,
   StandardHandler
-} from "./chunk-SUGWQSMQ.js";
-import "./chunk-NOA3GBJQ.js";
-import "./chunk-OWMUECGT.js";
+} from "./chunk-F75AQ6KO.js";
+import "./chunk-SV6DBVXJ.js";
+import "./chunk-XFBAK67J.js";
 
 // src/adapters/node/utils.ts
 import { Buffer, File } from "node:buffer";
 import { Readable } from "node:stream";
 import { once } from "@orpc/shared";
-import cd from "content-disposition";
+import { contentDisposition, parse as parseContentDisposition } from "@tinyhttp/content-disposition";
 function nodeHttpToStandardRequest(req, res) {
   const method = req.method ?? "GET";
   const protocol = "encrypted" in req.socket && req.socket.encrypted ? "https:" : "http:";
@@ -50,7 +50,7 @@ function nodeHttpResponseSendStandardResponse(res, standardResponse) {
         "content-length": standardResponse.body.size.toString()
       };
       if (!standardResponse.headers["content-disposition"] && standardResponse.body instanceof Blob) {
-        resHeaders["content-disposition"] = cd(standardResponse.body instanceof File ? standardResponse.body.name : "blob");
+        resHeaders["content-disposition"] = contentDisposition(standardResponse.body instanceof File ? standardResponse.body.name : "blob");
       }
       res.writeHead(standardResponse.status, resHeaders);
       Readable.fromWeb(
@@ -93,10 +93,10 @@ async function nodeHttpRequestToStandardBody(req) {
   if (method === "GET" || method === "HEAD") {
     return void 0;
   }
-  const contentDisposition = req.headers["content-disposition"];
-  const fileName = contentDisposition ? cd.parse(contentDisposition).parameters.filename : void 0;
+  const contentDisposition2 = req.headers["content-disposition"];
+  const fileName = contentDisposition2 ? parseContentDisposition(contentDisposition2).parameters.filename : void 0;
   const contentType = req.headers["content-type"];
-  if (fileName) {
+  if (typeof fileName === "string") {
     return await streamToFile(req, fileName, contentType || "application/octet-stream");
   }
   if (!contentType || contentType.startsWith("application/json")) {

package/dist/plugins.js

@@ -2,7 +2,7 @@ import {
   CORSPlugin,
   CompositePlugin,
   ResponseHeadersPlugin
-} from "./chunk-OWMUECGT.js";
+} from "./chunk-XFBAK67J.js";
 export {
   CORSPlugin,
   CompositePlugin,

package/dist/src/adapters/standard/handler.d.ts

@@ -1,7 +1,8 @@
-import type { HTTPPath } from '@orpc/contract';
+import type { ErrorMap, HTTPPath, Meta, Schema } from '@orpc/contract';
 import type { Interceptor } from '@orpc/shared';
 import type { Context } from '../../context';
 import type { Plugin } from '../../plugins';
+import type { CreateProcedureClientOptions } from '../../procedure-client';
 import type { Router } from '../../router';
 import type { StandardCodec, StandardMatcher, StandardRequest, StandardResponse } from './types';
 export type StandardHandleOptions<T extends Context> = {
@@ -25,6 +26,9 @@ export type StandardHandleResult = {
 export type StandardHandlerInterceptorOptions<TContext extends Context> = WellStandardHandleOptions<TContext> & {
     request: StandardRequest;
 };
+export type WellCreateProcedureClientOptions<TContext extends Context> = CreateProcedureClientOptions<TContext, Schema, Schema, unknown, ErrorMap, Meta, unknown> & {
+    context: TContext;
+};
 export interface StandardHandlerOptions<TContext extends Context> {
     plugins?: Plugin<TContext>[];
     /**

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

@@ -13,11 +13,11 @@ export interface ImplementedProcedure<TInitialContext extends Context, TCurrentC
     /**
      * Make this procedure callable (works like a function while still being a procedure).
      */
-    callable<TClientContext>(...rest: CreateProcedureClientRest<TInitialContext, TOutputSchema, THandlerOutput, TClientContext>): Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
+    callable<TClientContext>(...rest: CreateProcedureClientRest<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>): Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta> & 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).
      */
-    actionable<TClientContext>(...rest: CreateProcedureClientRest<TInitialContext, TOutputSchema, THandlerOutput, TClientContext>): Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta> & ((...rest: ClientRest<TClientContext, SchemaInput<TInputSchema>>) => Promise<SchemaOutput<TOutputSchema, THandlerOutput>>);
+    actionable<TClientContext>(...rest: CreateProcedureClientRest<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>): Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta> & ((...rest: ClientRest<TClientContext, SchemaInput<TInputSchema>>) => Promise<SchemaOutput<TOutputSchema, THandlerOutput>>);
 }
 /**
  * Like `ProcedureBuilderWithoutHandler`, but removed all method that can change the contract.

package/dist/src/plugins/base.d.ts

@@ -1,11 +1,13 @@
-import type { StandardHandlerOptions } from '../adapters/standard';
+import type { StandardHandlerInterceptorOptions, StandardHandlerOptions, WellCreateProcedureClientOptions } from '../adapters/standard';
 import type { Context } from '../context';
 export interface Plugin<TContext extends Context> {
     init?(options: StandardHandlerOptions<TContext>): void;
+    beforeCreateProcedureClient?(clientOptions: WellCreateProcedureClientOptions<TContext>, interceptorOptions: StandardHandlerInterceptorOptions<TContext>): void;
 }
 export declare class CompositePlugin<TContext extends Context> implements Plugin<TContext> {
     private readonly plugins;
     constructor(plugins?: Plugin<TContext>[]);
     init(options: StandardHandlerOptions<TContext>): void;
+    beforeCreateProcedureClient(clientOptions: WellCreateProcedureClientOptions<TContext>, interceptorOptions: StandardHandlerInterceptorOptions<TContext>): void;
 }
 //# sourceMappingURL=base.d.ts.map

package/dist/src/plugins/cors.d.ts

@@ -3,7 +3,8 @@ import type { Context } from '../context';
 import type { Plugin } from './base';
 import { type Value } from '@orpc/shared';
 export interface CORSOptions<TContext extends Context> {
-    origin: Value<string | string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
+    origin?: Value<string | string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
+    timingOrigin?: Value<string | string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
     allowMethods?: string[];
     allowHeaders?: string[];
     maxAge?: number;

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

@@ -1,20 +1,31 @@
-import type { Client, ErrorFromErrorMap, ErrorMap, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
-import type { Hooks, Value } from '@orpc/shared';
+import type { Client, ErrorFromErrorMap, ErrorMap, Meta, ORPCErrorConstructorMap, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { Interceptor, Value } from '@orpc/shared';
 import type { Context } from './context';
 import type { Lazyable } from './lazy';
 import type { Procedure } from './procedure';
 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>>;
+export interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TInputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    context: TInitialContext;
+    input: SchemaInput<TInputSchema>;
+    errors: ORPCErrorConstructorMap<TErrorMap>;
+    path: string[];
+    procedure: Procedure<Context, Context, Schema, Schema, unknown, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+}
 /**
  * Options for creating a procedure caller with comprehensive type safety
  */
-export type CreateProcedureClientOptions<TInitialContext extends Context, TCurrentContext extends Schema, THandlerOutput extends SchemaInput<TCurrentContext>, TClientContext> = {
+export type CreateProcedureClientOptions<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext> = {
     /**
      * This is helpful for logging and analytics.
      */
     path?: string[];
-} & ({
+    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TInputSchema, TErrorMap, TMeta>, SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>[];
+} & (Record<never, never> extends TInitialContext ? {
+    context?: Value<TInitialContext, [clientContext: TClientContext]>;
+} : {
     context: Value<TInitialContext, [clientContext: TClientContext]>;
-} | (Record<never, never> extends TInitialContext ? Record<never, never> : never)) & Hooks<unknown, SchemaOutput<TCurrentContext, THandlerOutput>, TInitialContext, any>;
-export type CreateProcedureClientRest<TInitialContext extends Context, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TClientContext> = [options: CreateProcedureClientOptions<TInitialContext, TOutputSchema, THandlerOutput, TClientContext>] | (Record<never, never> extends TInitialContext ? [] : never);
-export declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap, TClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, any>>, ...[options]: CreateProcedureClientRest<TInitialContext, TOutputSchema, THandlerOutput, TClientContext>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
+});
+export type CreateProcedureClientRest<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext> = [options: CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>] | (Record<never, never> extends TInitialContext ? [] : never);
+export declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>>, ...[options]: CreateProcedureClientRest<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
 //# sourceMappingURL=procedure-client.d.ts.map

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

@@ -12,10 +12,10 @@ export declare class DecoratedProcedure<TInitialContext extends Context, TCurren
     /**
      * Make this procedure callable (works like a function while still being a procedure).
      */
-    callable<TClientContext>(...rest: CreateProcedureClientRest<TInitialContext, TOutputSchema, THandlerOutput, TClientContext>): Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
+    callable<TClientContext>(...rest: CreateProcedureClientRest<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>): Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta> & 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).
      */
-    actionable<TClientContext>(...rest: CreateProcedureClientRest<TInitialContext, TOutputSchema, THandlerOutput, TClientContext>): Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta> & ((...rest: ClientRest<TClientContext, SchemaInput<TInputSchema>>) => Promise<SchemaOutput<TOutputSchema, THandlerOutput>>);
+    actionable<TClientContext>(...rest: CreateProcedureClientRest<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>): Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta> & ((...rest: ClientRest<TClientContext, SchemaInput<TInputSchema>>) => Promise<SchemaOutput<TOutputSchema, THandlerOutput>>);
 }
 //# sourceMappingURL=procedure-decorated.d.ts.map

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

@@ -1,4 +1,4 @@
-import type { ClientPromiseResult, ErrorFromErrorMap, ErrorMap, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ClientPromiseResult, ErrorFromErrorMap, ErrorMap, Meta, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { Context } from './context';
 import type { Lazyable } from './lazy';
 import type { Procedure } from './procedure';
@@ -13,5 +13,5 @@ import { type CreateProcedureClientRest } from './procedure-client';
  * ```
  *
  */
-export declare function call<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap>(procedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, any>>, input: SchemaInput<TInputSchema>, ...rest: CreateProcedureClientRest<TInitialContext, TOutputSchema, THandlerOutput, unknown>): ClientPromiseResult<SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>;
+export declare function call<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap, TMeta extends Meta>(procedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>>, input: SchemaInput<TInputSchema>, ...rest: CreateProcedureClientRest<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, unknown>): ClientPromiseResult<SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>;
 //# sourceMappingURL=procedure-utils.d.ts.map

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

@@ -1,4 +1,4 @@
-import type { Hooks, Value } from '@orpc/shared';
+import type { ErrorMap, Meta } from '@orpc/contract';
 import type { Lazy } from './lazy';
 import type { Procedure } from './procedure';
 import type { CreateProcedureClientRest, ProcedureClient } from './procedure-client';
@@ -6,17 +6,6 @@ import type { AnyRouter, Router } from './router';
 export type RouterClient<TRouter extends AnyRouter, TClientContext> = TRouter extends Lazy<infer U extends AnyRouter> ? RouterClient<U, TClientContext> : TRouter extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput, infer UErrorMap, any> ? ProcedureClient<TClientContext, UInputSchema, UOutputSchema, UFuncOutput, UErrorMap> : {
     [K in keyof TRouter]: TRouter[K] extends AnyRouter ? RouterClient<TRouter[K], TClientContext> : never;
 };
-export type CreateRouterClientOptions<TRouter extends AnyRouter> = {
-    /**
-     * This is helpful for logging and analytics.
-     *
-     * @internal
-     */
-    path?: string[];
-} & (TRouter extends Router<infer UContext, any> ? undefined extends UContext ? {
-    context?: Value<UContext>;
-} : {
-    context: Value<UContext>;
-} : never) & Hooks<unknown, unknown, TRouter extends Router<infer UContext, any> ? UContext : never, any>;
-export declare function createRouterClient<TRouter extends AnyRouter, TClientContext>(router: TRouter | Lazy<undefined>, ...rest: CreateProcedureClientRest<TRouter extends Router<infer UContext, any> ? UContext : never, undefined, unknown, TClientContext>): RouterClient<TRouter, TClientContext>;
+export type CreateRouterClientRest<TRouter extends AnyRouter, TClientContext> = CreateProcedureClientRest<TRouter extends Router<infer UContext, any> ? UContext : never, undefined, undefined, unknown, ErrorMap, Meta, TClientContext>;
+export declare function createRouterClient<TRouter extends AnyRouter, TClientContext>(router: TRouter | Lazy<undefined>, ...rest: CreateRouterClientRest<TRouter, TClientContext>): RouterClient<TRouter, TClientContext>;
 //# sourceMappingURL=router-client.d.ts.map

package/dist/standard.js

@@ -4,9 +4,9 @@ import {
   RPCSerializer,
   StandardHandler,
   serializeRPCJson
-} from "./chunk-SUGWQSMQ.js";
-import "./chunk-NOA3GBJQ.js";
-import "./chunk-OWMUECGT.js";
+} from "./chunk-F75AQ6KO.js";
+import "./chunk-SV6DBVXJ.js";
+import "./chunk-XFBAK67J.js";
 export {
   RPCCodec,
   RPCMatcher,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.35.1",
+  "version": "0.36.1",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -63,9 +63,9 @@
     "next": ">=14.0.0"
   },
   "dependencies": {
-    "content-disposition": "^0.5.4",
-    "@orpc/contract": "0.35.1",
-    "@orpc/shared": "0.35.1"
+    "@tinyhttp/content-disposition": "^2.2.2",
+    "@orpc/contract": "0.36.1",
+    "@orpc/shared": "0.36.1"
   },
   "devDependencies": {
     "light-my-request": "^6.5.1"