                              :width           (str (* scale 320) "px")
                              :height          view-h
                              :position        "relative"}}
-               (map (fn [ha i]
-                      (let [trans-count (count (required-transitions ha))
-                            trans-h (/ line-h trans-count)]
-                        [:div
-                         (map (fn [trans j]
-                                (let [[s e] (:interval trans)
-                                      sx (* scale (:x (extrapolate ha s)))
-                                      ex (* scale (:x (extrapolate ha e)))
-                                      line-top (+ (* i line-h) (* j trans-h))]
-                                  [:div {:style {:height        trans-h :width (.abs js/Math (- sx ex))
-                                                 :top           line-top :left (.min js/Math sx ex)
-                                                 :position      "absolute" :backgroundColor "grey"
-                                                 :pointerEvents "none"}}
-                                   [:div {:style {:position        "absolute"
-                                                  :width           "100px"
-                                                  :backgroundColor "rgba(255,255,255,0.5)"
-                                                  :pointerEvents   "none"}}
-                                    (str (:id ha) "-" (:target (:transition trans)))]
-                                   [:div {:style {:height          "100%" :width "2px"
-                                                  :position        "absolute" :left (if (< sx ex) "0%" "100%")
-                                                  :backgroundColor "green"
-                                                  :pointerEvents   "none"}}]
-                                   [:div {:style {:height          "100%" :width "2px"
-                                                  :position        "absolute" :left (if (< sx ex) "100%" "0%")
-                                                  :backgroundColor "red"
-                                                  :pointerEvents   "none"}}]]))
-                              (transition-intervals (:objects @scene)
-                                                    ha
-                                                    Infinity
-                                                    (required-transitions ha))
-                              (range 0 trans-count))]))
-                    (map #(extrapolate % (:now @scene)) (vals (:objects @scene)))
-                    (range 0 ct))
+               (when show-transition-thresholds
+                 (map (fn [ha i]
+                       (let [trans-count (count (required-transitions ha))
+                             trans-h (/ line-h trans-count)]
+                         [:div
+                          (map (fn [trans j]
+                                 (let [[s e] (:interval trans)
+                                       sx (* scale (:x (extrapolate ha s)))
+                                       ex (* scale (:x (extrapolate ha e)))
+                                       line-top (+ (* i line-h) (* j trans-h))]
+                                   [:div {:style {:height        trans-h :width (.abs js/Math (- sx ex))
+                                                  :top           line-top :left (.min js/Math sx ex)
+                                                  :position      "absolute" :backgroundColor "grey"
+                                                  :pointerEvents "none"}}
+                                    [:div {:style {:position        "absolute"
+                                                   :width           "100px"
+                                                   :backgroundColor "rgba(255,255,255,0.5)"
+                                                   :pointerEvents   "none"}}
+                                     (str (:id ha) "-" (:target (:transition trans)))]
+                                    [:div {:style {:height          "100%" :width "2px"
+                                                   :position        "absolute" :left (if (< sx ex) "0%" "100%")
+                                                   :backgroundColor "green"
+                                                   :pointerEvents   "none"}}]
+                                    [:div {:style {:height          "100%" :width "2px"
+                                                   :position        "absolute" :left (if (< sx ex) "100%" "0%")
+                                                   :backgroundColor "red"
+                                                   :pointerEvents   "none"}}]]))
+                               (transition-intervals (:objects @scene)
+                                                     ha
+                                                     Infinity
+                                                     (required-transitions ha))
+                               (range 0 trans-count))]))
+                     (map #(extrapolate % (:now @scene)) (vals (:objects @scene)))
+                     (range 0 ct)))
                (map (fn [[x y w h]]
                       [:div {:style {:width           (str (* scale w) "px") :height (str (* scale h) "px")
                                      :backgroundColor "white"

                :lt :gt))
        ; t REL rhs
        entry-time (:entry-time ha)
        ;_ (println (:id ha) simple-guard "et" entry-time "push up" time-unit rhs "to" (+ entry-time time-unit) (+ entry-time rhs) "sat?" sat)
        min-t (+ entry-time time-unit)
        rhs (+ entry-time rhs)]
    (assert (not (nil? v10))

                                                                    ha
                                                                    Infinity
                                                                    (required-transitions ha)))
        _ (assert (>= (first (:interval req)) now) "Can't transition until later than entry time")

        ; calculate intervals when optional guards will be satisfied up to and including the upcoming required guard, if any
        opts (transition-intervals has
                                   ha
