@orpc/server 0.0.0-next.3826d73 → 0.0.0-next.3afb521

package/dist/{index.js → index.mjs}

@@ -1,33 +1,12 @@
-import {
-  LAZY_LOADER_SYMBOL,
-  Procedure,
-  adaptRouter,
-  addMiddleware,
-  convertPathToHttpPath,
-  createAccessibleLazyRouter,
-  createContractedProcedure,
-  createLazyProcedureFormAnyLazy,
-  createProcedureClient,
-  deepSetLazyRouterPrefix,
-  eachAllContractProcedure,
-  eachContractProcedure,
-  flatLazy,
-  getLazyRouterPrefix,
-  getRouterChild,
-  getRouterContract,
-  isLazy,
-  isProcedure,
-  lazy,
-  middlewareOutputFn,
-  setRouterContract,
-  unlazy
-} from "./chunk-XXBE6CYD.js";
+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, e as enhanceRouter, l as lazy, s as setHiddenRouterContract, i as isProcedure, f as isLazy, h as createAssertedLazyProcedure, g as getRouter } from './shared/server.BFBhsdJr.mjs';
+export { L as LAZY_SYMBOL, k as call, o as createAccessibleLazyRouter, b as createContractedProcedure, n as getHiddenRouterContract, j as getLazyMeta, m as middlewareOutputFn, r as resolveContractProcedures, a as toHttpPath, t as traverseContractProcedures, u as unlazy } from './shared/server.BFBhsdJr.mjs';
+export { ORPCError, isDefinedError, safe } from '@orpc/client';
+export { onError, onFinish, onStart, onSuccess } from '@orpc/shared';
+export { getEventMeta, withEventMeta } from '@orpc/standard-server';
 
-// src/builder.ts
-import { mergeErrorMap as mergeErrorMap2, mergeMeta as mergeMeta2, mergePrefix, mergeRoute as mergeRoute2, mergeTags } from "@orpc/contract";
-
-// src/config.ts
-var DEFAULT_CONFIG = {
+const DEFAULT_CONFIG = {
   initialInputValidationIndex: 0,
   initialOutputValidationIndex: 0
 };
@@ -38,7 +17,6 @@ function fallbackConfig(key, value) {
   return value;
 }
 
-// src/middleware-decorated.ts
 function decorateMiddleware(middleware) {
   const decorated = middleware;
   decorated.mapInput = (mapInput) => {
@@ -65,30 +43,28 @@ function decorateMiddleware(middleware) {
   return decorated;
 }
 
-// src/procedure-decorated.ts
-import { mergeErrorMap, mergeMeta, mergeRoute } from "@orpc/contract";
-var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
+class DecoratedProcedure extends Procedure {
   errors(errors) {
-    return new _DecoratedProcedure({
+    return new DecoratedProcedure({
       ...this["~orpc"],
       errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
     });
   }
   meta(meta) {
-    return new _DecoratedProcedure({
+    return new DecoratedProcedure({
       ...this["~orpc"],
       meta: mergeMeta(this["~orpc"].meta, meta)
     });
   }
   route(route) {
-    return new _DecoratedProcedure({
+    return new DecoratedProcedure({
       ...this["~orpc"],
       route: mergeRoute(this["~orpc"].route, route)
     });
   }
   use(middleware, mapInput) {
     const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _DecoratedProcedure({
+    return new DecoratedProcedure({
       ...this["~orpc"],
       middlewares: addMiddleware(this["~orpc"].middlewares, mapped)
     });
@@ -108,10 +84,9 @@ var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
   actionable(...rest) {
     return this.callable(...rest);
   }
-};
+}
 
-// src/builder.ts
-var Builder = class _Builder {
+class Builder {
   "~orpc";
   constructor(def) {
     this["~orpc"] = def;
@@ -122,7 +97,7 @@ var Builder = class _Builder {
   $config(config) {
     const inputValidationCount = this["~orpc"].inputValidationIndex - fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex);
     const outputValidationCount = this["~orpc"].outputValidationIndex - fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex);
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       config,
       inputValidationIndex: fallbackConfig("initialInputValidationIndex", config.initialInputValidationIndex) + inputValidationCount,
@@ -133,7 +108,7 @@ var Builder = class _Builder {
    * Reset initial context
    */
   $context() {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       middlewares: [],
       inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
@@ -144,7 +119,7 @@ var Builder = class _Builder {
    * Reset initial meta
    */
   $meta(initialMeta) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       meta: initialMeta
     });
@@ -153,7 +128,7 @@ var Builder = class _Builder {
    * Reset initial route
    */
   $route(initialRoute) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       route: initialRoute
     });
@@ -162,39 +137,39 @@ var Builder = class _Builder {
     return decorateMiddleware(middleware);
   }
   errors(errors) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
-      errorMap: mergeErrorMap2(this["~orpc"].errorMap, errors)
+      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
     });
   }
   use(middleware, mapInput) {
     const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       middlewares: addMiddleware(this["~orpc"].middlewares, mapped)
     });
   }
   meta(meta) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
-      meta: mergeMeta2(this["~orpc"].meta, meta)
+      meta: mergeMeta(this["~orpc"].meta, meta)
     });
   }
   route(route) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
-      route: mergeRoute2(this["~orpc"].route, route)
+      route: mergeRoute(this["~orpc"].route, route)
     });
   }
   input(schema) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       inputSchema: schema,
       inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex) + this["~orpc"].middlewares.length
     });
   }
   output(schema) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       outputSchema: schema,
       outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex) + this["~orpc"].middlewares.length
@@ -207,25 +182,25 @@ var Builder = class _Builder {
     });
   }
   prefix(prefix) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       prefix: mergePrefix(this["~orpc"].prefix, prefix)
     });
   }
   tag(...tags) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       tags: mergeTags(this["~orpc"].tags, tags)
     });
   }
   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"]);
   }
-};
-var os = new Builder({
+}
+const os = new Builder({
   config: {},
   route: {},
   meta: {},
@@ -237,13 +212,10 @@ var os = new Builder({
   middlewares: []
 });
 
-// src/context.ts
 function mergeContext(context, other) {
   return { ...context, ...other };
 }
 
-// src/implementer.ts
-import { isContractProcedure } from "@orpc/contract";
 function implementerInternal(contract, config, middlewares) {
   if (isContractProcedure(contract)) {
     const impl2 = new Builder({
@@ -257,6 +229,9 @@ function implementerInternal(contract, config, middlewares) {
   }
   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);
@@ -270,23 +245,27 @@ 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
           });
-          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
           });
-          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);
@@ -329,28 +308,21 @@ function implement(contract, config = {}) {
   return impl;
 }
 
-// src/procedure-utils.ts
-function call(procedure, input, ...rest) {
-  return createProcedureClient(procedure, ...rest)(input);
-}
-
-// src/router-client.ts
-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]
@@ -360,53 +332,4 @@ function createRouterClient(router, ...rest) {
   return recursive;
 }
 
-// src/index.ts
-import { eventIterator, isDefinedError, ORPCError, safe, type, ValidationError } from "@orpc/contract";
-import { getEventMeta, withEventMeta } from "@orpc/server-standard";
-import { onError, onFinish, onStart, onSuccess } from "@orpc/shared";
-export {
-  Builder,
-  DecoratedProcedure,
-  LAZY_LOADER_SYMBOL,
-  ORPCError,
-  Procedure,
-  ValidationError,
-  adaptRouter,
-  call,
-  convertPathToHttpPath,
-  createAccessibleLazyRouter,
-  createContractedProcedure,
-  createLazyProcedureFormAnyLazy,
-  createProcedureClient,
-  createRouterClient,
-  decorateMiddleware,
-  deepSetLazyRouterPrefix,
-  eachAllContractProcedure,
-  eachContractProcedure,
-  eventIterator,
-  fallbackConfig,
-  flatLazy,
-  getEventMeta,
-  getLazyRouterPrefix,
-  getRouterChild,
-  getRouterContract,
-  implement,
-  implementerInternal,
-  isDefinedError,
-  isLazy,
-  isProcedure,
-  lazy,
-  mergeContext,
-  middlewareOutputFn,
-  onError,
-  onFinish,
-  onStart,
-  onSuccess,
-  os,
-  safe,
-  setRouterContract,
-  type,
-  unlazy,
-  withEventMeta
-};
-//# sourceMappingURL=index.js.map
+export { Builder, DecoratedProcedure, Procedure, createAssertedLazyProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, fallbackConfig, getRouter, implement, implementerInternal, isLazy, isProcedure, lazy, mergeContext, os, setHiddenRouterContract };

package/dist/plugins/index.d.mts

@@ -0,0 +1,31 @@
+import { a as StandardHandlerInterceptorOptions, H as HandlerPlugin, b as StandardHandlerOptions } from '../shared/server.rcYTv2pz.mjs';
+export { C as CompositePlugin } from '../shared/server.rcYTv2pz.mjs';
+import { Value } from '@orpc/shared';
+import { C as Context } from '../shared/server.C99bm-AA.mjs';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client';
+
+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[];
+    maxAge?: number;
+    credentials?: boolean;
+    exposeHeaders?: string[];
+}
+declare class CORSPlugin<TContext extends Context> implements HandlerPlugin<TContext> {
+    private readonly options;
+    constructor(options?: Partial<CORSOptions<TContext>>);
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+interface ResponseHeadersPluginContext {
+    resHeaders?: Headers;
+}
+declare class ResponseHeadersPlugin<TContext extends ResponseHeadersPluginContext & Context> implements HandlerPlugin<TContext> {
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+export { type CORSOptions, CORSPlugin, HandlerPlugin, ResponseHeadersPlugin, type ResponseHeadersPluginContext };

package/dist/plugins/index.d.ts

@@ -0,0 +1,31 @@
+import { a as StandardHandlerInterceptorOptions, H as HandlerPlugin, b as StandardHandlerOptions } from '../shared/server.SegZfF38.js';
+export { C as CompositePlugin } from '../shared/server.SegZfF38.js';
+import { Value } from '@orpc/shared';
+import { C as Context } from '../shared/server.C99bm-AA.js';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client';
+
+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[];
+    maxAge?: number;
+    credentials?: boolean;
+    exposeHeaders?: string[];
+}
+declare class CORSPlugin<TContext extends Context> implements HandlerPlugin<TContext> {
+    private readonly options;
+    constructor(options?: Partial<CORSOptions<TContext>>);
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+interface ResponseHeadersPluginContext {
+    resHeaders?: Headers;
+}
+declare class ResponseHeadersPlugin<TContext extends ResponseHeadersPluginContext & Context> implements HandlerPlugin<TContext> {
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+export { type CORSOptions, CORSPlugin, HandlerPlugin, ResponseHeadersPlugin, type ResponseHeadersPluginContext };

package/dist/{chunk-XI6WGCB3.js → plugins/index.mjs}

@@ -1,23 +1,7 @@
-// src/plugins/base.ts
-var CompositePlugin = class {
-  constructor(plugins = []) {
-    this.plugins = plugins;
-  }
-  init(options) {
-    for (const plugin of this.plugins) {
-      plugin.init?.(options);
-    }
-  }
-  beforeCreateProcedureClient(clientOptions, interceptorOptions) {
-    for (const plugin of this.plugins) {
-      plugin.beforeCreateProcedureClient?.(clientOptions, interceptorOptions);
-    }
-  }
-};
+export { C as CompositePlugin } from '../shared/server.Q6ZmnTgO.mjs';
+import { value } from '@orpc/shared';
 
-// src/plugins/cors.ts
-import { value } from "@orpc/shared";
-var CORSPlugin = class {
+class CORSPlugin {
   options;
   constructor(options) {
     const defaults = {
@@ -30,8 +14,8 @@ var CORSPlugin = class {
     };
   }
   init(options) {
-    options.interceptorsRoot ??= [];
-    options.interceptorsRoot.unshift(async (interceptorOptions) => {
+    options.rootInterceptors ??= [];
+    options.rootInterceptors.unshift(async (interceptorOptions) => {
       if (interceptorOptions.request.method === "OPTIONS") {
         const resHeaders = {};
         if (this.options.maxAge !== void 0) {
@@ -57,7 +41,7 @@ var CORSPlugin = class {
       }
       return interceptorOptions.next();
     });
-    options.interceptorsRoot.unshift(async (interceptorOptions) => {
+    options.rootInterceptors.unshift(async (interceptorOptions) => {
       const result = await interceptorOptions.next();
       if (!result.matched) {
         return result;
@@ -89,13 +73,12 @@ var CORSPlugin = class {
       return result;
     });
   }
-};
+}
 
-// src/plugins/response-headers.ts
-var ResponseHeadersPlugin = class {
+class ResponseHeadersPlugin {
   init(options) {
-    options.interceptorsRoot ??= [];
-    options.interceptorsRoot.push(async (interceptorOptions) => {
+    options.rootInterceptors ??= [];
+    options.rootInterceptors.push(async (interceptorOptions) => {
       const headers = new Headers();
       interceptorOptions.context.resHeaders = headers;
       const result = await interceptorOptions.next();
@@ -103,23 +86,18 @@ var ResponseHeadersPlugin = class {
         return result;
       }
       const responseHeaders = result.response.headers;
-      for (const [key, value2] of headers) {
+      for (const [key, value] of headers) {
         if (Array.isArray(responseHeaders[key])) {
-          responseHeaders[key].push(value2);
+          responseHeaders[key].push(value);
         } else if (responseHeaders[key] !== void 0) {
-          responseHeaders[key] = [responseHeaders[key], value2];
+          responseHeaders[key] = [responseHeaders[key], value];
         } else {
-          responseHeaders[key] = value2;
+          responseHeaders[key] = value;
         }
       }
       return result;
     });
   }
-};
+}
 
-export {
-  CompositePlugin,
-  CORSPlugin,
-  ResponseHeadersPlugin
-};
-//# sourceMappingURL=chunk-XI6WGCB3.js.map
+export { CORSPlugin, ResponseHeadersPlugin };

package/dist/shared/server.3cSam35R.mjs

@@ -0,0 +1,158 @@
+import { ORPCError, toORPCError } from '@orpc/client';
+import { intercept, trim, parseEmptyableJSON } from '@orpc/shared';
+import { C as CompositePlugin } from './server.Q6ZmnTgO.mjs';
+import { c as createProcedureClient, t as traverseContractProcedures, a as toHttpPath, i as isProcedure, u as unlazy, g as getRouter, b as createContractedProcedure } from './server.BFBhsdJr.mjs';
+
+class StandardHandler {
+  constructor(router, matcher, codec, options) {
+    this.matcher = matcher;
+    this.codec = codec;
+    this.options = options;
+    this.plugin = new CompositePlugin(options.plugins);
+    this.plugin.init(this.options);
+    this.matcher.init(router);
+  }
+  plugin;
+  handle(request, ...[options]) {
+    return intercept(
+      this.options.rootInterceptors ?? [],
+      {
+        request,
+        ...options,
+        context: options?.context ?? {}
+        // context is optional only when all fields are optional so we can safely force it to have a context
+      },
+      async (interceptorOptions) => {
+        let isDecoding = false;
+        try {
+          return await intercept(
+            this.options.interceptors ?? [],
+            interceptorOptions,
+            async (interceptorOptions2) => {
+              const method = interceptorOptions2.request.method;
+              const url = interceptorOptions2.request.url;
+              const pathname = `/${trim(url.pathname.replace(interceptorOptions2.prefix ?? "", ""), "/")}`;
+              const match = await this.matcher.match(method, pathname);
+              if (!match) {
+                return { matched: false, response: void 0 };
+              }
+              const client = createProcedureClient(match.procedure, {
+                context: interceptorOptions2.context,
+                path: match.path,
+                interceptors: this.options.clientInterceptors
+              });
+              isDecoding = true;
+              const input = await this.codec.decode(request, match.params, match.procedure);
+              isDecoding = false;
+              const lastEventId = Array.isArray(request.headers["last-event-id"]) ? request.headers["last-event-id"].at(-1) : request.headers["last-event-id"];
+              const output = await client(input, { signal: request.signal, lastEventId });
+              const response = this.codec.encode(output, match.procedure);
+              return {
+                matched: true,
+                response
+              };
+            }
+          );
+        } catch (e) {
+          const error = isDecoding ? 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 RPCCodec {
+  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 RPCMatcher {
+  tree = {};
+  pendingRouters = [];
+  init(router, path = []) {
+    const laziedOptions = traverseContractProcedures({ router, path }, ({ path: path2, contract }) => {
+      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
+    };
+  }
+}
+
+export { RPCCodec as R, StandardHandler as S, RPCMatcher as a };