strict contract when implement

packages/server/src/router-implementer.ts

@@ -1,10 +1,14 @@
 import type { ContractRouter } from '@orpc/contract'
 import type { ConflictContextGuard, Context, TypeCurrentContext, TypeInitialContext } from './context'
+import type { FlattenLazy } from './lazy'
 import type { Middleware } from './middleware'
-import type { Router } from './router'
-import { flatLazy, type FlattenLazy, lazy } from './lazy'
+import type { Router, RouterToContract } from './router'
+import { flatLazy, lazy } from './lazy'
 import { type UnshiftedMiddlewaresRouter, unshiftMiddlewaresRouter } from './router-utils'
 
+export type EqualContractGuard<TContract extends ContractRouter<any>, TRouter extends Router<any, TContract>> =
+  TContract extends RouterToContract<TRouter> ? unknown : never
+
 export interface RouterImplementerDef<
   TInitialContext extends Context,
   TCurrentContext extends Context,
@@ -48,13 +52,15 @@ export class RouterImplementer<
 
   router<U extends Router<TCurrentContext, TContract>>(
     router: U,
-  ): UnshiftedMiddlewaresRouter<U, TInitialContext> {
-    return unshiftMiddlewaresRouter(router, this['~orpc'])
+  ): EqualContractGuard<TContract, U> & UnshiftedMiddlewaresRouter<U, TInitialContext> {
+    const applied = unshiftMiddlewaresRouter(router, this['~orpc'])
+    return applied as typeof applied & EqualContractGuard<TContract, U>
   }
 
   lazy<U extends Router<TCurrentContext, TContract>>(
     loader: () => Promise<{ default: U }>,
-  ): UnshiftedMiddlewaresRouter<FlattenLazy<U>, TInitialContext> {
-    return unshiftMiddlewaresRouter(flatLazy(lazy(loader)), this['~orpc'])
+  ): EqualContractGuard<TContract, U> & UnshiftedMiddlewaresRouter<FlattenLazy<U>, TInitialContext> {
+    const applied = unshiftMiddlewaresRouter(flatLazy(lazy(loader)), this['~orpc'])
+    return applied as typeof applied & EqualContractGuard<TContract, U>
   }
 }

packages/server/src/router.ts

@@ -16,6 +16,15 @@ export type Router<
       }
 >
 
+export type RouterToContract<T extends Router<any, any>> =
+  T extends Lazy<infer U extends Router<any, any>>
+    ? RouterToContract<U>
+    : T extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, any, infer UErrorMap, infer URoute>
+      ? ContractProcedure<UInputSchema, UOutputSchema, UErrorMap, URoute>
+      : {
+          [K in keyof T]: T[K] extends Router<any, any> ? RouterToContract<T[K]> : never
+        }
+
 export type ANY_ROUTER = Router<any, any>
 
 export type InferRouterInputs<T extends ANY_ROUTER> =