   (step (assoc state :spec (get-in spec [:args :pred-form])) succ fail))
 
 (defn- normalize [{:keys [spec path val in]}]
-  (let [spec' (resolve-spec spec)
+  (let [spec' (conformed-spec spec)
         state {:spec spec'
                :path (vec path)
                :val val

              ret
              (step state
                    (fn [state' fail]
                      (let [state' (normalize state')]
                        #(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- parse-spec [spec]
  (let [result (s/conform ::specs/spec (s/form spec))]
    (if (= result ::s/invalid)
      ::s/invalid
      (let [[kind spec] result]
        spec))))

(defn- conformed-spec [spec]
  (let [spec' (if (keyword? spec)
                (parse-spec spec)
                spec)]
    (assert (not= spec' ::s/invalid)
            (str "spec macro " spec " must have its own spec definition"))
    spec'))

(defn step [{:keys [spec] :as state} succ fail]
  (let [spec (conformed-spec spec)
        state (assoc state :spec spec)]
    (if (or (set? spec) (symbol? spec) (keyword? spec))
      (succ state fail)
      (step* state succ fail))))

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