               (-> config :node-manager (invoke checkpoint :local) (assert-checkpoint config {})))))
     ))
 
+(defn checkpoint-env
+  [env checkpoint]
+  (let [out-arr (-> checkpoint :out :keys first keyword)
+        err-arr (-> checkpoint :err :keys first keyword)
+        exit-arr (-> checkpoint :exit :keys first keyword)
+        success-arr (-> checkpoint :success :keys first keyword)
+        out (-> checkpoint :out :value)
+        err (-> checkpoint :err :value)
+        exit (-> checkpoint :exit :value)
+        success (-> checkpoint :success :value)]
+    (reduce (fn [env [k v]]
+              (if-not (nil? k)
+                (assoc env k v) env))
+            env
+            [[out-arr (conj (get env out-arr) out)]
+             [(-> checkpoint :out :keys second keyword) out]
+             [err-arr (conj (get env err-arr) err)]
+             [(-> checkpoint :err :keys second keyword) err]
+             [exit-arr (conj (get env exit-arr) exit)]
+             [(-> checkpoint :exit :keys second keyword) exit]
+             [success-arr (conj (get env success-arr) success)]
+             [(-> checkpoint :success :keys second keyword) success]])))
 
 (defn run-module
   [m c]

                   (-> m :requires))
        missing (remove #(-> % second true?)
                        (map (fn [v]
                               [v (or ;; Is it both boolean and true, signifying a default value exists?
                                      (and (bool? v)
                                           (true? v))
                                      ;; Or is it a keyword and found in the current env?
                                      (and (keyword? v)
                                           (not (nil? (-> env v)))))])
                             vars))]
    (if-not (empty? missing)
      ;; If some of the `requires` interfaces are missing, don't bother running it, and
      ;; return nil.
      (throw (AssertionError. (format "Some required inputs are missing for module `%s`.\nMissing: %s\n\n"
                (:name m)
                (into [] (map first missing))
                )))
      #_(log :error
        (format "Some required inputs are missing for module `%s`.\nMissing: %s\n\nEnvironment:\n%s"
                (:name m)
                (into [] (map first missing))
                env))
      ;; All `requires` interfaces exist, so we're a "go."
      ;; Run the checkpoints. Each checkpoint run will return its return code and
      ;; the vars that should be added to the env.

                                          (-> (java.util.Date.) .getTime)))]
                      (log :info (str "Seed: " (.getTime effective)))
                      effective)
          result (run-program (assoc config ;; This timestamp is also intended to be
                                            ;; used (via .getTime) as a seed for any
                                            ;; pseudorandom number generation, so that
                                            ;; randomized testing can be retested as
                                            ;; deterministically as possible.
                                            :effective effective
                                            ;; Instantiate a node manager with an empty
                                            ;; node map as an atom.
                                            ;; Takes a seed.
                                            :node-manager (node-manager effective)
                                            ;; The data connector is for resolving
                                            ;; literal representations of particular
                                            ;; resources. In the future, database
                                            ;; persistence should be supported, with
                                            ;; continued support for file based
                                            ;; configuration, too.
                                            :data-connector data-connector
                                            :genv (or (:genv config) (atom {}))))]
      (log :info (str "Seed: " (.getTime effective)))
