@temporary-name/server 1.9.3-alpha.30822ad82102dcf9276d473ba372416778807e52 → 1.9.3-alpha.3f3cdc28e4c507442c043c8988bb757a44b8785b

package/dist/plugins/index.d.mts

@@ -1,8 +1,8 @@
 import { Value, Promisable, ORPCError } from '@temporary-name/shared';
 import { StandardRequest, StandardHeaders } from '@temporary-name/standard-server';
 import { BatchResponseBodyItem } from '@temporary-name/standard-server/batch';
-import { c as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, d as StandardHandlerOptions } from '../shared/server.Bo94xDTv.mjs';
-import { C as Context, P as ProcedureClientInterceptorOptions } from '../shared/server.C1YnHvvf.mjs';
+import { S as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, b as StandardHandlerOptions } from '../shared/server.CT1xhSmE.mjs';
+import { C as Context, E as ProcedureClientInterceptorOptions } from '../shared/server.C3RuMHWl.mjs';
 import { Meta } from '@temporary-name/contract';
 
 interface BatchHandlerOptions<T extends Context> {

package/dist/plugins/index.d.ts

@@ -1,8 +1,8 @@
 import { Value, Promisable, ORPCError } from '@temporary-name/shared';
 import { StandardRequest, StandardHeaders } from '@temporary-name/standard-server';
 import { BatchResponseBodyItem } from '@temporary-name/standard-server/batch';
-import { c as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, d as StandardHandlerOptions } from '../shared/server.Btxrgkj5.js';
-import { C as Context, P as ProcedureClientInterceptorOptions } from '../shared/server.C1YnHvvf.js';
+import { S as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, b as StandardHandlerOptions } from '../shared/server.cjcgLdr1.js';
+import { C as Context, E as ProcedureClientInterceptorOptions } from '../shared/server.C3RuMHWl.js';
 import { Meta } from '@temporary-name/contract';
 
 interface BatchHandlerOptions<T extends Context> {

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

@@ -0,0 +1,23 @@
+import { HTTPPath } from '@temporary-name/shared';
+import { C as Context } from './server.C3RuMHWl.mjs';
+import { c as StandardHandleOptions } from './server.CT1xhSmE.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>;
+/**
+ * {@link https://github.com/unjs/rou3}
+ *
+ * @internal
+ */
+declare function toRou3Pattern(path: HTTPPath): string;
+/**
+ * @internal
+ */
+declare function decodeParams(params: Record<string, string>): Record<string, string>;
+
+export { decodeParams as d, resolveFriendlyStandardHandleOptions as r, toRou3Pattern as t };
+export type { FriendlyStandardHandleOptions as F };

package/dist/shared/{server.BEQrAa3A.mjs → server.BYYf0Wn6.mjs}

@@ -1,26 +1,7 @@
 import { validateORPCError, ValidationError } from '@temporary-name/contract';
 import { resolveMaybeOptionalOptions, ORPCError, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, overlayProxy, asyncIteratorWithSpan } from '@temporary-name/shared';
 import { HibernationEventIterator, mapEventIterator } from '@temporary-name/standard-server';
-import { g as gatingContext, w as withoutGatedFields } from './server.D6K9uoPI.mjs';
-
-const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
-function lazy(loader, meta = {}) {
-  return {
-    [LAZY_SYMBOL]: {
-      loader,
-      meta
-    }
-  };
-}
-function isLazy(item) {
-  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_SYMBOL in item;
-}
-function getLazyMeta(lazied) {
-  return lazied[LAZY_SYMBOL].meta;
-}
-function unlazy(lazied) {
-  return isLazy(lazied) ? lazied[LAZY_SYMBOL].loader() : Promise.resolve({ default: lazied });
-}
+import { safeParseAsync } from '@temporary-name/zod';
 
 function mergeCurrentContext(context, other) {
   return { ...context, ...other };
@@ -49,6 +30,25 @@ function createORPCErrorConstructorMap(errors) {
   return proxy;
 }
 
+const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
+function lazy(loader, meta = {}) {
+  return {
+    [LAZY_SYMBOL]: {
+      loader,
+      meta
+    }
+  };
+}
+function isLazy(item) {
+  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_SYMBOL in item;
+}
+function getLazyMeta(lazied) {
+  return lazied[LAZY_SYMBOL].meta;
+}
+function unlazy(lazied) {
+  return isLazy(lazied) ? lazied[LAZY_SYMBOL].loader() : Promise.resolve({ default: lazied });
+}
+
 function middlewareOutputFn(output) {
   return { output, context: {} };
 }
@@ -115,37 +115,41 @@ async function validateInput(procedure, input) {
     return input;
   }
   return runWithSpan({ name: "validate_input" }, async () => {
-    const result = await schema["~standard"].validate(input);
-    if (result.issues) {
+    const result = await safeParseAsync(schema, input);
+    if (!result.success) {
       throw new ORPCError("BAD_REQUEST", {
         message: "Input validation failed",
         data: {
-          issues: result.issues
+          issues: result.error.issues
         },
         cause: new ValidationError({
           message: "Input validation failed",
-          issues: result.issues,
+          issues: result.error.issues,
           data: input
         })
       });
     }
-    return result.value;
+    return result.data;
   });
 }
-async function validateOutput(schema, output) {
+async function validateOutput(procedure, output) {
+  const schema = procedure["~orpc"].outputSchema;
+  if (!schema) {
+    return output;
+  }
   return runWithSpan({ name: "validate_output" }, async () => {
-    const result = await schema["~standard"].validate(output);
-    if (result.issues) {
+    const result = await safeParseAsync(schema, output);
+    if (!result.success) {
       throw new ORPCError("INTERNAL_SERVER_ERROR", {
         message: "Output validation failed",
         cause: new ValidationError({
           message: "Output validation failed",
-          issues: result.issues,
+          issues: result.error.issues,
           data: output
         })
       });
     }
-    return result.value;
+    return result.data;
   });
 }
 async function executeProcedureInternal(procedure, options) {
@@ -188,16 +192,7 @@ async function executeProcedureInternal(procedure, options) {
       () => procedure["~orpc"].handler({ ...options, context, input: currentInput })
     );
     if (index === outputValidationIndex) {
-      const schema = procedure["~orpc"].outputSchema;
-      if (!schema) {
-        return output;
-      }
-      const validated = await validateOutput(schema, output);
-      const isGateEnabled = gatingContext.getStore();
-      if (!validated || !isGateEnabled) {
-        return validated;
-      }
-      return withoutGatedFields(validated, schema, isGateEnabled);
+      return await validateOutput(procedure, output);
     }
     return output;
   };

package/dist/shared/{server.C1YnHvvf.d.ts → server.C3RuMHWl.d.mts}

@@ -1,5 +1,5 @@
 import { ErrorMap, ErrorMapItem, InferSchemaInput, AnySchema, Meta, ContractProcedureDef, InferSchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure } from '@temporary-name/contract';
-import { ORPCErrorCode, MaybeOptionalOptions, ORPCErrorOptions, ORPCError, HTTPPath, Promisable, ClientContext, Interceptor, PromiseWithError, Value, Client } from '@temporary-name/shared';
+import { ORPCErrorCode, MaybeOptionalOptions, ORPCErrorOptions, ORPCError, Promisable, HTTPPath, ClientContext, Interceptor, PromiseWithError, Value, Client } from '@temporary-name/shared';
 
 type Context = Record<PropertyKey, any>;
 type MergedInitialContext<TInitial extends Context, TAdditional extends Context, TCurrent extends Context> = TInitial & Omit<TAdditional, keyof TCurrent>;
@@ -13,33 +13,6 @@ type ORPCErrorConstructorMap<T extends ErrorMap> = {
 };
 declare function createORPCErrorConstructorMap<T extends ErrorMap>(errors: T): ORPCErrorConstructorMap<T>;
 
-declare const LAZY_SYMBOL: unique symbol;
-interface LazyMeta {
-    prefix?: HTTPPath;
-}
-interface Lazy<T> {
-    [LAZY_SYMBOL]: {
-        loader: () => Promise<{
-            default: T;
-        }>;
-        meta: LazyMeta;
-    };
-}
-type Lazyable<T> = T | Lazy<T>;
-/**
- * Creates a lazy-loaded item.
- *
- * @warning The `prefix` in `meta` only holds metadata and does not apply the prefix to the lazy router, use `os.prefix(...).lazyRoute(...)` instead.
- */
-declare function lazy<T>(loader: () => Promise<{
-    default: T;
-}>, meta?: LazyMeta): Lazy<T>;
-declare function isLazy(item: unknown): item is Lazy<any>;
-declare function getLazyMeta(lazied: Lazy<any>): LazyMeta;
-declare function unlazy<T extends Lazyable<any>>(lazied: T): Promise<{
-    default: T extends Lazy<infer U> ? U : T;
-}>;
-
 interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
     context: TCurrentContext;
     input: TInput;
@@ -71,7 +44,7 @@ declare class Procedure<TInitialContext extends Context, TCurrentContext extends
     '~orpc': ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
     constructor(def: ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>);
 }
-type AnyProcedure = Procedure<any, any, any, any, any, any>;
+type AnyProcedure = Procedure<any, any, AnySchema, AnySchema, any, any>;
 declare function isProcedure(item: unknown): item is AnyProcedure;
 
 type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
@@ -112,6 +85,33 @@ interface MapInputMiddleware<TInput, TMappedInput> {
 }
 declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
 
+declare const LAZY_SYMBOL: unique symbol;
+interface LazyMeta {
+    prefix?: HTTPPath;
+}
+interface Lazy<T> {
+    [LAZY_SYMBOL]: {
+        loader: () => Promise<{
+            default: T;
+        }>;
+        meta: LazyMeta;
+    };
+}
+type Lazyable<T> = T | Lazy<T>;
+/**
+ * Creates a lazy-loaded item.
+ *
+ * @warning The `prefix` in `meta` only holds metadata and does not apply the prefix to the lazy router, use `os.prefix(...).lazyRoute(...)` instead.
+ */
+declare function lazy<T>(loader: () => Promise<{
+    default: T;
+}>, meta?: LazyMeta): Lazy<T>;
+declare function isLazy(item: unknown): item is Lazy<any>;
+declare function getLazyMeta(lazied: Lazy<any>): LazyMeta;
+declare function unlazy<T extends Lazyable<any>>(lazied: T): Promise<{
+    default: T extends Lazy<infer U> ? U : T;
+}>;
+
 type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
 interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap, TMeta extends Meta> {
     context: TInitialContext;
@@ -188,5 +188,5 @@ type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
 };
 
-export { isProcedure as E, createProcedureClient as F, Procedure as b, mergeCurrentContext as m, createORPCErrorConstructorMap as n, LAZY_SYMBOL as o, lazy as q, isLazy as r, getLazyMeta as s, unlazy as u, middlewareOutputFn as z };
-export type { AnyRouter as A, ProcedureHandlerOptions as B, Context as C, ProcedureDef as D, InferRouterInitialContexts as G, InferRouterCurrentContexts as H, InferRouterInitialContext as I, InferRouterInputs as J, InferRouterOutputs as K, Lazyable as L, Middleware as M, ORPCErrorConstructorMap as O, ProcedureClientInterceptorOptions as P, Router as R, AnyProcedure as a, MergedInitialContext as c, MergedCurrentContext as d, MapInputMiddleware as e, CreateProcedureClientOptions as f, ProcedureClient as g, AnyMiddleware as h, Lazy as i, ProcedureHandler as j, ORPCErrorConstructorMapItemOptions as k, ORPCErrorConstructorMapItem as l, LazyMeta as p, MiddlewareResult as t, MiddlewareNextFnOptions as v, MiddlewareNextFn as w, MiddlewareOutputFn as x, MiddlewareOptions as y };
+export { isProcedure as D, createProcedureClient as F, Procedure as P, createORPCErrorConstructorMap as l, mergeCurrentContext as m, LAZY_SYMBOL as n, lazy as p, isLazy as q, getLazyMeta as r, unlazy as u, middlewareOutputFn as y };
+export type { AnyMiddleware as A, ProcedureDef as B, Context as C, ProcedureClientInterceptorOptions as E, InferRouterInitialContexts as G, InferRouterCurrentContexts as H, InferRouterInitialContext as I, InferRouterInputs as J, InferRouterOutputs as K, Lazyable as L, MergedInitialContext as M, ORPCErrorConstructorMap as O, Router as R, CreateProcedureClientOptions as a, ProcedureClient as b, AnyRouter as c, Lazy as d, AnyProcedure as e, Middleware as f, MergedCurrentContext as g, ProcedureHandler as h, MapInputMiddleware as i, ORPCErrorConstructorMapItemOptions as j, ORPCErrorConstructorMapItem as k, LazyMeta as o, MiddlewareResult as s, MiddlewareNextFnOptions as t, MiddlewareNextFn as v, MiddlewareOutputFn as w, MiddlewareOptions as x, ProcedureHandlerOptions as z };

package/dist/shared/{server.C1YnHvvf.d.mts → server.C3RuMHWl.d.ts}

@@ -1,5 +1,5 @@
 import { ErrorMap, ErrorMapItem, InferSchemaInput, AnySchema, Meta, ContractProcedureDef, InferSchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure } from '@temporary-name/contract';
-import { ORPCErrorCode, MaybeOptionalOptions, ORPCErrorOptions, ORPCError, HTTPPath, Promisable, ClientContext, Interceptor, PromiseWithError, Value, Client } from '@temporary-name/shared';
+import { ORPCErrorCode, MaybeOptionalOptions, ORPCErrorOptions, ORPCError, Promisable, HTTPPath, ClientContext, Interceptor, PromiseWithError, Value, Client } from '@temporary-name/shared';
 
 type Context = Record<PropertyKey, any>;
 type MergedInitialContext<TInitial extends Context, TAdditional extends Context, TCurrent extends Context> = TInitial & Omit<TAdditional, keyof TCurrent>;
@@ -13,33 +13,6 @@ type ORPCErrorConstructorMap<T extends ErrorMap> = {
 };
 declare function createORPCErrorConstructorMap<T extends ErrorMap>(errors: T): ORPCErrorConstructorMap<T>;
 
-declare const LAZY_SYMBOL: unique symbol;
-interface LazyMeta {
-    prefix?: HTTPPath;
-}
-interface Lazy<T> {
-    [LAZY_SYMBOL]: {
-        loader: () => Promise<{
-            default: T;
-        }>;
-        meta: LazyMeta;
-    };
-}
-type Lazyable<T> = T | Lazy<T>;
-/**
- * Creates a lazy-loaded item.
- *
- * @warning The `prefix` in `meta` only holds metadata and does not apply the prefix to the lazy router, use `os.prefix(...).lazyRoute(...)` instead.
- */
-declare function lazy<T>(loader: () => Promise<{
-    default: T;
-}>, meta?: LazyMeta): Lazy<T>;
-declare function isLazy(item: unknown): item is Lazy<any>;
-declare function getLazyMeta(lazied: Lazy<any>): LazyMeta;
-declare function unlazy<T extends Lazyable<any>>(lazied: T): Promise<{
-    default: T extends Lazy<infer U> ? U : T;
-}>;
-
 interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
     context: TCurrentContext;
     input: TInput;
@@ -71,7 +44,7 @@ declare class Procedure<TInitialContext extends Context, TCurrentContext extends
     '~orpc': ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
     constructor(def: ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>);
 }
-type AnyProcedure = Procedure<any, any, any, any, any, any>;
+type AnyProcedure = Procedure<any, any, AnySchema, AnySchema, any, any>;
 declare function isProcedure(item: unknown): item is AnyProcedure;
 
 type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
@@ -112,6 +85,33 @@ interface MapInputMiddleware<TInput, TMappedInput> {
 }
 declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
 
+declare const LAZY_SYMBOL: unique symbol;
+interface LazyMeta {
+    prefix?: HTTPPath;
+}
+interface Lazy<T> {
+    [LAZY_SYMBOL]: {
+        loader: () => Promise<{
+            default: T;
+        }>;
+        meta: LazyMeta;
+    };
+}
+type Lazyable<T> = T | Lazy<T>;
+/**
+ * Creates a lazy-loaded item.
+ *
+ * @warning The `prefix` in `meta` only holds metadata and does not apply the prefix to the lazy router, use `os.prefix(...).lazyRoute(...)` instead.
+ */
+declare function lazy<T>(loader: () => Promise<{
+    default: T;
+}>, meta?: LazyMeta): Lazy<T>;
+declare function isLazy(item: unknown): item is Lazy<any>;
+declare function getLazyMeta(lazied: Lazy<any>): LazyMeta;
+declare function unlazy<T extends Lazyable<any>>(lazied: T): Promise<{
+    default: T extends Lazy<infer U> ? U : T;
+}>;
+
 type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
 interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap, TMeta extends Meta> {
     context: TInitialContext;
@@ -188,5 +188,5 @@ type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
 };
 
-export { isProcedure as E, createProcedureClient as F, Procedure as b, mergeCurrentContext as m, createORPCErrorConstructorMap as n, LAZY_SYMBOL as o, lazy as q, isLazy as r, getLazyMeta as s, unlazy as u, middlewareOutputFn as z };
-export type { AnyRouter as A, ProcedureHandlerOptions as B, Context as C, ProcedureDef as D, InferRouterInitialContexts as G, InferRouterCurrentContexts as H, InferRouterInitialContext as I, InferRouterInputs as J, InferRouterOutputs as K, Lazyable as L, Middleware as M, ORPCErrorConstructorMap as O, ProcedureClientInterceptorOptions as P, Router as R, AnyProcedure as a, MergedInitialContext as c, MergedCurrentContext as d, MapInputMiddleware as e, CreateProcedureClientOptions as f, ProcedureClient as g, AnyMiddleware as h, Lazy as i, ProcedureHandler as j, ORPCErrorConstructorMapItemOptions as k, ORPCErrorConstructorMapItem as l, LazyMeta as p, MiddlewareResult as t, MiddlewareNextFnOptions as v, MiddlewareNextFn as w, MiddlewareOutputFn as x, MiddlewareOptions as y };
+export { isProcedure as D, createProcedureClient as F, Procedure as P, createORPCErrorConstructorMap as l, mergeCurrentContext as m, LAZY_SYMBOL as n, lazy as p, isLazy as q, getLazyMeta as r, unlazy as u, middlewareOutputFn as y };
+export type { AnyMiddleware as A, ProcedureDef as B, Context as C, ProcedureClientInterceptorOptions as E, InferRouterInitialContexts as G, InferRouterCurrentContexts as H, InferRouterInitialContext as I, InferRouterInputs as J, InferRouterOutputs as K, Lazyable as L, MergedInitialContext as M, ORPCErrorConstructorMap as O, Router as R, CreateProcedureClientOptions as a, ProcedureClient as b, AnyRouter as c, Lazy as d, AnyProcedure as e, Middleware as f, MergedCurrentContext as g, ProcedureHandler as h, MapInputMiddleware as i, ORPCErrorConstructorMapItemOptions as j, ORPCErrorConstructorMapItem as k, LazyMeta as o, MiddlewareResult as s, MiddlewareNextFnOptions as t, MiddlewareNextFn as v, MiddlewareOutputFn as w, MiddlewareOptions as x, ProcedureHandlerOptions as z };

package/dist/shared/{server.Btxrgkj5.d.ts → server.CT1xhSmE.d.mts}

@@ -1,7 +1,7 @@
 import { Meta } from '@temporary-name/contract';
-import { HTTPPath, ORPCError, Interceptor } from '@temporary-name/shared';
-import { StandardResponse, StandardLazyRequest } from '@temporary-name/standard-server';
-import { C as Context, R as Router, A as AnyRouter, a as AnyProcedure, P as ProcedureClientInterceptorOptions } from './server.C1YnHvvf.js';
+import { HTTPPath, Interceptor } from '@temporary-name/shared';
+import { StandardLazyRequest, StandardResponse } from '@temporary-name/standard-server';
+import { C as Context, R as Router, E as ProcedureClientInterceptorOptions } from './server.C3RuMHWl.mjs';
 
 interface StandardHandlerPlugin<T extends Context> {
     order?: number;
@@ -13,22 +13,6 @@ declare class CompositeStandardHandlerPlugin<T extends Context, TPlugin extends
     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;
@@ -60,14 +44,13 @@ interface StandardHandlerOptions<TContext extends Context> {
     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>>);
+    private readonly matcher;
+    constructor(router: Router<any, T>, options: NoInfer<StandardHandlerOptions<T>>);
     handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
 }
 
-export { CompositeStandardHandlerPlugin as C, StandardHandler as S };
-export type { StandardHandlerPlugin as a, StandardHandleOptions as b, StandardHandlerInterceptorOptions as c, StandardHandlerOptions as d, StandardHandleResult as e, StandardParams as f, StandardMatchResult as g, StandardMatcher as h, StandardCodec as i };
+export { CompositeStandardHandlerPlugin as C, StandardHandler as e };
+export type { StandardHandlerInterceptorOptions as S, StandardHandlerPlugin as a, StandardHandlerOptions as b, StandardHandleOptions as c, StandardHandleResult as d };