         [clojure.core.reducers :as r]
         [cljs.core.async :as async :refer [<! >!]])]))
 
+#?(:cljs
+   (when-not (satisfies? IReduce LazyTransformer)
+     (defn- seq-reduce*
+       ([f coll]
+        (if-let [s (seq coll)]
+          (reduce f (first s) (next s))
+          (f)))
+       ([f val coll]
+        (loop [val val, coll (seq coll)]
+          (if coll
+            (let [nval (f val (first coll))]
+              (if (reduced? nval)
+                @nval
+                (recur nval (next coll))))
+            val))))
+
+     (extend-type LazyTransformer
+       IReduce
+       (-reduce
+         ([coll f] (seq-reduce* f coll))
+         ([coll f start] (seq-reduce* f start coll))))))
+
 ;;#?(:clj (taoensso.timbre/set-level! :warn))
 
 ;; (warn :free-ram (.freeMemory (Runtime/getRuntime)))

                (let [grp-size            (max 512 (long (/ (count @active) threads)))
                      [act' sigs' colls'] (scheduler grp-size @active)]
                  ;;(warn :auto (count @queue))
                  (reset! active
                          #?(:clj
                             (into (into #{} v-filter act') @queue)
                             :cljs ;; FIXME CLJS doesn't support reducers on sets
                             (vec (into (into #{} v-filter act') @queue))))
                  (reset! queue #{})
                  (recur (long (+ colls colls')) (long (+ sigs sigs'))))
                (->result :max-ops-reached sigs colls t0))

      (execute!
        [_]
        (let [t0     (now)
              active (atom (sequence v-filter (vertices g)))
              queue  (atom #{})]
          (add-context-watches g watch-id queue)
          (loop [colls 0, sigs 0]
