             parents (filter #(not (fail? %)) (map (fn [rule] (unifyc spec rule)) grammar))]
         (let [lexical ;; 1. generate list of all phrases where the head child of each parent is a lexeme.
               (reduce concat
-                      (pmap (fn [parent]
+                      (map (fn [parent]
                               (if (= false (get-in parent [:head :phrasal] false))
                                 (let [candidate-lexemes (get-lex parent :head index spec)]
                                   (over/overh parent
-                                              (map copy (lazy-shuffle candidate-lexemes))))))
+                                              (map copy (take 1 (lazy-shuffle candidate-lexemes)))))))
                             parents))
               phrasal ;; 2. generate list of all phrases where the head child of each parent is itself a phrase.
               (if (< depth max-total-depth)
-                (reduce concat (pmap (fn [parent]
+                (reduce concat (map (fn [parent]
                                        (over/overh parent (lightning-bolt grammar lexicon (get-in parent [:head])
                                                                           (+ 1 depth) index morph (+ 1 total-depth))))
                                      parents)))]
           (if (lexemes-before-phrases total-depth)
-            (lazy-cat lexical phrasal)
-            (lazy-cat phrasal lexical)))))))
+            (take 1 (lazy-cat lexical phrasal))
+            (take 1 (lazy-cat phrasal lexical))))))))
 
 (defn add-complement [bolt path spec grammar lexicon cache morph depth total-depth]
   (log/info (str "add-complement: " (show-bolt bolt path morph)))

                       phrasal-complements (if (> max-total-depth total-depth)
                                             (generate-all spec grammar lexicon cache morph (+ depth total-depth)))]
                   (if (lexemes-before-phrases total-depth)
                     (lazy-cat shuffled-candidate-lexical-complements phrasal-complements)
                     (lazy-cat phrasal-complements shuffled-candidate-lexical-complements)))))))

(defn path-to-map [path val]
  (let [feat (first path)]

    (log/info (str "using grammar of size: " (count grammar)))
    (log/info (str "using index of size: " (count index)))
    (if (seq? spec)
      #?(:clj (map generate-all spec grammar lexicon index morph))
      #?(:cljs (map generate-all spec grammar lexicon index morph))
      (generate spec grammar
                (flatten (vals lexicon))
