 
                :dependencies
                (->>
-                   (for [m modules
-                         :let [mkey #(if (keyword? %) (make-key (:module m) %)
-                                         (apply make-key %))]
-
-                         [k v] (:dependencies m)
-                         [n v] (ensure-map v)
-                         ]
-                     [(mkey k) [n (mkey v)]])
-                 ;; This call to 'first' should actually check to ensure
-                 ;; there aren't multiple entries, if there are it means
-                 ;; we have a conflict - more than one dependency is trying to bind
-                 (gbf #(into {} (gbf first %)))
-                 (into {})
-                 )
+                (for [m modules
+                      :let [mkey #(if (keyword? %) (make-key (:module m) %)
+                                      (apply make-key %))]
+
+                      [k v] (:dependencies m)
+                      [n v] (ensure-map v)
+                      ]
+                  [(mkey k) [n (mkey v)]])
+                ;; This call to 'first' should actually check to ensure
+                ;; there aren't multiple entries, if there are it means
+                ;; we have a conflict - more than one dependency is trying to bind
+                (gbf #(into {} (gbf first %)))
+                (into {})
+                )
 
                :co-dependencies
                (->>
-                   (for [m modules
-                         :let [mkey #(if (keyword? %) (make-key (:module m) %)
-                                         (apply make-key %))]
-
-                         [k v] (:co-dependencies m)
-                         [n v] (ensure-map v)
-                         ]
-                     [(mkey k) [n (mkey v)]])
-                 ;; This call to 'first' should actually check to ensure
-                 ;; there aren't multiple entries, if there are it means
-                 ;; we have a conflict - more than one dependency is trying to bind
-                 (gbf #(into {} (gbf first %)))
-                 (into {}))
+                (for [m modules
+                      :let [mkey #(if (keyword? %) (make-key (:module m) %)
+                                      (apply make-key %))]
+
+                      [k v] (:co-dependencies m)
+                      [n v] (ensure-map v)
+                      ]
+                  [(mkey k) [n (mkey v)]])
+                ;; This call to 'first' should actually check to ensure
+                ;; there aren't multiple entries, if there are it means
+                ;; we have a conflict - more than one dependency is trying to bind
+                (gbf #(into {} (gbf first %)))
+                (into {}))
 
                :files (concat (get-in manifest [:application-templates app-template :files] [])
                               (mapcat :files modules))}]

  ([name app-template & args]

   (let [augment-by (->> args
                      (keep (partial re-matches #"\+(.*)") )
                      (map second)    ; take the grouping
                      (map #(split % #"/"))
                      (map (partial apply keyword))
                      set)

         diminish-by (->> args
                       (keep (partial re-matches #"\-(.*)") )
                       (map second)   ; take the grouping
                       (map #(split % #"/"))
                       (map (partial apply keyword))
                       set)

         manifest (load-manifest (io/resource "manifest.edn") name)


               ;; these can be resolved later
               :library-dependencies
               (->>
                (for [module modules
                      ;; this conj ensures module-level library dependencies are included
                      c (conj (:components module) module)
                      dep (:library-dependencies c)]
                  dep)
                sort distinct)

               :refers
               (->>
                (for [module modules
                      c (:components module)
                      refer (:refers c)]
                  refer)
                sort distinct
                (group-by (comp symbol namespace))
                (reduce-kv
                 (fn [a k v] (conj a {:namespace k
                                      :refers (apply str (interpose " " (distinct (map (comp clojure.core/name) v))))}))
                 []))

               :dev-refers
               (->>
                (for [module modules
                      refer (:dev-refers module)]
                  refer)
                sort distinct
                (group-by (comp symbol namespace))
                (reduce-kv
                 (fn [a k v] (conj a {:namespace k
                                      :refers (apply str (interpose " " (distinct (map (comp clojure.core/name) v))))}))
                 []))

               :dev-snippets
               (apply str
