@temporary-name/server 1.9.3-alpha.9f176ca3f9388d51e8dffa98a15fcf9f14f6a75e → 1.9.3-alpha.e09726e1bf5340c7b7052eeabcb4935b3c85ce93

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.C1fnTLq0.mjs';
+import { C as Context, E as ProcedureClientInterceptorOptions } from '../shared/server.BKSOrA6h.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.CQyYNJ1H.js';
+import { C as Context, E as ProcedureClientInterceptorOptions } from '../shared/server.BKSOrA6h.js';
 import { Meta } from '@temporary-name/contract';
 
 interface BatchHandlerOptions<T extends Context> {

package/dist/shared/server.BEHw7Eyx.mjs

@@ -0,0 +1,247 @@
+import { isObject, NullProtoObj, isAsyncIteratorObject, isORPCErrorJson, createORPCErrorFromJson, toORPCError } from '@temporary-name/shared';
+import { mapEventIterator, ErrorEvent } from '@temporary-name/standard-server';
+
+function bracketNotationSerialize(data, segments = [], result = []) {
+  if (Array.isArray(data)) {
+    data.forEach((item, i) => {
+      bracketNotationSerialize(item, [...segments, i], result);
+    });
+  } else if (isObject(data)) {
+    for (const key in data) {
+      bracketNotationSerialize(data[key], [...segments, key], result);
+    }
+  } else {
+    result.push([stringifyPath(segments), data]);
+  }
+  return result;
+}
+function bracketNotationDeserialize(serialized, { maxArrayIndex = 9999 } = {}) {
+  if (serialized.length === 0) {
+    return {};
+  }
+  const arrayPushStyles = /* @__PURE__ */ new WeakSet();
+  const ref = { value: [] };
+  for (const [path, value] of serialized) {
+    const segments = parsePath(path);
+    let currentRef = ref;
+    let nextSegment = "value";
+    segments.forEach((segment, i) => {
+      if (!Array.isArray(currentRef[nextSegment]) && !isObject(currentRef[nextSegment])) {
+        currentRef[nextSegment] = [];
+      }
+      if (i !== segments.length - 1) {
+        if (Array.isArray(currentRef[nextSegment]) && !isValidArrayIndex(segment, maxArrayIndex)) {
+          if (arrayPushStyles.has(currentRef[nextSegment])) {
+            arrayPushStyles.delete(currentRef[nextSegment]);
+            currentRef[nextSegment] = pushStyleArrayToObject(currentRef[nextSegment]);
+          } else {
+            currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
+          }
+        }
+      } else {
+        if (Array.isArray(currentRef[nextSegment])) {
+          if (segment === "") {
+            if (currentRef[nextSegment].length && !arrayPushStyles.has(currentRef[nextSegment])) {
+              currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
+            }
+          } else {
+            if (arrayPushStyles.has(currentRef[nextSegment])) {
+              arrayPushStyles.delete(currentRef[nextSegment]);
+              currentRef[nextSegment] = pushStyleArrayToObject(currentRef[nextSegment]);
+            } else if (!isValidArrayIndex(segment, maxArrayIndex)) {
+              currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
+            }
+          }
+        }
+      }
+      currentRef = currentRef[nextSegment];
+      nextSegment = segment;
+    });
+    if (Array.isArray(currentRef) && nextSegment === "") {
+      arrayPushStyles.add(currentRef);
+      currentRef.push(value);
+    } else if (nextSegment in currentRef) {
+      if (Array.isArray(currentRef[nextSegment])) {
+        currentRef[nextSegment].push(value);
+      } else {
+        currentRef[nextSegment] = [currentRef[nextSegment], value];
+      }
+    } else {
+      currentRef[nextSegment] = value;
+    }
+  }
+  return ref.value;
+}
+function stringifyPath(segments) {
+  return segments.map((segment) => {
+    return segment.toString().replace(/[\\[\]]/g, (match) => {
+      switch (match) {
+        case "\\":
+          return "\\\\";
+        case "[":
+          return "\\[";
+        case "]":
+          return "\\]";
+        /* v8 ignore next 2 */
+        default:
+          return match;
+      }
+    });
+  }).reduce((result, segment, i) => {
+    if (i === 0) {
+      return segment;
+    }
+    return `${result}[${segment}]`;
+  }, "");
+}
+function parsePath(path) {
+  const segments = [];
+  let inBrackets = false;
+  let currentSegment = "";
+  let backslashCount = 0;
+  for (let i = 0; i < path.length; i++) {
+    const char = path[i];
+    const nextChar = path[i + 1];
+    if (inBrackets && char === "]" && (nextChar === void 0 || nextChar === "[") && backslashCount % 2 === 0) {
+      if (nextChar === void 0) {
+        inBrackets = false;
+      }
+      segments.push(currentSegment);
+      currentSegment = "";
+      i++;
+    } else if (segments.length === 0 && char === "[" && backslashCount % 2 === 0) {
+      inBrackets = true;
+      segments.push(currentSegment);
+      currentSegment = "";
+    } else if (char === "\\") {
+      backslashCount++;
+    } else {
+      currentSegment += "\\".repeat(backslashCount / 2) + char;
+      backslashCount = 0;
+    }
+  }
+  return inBrackets || segments.length === 0 ? [path] : segments;
+}
+function isValidArrayIndex(value, maxIndex) {
+  return /^0$|^[1-9]\d*$/.test(value) && Number(value) <= maxIndex;
+}
+function arrayToObject(array) {
+  const obj = new NullProtoObj();
+  array.forEach((item, i) => {
+    obj[i] = item;
+  });
+  return obj;
+}
+function pushStyleArrayToObject(array) {
+  const obj = new NullProtoObj();
+  obj[""] = array.length === 1 ? array[0] : array;
+  return obj;
+}
+
+function jsonSerialize(data, hasBlobRef = { value: false }) {
+  if (data instanceof Blob) {
+    hasBlobRef.value = true;
+    return [data, hasBlobRef.value];
+  }
+  if (data instanceof Set) {
+    return jsonSerialize(Array.from(data), hasBlobRef);
+  }
+  if (data instanceof Map) {
+    return jsonSerialize(Array.from(data.entries()), hasBlobRef);
+  }
+  if (Array.isArray(data)) {
+    const json = data.map((v) => v === void 0 ? null : jsonSerialize(v, hasBlobRef)[0]);
+    return [json, hasBlobRef.value];
+  }
+  if (isObject(data)) {
+    const json = {};
+    for (const k in data) {
+      if (k === "toJSON" && typeof data[k] === "function") {
+        continue;
+      }
+      json[k] = jsonSerialize(data[k], hasBlobRef)[0];
+    }
+    return [json, hasBlobRef.value];
+  }
+  if (typeof data === "bigint" || data instanceof RegExp || data instanceof URL) {
+    return [data.toString(), hasBlobRef.value];
+  }
+  if (data instanceof Date) {
+    return [Number.isNaN(data.getTime()) ? null : data.toISOString(), hasBlobRef.value];
+  }
+  if (Number.isNaN(data)) {
+    return [null, hasBlobRef.value];
+  }
+  return [data, hasBlobRef.value];
+}
+
+function serialize(data, options = {}) {
+  if (isAsyncIteratorObject(data) && !options.outputFormat) {
+    return mapEventIterator(data, {
+      value: async (value) => _serialize(value, { outputFormat: "plain" }),
+      error: async (e) => {
+        return new ErrorEvent({
+          data: _serialize(toORPCError(e).toJSON(), { outputFormat: "plain" }),
+          cause: e
+        });
+      }
+    });
+  }
+  return _serialize(data, options);
+}
+function _serialize(data, options) {
+  const [json, hasBlob] = jsonSerialize(data);
+  if (options.outputFormat === "plain") {
+    return json;
+  }
+  if (options.outputFormat === "URLSearchParams") {
+    const params = new URLSearchParams();
+    for (const [path, value] of bracketNotationSerialize(json)) {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        params.append(path, value.toString());
+      }
+    }
+    return params;
+  }
+  if (json instanceof Blob || json === void 0 || !hasBlob) {
+    return json;
+  }
+  const form = new FormData();
+  for (const [path, value] of bracketNotationSerialize(json)) {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      form.append(path, value.toString());
+    } else if (value instanceof Blob) {
+      form.append(path, value);
+    }
+  }
+  return form;
+}
+function deserialize(data) {
+  if (data instanceof URLSearchParams || data instanceof FormData) {
+    return bracketNotationDeserialize(Array.from(data.entries()));
+  }
+  if (isAsyncIteratorObject(data)) {
+    return mapEventIterator(data, {
+      value: async (value) => value,
+      error: async (e) => {
+        if (e instanceof ErrorEvent && isORPCErrorJson(e.data)) {
+          return createORPCErrorFromJson(e.data, { cause: e });
+        }
+        return e;
+      }
+    });
+  }
+  return data;
+}
+
+function standardizeHTTPPath(path) {
+  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
+}
+function getDynamicParams(path) {
+  return path ? standardizeHTTPPath(path).match(/\/\{[^}]+\}/g)?.map((v) => ({
+    raw: v,
+    name: v.match(/\{\+?([^}]+)\}/)[1]
+  })) : void 0;
+}
+
+export { standardizeHTTPPath as a, deserialize as d, getDynamicParams as g, jsonSerialize as j, serialize as s };

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

@@ -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, Middleware as M, ORPCErrorConstructorMap as O, Router as R, MergedInitialContext as a, MergedCurrentContext as b, MapInputMiddleware as c, CreateProcedureClientOptions as d, ProcedureClient as e, AnyRouter as f, Lazy as g, AnyProcedure as h, ProcedureHandler 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.BKSOrA6h.d.ts}

@@ -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, Middleware as M, ORPCErrorConstructorMap as O, Router as R, MergedInitialContext as a, MergedCurrentContext as b, MapInputMiddleware as c, CreateProcedureClientOptions as d, ProcedureClient as e, AnyRouter as f, Lazy as g, AnyProcedure as h, ProcedureHandler 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.BEQrAa3A.mjs → server.BKh8I1Ny.mjs}

@@ -1,7 +1,39 @@
 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';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import 'zod';
+import * as z4 from 'zod/v4/core';
+
+const gatingContext = new AsyncLocalStorage();
+function withoutGatedFields(data, schema, isGateEnabled) {
+  const filtered = { ...data };
+  const gatedFields = getGatedFields(schema);
+  for (const [fieldName, gate] of gatedFields) {
+    if (!isGateEnabled(gate)) {
+      delete filtered[fieldName];
+    }
+  }
+  return filtered;
+}
+function getGatedFields(schema) {
+  if (!schema || schema["~standard"].vendor !== "zod") {
+    return [];
+  }
+  const gatedFields = [];
+  const zodDef = schema._zod.def;
+  if (zodDef.type === "object") {
+    const shape = zodDef.shape;
+    for (const fieldName in shape) {
+      const fieldSchema = shape[fieldName];
+      const gate = z4.globalRegistry.get(fieldSchema)?.gate;
+      if (gate) {
+        gatedFields.push([fieldName, gate]);
+      }
+    }
+  }
+  return gatedFields;
+}
 
 const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
 function lazy(loader, meta = {}) {
@@ -204,4 +236,4 @@ async function executeProcedureInternal(procedure, options) {
   return next(0, options.context, options.input);
 }
 
-export { LAZY_SYMBOL as L, createORPCErrorConstructorMap as a, middlewareOutputFn as b, createProcedureClient as c, getLazyMeta as g, isLazy as i, lazy as l, mergeCurrentContext as m, unlazy as u };
+export { LAZY_SYMBOL as L, gatingContext as a, createORPCErrorConstructorMap as b, createProcedureClient as c, middlewareOutputFn as d, getLazyMeta as g, isLazy as i, lazy as l, mergeCurrentContext as m, unlazy as u };

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

@@ -0,0 +1,23 @@
+import { HTTPPath } from '@temporary-name/shared';
+import { C as Context } from './server.BKSOrA6h.mjs';
+import { c as StandardHandleOptions } from './server.C1fnTLq0.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.Btxrgkj5.d.ts → server.C1fnTLq0.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.BKSOrA6h.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,14 @@ 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;
+    private readonly codec;
+    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 };

package/dist/shared/{server.Bo94xDTv.d.mts → server.CQyYNJ1H.d.ts}

@@ -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.mjs';
+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.BKSOrA6h.js';
 
 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,14 @@ 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;
+    private readonly codec;
+    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 };