           (:name m)))))
 
 (defn wrap-funs [fmap]
-  (let [fun-map (if-some [cf (:componentFunction fmap)]
-                  (-> fmap
-                      (assoc :reagentRender cf)
-                      (dissoc :componentFunction))
-                  fmap)
-        render-fun (:reagentRender fun-map)
+  (when (dev?)
+    (let [renders (select-keys fmap [:render :reagentRender :componentFunction])
+          render-fun (-> renders vals first)]
+      (assert (pos? (count renders)) "Missing reagent-render")
+      (assert (== 1 (count renders)) "Too many render functions supplied")
+      (assert (ifn? render-fun) (str "Render must be a function, not "
+                                     (pr-str render-fun)))))
+  (let [render-fun (or (:reagentRender fmap)
+                       (:componentFunction fmap))
         legacy-render (nil? render-fun)
         render-fun (or render-fun
-                       (:render fun-map))
-        _ (assert (ifn? render-fun)
-                  (str "Render must be a function, not "
-                       (pr-str render-fun)))
-        name (str (or (:displayName fun-map)
+                       (:render fmap))
+        name (str (or (:displayName fmap)
                       (fun-name render-fun)))
         name (if (empty? name)
                (str (gensym "reagent"))
-               (clojure.string/replace name #"\$" "."))
-        fmap (-> fun-map
-                 (assoc :cljsLegacyRender legacy-render
-                        :displayName name)
-                 (add-render render-fun name))]
+               (clojure.string/replace name "$" "."))
+        fmap (assoc fmap
+                    :displayName name
+                    :cljsLegacyRender legacy-render
+                    :reagentRender render-fun
+                    :render (:render static-fns))]
     (reduce-kv (fn [m k v]
                  (assoc m k (get-wrapper k v name)))
                {} fmap)))

  (if (dev?)
    (let [c *current-component*
          n (or (component-path c)
                (some-> c (.' cljsName)))]
      (if-not (empty? n)
        (str " (in " n ")")
        ""))

      wrap-funs
      map-to-js))

(defn create-class [body]
  {:pre [(map? body)]}
  (let [spec (cljsify body)
        res (.' js/React createClass spec)]
    (util/cache-react-class res res)
    res))

(defn component-path [c]
  (let [elem (some-> (or (some-> c (.' :_reactInternalInstance))
                          c)
                     (.' :_currentElement))
        name (some-> elem
