                              bolts-at)))))))))))
 
 (defn add-bolt-at [top-bolt bolt path bolt-at model depth max-depth truncate? & [take-n]]
-  (lazy-seq
-   (mapfn #(do-defaults % model)
-          (let [comp-paths (find-comp-paths bolt-at)
-                comp-bolts
-                (mapfn #(comp-path-to-bolts bolt-at % model (+ 1 depth) max-depth)
-                       comp-paths)]
-            (log/debug (str "add-bolt-at:" ((:morph-ps model) bolt-at) "; comp-paths: " (string/join "," comp-paths)))
-            (when (not (some empty? comp-bolts))
-              (take take-n
-                    (filter #(not (= :fail %))
-                            (mapfn #(let [assoc (if (empty? path) %
-                                                    (assoc-in bolt path %))]
-                                      assoc)
-                                   (filter (fn [with-comps] (not (nil? with-comps)))
-                                           (add-comps bolt-at
-                                                      model
-                                                      comp-paths
-                                                      comp-bolts
-                                                      (+ 1 depth)
-                                                      max-depth
-                                                      top-bolt
-                                                      truncate?
-                                                      take-n))))))))))
+  (mapfn #(do-defaults % model)
+         (let [comp-paths (find-comp-paths bolt-at)
+               comp-bolts
+               (mapfn #(comp-path-to-bolts bolt-at % model (+ 1 depth) max-depth)
+                      comp-paths)]
+           (log/debug (str "add-bolt-at:" ((:morph-ps model) bolt-at) "; comp-paths: " (string/join "," comp-paths)))
+           (when (not (some empty? comp-bolts))
+             (take take-n
+                   (filter #(not (= :fail %))
+                           (mapfn #(let [assoc (if (empty? path) %
+                                                   (assoc-in bolt path %))]
+                                     assoc)
+                                  (filter (fn [with-comps]
+                                            (do
+                                              (log/debug (str "add-bolt-at: added all comps to bolt: " ((:morph model)
+                                                                                                        with-comps)))
+                                              (not (nil? with-comps))))
+                                          (add-comps bolt-at
+                                                     model
+                                                     comp-paths
+                                                     comp-bolts
+                                                     (+ 1 depth)
+                                                     max-depth
+                                                     top-bolt
+                                                     truncate?
+                                                     take-n)))))))))
 (defn generate
   "Return one (by default) or _n_ (using :take _n_) expressions matching spec _spec_ given the model _model_."
   [spec language-model

                                        
;; during generation, will not decend deeper than this when creating a tree:
;; TODO: should also be possible to override per-language.
(def ^:const max-total-depth 6)

;; TODO support setting max-generated-complements to :unlimited
(def ^:const max-generated-complements 20000)

     (clojure.core/take
      take
      (reduce concat
              (map #(do
                      (log/trace (str "add-bolt-at:" ((:morph-ps language-model) %)))
                      (let [result (filter (fn [x] (not (= :fail x)))
                                           (add-bolt-at % % [] % language-model depth max-depth truncate-children take))]
                        result))
                   (lightning-bolts language-model spec 0 max-total-depth))))
     ((fn [seq]
        (if (= take 1)
          (first seq) ;; if caller only wants one, return just that one, rather than a singleton list.
