                            (apply rook/wrap-with-arg-resolvers
                              (mw handler) resolvers)))
                        mw)
-                  #_#_
-                  mw (if schema
-                       (fn [handler]
-                         (wrap-with-schema (mw handler) schema))
-                       mw)
 
                   ef (ensure-fn verb-fn-sym)
                   f  (fn wrapped-handler [request]
-                       (apply ef (resolve-args request))
-                       #_
-                       (let [resolvers (get-in request [:rook :arg-resolvers])
-                             args (map #(internals/extract-argument-value
-                                          % request resolvers)
-                                    arglist)]
-                         (apply ef args)))
+                       (apply ef (resolve-args request)))
                   h  (apply-middleware mw sync? f)
                   h  (fn wrapped-with-rook-metadata [request]
                        (h (-> request

                                 arglist
                                 (resolvers-for arglist (:resolvers metadata))
                                 route-params)

                  #_#_
                  route-param-resolver
                  (if (seq route-params)
                    [(make-route-param-resolver route-params)])

                  mw (get middleware middleware-sym)
                  mw (ensure-fn mw)

              (maybe-resolver-by-tag arg)))
      arglist)))

(defn build-dispatch-map
  "Returns a dispatch-map for use with map-traversal-dispatcher."
  [{:keys [routes handlers middleware]}
