@orpc/server 2.0.0-beta.3 → 2.0.0-beta.31

package/dist/shared/{server.BwHnWUuN.mjs → server.Dh77P3ii.mjs}

@@ -1,6 +1,6 @@
-import { c as createProcedureClient, P as Procedure, L as Lazy, u as unlazy } from './server.CrlKQucM.mjs';
+import { c as createProcedureClient, P as Procedure, L as Lazy, u as unlazy } from './server.CkButhNT.mjs';
 import { resolveMetaPlugins, mergeErrorMap, ProcedureContract } from '@orpc/contract';
-import { getOrBind, isTypescriptObject } from '@orpc/shared';
+import { omit, isTypescriptObject } from '@orpc/shared';
 
 const DEFAULT_SUCCESS_STATUS = 200;
 const DEFAULT_ERROR_STATUS = 500;
@@ -44,7 +44,7 @@ function withHiddenRouterContract(router, contract) {
       if (key === HIDDEN_ROUTER_CONTRACT_SYMBOL) {
         return contract;
       }
-      return getOrBind(target, key);
+      return Reflect.get(target, key);
     }
   });
 }
@@ -77,6 +77,7 @@ function augmentRouter(router, options) {
       router["~orpc"].metaPlugins
     );
     const enhanced2 = new Procedure({
+      ...omit(options, ["middlewares", "errorMap", "meta", "metaPlugins"]),
       ...router["~orpc"],
       meta,
       metaPlugins,
@@ -111,6 +112,7 @@ function augmentImplementedRouter(router, options) {
   }
   if (router instanceof Procedure) {
     const enhanced2 = new Procedure({
+      ...omit(options, ["middlewares"]),
       ...router["~orpc"],
       orderedMiddlewares: [
         ...options.middlewares.map((middleware) => ({ middleware, inputSchemasLengthAtUse: 0, outputSchemasLengthAtUse: 0 })),
@@ -159,27 +161,32 @@ function getRouter(router, path) {
   return current;
 }
 function walkProcedureContractsSync(router, callback, path = []) {
+  const lazyResults = [];
+  walkProcedureContractsSyncInternal(router, callback, path.slice(), lazyResults);
+  return lazyResults;
+}
+function walkProcedureContractsSyncInternal(router, callback, path, lazyResults) {
   const hiddenContract = getHiddenRouterContract(router);
   if (hiddenContract !== void 0) {
     router = hiddenContract;
   }
   if (router instanceof ProcedureContract) {
-    callback(router, path);
-    return [];
+    callback(router, path.slice());
+    return;
   }
   if (!isTypescriptObject(router)) {
-    return [];
+    return;
   }
-  const lazyResults = [];
   for (const key in router) {
     const value = router[key];
+    path.push(key);
     if (value instanceof Lazy) {
-      lazyResults.push({ router: value, path: [...path, key] });
+      lazyResults.push({ router: value, path: path.slice() });
     } else {
-      lazyResults.push(...walkProcedureContractsSync(value, callback, [...path, key]));
+      walkProcedureContractsSyncInternal(value, callback, path, lazyResults);
     }
+    path.pop();
   }
-  return lazyResults;
 }
 async function walkProcedureContractsAsync(router, callback, path = []) {
   const hiddenContract = getHiddenRouterContract(router);

package/dist/shared/{server.Pa0F03f_.d.ts → server.Dm0os-OP.d.mts}

@@ -1,5 +1,5 @@
 import { RouterContract, ProcedureContract, ORPCErrorFromErrorMap, ThrowableError, InferSchemaInput, InferSchemaOutput } from '@orpc/contract';
-import { C as Context, a as Procedure, L as Lazyable, M as MergedContext } from './server.BL22TloH.js';
+import { C as Context, a as Procedure, L as Lazyable, M as MergedContext } from './server.CwrYlF72.mjs';
 
 type Router<TInitialContext extends Context> = Procedure<TInitialContext, any, any, any, any, any> | {
     [k: string]: Lazyable<Router<TInitialContext>>;
@@ -12,8 +12,10 @@ type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer $>
 /**
  * Infer all initial context of the router.
  *
- * @info A procedure is a router too.
- * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ * @remarks
+ * **Note**: A procedure is a router too.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-initial-contexts | Router - Infer Router Initial Contexts}
  */
 type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any, any> ? UInitialContext : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : never;
@@ -21,41 +23,51 @@ type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer
 /**
  * Infer all current context of the router.
  *
- * @info A procedure is a router too.
- * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ * @remarks
+ * **Note**: A procedure is a router too.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-final-contexts | Router - Infer Router Final Contexts}
  */
 type InferRouterFinalContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, infer UInjectedContext, any, any, any, any> ? MergedContext<UInitialContext, UInjectedContext> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterFinalContexts<U> : never;
 };
 /**
- * Infer all router inputs
+ * Infer all router inputs.
+ *
+ * @remarks
+ * **Note**: A procedure is a router too.
  *
- * @info A procedure is a router too.
- * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ * @see {@link https://orpc.dev/docs/router#infer-router-inputs | Router - Infer Router Inputs}
  */
 type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any, any> ? InferSchemaInput<UInputSchema> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
 };
 /**
- * Infer all router outputs
+ * Infer all router outputs.
  *
- * @info A procedure is a router too.
- * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ * @remarks
+ * **Note**: A procedure is a router too.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-outputs | Router - Infer Router Outputs}
  */
 type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, any, any> ? InferSchemaOutput<UOutputSchema> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
 };
 /**
  * Infer the union of throwable errors for entire router.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-error | Router - Infer Router Error}
  */
 type InferRouterError<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap, infer UReturnedError> ? ORPCErrorFromErrorMap<UErrorMap> | UReturnedError | ThrowableError : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterError<U> : never;
 }[keyof T];
 /**
  * Infer throwable errors for each procedure, preserving the router shape.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-errors | Router - Infer Router Errors}
  */
 type InferRouterErrors<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap, infer UReturnedError> ? ORPCErrorFromErrorMap<UErrorMap> | UReturnedError | ThrowableError : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterErrors<U> : never;
 };
 
-export type { AnyRouter as A, ContractedRouter as C, InferRouterInitialContext as I, Router as R, InferRouterError as a, InferRouterErrors as b, InferRouterFinalContexts as c, InferRouterInitialContexts as d, InferRouterInputs as e, InferRouterOutputs as f };
+export type { AnyRouter as A, ContractedRouter as C, InferRouterInitialContext as I, Router as R, InferRouterFinalContexts as a, InferRouterError as b, InferRouterErrors as c, InferRouterInitialContexts as d, InferRouterInputs as e, InferRouterOutputs as f };

package/dist/shared/{server.GDpX6Df8.mjs → server.DpUGXBi2.mjs}

@@ -1,8 +1,8 @@
 import { ORPCError, toORPCError, RPCSerializer, COMMON_ERROR_STATUS_MAP } from '@orpc/client';
-import { sortPlugins, getOpenTelemetryConfig, runWithSpan, toArray, matchesHttpPathPrefix, intercept, ORPC_NAME, isAsyncIteratorObject, override, traceAsyncIterator, recordSpanError, pathToHttpPath, normalizeHttpPath, value, parseEmptyableJSON } from '@orpc/shared';
+import { sortPlugins, getOpenTelemetryConfig, runWithSpan, toArray, matchesHttpPathPrefix, intercept, ORPC_NAME, isAsyncIteratorObject, override, traceAsyncIterator, recordSpanError, pathToHttpPath, normalizeHttpPath, value, parseEmptyableJSON, getOwn } from '@orpc/shared';
 import { flattenStandardHeader, parseStandardUrl } from '@standardserver/core';
-import { c as createProcedureClient, u as unlazy, P as Procedure } from './server.CrlKQucM.mjs';
-import { w as walkProcedureContractsSync, g as getRouter, c as createContractProcedure, D as DEFAULT_SUCCESS_STATUS, a as DEFAULT_ERROR_STATUS } from './server.BwHnWUuN.mjs';
+import { c as createProcedureClient, u as unlazy, P as Procedure } from './server.CkButhNT.mjs';
+import { w as walkProcedureContractsSync, g as getRouter, c as createContractProcedure, D as DEFAULT_SUCCESS_STATUS, a as DEFAULT_ERROR_STATUS } from './server.Dh77P3ii.mjs';
 
 class CompositeStandardHandlerPlugin {
   name = "~composite";
@@ -64,7 +64,7 @@ class StandardHandler {
               let input = await runWithSpan("decode_input", decodeInput2);
               step = void 0;
               if (isAsyncIteratorObject(input)) {
-                input = override(input, traceAsyncIterator("consume_event_iterator_input", input));
+                input = override(input, traceAsyncIterator("consume_async_iterator_object_input", input));
               }
               const client = createProcedureClient(procedure2, {
                 context: context3,
@@ -121,13 +121,22 @@ class OtelHandlerPlugin {
   }
 }
 
+const RPC_DEFAULT_ALLOW_METHODS = ["POST", "PUT", "PATCH", "DELETE"];
 class RPCMatcher {
   filter;
+  allowMethodsSet;
+  allowMethodsFn;
   rootRouter;
   tree = /* @__PURE__ */ new Map();
-  pendingLazyRouters = [];
+  pendingLazyRouters = /* @__PURE__ */ new Map();
   constructor(router, options = {}) {
     this.filter = options.filter ?? true;
+    const allowMethods = options.allowMethods ?? RPC_DEFAULT_ALLOW_METHODS;
+    if (typeof allowMethods !== "function") {
+      this.allowMethodsSet = new Set(allowMethods);
+    } else {
+      this.allowMethodsFn = allowMethods;
+    }
     this.rootRouter = router;
     this.index(router);
   }
@@ -136,28 +145,21 @@ class RPCMatcher {
       if (!value(this.filter, procedure, procedurePath)) {
         return;
       }
-      const httpPath = pathToHttpPath(procedurePath);
-      if (procedure instanceof Procedure) {
-        this.tree.set(httpPath, {
-          path: procedurePath,
-          contract: procedure,
-          procedure
-        });
-      } else {
-        this.tree.set(httpPath, {
-          path: procedurePath,
-          contract: procedure
-        });
-      }
+      this.tree.set(pathToHttpPath(procedurePath), {
+        path: procedurePath,
+        contract: procedure,
+        // contract-first entries have no implementation yet, resolveProcedure fills it in on demand
+        procedure: procedure instanceof Procedure ? procedure : void 0
+      });
     }, path);
-    this.pendingLazyRouters.push(
-      ...lazyResults.map((result) => ({
-        ...result,
-        httpPathPrefix: pathToHttpPath(result.path)
-      }))
-    );
+    for (const result of lazyResults) {
+      this.pendingLazyRouters.set(pathToHttpPath(result.path), result);
+    }
   }
-  async match(_method, pathname, prefix) {
+  async match(method, pathname, prefix) {
+    if (this.allowMethodsSet && !this.allowMethodsSet.has(method)) {
+      return void 0;
+    }
     if (pathname.length > 1 && pathname.endsWith("/")) {
       pathname = pathname.slice(0, -1);
     }
@@ -176,40 +178,71 @@ class RPCMatcher {
         return void 0;
       }
     }
-    const result = await this.matchPathname(pathname);
-    if (!result && pathname.includes("%")) {
-      return this.matchPathname(normalizeHttpPath(pathname));
+    const loading = this.resolvePendingLazyRouters(pathname);
+    if (loading !== void 0) {
+      await loading;
     }
-    return result;
-  }
-  async matchPathname(pathname) {
-    await this.resolvePendingLazyRouters(pathname);
-    const entry = this.tree.get(pathname);
-    if (!entry) {
+    let entry = this.tree.get(pathname);
+    if (entry === void 0 && pathname.includes("%")) {
+      const normalizedPathname = normalizeHttpPath(pathname);
+      const normalizedLoading = this.resolvePendingLazyRouters(normalizedPathname);
+      if (normalizedLoading !== void 0) {
+        await normalizedLoading;
+      }
+      entry = this.tree.get(normalizedPathname);
+    }
+    if (entry === void 0) {
+      return void 0;
+    }
+    const procedure = entry.procedure ?? await this.resolveProcedure(entry);
+    if (this.allowMethodsFn && !this.allowMethodsFn(method, procedure, entry.path)) {
       return void 0;
     }
-    const procedure = await this.resolveProcedure(entry);
-    return { path: entry.path, procedure };
+    return {
+      path: entry.path,
+      procedure
+    };
   }
-  async resolvePendingLazyRouters(pathname) {
-    if (!this.pendingLazyRouters.length) {
+  resolvePendingLazyRouters(pathname) {
+    if (this.pendingLazyRouters.size === 0) {
       return;
     }
-    const stillPending = [];
-    for (const pending of this.pendingLazyRouters) {
-      if (pathname.startsWith(pending.httpPathPrefix)) {
-        const { default: router } = await unlazy(pending.router);
-        this.index(router, pending.path);
-      } else {
-        stillPending.push(pending);
+    let slashIndex = 0;
+    while (slashIndex !== -1) {
+      const nextSlashIndex = pathname.indexOf("/", slashIndex + 1);
+      const httpPathPrefix = nextSlashIndex === -1 ? pathname : pathname.slice(0, nextSlashIndex);
+      if (this.pendingLazyRouters.has(httpPathPrefix)) {
+        return this.loadPendingLazyRouters(pathname, slashIndex);
       }
+      slashIndex = nextSlashIndex;
     }
-    this.pendingLazyRouters = stillPending;
   }
-  async resolveProcedure(entry) {
-    if (entry.procedure) {
-      return entry.procedure;
+  async loadPendingLazyRouters(pathname, slashIndex) {
+    while (slashIndex !== -1) {
+      const nextSlashIndex = pathname.indexOf("/", slashIndex + 1);
+      const httpPathPrefix = nextSlashIndex === -1 ? pathname : pathname.slice(0, nextSlashIndex);
+      const pending = this.pendingLazyRouters.get(httpPathPrefix);
+      if (pending !== void 0) {
+        await this.loadPendingLazyRouter(httpPathPrefix, pending);
+      }
+      slashIndex = nextSlashIndex;
     }
+  }
+  loadPendingLazyRouter(httpPathPrefix, pending) {
+    if (pending.loading === void 0) {
+      pending.loading = this.indexPendingLazyRouter(httpPathPrefix, pending).catch((error) => {
+        pending.loading = void 0;
+        throw error;
+      });
+    }
+    return pending.loading;
+  }
+  async indexPendingLazyRouter(httpPathPrefix, pending) {
+    const { default: router } = await unlazy(pending.router);
+    this.index(router, pending.path);
+    this.pendingLazyRouters.delete(httpPathPrefix);
+  }
+  async resolveProcedure(entry) {
     const { default: maybeProcedure } = await unlazy(getRouter(this.rootRouter, entry.path));
     if (!(maybeProcedure instanceof Procedure)) {
       throw new TypeError(
@@ -259,7 +292,7 @@ class RPCHandlerCodec {
     };
   }
   encodeError(error, _procedure, _path, _options) {
-    const status = this.errorStatusMap[error.code] ?? DEFAULT_ERROR_STATUS;
+    const status = getOwn(this.errorStatusMap, error.code) ?? DEFAULT_ERROR_STATUS;
     return {
       headers: {},
       status,
@@ -268,4 +301,4 @@ class RPCHandlerCodec {
   }
 }
 
-export { CompositeStandardHandlerPlugin as C, OtelHandlerPlugin as O, RPCHandlerCodec as R, StandardHandler as S, RPCMatcher as a };
+export { CompositeStandardHandlerPlugin as C, OtelHandlerPlugin as O, RPCHandlerCodec as R, StandardHandler as S, RPCMatcher as a, RPC_DEFAULT_ALLOW_METHODS as b };

package/dist/shared/{server.EOHJ3NJr.d.ts → server.DrN1Pj1-.d.ts}

@@ -1,7 +1,7 @@
 import { AnyORPCError } from '@orpc/client';
 import { OrderablePlugin, Interceptor, Promisable } from '@orpc/shared';
 import { StandardLazyRequest, StandardResponse } from '@standardserver/core';
-import { C as Context, c as ProcedureClientInterceptor, A as AnyProcedure } from './server.BL22TloH.js';
+import { C as Context, c as ProcedureClientInterceptor, A as AnyProcedure } from './server.CwrYlF72.js';
 import { Schema, ErrorMap } from '@orpc/contract';
 
 interface StandardHandlerPlugin<T extends Context> extends OrderablePlugin {
@@ -100,5 +100,5 @@ interface StandardHandlerCodec<T extends Context> {
     encodeError(error: AnyORPCError, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
 }
 
-export { CompositeStandardHandlerPlugin as C, OtelHandlerPlugin as O, StandardHandler as S };
-export type { StandardHandlerOptions as a, StandardHandlerHandleOptions as b, StandardHandlerCodec as c, StandardHandlerCodecResolvedProcedure as d, StandardHandlerPlugin as e, StandardHandlerRoutingInterceptorOptions as f, StandardHandlerHandleResult as g, StandardHandlerInterceptor as h, StandardHandlerInterceptorOptions as i, StandardHandlerRoutingInterceptor as j };
+export { CompositeStandardHandlerPlugin as C, OtelHandlerPlugin as O, StandardHandler as b };
+export type { StandardHandlerPlugin as S, StandardHandlerOptions as a, StandardHandlerHandleOptions as c, StandardHandlerCodec as d, StandardHandlerCodecResolvedProcedure as e, StandardHandlerRoutingInterceptorOptions as f, StandardHandlerInterceptorOptions as g, StandardHandlerHandleResult as h, StandardHandlerInterceptor as i, StandardHandlerRoutingInterceptor as j };

package/dist/shared/{server.BsNNjG5J.d.mts → server.DtfwuV6U.d.ts}

@@ -1,5 +1,5 @@
 import { RouterContract, ProcedureContract, ORPCErrorFromErrorMap, ThrowableError, InferSchemaInput, InferSchemaOutput } from '@orpc/contract';
-import { C as Context, a as Procedure, L as Lazyable, M as MergedContext } from './server.BL22TloH.mjs';
+import { C as Context, a as Procedure, L as Lazyable, M as MergedContext } from './server.CwrYlF72.js';
 
 type Router<TInitialContext extends Context> = Procedure<TInitialContext, any, any, any, any, any> | {
     [k: string]: Lazyable<Router<TInitialContext>>;
@@ -12,8 +12,10 @@ type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer $>
 /**
  * Infer all initial context of the router.
  *
- * @info A procedure is a router too.
- * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ * @remarks
+ * **Note**: A procedure is a router too.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-initial-contexts | Router - Infer Router Initial Contexts}
  */
 type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any, any> ? UInitialContext : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : never;
@@ -21,41 +23,51 @@ type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer
 /**
  * Infer all current context of the router.
  *
- * @info A procedure is a router too.
- * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ * @remarks
+ * **Note**: A procedure is a router too.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-final-contexts | Router - Infer Router Final Contexts}
  */
 type InferRouterFinalContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, infer UInjectedContext, any, any, any, any> ? MergedContext<UInitialContext, UInjectedContext> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterFinalContexts<U> : never;
 };
 /**
- * Infer all router inputs
+ * Infer all router inputs.
+ *
+ * @remarks
+ * **Note**: A procedure is a router too.
  *
- * @info A procedure is a router too.
- * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ * @see {@link https://orpc.dev/docs/router#infer-router-inputs | Router - Infer Router Inputs}
  */
 type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any, any> ? InferSchemaInput<UInputSchema> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
 };
 /**
- * Infer all router outputs
+ * Infer all router outputs.
  *
- * @info A procedure is a router too.
- * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ * @remarks
+ * **Note**: A procedure is a router too.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-outputs | Router - Infer Router Outputs}
  */
 type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, any, any> ? InferSchemaOutput<UOutputSchema> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
 };
 /**
  * Infer the union of throwable errors for entire router.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-error | Router - Infer Router Error}
  */
 type InferRouterError<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap, infer UReturnedError> ? ORPCErrorFromErrorMap<UErrorMap> | UReturnedError | ThrowableError : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterError<U> : never;
 }[keyof T];
 /**
  * Infer throwable errors for each procedure, preserving the router shape.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-errors | Router - Infer Router Errors}
  */
 type InferRouterErrors<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap, infer UReturnedError> ? ORPCErrorFromErrorMap<UErrorMap> | UReturnedError | ThrowableError : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterErrors<U> : never;
 };
 
-export type { AnyRouter as A, ContractedRouter as C, InferRouterInitialContext as I, Router as R, InferRouterError as a, InferRouterErrors as b, InferRouterFinalContexts as c, InferRouterInitialContexts as d, InferRouterInputs as e, InferRouterOutputs as f };
+export type { AnyRouter as A, ContractedRouter as C, InferRouterInitialContext as I, Router as R, InferRouterFinalContexts as a, InferRouterError as b, InferRouterErrors as c, InferRouterInitialContexts as d, InferRouterInputs as e, InferRouterOutputs as f };

package/dist/shared/{server.BB_Ik9Ph.d.mts → server.JbCIPL4P.d.mts}

@@ -1,7 +1,7 @@
 import { AnyORPCError } from '@orpc/client';
 import { OrderablePlugin, Interceptor, Promisable } from '@orpc/shared';
 import { StandardLazyRequest, StandardResponse } from '@standardserver/core';
-import { C as Context, c as ProcedureClientInterceptor, A as AnyProcedure } from './server.BL22TloH.mjs';
+import { C as Context, c as ProcedureClientInterceptor, A as AnyProcedure } from './server.CwrYlF72.mjs';
 import { Schema, ErrorMap } from '@orpc/contract';
 
 interface StandardHandlerPlugin<T extends Context> extends OrderablePlugin {
@@ -100,5 +100,5 @@ interface StandardHandlerCodec<T extends Context> {
     encodeError(error: AnyORPCError, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
 }
 
-export { CompositeStandardHandlerPlugin as C, OtelHandlerPlugin as O, StandardHandler as S };
-export type { StandardHandlerOptions as a, StandardHandlerHandleOptions as b, StandardHandlerCodec as c, StandardHandlerCodecResolvedProcedure as d, StandardHandlerPlugin as e, StandardHandlerRoutingInterceptorOptions as f, StandardHandlerHandleResult as g, StandardHandlerInterceptor as h, StandardHandlerInterceptorOptions as i, StandardHandlerRoutingInterceptor as j };
+export { CompositeStandardHandlerPlugin as C, OtelHandlerPlugin as O, StandardHandler as b };
+export type { StandardHandlerPlugin as S, StandardHandlerOptions as a, StandardHandlerHandleOptions as c, StandardHandlerCodec as d, StandardHandlerCodecResolvedProcedure as e, StandardHandlerRoutingInterceptorOptions as f, StandardHandlerInterceptorOptions as g, StandardHandlerHandleResult as h, StandardHandlerInterceptor as i, StandardHandlerRoutingInterceptor as j };

package/dist/shared/{server.CjOb6ItT.mjs → server.eCTV8Vpp.mjs}

@@ -1,5 +1,5 @@
 import { resolveMetaPlugins, mergeErrorMap, getHiddenMetaPlugins } from '@orpc/contract';
-import { P as Procedure } from './server.CrlKQucM.mjs';
+import { P as Procedure } from './server.CkButhNT.mjs';
 
 class DecoratedProcedure extends Procedure {
   meta(...plugins) {

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "2.0.0-beta.3",
+  "version": "2.0.0-beta.31",
+  "description": "Build typesafe APIs with oRPC: RPC and OpenAPI support, middleware, and adapters for Node.js, Bun, Deno, Fetch, Fastify, WebSocket, AWS Lambda, and more",
   "license": "MIT",
+  "funding": [
+    "https://github.com/sponsors/dinwwwh",
+    "https://opencollective.com/middleapi"
+  ],
   "homepage": "https://orpc.dev",
   "repository": {
     "type": "git",
@@ -10,7 +15,20 @@
     "directory": "packages/server"
   },
   "keywords": [
-    "orpc"
+    "orpc",
+    "rpc",
+    "api",
+    "typescript",
+    "typesafe",
+    "server",
+    "openapi",
+    "middleware",
+    "nodejs",
+    "bun",
+    "deno",
+    "fastify",
+    "websocket",
+    "aws-lambda"
   ],
   "sideEffects": [
     "./dist/extensions/callable.mjs"
@@ -52,6 +70,16 @@
       "import": "./dist/adapters/node/index.mjs",
       "default": "./dist/adapters/node/index.mjs"
     },
+    "./aws-lambda": {
+      "types": "./dist/adapters/aws-lambda/index.d.mts",
+      "import": "./dist/adapters/aws-lambda/index.mjs",
+      "default": "./dist/adapters/aws-lambda/index.mjs"
+    },
+    "./fastify": {
+      "types": "./dist/adapters/fastify/index.d.mts",
+      "import": "./dist/adapters/fastify/index.mjs",
+      "default": "./dist/adapters/fastify/index.mjs"
+    },
     "./websocket": {
       "types": "./dist/adapters/websocket/index.d.mts",
       "import": "./dist/adapters/websocket/index.mjs",
@@ -77,26 +105,32 @@
     "dist"
   ],
   "peerDependencies": {
-    "crossws": ">=0.3.4"
+    "crossws": ">=0.3.4",
+    "fastify": ">=5.6.1"
   },
   "peerDependenciesMeta": {
     "crossws": {
       "optional": true
+    },
+    "fastify": {
+      "optional": true
     }
   },
   "dependencies": {
-    "@standardserver/core": "^0.0.25",
-    "@standardserver/fetch": "^0.0.25",
-    "@standardserver/node": "^0.0.25",
-    "@standardserver/peer": "^0.0.25",
-    "cookie": "^1.1.1",
-    "@orpc/contract": "2.0.0-beta.3",
-    "@orpc/interop": "2.0.0-beta.3",
-    "@orpc/shared": "2.0.0-beta.3",
-    "@orpc/client": "2.0.0-beta.3"
+    "@standardserver/aws-lambda": "^0.8.0",
+    "@standardserver/core": "^0.8.0",
+    "@standardserver/fastify": "^0.8.0",
+    "@standardserver/fetch": "^0.8.0",
+    "@standardserver/node": "^0.8.0",
+    "@standardserver/peer": "^0.8.0",
+    "cookie": "^2.0.1",
+    "@orpc/contract": "2.0.0-beta.31",
+    "@orpc/client": "2.0.0-beta.31",
+    "@orpc/shared": "2.0.0-beta.31"
   },
   "devDependencies": {
     "crossws": "^0.4.6",
+    "fastify": "^5.12.1",
     "supertest": "^7.2.2",
     "zod": "^4.4.3"
   },

package/dist/shared/server.D_QauotT.mjs

@@ -1,30 +0,0 @@
-import { ORPCError } from '@orpc/client';
-import { toArray } from '@orpc/shared';
-import { flattenStandardHeader } from '@standardserver/core';
-
-class CSRFGuardHandlerPlugin {
-  name = "~csrf-guard";
-  init(options) {
-    const interceptor = async (interceptorOptions) => {
-      const mode = flattenStandardHeader(
-        interceptorOptions.request.headers["sec-fetch-mode"]
-      )?.toLowerCase();
-      if (mode === void 0) {
-        return interceptorOptions.next();
-      }
-      if (mode === "cors" || mode === "same-origin") {
-        return interceptorOptions.next();
-      }
-      throw new ORPCError("FORBIDDEN", {
-        message: "Request blocked by CSRF protection."
-      });
-    };
-    return {
-      ...options,
-      // appended last so user's interceptors can catch ORPCError
-      interceptors: [...toArray(options.interceptors), interceptor]
-    };
-  }
-}
-
-export { CSRFGuardHandlerPlugin as C };