                    (generate-all (get-in bolt path) model
                                  (+ 1 depth) max-depth))
         lexemes-before-phrases
-        (lexemes-before-phrases depth max-depth)]
+        (or true (lexemes-before-phrases depth max-depth))]
     (if (not (nil? bolts-at)) (log/info (str "realized? of bolts-at:" (realized? bolts-at))))
     (cond (nil? bolts-at)
           (lazy-seq lexemes)

     ;; for each such map in each bolt, find all possible combinations of complements, taking one complement per path.
     ;; the result is a trellis for each bolt, and a path through this trellis is one complement for each complement position.
     (map (fn [each-bolt-and-comps]
            (map (fn [each-path-through-trellis]
                   (zipmap (keys each-bolt-and-comps)
                           each-path-through-trellis))
                 (apply combo/cartesian-product (vals each-bolt-and-comps)))))

     (mapcat (fn [bolt-group]
               (->> bolt-group
                    (map (fn [bolt-and-comps]
                           (let [bolt (get bolt-and-comps [])
                                 paths-and-comps (dissoc bolt-and-comps [])
                                 paths (keys paths-and-comps)]
                             (apply unify
                                    (cons bolt
                                          (map (fn [path]
                                                 (let [result (assoc-in bolt path (get paths-and-comps path))]
                                                   (if (= true truncate)
                                                     (dissoc-paths result [path])
                                                     result)))
                                               paths)))))))))
     (map #(do-defaults % model)))))

(defn generate
  "Return one (by default) or _n_ (using :take _n_) expressions matching spec _spec_ given the model _model_."

  (log/info (str "comp-paths-to-complements: bolt:" ((:morph-ps model) bolt)))
  (into {}
        (map (fn [path]
               [path (comp-path-to-complements bolt path model depth max-depth)])
             (find-comp-paths bolt))))

(defn comp-path-to-complements
