@orpc/server 0.0.0-next.b5ac9a3 → 0.0.0-next.b5e327f

package/dist/shared/{server.BtxZnWJ9.mjs → server.7jWaIryJ.mjs}

@@ -1,6 +1,7 @@
 import { isContractProcedure, ValidationError, mergePrefix, mergeErrorMap, enhanceRoute } from '@orpc/contract';
-import { fallbackORPCErrorStatus, ORPCError } from '@orpc/client';
-import { value, intercept, toError } from '@orpc/shared';
+import { resolveMaybeOptionalOptions, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, asyncIteratorWithSpan } from '@orpc/shared';
+import { ORPCError, fallbackORPCErrorStatus, mapEventIterator } from '@orpc/client';
+import { HibernationEventIterator } from '@orpc/standard-server';
 
 const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
 function lazy(loader, meta = {}) {
@@ -46,6 +47,9 @@ function addMiddleware(middlewares, addition) {
 }
 
 class Procedure {
+  /**
+   * This property holds the defined options.
+   */
   "~orpc";
   constructor(def) {
     this["~orpc"] = def;
@@ -68,14 +72,15 @@ function createORPCErrorConstructorMap(errors) {
       if (typeof code !== "string") {
         return Reflect.get(target, code);
       }
-      const item = (...[options]) => {
+      const item = (...rest) => {
+        const options = resolveMaybeOptionalOptions(rest);
         const config = errors[code];
         return new ORPCError(code, {
           defined: Boolean(config),
           status: config?.status,
-          message: options?.message ?? config?.message,
-          data: options?.data,
-          cause: options?.cause
+          message: options.message ?? config?.message,
+          data: options.data,
+          cause: options.cause
         });
       };
       return item;
@@ -103,34 +108,59 @@ function middlewareOutputFn(output) {
   return { output, context: {} };
 }
 
-function createProcedureClient(lazyableProcedure, ...[options]) {
+function createProcedureClient(lazyableProcedure, ...rest) {
+  const options = resolveMaybeOptionalOptions(rest);
   return async (...[input, callerOptions]) => {
-    const path = options?.path ?? [];
+    const path = toArray(options.path);
     const { default: procedure } = await unlazy(lazyableProcedure);
     const clientContext = callerOptions?.context ?? {};
-    const context = await value(options?.context ?? {}, clientContext);
+    const context = await value(options.context ?? {}, clientContext);
     const errors = createORPCErrorConstructorMap(procedure["~orpc"].errorMap);
+    const validateError = async (e) => {
+      if (e instanceof ORPCError) {
+        return await validateORPCError(procedure["~orpc"].errorMap, e);
+      }
+      return e;
+    };
     try {
-      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,
-          lastEventId: callerOptions?.lastEventId
-        },
-        (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions)
+      const output = await runWithSpan(
+        { name: "call_procedure", signal: callerOptions?.signal },
+        (span) => {
+          span?.setAttribute("procedure.path", [...path]);
+          return intercept(
+            toArray(options.interceptors),
+            {
+              context,
+              input,
+              // input only optional when it undefinable so we can safely cast it
+              errors,
+              path,
+              procedure,
+              signal: callerOptions?.signal,
+              lastEventId: callerOptions?.lastEventId
+            },
+            (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions)
+          );
+        }
       );
-    } catch (e) {
-      if (!(e instanceof ORPCError)) {
-        throw toError(e);
+      if (isAsyncIteratorObject(output)) {
+        if (output instanceof HibernationEventIterator) {
+          return output;
+        }
+        return mapEventIterator(
+          asyncIteratorWithSpan(
+            { name: "consume_event_iterator_output", signal: callerOptions?.signal },
+            output
+          ),
+          {
+            value: (v) => v,
+            error: (e) => validateError(e)
+          }
+        );
       }
-      const validated = await validateORPCError(procedure["~orpc"].errorMap, e);
-      throw validated;
+      return output;
+    } catch (e) {
+      throw await validateError(e);
     }
   };
 }
@@ -139,65 +169,80 @@ async function validateInput(procedure, input) {
   if (!schema) {
     return input;
   }
-  const result = await schema["~standard"].validate(input);
-  if (result.issues) {
-    throw new ORPCError("BAD_REQUEST", {
-      message: "Input validation failed",
-      data: {
-        issues: result.issues
-      },
-      cause: new ValidationError({ message: "Input validation failed", issues: result.issues })
-    });
-  }
-  return result.value;
+  return runWithSpan(
+    { name: "validate_input" },
+    async () => {
+      const result = await schema["~standard"].validate(input);
+      if (result.issues) {
+        throw new ORPCError("BAD_REQUEST", {
+          message: "Input validation failed",
+          data: {
+            issues: result.issues
+          },
+          cause: new ValidationError({ message: "Input validation failed", issues: result.issues })
+        });
+      }
+      return result.value;
+    }
+  );
 }
 async function validateOutput(procedure, output) {
   const schema = procedure["~orpc"].outputSchema;
   if (!schema) {
     return output;
   }
-  const result = await schema["~standard"].validate(output);
-  if (result.issues) {
-    throw new ORPCError("INTERNAL_SERVER_ERROR", {
-      message: "Output validation failed",
-      cause: new ValidationError({ message: "Output validation failed", issues: result.issues })
-    });
-  }
-  return result.value;
+  return runWithSpan(
+    { name: "validate_output" },
+    async () => {
+      const result = await schema["~standard"].validate(output);
+      if (result.issues) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Output validation failed",
+          cause: new ValidationError({ message: "Output validation failed", issues: result.issues })
+        });
+      }
+      return result.value;
+    }
+  );
 }
 async function executeProcedureInternal(procedure, options) {
   const middlewares = procedure["~orpc"].middlewares;
   const inputValidationIndex = Math.min(Math.max(0, procedure["~orpc"].inputValidationIndex), middlewares.length);
   const outputValidationIndex = Math.min(Math.max(0, procedure["~orpc"].outputValidationIndex), middlewares.length);
-  let currentIndex = 0;
-  let currentContext = options.context;
-  let currentInput = options.input;
-  const next = async (...[nextOptions]) => {
-    const index = currentIndex;
-    const midContext = nextOptions?.context ?? {};
-    currentIndex += 1;
-    currentContext = mergeCurrentContext(currentContext, midContext);
+  const next = async (index, context, input) => {
+    let currentInput = input;
     if (index === inputValidationIndex) {
       currentInput = await validateInput(procedure, currentInput);
     }
     const mid = middlewares[index];
-    const result = mid ? {
-      context: midContext,
-      output: (await mid({ ...options, context: currentContext, next }, currentInput, middlewareOutputFn)).output
-    } : {
-      context: midContext,
-      output: await procedure["~orpc"].handler({ ...options, context: currentContext, input: currentInput })
-    };
+    const output = mid ? await runWithSpan(
+      { name: `middleware.${mid.name}`, signal: options.signal },
+      async (span) => {
+        span?.setAttribute("middleware.index", index);
+        span?.setAttribute("middleware.name", mid.name);
+        const result = await mid({
+          ...options,
+          context,
+          next: async (...[nextOptions]) => {
+            const nextContext = nextOptions?.context ?? {};
+            return {
+              output: await next(index + 1, mergeCurrentContext(context, nextContext), currentInput),
+              context: nextContext
+            };
+          }
+        }, currentInput, middlewareOutputFn);
+        return result.output;
+      }
+    ) : await runWithSpan(
+      { name: "handler", signal: options.signal },
+      () => procedure["~orpc"].handler({ ...options, context, input: currentInput })
+    );
     if (index === outputValidationIndex) {
-      const validatedOutput = await validateOutput(procedure, result.output);
-      return {
-        context: result.context,
-        output: validatedOutput
-      };
+      return await validateOutput(procedure, output);
     }
-    return result;
+    return output;
   };
-  return (await next()).output;
+  return next(0, options.context, options.input);
 }
 
 const HIDDEN_ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_HIDDEN_ROUTER_CONTRACT");
@@ -364,11 +409,8 @@ function createContractedProcedure(procedure, contract) {
   });
 }
 function call(procedure, input, ...rest) {
-  return createProcedureClient(procedure, ...rest)(input);
-}
-
-function toHttpPath(path) {
-  return `/${path.map(encodeURIComponent).join("/")}`;
+  const options = resolveMaybeOptionalOptions(rest);
+  return createProcedureClient(procedure, options)(input, options);
 }
 
-export { LAZY_SYMBOL as L, Procedure as P, toHttpPath as a, createContractedProcedure as b, createProcedureClient as c, addMiddleware as d, enhanceRouter as e, isLazy as f, getRouter as g, createAssertedLazyProcedure as h, isProcedure as i, createORPCErrorConstructorMap as j, getLazyMeta as k, lazy as l, mergeCurrentContext as m, middlewareOutputFn as n, isStartWithMiddlewares as o, mergeMiddlewares as p, call as q, getHiddenRouterContract as r, setHiddenRouterContract as s, traverseContractProcedures as t, unlazy as u, validateORPCError as v, createAccessibleLazyRouter as w, resolveContractProcedures as x, unlazyRouter as y };
+export { LAZY_SYMBOL as L, Procedure as P, createContractedProcedure as a, addMiddleware as b, createProcedureClient as c, isLazy as d, enhanceRouter as e, createAssertedLazyProcedure as f, getRouter as g, createORPCErrorConstructorMap as h, isProcedure as i, getLazyMeta as j, middlewareOutputFn as k, lazy as l, mergeCurrentContext as m, isStartWithMiddlewares as n, mergeMiddlewares as o, call as p, getHiddenRouterContract as q, createAccessibleLazyRouter as r, setHiddenRouterContract as s, traverseContractProcedures as t, unlazy as u, validateORPCError as v, resolveContractProcedures as w, unlazyRouter as x };

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

@@ -0,0 +1,12 @@
+import { C as Context } from './server.CYNGeoCm.js';
+import { b as StandardHandleOptions } from './server.Bmh5xd4n.js';
+
+type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+declare function resolveFriendlyStandardHandleOptions<T extends Context>(options: FriendlyStandardHandleOptions<T>): StandardHandleOptions<T>;
+
+export { resolveFriendlyStandardHandleOptions as r };
+export type { FriendlyStandardHandleOptions as F };

package/dist/shared/server.BEFBl-Cb.d.mts

@@ -0,0 +1,12 @@
+import { C as Context } from './server.CYNGeoCm.mjs';
+import { b as StandardHandleOptions } from './server.gqRxT-yN.mjs';
+
+type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+declare function resolveFriendlyStandardHandleOptions<T extends Context>(options: FriendlyStandardHandleOptions<T>): StandardHandleOptions<T>;
+
+export { resolveFriendlyStandardHandleOptions as r };
+export type { FriendlyStandardHandleOptions as F };

package/dist/shared/server.BHZCyRuJ.mjs

@@ -0,0 +1,219 @@
+import { toHttpPath, StandardRPCJsonSerializer, StandardRPCSerializer } from '@orpc/client/standard';
+import { ORPCError, toORPCError } from '@orpc/client';
+import { toArray, intercept, runWithSpan, ORPC_NAME, isAsyncIteratorObject, asyncIteratorWithSpan, setSpanError, parseEmptyableJSON, NullProtoObj, value } from '@orpc/shared';
+import { flattenHeader } from '@orpc/standard-server';
+import { c as createProcedureClient, t as traverseContractProcedures, i as isProcedure, u as unlazy, g as getRouter, a as createContractedProcedure } from './server.7jWaIryJ.mjs';
+
+class CompositeStandardHandlerPlugin {
+  plugins;
+  constructor(plugins = []) {
+    this.plugins = [...plugins].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  }
+  init(options, router) {
+    for (const plugin of this.plugins) {
+      plugin.init?.(options, router);
+    }
+  }
+}
+
+class StandardHandler {
+  constructor(router, matcher, codec, options) {
+    this.matcher = matcher;
+    this.codec = codec;
+    const plugins = new CompositeStandardHandlerPlugin(options.plugins);
+    plugins.init(options, router);
+    this.interceptors = toArray(options.interceptors);
+    this.clientInterceptors = toArray(options.clientInterceptors);
+    this.rootInterceptors = toArray(options.rootInterceptors);
+    this.matcher.init(router);
+  }
+  interceptors;
+  clientInterceptors;
+  rootInterceptors;
+  async handle(request, options) {
+    const prefix = options.prefix?.replace(/\/$/, "") || void 0;
+    if (prefix && !request.url.pathname.startsWith(`${prefix}/`) && request.url.pathname !== prefix) {
+      return { matched: false, response: void 0 };
+    }
+    return intercept(
+      this.rootInterceptors,
+      { ...options, request, prefix },
+      async (interceptorOptions) => {
+        return runWithSpan(
+          { name: `${request.method} ${request.url.pathname}` },
+          async (span) => {
+            let step;
+            try {
+              return await intercept(
+                this.interceptors,
+                interceptorOptions,
+                async ({ request: request2, context, prefix: prefix2 }) => {
+                  const method = request2.method;
+                  const url = request2.url;
+                  const pathname = prefix2 ? url.pathname.replace(prefix2, "") : url.pathname;
+                  const match = await runWithSpan(
+                    { name: "find_procedure" },
+                    () => this.matcher.match(method, `/${pathname.replace(/^\/|\/$/g, "")}`)
+                  );
+                  if (!match) {
+                    return { matched: false, response: void 0 };
+                  }
+                  span?.updateName(`${ORPC_NAME}.${match.path.join("/")}`);
+                  span?.setAttribute("rpc.system", ORPC_NAME);
+                  span?.setAttribute("rpc.method", match.path.join("."));
+                  step = "decode_input";
+                  let input = await runWithSpan(
+                    { name: "decode_input" },
+                    () => this.codec.decode(request2, match.params, match.procedure)
+                  );
+                  step = void 0;
+                  if (isAsyncIteratorObject(input)) {
+                    input = asyncIteratorWithSpan(
+                      { name: "consume_event_iterator_input", signal: request2.signal },
+                      input
+                    );
+                  }
+                  const client = createProcedureClient(match.procedure, {
+                    context,
+                    path: match.path,
+                    interceptors: this.clientInterceptors
+                  });
+                  step = "call_procedure";
+                  const output = await client(input, {
+                    signal: request2.signal,
+                    lastEventId: flattenHeader(request2.headers["last-event-id"])
+                  });
+                  step = void 0;
+                  const response = this.codec.encode(output, match.procedure);
+                  return {
+                    matched: true,
+                    response
+                  };
+                }
+              );
+            } catch (e) {
+              if (step !== "call_procedure") {
+                setSpanError(span, e);
+              }
+              const error = step === "decode_input" && !(e instanceof ORPCError) ? new ORPCError("BAD_REQUEST", {
+                message: `Malformed request. Ensure the request body is properly formatted and the 'Content-Type' header is set correctly.`,
+                cause: e
+              }) : toORPCError(e);
+              const response = this.codec.encodeError(error);
+              return {
+                matched: true,
+                response
+              };
+            }
+          }
+        );
+      }
+    );
+  }
+}
+
+class StandardRPCCodec {
+  constructor(serializer) {
+    this.serializer = serializer;
+  }
+  async decode(request, _params, _procedure) {
+    const serialized = request.method === "GET" ? parseEmptyableJSON(request.url.searchParams.getAll("data").at(-1)) : await request.body();
+    return this.serializer.deserialize(serialized);
+  }
+  encode(output, _procedure) {
+    return {
+      status: 200,
+      headers: {},
+      body: this.serializer.serialize(output)
+    };
+  }
+  encodeError(error) {
+    return {
+      status: error.status,
+      headers: {},
+      body: this.serializer.serialize(error.toJSON())
+    };
+  }
+}
+
+class StandardRPCMatcher {
+  filter;
+  tree = new NullProtoObj();
+  pendingRouters = [];
+  constructor(options = {}) {
+    this.filter = options.filter ?? true;
+  }
+  init(router, path = []) {
+    const laziedOptions = traverseContractProcedures({ router, path }, (traverseOptions) => {
+      if (!value(this.filter, traverseOptions)) {
+        return;
+      }
+      const { path: path2, contract } = traverseOptions;
+      const httpPath = toHttpPath(path2);
+      if (isProcedure(contract)) {
+        this.tree[httpPath] = {
+          path: path2,
+          contract,
+          procedure: contract,
+          // this mean dev not used contract-first so we can used contract as procedure directly
+          router
+        };
+      } else {
+        this.tree[httpPath] = {
+          path: path2,
+          contract,
+          procedure: void 0,
+          router
+        };
+      }
+    });
+    this.pendingRouters.push(...laziedOptions.map((option) => ({
+      ...option,
+      httpPathPrefix: toHttpPath(option.path)
+    })));
+  }
+  async match(_method, pathname) {
+    if (this.pendingRouters.length) {
+      const newPendingRouters = [];
+      for (const pendingRouter of this.pendingRouters) {
+        if (pathname.startsWith(pendingRouter.httpPathPrefix)) {
+          const { default: router } = await unlazy(pendingRouter.router);
+          this.init(router, pendingRouter.path);
+        } else {
+          newPendingRouters.push(pendingRouter);
+        }
+      }
+      this.pendingRouters = newPendingRouters;
+    }
+    const match = this.tree[pathname];
+    if (!match) {
+      return void 0;
+    }
+    if (!match.procedure) {
+      const { default: maybeProcedure } = await unlazy(getRouter(match.router, match.path));
+      if (!isProcedure(maybeProcedure)) {
+        throw new Error(`
+          [Contract-First] Missing or invalid implementation for procedure at path: ${toHttpPath(match.path)}.
+          Ensure that the procedure is correctly defined and matches the expected contract.
+        `);
+      }
+      match.procedure = createContractedProcedure(maybeProcedure, match.contract);
+    }
+    return {
+      path: match.path,
+      procedure: match.procedure
+    };
+  }
+}
+
+class StandardRPCHandler extends StandardHandler {
+  constructor(router, options = {}) {
+    const jsonSerializer = new StandardRPCJsonSerializer(options);
+    const serializer = new StandardRPCSerializer(jsonSerializer);
+    const matcher = new StandardRPCMatcher(options);
+    const codec = new StandardRPCCodec(serializer);
+    super(router, matcher, codec, options);
+  }
+}
+
+export { CompositeStandardHandlerPlugin as C, StandardHandler as S, StandardRPCCodec as a, StandardRPCHandler as b, StandardRPCMatcher as c };

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

@@ -0,0 +1,32 @@
+import { StandardRPCJsonSerializerOptions } from '@orpc/client/standard';
+import { b as AnyRouter, C as Context, R as Router } from './server.CYNGeoCm.mjs';
+import { i as StandardMatcher, h as StandardMatchResult, e as StandardHandlerOptions, f as StandardHandler } from './server.gqRxT-yN.mjs';
+import { HTTPPath } from '@orpc/client';
+import { Value } from '@orpc/shared';
+import { T as TraverseContractProcedureCallbackOptions } from './server.DhJj-1X9.mjs';
+
+interface StandardRPCMatcherOptions {
+    /**
+     * Filter procedures. Return `false` to exclude a procedure from matching.
+     *
+     * @default true
+     */
+    filter?: Value<boolean, [options: TraverseContractProcedureCallbackOptions]>;
+}
+declare class StandardRPCMatcher implements StandardMatcher {
+    private readonly filter;
+    private readonly tree;
+    private pendingRouters;
+    constructor(options?: StandardRPCMatcherOptions);
+    init(router: AnyRouter, path?: readonly string[]): void;
+    match(_method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+
+interface StandardRPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, StandardRPCJsonSerializerOptions, StandardRPCMatcherOptions {
+}
+declare class StandardRPCHandler<T extends Context> extends StandardHandler<T> {
+    constructor(router: Router<any, T>, options?: StandardRPCHandlerOptions<T>);
+}
+
+export { StandardRPCHandler as a, StandardRPCMatcher as c };
+export type { StandardRPCHandlerOptions as S, StandardRPCMatcherOptions as b };

package/dist/shared/server.BW-nUGgA.mjs

@@ -0,0 +1,36 @@
+import { ORPCError, fallbackContractConfig } from '@orpc/contract';
+
+const STRICT_GET_METHOD_PLUGIN_IS_GET_METHOD_CONTEXT_SYMBOL = Symbol("STRICT_GET_METHOD_PLUGIN_IS_GET_METHOD_CONTEXT");
+class StrictGetMethodPlugin {
+  error;
+  order = 7e6;
+  constructor(options = {}) {
+    this.error = options.error ?? new ORPCError("METHOD_NOT_SUPPORTED");
+  }
+  init(options) {
+    options.rootInterceptors ??= [];
+    options.clientInterceptors ??= [];
+    options.rootInterceptors.unshift((options2) => {
+      const isGetMethod = options2.request.method === "GET";
+      return options2.next({
+        ...options2,
+        context: {
+          ...options2.context,
+          [STRICT_GET_METHOD_PLUGIN_IS_GET_METHOD_CONTEXT_SYMBOL]: isGetMethod
+        }
+      });
+    });
+    options.clientInterceptors.unshift((options2) => {
+      if (typeof options2.context[STRICT_GET_METHOD_PLUGIN_IS_GET_METHOD_CONTEXT_SYMBOL] !== "boolean") {
+        throw new TypeError("[StrictGetMethodPlugin] strict GET method context has been corrupted or modified by another plugin or interceptor");
+      }
+      const procedureMethod = fallbackContractConfig("defaultMethod", options2.procedure["~orpc"].route.method);
+      if (options2.context[STRICT_GET_METHOD_PLUGIN_IS_GET_METHOD_CONTEXT_SYMBOL] && procedureMethod !== "GET") {
+        throw this.error;
+      }
+      return options2.next();
+    });
+  }
+}
+
+export { StrictGetMethodPlugin as S };

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

@@ -0,0 +1,74 @@
+import { HTTPPath, ORPCError } from '@orpc/client';
+import { Meta } from '@orpc/contract';
+import { Interceptor } from '@orpc/shared';
+import { StandardResponse, StandardLazyRequest } from '@orpc/standard-server';
+import { C as Context, R as Router, b as AnyRouter, A as AnyProcedure, d as ProcedureClientInterceptorOptions } from './server.CYNGeoCm.js';
+
+interface StandardHandlerPlugin<T extends Context> {
+    order?: number;
+    init?(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
+}
+declare class CompositeStandardHandlerPlugin<T extends Context, TPlugin extends StandardHandlerPlugin<T>> implements StandardHandlerPlugin<T> {
+    protected readonly plugins: TPlugin[];
+    constructor(plugins?: readonly TPlugin[]);
+    init(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
+}
+
+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 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>, Promise<StandardHandleResult>>[];
+    /**
+     * Interceptors at the root level, helpful when you want override the request/response
+     */
+    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, Promise<StandardHandleResult>>[];
+    /**
+     *
+     * Interceptors for procedure client.
+     */
+    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Record<never, never>, Meta>, Promise<unknown>>[];
+}
+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 { CompositeStandardHandlerPlugin as C, StandardHandler as f };
+export type { StandardCodec as S, StandardParams as a, StandardHandleOptions as b, StandardHandleResult as c, StandardHandlerInterceptorOptions as d, StandardHandlerOptions as e, StandardHandlerPlugin as g, StandardMatchResult as h, StandardMatcher as i };