@orpc/server 2.0.0-beta.4 → 2.0.0-beta.40

package/dist/shared/{server.BwHnWUuN.mjs → server.BynNaBBA.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.Djb_ebJT.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,
@@ -92,8 +93,8 @@ function augmentRouter(router, options) {
     return router;
   }
   const enhanced = {};
-  for (const key in router) {
-    enhanced[key] = augmentRouter(router[key], options);
+  for (const [key, child] of Object.entries(router)) {
+    enhanced[key] = augmentRouter(child, options);
   }
   return enhanced;
 }
@@ -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 })),
@@ -123,8 +125,8 @@ function augmentImplementedRouter(router, options) {
     return router;
   }
   const enhanced = {};
-  for (const key in router) {
-    enhanced[key] = augmentImplementedRouter(router[key], options);
+  for (const [key, child] of Object.entries(router)) {
+    enhanced[key] = augmentImplementedRouter(child, options);
   }
   return enhanced;
 }
@@ -159,27 +161,31 @@ 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];
+  for (const [key, value] of Object.entries(router)) {
+    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);
@@ -193,8 +199,7 @@ async function walkProcedureContractsAsync(router, callback, path = []) {
   if (!isTypescriptObject(router)) {
     return;
   }
-  for (const key in router) {
-    const value = router[key];
+  for (const [key, value] of Object.entries(router)) {
     if (value instanceof Lazy) {
       const { default: router2 } = await unlazy(value);
       await walkProcedureContractsAsync(router2, callback, [...path, key]);
@@ -211,7 +216,7 @@ async function unlazyRouter(router) {
     return router;
   }
   const unlazied = {};
-  for (const key in router) {
+  for (const key of Object.keys(router)) {
     const item = router[key];
     const { default: unlaziedRouter } = await unlazy(item);
     unlazied[key] = await unlazyRouter(unlaziedRouter);

package/dist/shared/{server.GDpX6Df8.mjs → server.C0lFtoHU.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 { 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 { sortPlugins, toArray, matchesHttpPathPrefix, value, intercept, getTracer, runWithSpan, ORPC_NAME, isAsyncIteratorObject, override, traceAsyncIterator, traceReadableStream, recordSpanError, wrapAsyncIterator, toTracingException, wrapReadableStream, pathToHttpPath, normalizeHttpPath, parseEmptyableJSON, getOwn } from '@orpc/shared';
+import { flattenStandardHeader, parseStandardUrl, ErrorEvent } from '@standard-server/core';
+import { c as createProcedureClient, u as unlazy, P as Procedure } from './server.Djb_ebJT.mjs';
+import { w as walkProcedureContractsSync, g as getRouter, c as createContractProcedure, D as DEFAULT_SUCCESS_STATUS, a as DEFAULT_ERROR_STATUS } from './server.BynNaBBA.mjs';
 
 class CompositeStandardHandlerPlugin {
   name = "~composite";
@@ -24,8 +24,8 @@ class StandardHandler {
   constructor(codec, options) {
     this.codec = codec;
     options = new CompositeStandardHandlerPlugin([
-      new OtelHandlerPlugin(),
-      ...toArray(options.plugins)
+      ...toArray(options.plugins),
+      new TracingHandlerPlugin()
     ]).init(options);
     this.routingInterceptors = options.routingInterceptors;
     this.interceptors = options.interceptors;
@@ -34,15 +34,17 @@ class StandardHandler {
   routingInterceptors;
   interceptors;
   clientInterceptors;
-  async handle(request, { context, prefix }) {
+  async handle(request, options) {
+    const { prefix } = options;
     if (prefix && !matchesHttpPathPrefix(request.url, prefix)) {
       return { matched: false, response: void 0 };
     }
+    const context = await value(options.context, request);
     return intercept(
       this.routingInterceptors,
       { context, prefix, request },
       async ({ context: context2, prefix: prefix2, request: request2 }) => {
-        const span = getOpenTelemetryConfig()?.trace.getActiveSpan();
+        const span = getTracer()?.getActiveSpan();
         let step;
         const matchedOrNot = await runWithSpan("find_procedure", () => this.codec.resolveProcedure(request2, { context: context2, prefix: prefix2 }));
         if (!matchedOrNot) {
@@ -63,8 +65,10 @@ class StandardHandler {
               step = "decode_input";
               let input = await runWithSpan("decode_input", decodeInput2);
               step = void 0;
-              if (isAsyncIteratorObject(input)) {
-                input = override(input, traceAsyncIterator("consume_event_iterator_input", input));
+              if (getTracer() && isAsyncIteratorObject(input)) {
+                input = override(input, traceAsyncIterator("consume_async_iterator_object_input", input));
+              } else if (getTracer() && input instanceof ReadableStream) {
+                input = override(input, traceReadableStream("consume_octet_stream_input", input));
               }
               const client = createProcedureClient(procedure2, {
                 context: context3,
@@ -97,23 +101,80 @@ class StandardHandler {
     );
   }
 }
-class OtelHandlerPlugin {
-  name = "~opentelemetry";
+class TracingHandlerPlugin {
+  name = "~tracing";
   init(options) {
     return {
       ...options,
       routingInterceptors: [
-        // Should be placed before user-provided interceptors to help them access the current active context.
+        // Should be placed before user-provided interceptors to help them access the current active span.
         async ({ next, request }) => {
-          const otelConfig = getOpenTelemetryConfig();
-          let propagationContext;
-          if (otelConfig?.propagation) {
-            propagationContext = otelConfig.propagation.extract(otelConfig.context.active(), request.headers);
+          const tracer = getTracer();
+          if (!tracer) {
+            return next();
           }
-          return runWithSpan(
-            { name: `${request.method} ${request.url}`, context: propagationContext },
-            () => next()
-          );
+          const parent = tracer.extract?.(request.headers);
+          const [pathname] = parseStandardUrl(request.url);
+          return tracer.startActiveSpan(`${request.method} ${pathname}`, parent, async (span) => {
+            try {
+              const result = await next();
+              if (!result.matched) {
+                span.end();
+                return result;
+              }
+              const body = result.response.body;
+              if (isAsyncIteratorObject(body)) {
+                return {
+                  ...result,
+                  response: {
+                    ...result.response,
+                    /**
+                     * @remarks
+                     * **Warning**: Remember use `override` for remaining special properties
+                     */
+                    body: override(body, wrapAsyncIterator(body, {
+                      runWith: (fn) => tracer.withActiveSpan(span, fn),
+                      onError(error) {
+                        if (!(error instanceof ErrorEvent)) {
+                          span.recordException("error", toTracingException(error));
+                        }
+                      },
+                      onFinish() {
+                        span.end();
+                      }
+                    }))
+                  }
+                };
+              }
+              if (body instanceof ReadableStream) {
+                return {
+                  ...result,
+                  response: {
+                    ...result.response,
+                    /**
+                     * @remarks
+                     * **Warning**: Remember use `override` for remaining special properties
+                     */
+                    body: override(body, wrapReadableStream(body, {
+                      runWith: (fn) => tracer.withActiveSpan(span, fn),
+                      onError(error) {
+                        span.recordException("error", toTracingException(error));
+                      },
+                      onFinish() {
+                        span.end();
+                      }
+                    }))
+                  }
+                };
+              }
+              span.end();
+              return result;
+            } catch (e) {
+              span.recordException("error", toTracingException(e));
+              span.end();
+              throw e;
+            }
+          });
         },
         ...toArray(options.routingInterceptors)
       ]
@@ -121,13 +182,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 +206,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 +239,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 +353,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 +362,4 @@ class RPCHandlerCodec {
   }
 }
 
-export { CompositeStandardHandlerPlugin as C, OtelHandlerPlugin as O, RPCHandlerCodec as R, StandardHandler as S, RPCMatcher as a };
+export { CompositeStandardHandlerPlugin as C, RPCHandlerCodec as R, StandardHandler as S, TracingHandlerPlugin as T, RPCMatcher as a, RPC_DEFAULT_ALLOW_METHODS as b };

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

@@ -0,0 +1,34 @@
+import { C as Context } from './server.BsujoJoF.mjs';
+import { b as StandardHandlerPlugin, c as StandardHandlerOptions } from './server.B5K1CViq.mjs';
+
+interface RequestLimitHandlerPluginOptions {
+    /**
+     * The maximum allowed request body size in bytes.
+     */
+    maxBodySize: number;
+}
+/**
+ * Rejects requests whose body exceeds `maxBodySize`.
+ *
+ * When used with the request compression plugin, the limit applies to the
+ * decompressed payload rather than the compressed wire size.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/request-limit | Request Limit Plugin}
+ */
+declare class RequestLimitHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    name: string;
+    /**
+     * Should limit the original batch request body instead of sub-requests.
+     */
+    after: string[];
+    /**
+     * Should limit the final body size instead of the compressed one.
+     */
+    before: string[];
+    private readonly maxBodySize;
+    constructor(options: RequestLimitHandlerPluginOptions);
+    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}
+
+export { RequestLimitHandlerPlugin as R };
+export type { RequestLimitHandlerPluginOptions as a };

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

@@ -0,0 +1,14 @@
+import { Value, Promisable } from '@orpc/shared';
+import { StandardLazyRequest } from '@standard-server/core';
+import { C as Context } from './server.BsujoJoF.mjs';
+import { a as StandardHandlerHandleOptions } from './server.B5K1CViq.mjs';
+
+type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
+    context?: Value<Promisable<T>, [request: StandardLazyRequest]>;
+} : {
+    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
+});
+declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;
+
+export { resolveFriendlyStandardHandlerHandleOptions as r };
+export type { FriendlyStandardHandlerHandleOptions as F };

package/dist/shared/{server.Pa0F03f_.d.ts → server.CRwPbhLO.d.ts}

@@ -1,10 +1,10 @@
 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.BsujoJoF.js';
 
-type Router<TInitialContext extends Context> = Procedure<TInitialContext, any, any, any, any, any> | {
+type Router<TInitialContext extends Context> = Procedure<TInitialContext, any, any, any, any> | {
     [k: string]: Lazyable<Router<TInitialContext>>;
 };
-type ContractedRouter<T extends RouterContract, TInitialContext extends Context> = T extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? Procedure<TInitialContext, any, $InputSchema, $OutputSchema, $ErrorMap, never> : {
+type ContractedRouter<T extends RouterContract, TInitialContext extends Context> = T extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? Procedure<TInitialContext, any, $InputSchema, $OutputSchema, $ErrorMap> : {
     [K in keyof T]: T[K] extends RouterContract ? Lazyable<ContractedRouter<T[K], TInitialContext>> : never;
 };
 type AnyRouter = Router<any>;
@@ -12,50 +12,62 @@ 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 : {
+type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any> ? UInitialContext : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : never;
 };
 /**
  * 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> : {
+type InferRouterFinalContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, infer UInjectedContext, 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> : {
+type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, 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> : {
+type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, 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 : {
+type InferRouterError<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | 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 : {
+type InferRouterErrors<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | 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 };