               ret
               (step state
                     (fn [state' fail]
-                      (let [state' (normalize state')]
+                      (let [state' (-> state'
+                                       (update :spec second)
+                                       normalize)]
                         #(rec state' fail (conj ret state'))))
                     (fn [] fail))))]
     (let [state (normalize {:spec spec :path path :val value :in in})]

                  " must have its own method implementation for spectrace.trace/step*")
             {:spec spec})))

(defn- resolve-spec [spec]
  (cond-> spec
    (keyword? spec) s/form))

(defn step [{:keys [spec] :as state} succ fail]
  (let [spec (resolve-spec spec)]
    (if (symbol? spec)
      (succ (assoc state :spec spec) fail)
      (let [spec' (s/conform ::specs/spec-form spec)]
        (assert (not= spec' ::s/invalid)
                (str "spec macro " spec
                     " must have its own spec definition"))
        (step* (assoc state :spec spec') succ fail)))))

(defn- with-cont [succ fail ret]
  (if ret

  (step (assoc state :spec (get-in spec [:args :pred-form])) succ fail))

(defn- normalize [{:keys [spec path val in]}]
  (let [spec' (conformed-spec spec)
        state {:spec spec'
               :path (vec path)
               :val val
