   :args (s/cat :env (s/keys :req [::data-bank])
                :resolver (s/keys :req [::p.connect/input])
                :in-data (s/map-of keyword? set?))
-  :ret (s/coll-of (s/map-of keyword? any?)))
+  :ret (s/coll-of (s/map-of ::p.connect/attribute any?)))
 
 (defn test-resolver
   "Test a resolver."
   ([{::keys [data-bank] :as env} {::p.connect/keys [sym] :as resolver}]
    (let [db      @data-bank
          in-data (discover-data env resolver)]
-     (if (some (fn [[_ v]] (= v ::unreachable)) in-data)
+     (print-trace env "discovered input" sym (pr-str in-data))
+     (if (some ::error (vals in-data))
        (log! env resolver {:in in-data :out ::unreachable})
        (if-let [input' (->> (input-list env resolver in-data)
                             (remove (get-in db [::call-history sym] {}))

     (:import (java.util Date))))

(s/def ::values set?)
(s/def ::data-bank (s/map-of keyword? ::values))
(s/def ::call-history (s/map-of symbol? ::data-bank))
(s/def ::calls (s/coll-of map? :kind set?))
(s/def ::log (s/tuple inst? symbol? map? map?))
(s/def ::call-log (s/coll-of ::log :kind vector?))
(s/def ::multi-args (s/coll-of ::p.connect/attributes-set :kind set?))

(declare test-resolver discover-data)

(defn add-subsets [{::keys [multi-args] :as a} b]
  (let [b-keys (set (keys b))]

  (let [db @data-bank]
    (or (get db attr)
        (if (contains? (::unreachable db) attr)
          {::error ::unreachable}
          (seek-attr env attr)))))

(defn discover-data
