         repl-build   (first (config/narrow-builds* all-builds' build-ids))
         build-ids    (or (not-empty build-ids) [(:id repl-build)]) ;; give a default build-id
         control-fns  (setup-control-fns all-builds' build-ids figwheel-server)
-        special-fns  (into {} (map (fn [[k v]] [k (make-special-fn v)]) control-fns))]
+        special-fns  (into {} (map (fn [[k v]] [k (make-special-fn v)]) control-fns))
+        special-fns  (merge cljs.repl/default-special-fns special-fns)
+        ;; TODO remove this when cljs.repl error catching code makes it to release
+        special-fns  (into {} (map (fn [[k v]] [k (catch-special-fn-errors v)]) special-fns))]
     ((get control-fns 'start-autobuild) build-ids)
     (newline)
     (print "Launching ClojureScript REPL")
     (when-let [id (:id repl-build)] (println " for build:" id))
     (println (repl-function-docs))
     (println "Prompt will show when figwheel connects to your application")
-    ;; it would be cool to switch the repl's build as well is this possible?
+    ;; it would be cool to switch the repl's build as well, is this possible?
     (fig-repl/repl repl-build figwheel-server {:special-fns special-fns})))
 
 (defn autobuild [src-dirs build-options figwheel-options]

   [clojure.pprint :as p]
   [figwheel-sidecar.core :as fig]
   [figwheel-sidecar.repl :as fig-repl]
   [figwheel-sidecar.config :as config]   
   [cljs.analyzer]
   [cljs.env]
   [clj-stacktrace.repl]

                                 :focus-ids  build-ids})
        validate-build-ids (let [bs (set (keep :id all-builds))]
                             (fn [ids]
                               (vec (keep #(if (bs %) % (println "No such build id:" %)) ids))))
        get-ids            (fn [ids]
                             (or (and (empty? ids)
                                      (:focus-ids @state-atom))
                                 (validate-build-ids ids)))
        display-focus-ids (fn [ids]
                            (when (not-empty ids)
                              (println "Focusing on build ids:" (string/join ", " ids))))
        builder-running? #(:autobuilder @state-atom)
        ;; we are going to take an optiona id here
        build-once*     (fn [ids]
                          (let [bs (set (get-ids ids))
                                builds (filter #(bs (:id %)) all-builds)]
                            (display-focus-ids (map :id builds))
                            (mapv auto/build-once builds)))
        clean-build*    (fn [ids]
                          (let [bs (set (get-ids ids))
                                builds (filter #(bs (:id %)) all-builds)]
                            (display-focus-ids (map :id builds))
                            (mapv cbuild/clean-build (map :build-options builds))
                            (println "Deleting ClojureScript compilation target files.")))
        run-autobuilder (fn [figwheel-server build-ids]
                          (when-not (builder-running?)
                            (build-once* build-ids)
                            (binding [*out* log-writer
                                      *err* log-writer]
                              (when-let [abuild (autobuild-ids
                                                 { :all-builds all-builds
                                                   :build-ids build-ids
                                                   :figwheel-server figwheel-server })]
                                (reset! state-atom { :autobuilder abuild
                                                     :focus-ids build-ids})))))
        stop-autobuild*  (fn [_]
