@orpc/server 0.0.0-next.954e6e2 → 0.0.0-next.96f9dd3

package/dist/index.mjs

@@ -1,14 +1,16 @@
-import { mergeErrorMap, mergeMeta, mergeRoute, mergePrefix, mergeTags, isContractProcedure } from '@orpc/contract';
+import { mergeErrorMap, mergeMeta, mergeRoute, mergePrefix, mergeTags, isContractProcedure, getContractRouter } from '@orpc/contract';
 export { ValidationError, eventIterator, type } from '@orpc/contract';
-import { P as Procedure, d as addMiddleware, c as createProcedureClient, f as adaptRouter, h as flatLazy, l as lazy, s as setRouterContract, i as isProcedure, j as isLazy, k as createLazyProcedureFormAnyLazy, g as getRouterChild } from './shared/server.V6zT5iYQ.mjs';
-export { L as LAZY_LOADER_SYMBOL, a as convertPathToHttpPath, q as createAccessibleLazyRouter, b as createContractedProcedure, n as deepSetLazyRouterPrefix, r as eachAllContractProcedure, e as eachContractProcedure, o as getLazyRouterPrefix, m as getRouterContract, p as middlewareOutputFn, u as unlazy } from './shared/server.V6zT5iYQ.mjs';
+import { P as Procedure, b as addMiddleware, c as createProcedureClient, e as enhanceRouter, l as lazy, s as setHiddenRouterContract, i as isProcedure, d as isLazy, f as createAssertedLazyProcedure, g as getRouter } from './shared/server.C37gDhSZ.mjs';
+export { L as LAZY_SYMBOL, p as call, r as createAccessibleLazyRouter, a as createContractedProcedure, h as createORPCErrorConstructorMap, q as getHiddenRouterContract, j as getLazyMeta, n as isStartWithMiddlewares, m as mergeCurrentContext, o as mergeMiddlewares, k as middlewareOutputFn, w as resolveContractProcedures, t as traverseContractProcedures, u as unlazy, x as unlazyRouter, v as validateORPCError } from './shared/server.C37gDhSZ.mjs';
+import { toORPCError } from '@orpc/client';
 export { ORPCError, isDefinedError, safe } from '@orpc/client';
 export { onError, onFinish, onStart, onSuccess } from '@orpc/shared';
 export { getEventMeta, withEventMeta } from '@orpc/standard-server';
 
 const DEFAULT_CONFIG = {
   initialInputValidationIndex: 0,
-  initialOutputValidationIndex: 0
+  initialOutputValidationIndex: 0,
+  dedupeLeadingMiddlewares: true
 };
 function fallbackConfig(key, value) {
   if (value === void 0) {
@@ -18,7 +20,7 @@ function fallbackConfig(key, value) {
 }
 
 function decorateMiddleware(middleware) {
-  const decorated = middleware;
+  const decorated = (...args) => middleware(...args);
   decorated.mapInput = (mapInput) => {
     const mapped = decorateMiddleware(
       (options, input, ...rest) => middleware(options, mapInput(input), ...rest)
@@ -43,6 +45,17 @@ function decorateMiddleware(middleware) {
   return decorated;
 }
 
+function createActionableClient(client) {
+  const action = async (input) => {
+    try {
+      return [null, await client(input)];
+    } catch (error) {
+      return [toORPCError(error).toJSON(), void 0];
+    }
+  };
+  return action;
+}
+
 class DecoratedProcedure extends Procedure {
   errors(errors) {
     return new DecoratedProcedure({
@@ -73,16 +86,29 @@ class DecoratedProcedure extends Procedure {
    * Make this procedure callable (works like a function while still being a procedure).
    */
   callable(...rest) {
-    return Object.assign(createProcedureClient(this, ...rest), {
-      "~type": "Procedure",
-      "~orpc": this["~orpc"]
+    const client = createProcedureClient(this, ...rest);
+    return new Proxy(client, {
+      get: (target, key) => {
+        return Reflect.has(this, key) ? Reflect.get(this, key) : Reflect.get(target, key);
+      },
+      has: (target, key) => {
+        return Reflect.has(this, key) || Reflect.has(target, key);
+      }
     });
   }
   /**
-   * Make this procedure compatible with server action (the same as .callable, but the type is compatible with server action).
+   * Make this procedure compatible with server action.
    */
   actionable(...rest) {
-    return this.callable(...rest);
+    const action = createActionableClient(createProcedureClient(this, ...rest));
+    return new Proxy(action, {
+      get: (target, key) => {
+        return Reflect.has(this, key) ? Reflect.get(this, key) : Reflect.get(target, key);
+      },
+      has: (target, key) => {
+        return Reflect.has(this, key) || Reflect.has(target, key);
+      }
+    });
   }
 }
 
@@ -100,6 +126,7 @@ class Builder {
     return new Builder({
       ...this["~orpc"],
       config,
+      dedupeLeadingMiddlewares: fallbackConfig("dedupeLeadingMiddlewares", config.dedupeLeadingMiddlewares),
       inputValidationIndex: fallbackConfig("initialInputValidationIndex", config.initialInputValidationIndex) + inputValidationCount,
       outputValidationIndex: fallbackConfig("initialOutputValidationIndex", config.initialOutputValidationIndex) + outputValidationCount
     });
@@ -133,6 +160,12 @@ class Builder {
       route: initialRoute
     });
   }
+  $input(initialInputSchema) {
+    return new Builder({
+      ...this["~orpc"],
+      inputSchema: initialInputSchema
+    });
+  }
   middleware(middleware) {
     return decorateMiddleware(middleware);
   }
@@ -194,10 +227,10 @@ class Builder {
     });
   }
   router(router) {
-    return adaptRouter(router, this["~orpc"]);
+    return enhanceRouter(router, this["~orpc"]);
   }
   lazy(loader) {
-    return adaptRouter(flatLazy(lazy(loader)), this["~orpc"]);
+    return enhanceRouter(lazy(loader), this["~orpc"]);
   }
 }
 const os = new Builder({
@@ -205,17 +238,12 @@ const os = new Builder({
   route: {},
   meta: {},
   errorMap: {},
-  inputSchema: void 0,
-  outputSchema: void 0,
   inputValidationIndex: fallbackConfig("initialInputValidationIndex"),
   outputValidationIndex: fallbackConfig("initialOutputValidationIndex"),
-  middlewares: []
+  middlewares: [],
+  dedupeLeadingMiddlewares: true
 });
 
-function mergeContext(context, other) {
-  return { ...context, ...other };
-}
-
 function implementerInternal(contract, config, middlewares) {
   if (isContractProcedure(contract)) {
     const impl2 = new Builder({
@@ -223,12 +251,16 @@ function implementerInternal(contract, config, middlewares) {
       config,
       middlewares,
       inputValidationIndex: fallbackConfig("initialInputValidationIndex", config?.initialInputValidationIndex) + middlewares.length,
-      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", config?.initialOutputValidationIndex) + middlewares.length
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", config?.initialOutputValidationIndex) + middlewares.length,
+      dedupeLeadingMiddlewares: fallbackConfig("dedupeLeadingMiddlewares", config.dedupeLeadingMiddlewares)
     });
     return impl2;
   }
   const impl = new Proxy(contract, {
     get: (target, key) => {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
       let method;
       if (key === "middleware") {
         method = (mid) => decorateMiddleware(mid);
@@ -242,23 +274,29 @@ function implementerInternal(contract, config, middlewares) {
         };
       } else if (key === "router") {
         method = (router) => {
-          const adapted = adaptRouter(router, {
+          const adapted = enhanceRouter(router, {
             middlewares,
-            errorMap: {}
+            errorMap: {},
+            prefix: void 0,
+            tags: void 0,
+            dedupeLeadingMiddlewares: fallbackConfig("dedupeLeadingMiddlewares", config.dedupeLeadingMiddlewares)
           });
-          return setRouterContract(adapted, contract);
+          return setHiddenRouterContract(adapted, contract);
         };
       } else if (key === "lazy") {
         method = (loader) => {
-          const adapted = adaptRouter(flatLazy(lazy(loader)), {
+          const adapted = enhanceRouter(lazy(loader), {
             middlewares,
-            errorMap: {}
+            errorMap: {},
+            prefix: void 0,
+            tags: void 0,
+            dedupeLeadingMiddlewares: fallbackConfig("dedupeLeadingMiddlewares", config.dedupeLeadingMiddlewares)
           });
-          return setRouterContract(adapted, contract);
+          return setHiddenRouterContract(adapted, contract);
         };
       }
-      const next = Reflect.get(target, key);
-      if (!next || typeof next !== "function" && typeof next !== "object") {
+      const next = getContractRouter(target, [key]);
+      if (!next) {
         return method ?? next;
       }
       const nextImpl = implementerInternal(next, config, middlewares);
@@ -285,42 +323,34 @@ function implement(contract, config = {}) {
         method = (config2) => implement(contract, config2);
       }
       const next = Reflect.get(target, key);
-      if (!next || typeof next !== "function" && typeof next !== "object") {
-        return method ?? next;
-      }
-      if (method) {
-        return new Proxy(method, {
-          get(_, key2) {
-            return Reflect.get(next, key2);
-          }
-        });
+      if (!method || !next || typeof next !== "function" && typeof next !== "object") {
+        return method || next;
       }
-      return next;
+      return new Proxy(method, {
+        get(_, key2) {
+          return Reflect.get(next, key2);
+        }
+      });
     }
   });
   return impl;
 }
 
-function call(procedure, input, ...rest) {
-  return createProcedureClient(procedure, ...rest)(input);
-}
-
-function createRouterClient(router, ...rest) {
+function createRouterClient(router, ...[options]) {
   if (isProcedure(router)) {
-    const caller = createProcedureClient(router, ...rest);
+    const caller = createProcedureClient(router, options);
     return caller;
   }
-  const procedureCaller = isLazy(router) ? createProcedureClient(createLazyProcedureFormAnyLazy(router), ...rest) : {};
+  const procedureCaller = isLazy(router) ? createProcedureClient(createAssertedLazyProcedure(router), options) : {};
   const recursive = new Proxy(procedureCaller, {
     get(target, key) {
       if (typeof key !== "string") {
         return Reflect.get(target, key);
       }
-      const next = getRouterChild(router, key);
+      const next = getRouter(router, [key]);
       if (!next) {
         return Reflect.get(target, key);
       }
-      const [options] = rest;
       return createRouterClient(next, {
         ...options,
         path: [...options?.path ?? [], key]
@@ -330,4 +360,4 @@ function createRouterClient(router, ...rest) {
   return recursive;
 }
 
-export { Builder, DecoratedProcedure, Procedure, adaptRouter, call, createLazyProcedureFormAnyLazy, createProcedureClient, createRouterClient, decorateMiddleware, fallbackConfig, flatLazy, getRouterChild, implement, implementerInternal, isLazy, isProcedure, lazy, mergeContext, os, setRouterContract };
+export { Builder, DecoratedProcedure, Procedure, addMiddleware, createActionableClient, createAssertedLazyProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, fallbackConfig, getRouter, implement, implementerInternal, isLazy, isProcedure, lazy, os, setHiddenRouterContract };

package/dist/plugins/index.d.mts

@@ -1,31 +1,66 @@
-import { d as StandardHandlerInterceptorOptions, P as Plugin, a as StandardHandlerOptions } from '../shared/server.DJrh0Ceu.mjs';
-export { C as CompositePlugin } from '../shared/server.DJrh0Ceu.mjs';
 import { Value } from '@orpc/shared';
-import { C as Context } from '../shared/server.Cn9ybJtE.mjs';
-import '@orpc/contract';
-import '@orpc/standard-server';
+import { StandardRequest, StandardHeaders } from '@orpc/standard-server';
+import { BatchResponseBodyItem } from '@orpc/standard-server/batch';
+import { h as StandardHandlerInterceptorOptions, g as StandardHandlerPlugin, a as StandardHandlerOptions } from '../shared/server.BlxK0o8R.mjs';
+import { C as Context } from '../shared/server.DLt5njUb.mjs';
 import '@orpc/client';
+import '@orpc/contract';
+
+interface BatchHandlerOptions<T extends Context> {
+    /**
+     * The max size of the batch allowed.
+     *
+     * @default 10
+     */
+    maxSize?: Value<number, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * Map the request before processing it.
+     *
+     * @default merged back batch request headers into the request
+     */
+    mapRequestItem?(request: StandardRequest, batchOptions: StandardHandlerInterceptorOptions<T>): StandardRequest;
+    /**
+     * Success batch response status code.
+     *
+     * @default 207
+     */
+    successStatus?: Value<number, [responses: Promise<BatchResponseBodyItem>[], batchOptions: StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * success batch response headers.
+     *
+     * @default {}
+     */
+    headers?: Value<StandardHeaders, [responses: Promise<BatchResponseBodyItem>[], batchOptions: StandardHandlerInterceptorOptions<T>]>;
+}
+declare class BatchHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    private readonly maxSize;
+    private readonly mapRequestItem;
+    private readonly successStatus;
+    private readonly headers;
+    constructor(options?: BatchHandlerOptions<T>);
+    init(options: StandardHandlerOptions<T>): void;
+}
 
-interface CORSOptions<TContext extends Context> {
-    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[];
+interface CORSOptions<T extends Context> {
+    origin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<T>]>;
+    timingOrigin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<T>]>;
+    allowMethods?: readonly string[];
+    allowHeaders?: readonly string[];
     maxAge?: number;
     credentials?: boolean;
-    exposeHeaders?: string[];
+    exposeHeaders?: readonly string[];
 }
-declare class CORSPlugin<TContext extends Context> implements Plugin<TContext> {
+declare class CORSPlugin<T extends Context> implements StandardHandlerPlugin<T> {
     private readonly options;
-    constructor(options?: Partial<CORSOptions<TContext>>);
-    init(options: StandardHandlerOptions<TContext>): void;
+    constructor(options?: CORSOptions<T>);
+    init(options: StandardHandlerOptions<T>): void;
 }
 
 interface ResponseHeadersPluginContext {
     resHeaders?: Headers;
 }
-declare class ResponseHeadersPlugin<TContext extends ResponseHeadersPluginContext & Context> implements Plugin<TContext> {
-    init(options: StandardHandlerOptions<TContext>): void;
+declare class ResponseHeadersPlugin<T extends ResponseHeadersPluginContext> implements StandardHandlerPlugin<T> {
+    init(options: StandardHandlerOptions<T>): void;
 }
 
-export { type CORSOptions, CORSPlugin, Plugin, ResponseHeadersPlugin, type ResponseHeadersPluginContext };
+export { type BatchHandlerOptions, BatchHandlerPlugin, type CORSOptions, CORSPlugin, ResponseHeadersPlugin, type ResponseHeadersPluginContext };

package/dist/plugins/index.d.ts

@@ -1,31 +1,66 @@
-import { d as StandardHandlerInterceptorOptions, P as Plugin, a as StandardHandlerOptions } from '../shared/server.B-ewprcf.js';
-export { C as CompositePlugin } from '../shared/server.B-ewprcf.js';
 import { Value } from '@orpc/shared';
-import { C as Context } from '../shared/server.Cn9ybJtE.js';
-import '@orpc/contract';
-import '@orpc/standard-server';
+import { StandardRequest, StandardHeaders } from '@orpc/standard-server';
+import { BatchResponseBodyItem } from '@orpc/standard-server/batch';
+import { h as StandardHandlerInterceptorOptions, g as StandardHandlerPlugin, a as StandardHandlerOptions } from '../shared/server.DuTpqr2w.js';
+import { C as Context } from '../shared/server.DLt5njUb.js';
 import '@orpc/client';
+import '@orpc/contract';
+
+interface BatchHandlerOptions<T extends Context> {
+    /**
+     * The max size of the batch allowed.
+     *
+     * @default 10
+     */
+    maxSize?: Value<number, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * Map the request before processing it.
+     *
+     * @default merged back batch request headers into the request
+     */
+    mapRequestItem?(request: StandardRequest, batchOptions: StandardHandlerInterceptorOptions<T>): StandardRequest;
+    /**
+     * Success batch response status code.
+     *
+     * @default 207
+     */
+    successStatus?: Value<number, [responses: Promise<BatchResponseBodyItem>[], batchOptions: StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * success batch response headers.
+     *
+     * @default {}
+     */
+    headers?: Value<StandardHeaders, [responses: Promise<BatchResponseBodyItem>[], batchOptions: StandardHandlerInterceptorOptions<T>]>;
+}
+declare class BatchHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    private readonly maxSize;
+    private readonly mapRequestItem;
+    private readonly successStatus;
+    private readonly headers;
+    constructor(options?: BatchHandlerOptions<T>);
+    init(options: StandardHandlerOptions<T>): void;
+}
 
-interface CORSOptions<TContext extends Context> {
-    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[];
+interface CORSOptions<T extends Context> {
+    origin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<T>]>;
+    timingOrigin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<T>]>;
+    allowMethods?: readonly string[];
+    allowHeaders?: readonly string[];
     maxAge?: number;
     credentials?: boolean;
-    exposeHeaders?: string[];
+    exposeHeaders?: readonly string[];
 }
-declare class CORSPlugin<TContext extends Context> implements Plugin<TContext> {
+declare class CORSPlugin<T extends Context> implements StandardHandlerPlugin<T> {
     private readonly options;
-    constructor(options?: Partial<CORSOptions<TContext>>);
-    init(options: StandardHandlerOptions<TContext>): void;
+    constructor(options?: CORSOptions<T>);
+    init(options: StandardHandlerOptions<T>): void;
 }
 
 interface ResponseHeadersPluginContext {
     resHeaders?: Headers;
 }
-declare class ResponseHeadersPlugin<TContext extends ResponseHeadersPluginContext & Context> implements Plugin<TContext> {
-    init(options: StandardHandlerOptions<TContext>): void;
+declare class ResponseHeadersPlugin<T extends ResponseHeadersPluginContext> implements StandardHandlerPlugin<T> {
+    init(options: StandardHandlerOptions<T>): void;
 }
 
-export { type CORSOptions, CORSPlugin, Plugin, ResponseHeadersPlugin, type ResponseHeadersPluginContext };
+export { type BatchHandlerOptions, BatchHandlerPlugin, type CORSOptions, CORSPlugin, ResponseHeadersPlugin, type ResponseHeadersPluginContext };

package/dist/plugins/index.mjs

@@ -1,9 +1,97 @@
-export { C as CompositePlugin } from '../shared/server.Q6ZmnTgO.mjs';
 import { value } from '@orpc/shared';
+import { parseBatchRequest, toBatchResponse } from '@orpc/standard-server/batch';
+
+class BatchHandlerPlugin {
+  maxSize;
+  mapRequestItem;
+  successStatus;
+  headers;
+  constructor(options = {}) {
+    this.maxSize = options.maxSize ?? 10;
+    this.mapRequestItem = options.mapRequestItem ?? ((request, { request: batchRequest }) => ({
+      ...request,
+      headers: {
+        ...batchRequest.headers,
+        ...request.headers
+      }
+    }));
+    this.successStatus = options.successStatus ?? 207;
+    this.headers = options.headers ?? {};
+  }
+  init(options) {
+    options.rootInterceptors ??= [];
+    options.rootInterceptors.unshift(async (options2) => {
+      if (options2.request.headers["x-orpc-batch"] !== "1") {
+        return options2.next();
+      }
+      let isParsing = false;
+      try {
+        isParsing = true;
+        const parsed = parseBatchRequest({ ...options2.request, body: await options2.request.body() });
+        isParsing = false;
+        const maxSize = await value(this.maxSize, options2);
+        if (parsed.length > maxSize) {
+          return {
+            matched: true,
+            response: {
+              status: 413,
+              headers: {},
+              body: "Batch request size exceeds the maximum allowed size"
+            }
+          };
+        }
+        const responses = parsed.map(
+          (request, index) => {
+            const mapped = this.mapRequestItem(request, options2);
+            return options2.next({ ...options2, request: { ...mapped, body: () => Promise.resolve(mapped.body) } }).then(({ response: response2, matched }) => {
+              if (matched) {
+                return { ...response2, index };
+              }
+              return { index, status: 404, headers: {}, body: "No procedure matched" };
+            }).catch(() => {
+              return { index, status: 500, headers: {}, body: "Internal server error" };
+            });
+          }
+        );
+        await Promise.race(responses);
+        const status = await value(this.successStatus, responses, options2);
+        const headers = await value(this.headers, responses, options2);
+        const response = toBatchResponse({
+          status,
+          headers,
+          body: async function* () {
+            const promises = [...responses];
+            while (true) {
+              const handling = promises.filter((p) => p !== void 0);
+              if (handling.length === 0) {
+                return;
+              }
+              const result = await Promise.race(handling);
+              promises[result.index] = void 0;
+              yield result;
+            }
+          }()
+        });
+        return {
+          matched: true,
+          response
+        };
+      } catch (cause) {
+        if (isParsing) {
+          return {
+            matched: true,
+            response: { status: 400, headers: {}, body: "Invalid batch request, this could be caused by a malformed request body or a missing header" }
+          };
+        }
+        throw cause;
+      }
+    });
+  }
+}
 
 class CORSPlugin {
   options;
-  constructor(options) {
+  constructor(options = {}) {
     const defaults = {
       origin: (origin) => origin,
       allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"]
@@ -79,14 +167,19 @@ class ResponseHeadersPlugin {
   init(options) {
     options.rootInterceptors ??= [];
     options.rootInterceptors.push(async (interceptorOptions) => {
-      const headers = new Headers();
-      interceptorOptions.context.resHeaders = headers;
-      const result = await interceptorOptions.next();
+      const resHeaders = interceptorOptions.context.resHeaders ?? new Headers();
+      const result = await interceptorOptions.next({
+        ...interceptorOptions,
+        context: {
+          ...interceptorOptions.context,
+          resHeaders
+        }
+      });
       if (!result.matched) {
         return result;
       }
       const responseHeaders = result.response.headers;
-      for (const [key, value] of headers) {
+      for (const [key, value] of resHeaders) {
         if (Array.isArray(responseHeaders[key])) {
           responseHeaders[key].push(value);
         } else if (responseHeaders[key] !== void 0) {
@@ -100,4 +193,4 @@ class ResponseHeadersPlugin {
   }
 }
 
-export { CORSPlugin, ResponseHeadersPlugin };
+export { BatchHandlerPlugin, CORSPlugin, ResponseHeadersPlugin };

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

@@ -0,0 +1,8 @@
+import { StandardRPCJsonSerializerOptions } from '@orpc/client/standard';
+import { C as Context } from './server.DLt5njUb.js';
+import { a as StandardHandlerOptions } from './server.DuTpqr2w.js';
+
+interface StandardRPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, StandardRPCJsonSerializerOptions {
+}
+
+export type { StandardRPCHandlerOptions as S };

package/dist/shared/server.BVwwTHyO.mjs

@@ -0,0 +1,9 @@
+function resolveFriendlyStandardHandleOptions(options) {
+  return {
+    ...options,
+    context: options?.context ?? {}
+    // Context only optional if all fields are optional
+  };
+}
+
+export { resolveFriendlyStandardHandleOptions as r };

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

@@ -0,0 +1,10 @@
+import { C as Context } from './server.DLt5njUb.js';
+import { S as StandardHandleOptions } from './server.DuTpqr2w.js';
+
+type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+
+export type { FriendlyStandardHandleOptions as F };

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

@@ -0,0 +1,66 @@
+import { HTTPPath, ORPCError } from '@orpc/client';
+import { Meta, InferSchemaOutput, AnySchema, ErrorFromErrorMap } from '@orpc/contract';
+import { Interceptor, ThrowableError } from '@orpc/shared';
+import { StandardResponse, StandardLazyRequest } from '@orpc/standard-server';
+import { a as AnyRouter, A as AnyProcedure, C as Context, P as ProcedureClientInterceptorOptions, R as Router } from './server.DLt5njUb.mjs';
+
+type StandardParams = Record<string, string>;
+type StandardMatchResult = {
+    path: readonly string[];
+    procedure: AnyProcedure;
+    params?: StandardParams;
+} | undefined;
+interface StandardMatcher {
+    init(router: AnyRouter): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+interface StandardCodec {
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+    decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
+}
+
+interface StandardHandleOptions<T extends Context> {
+    prefix?: HTTPPath;
+    context: T;
+}
+type StandardHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response: undefined;
+};
+interface StandardHandlerPlugin<TContext extends Context> {
+    init?(options: StandardHandlerOptions<TContext>): void;
+}
+interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
+    request: StandardLazyRequest;
+}
+interface StandardHandlerOptions<TContext extends Context> {
+    plugins?: StandardHandlerPlugin<TContext>[];
+    /**
+     * Interceptors at the request level, helpful when you want catch errors
+     */
+    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, ThrowableError>[];
+    /**
+     * Interceptors at the root level, helpful when you want override the request/response
+     */
+    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, ThrowableError>[];
+    /**
+     *
+     * Interceptors for procedure client.
+     */
+    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Record<never, never>, Meta>, InferSchemaOutput<AnySchema>, ErrorFromErrorMap<Record<never, never>>>[];
+}
+declare class StandardHandler<T extends Context> {
+    private readonly matcher;
+    private readonly codec;
+    private readonly interceptors;
+    private readonly clientInterceptors;
+    private readonly rootInterceptors;
+    constructor(router: Router<any, T>, matcher: StandardMatcher, codec: StandardCodec, options: NoInfer<StandardHandlerOptions<T>>);
+    handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
+}
+
+export { type StandardHandleOptions as S, type StandardHandlerOptions as a, type StandardCodec as b, type StandardParams as c, type StandardMatcher as d, type StandardMatchResult as e, type StandardHandleResult as f, type StandardHandlerPlugin as g, type StandardHandlerInterceptorOptions as h, StandardHandler as i };