docs: add JSDoc comments to exported router utility functions

Adds docstring coverage to satisfy the 80% threshold required by
CodeRabbit pre-merge checks.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: jameskranz

packages/server/src/router-utils.ts

@@ -10,6 +10,12 @@ import { mergeMiddlewares } from './middleware-utils'
 import { isProcedure, Procedure } from './procedure'
 import { getHiddenRouterContract } from './router-hidden'
 
+/**
+ * Navigates a nested router structure using a path array, resolving each segment
+ * and handling lazy-loaded routers by wrapping remaining segments in a new lazy loader.
+ *
+ * Returns `undefined` if the path leads through a procedure or a falsy value.
+ */
 export function getRouter<T extends Lazyable<AnyRouter | undefined>>(
   router: T,
   path: readonly string[],
@@ -57,6 +63,10 @@ export type AccessibleLazyRouter<T extends Lazyable<AnyRouter | undefined>>
         [K in keyof T]: T[K] extends Lazyable<AnyRouter> ? AccessibleLazyRouter<T[K]> : never
       }
 
+/**
+ * Creates a proxy around a lazy router that allows property access to transparently
+ * return nested lazy routers, enabling dot-notation traversal without eagerly loading.
+ */
 export function createAccessibleLazyRouter<T extends Lazy<AnyRouter | undefined>>(lazied: T): AccessibleLazyRouter<T> {
   const recursive = new Proxy(lazied, {
     get(target, key) {
@@ -107,6 +117,12 @@ export interface EnhanceRouterOptions<TErrorMap extends ErrorMap> extends Enhanc
   dedupeLeadingMiddlewares: boolean
 }
 
+/**
+ * Recursively enhances a router by applying middlewares, error maps, and route options
+ * to every procedure in the tree. Lazy routers are wrapped so enhancement is deferred
+ * until loading. Non-object primitive values are passed through unchanged to guard
+ * against infinite recursion when router modules export non-router members.
+ */
 export function enhanceRouter<
   T extends Lazyable<AnyRouter>,
   TInitialContext extends Context,
@@ -183,6 +199,11 @@ export interface LazyTraverseContractProceduresOptions {
   path: readonly string[]
 }
 
+/**
+ * Synchronously walks a router tree, invoking {@link callback} for each contract procedure
+ * found and collecting lazy routers for deferred resolution. Non-object primitive values
+ * in the tree are safely skipped.
+ */
 export function traverseContractProcedures(
   options: TraverseContractProceduresOptions,
   callback: (options: TraverseContractProcedureCallbackOptions) => void,
@@ -226,6 +247,11 @@ export function traverseContractProcedures(
   return lazyOptions
 }
 
+/**
+ * Asynchronously resolves all procedures in a router tree, including those behind
+ * lazy loaders. Iteratively unlazies deferred routers and invokes {@link callback}
+ * for every contract procedure discovered.
+ */
 export async function resolveContractProcedures(
   options: TraverseContractProceduresOptions,
   callback: (options: TraverseContractProcedureCallbackOptions) => void,
@@ -253,6 +279,11 @@ export type UnlaziedRouter<T extends AnyRouter>
         [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? UnlaziedRouter<U> : never
       }
 
+/**
+ * Recursively resolves all lazy-loaded components in a router tree, returning a
+ * fully eagerly-loaded copy. Procedures are returned as-is, and non-object primitive
+ * values are passed through to avoid infinite recursion on non-router exports.
+ */
 export async function unlazyRouter<T extends AnyRouter>(router: T): Promise<UnlaziedRouter<T>> {
   if (isProcedure(router)) {
     return router as any