        (let [project (get-project* project-name)
              run-state @(project ::run-state)]
          {:body (pprint-str
-                 {:computed-map-url (str (url-for-project project-name)
-                                         "/computed-map")
-                  :repl {:state (if (run-state :repl)
-                                  :started
-                                  :stopped)
-                         :url (str (url-for-project project-name)
-                                   "/repl")}})
+                 (merge (project-summary project)
+                        ;; TODO just include these in the summary?
+                        {:map-url (str (url-for-project project-name)
+                                                "/map")
+                         :raw-map-url (str (url-for-project project-name)
+                                           "/raw-map")
+                         :repl {:state (if (run-state :repl)
+                                         :started
+                                         :stopped)
+                                :url (str (url-for-project project-name)
+                                          "/repl")}}))
           :status 200}))
-  (GET "/api/projects/:project-name/computed-map" [project-name]
-       {:body (pprint-str
-               )})
+  (GET "/api/projects/:project-name/map" [project-name]
+       {:body (pprint-str (get-readable-project project-name))
+        :status 200})
+  (GET "/api/projects/:project-name/raw-map" [project-name]
+       {:body (pprint-str (get-readable-raw-project project-name))
+        :status 200})
   (POST "/api/projects" [root]
         (let [name (load-project! root)]
           {:status 201

(defn start-server [& args] ;; entry point, lein run will pick up and start from here
  (when @server
    (throw (ex-info "Server running!" {})))
  (let [handler (reload/wrap-reload (site #'all-routes))]    
    (reset! server (server/run-server handler {:port 8000}))))

(defn stop-server []


(defonce projects (atom {}))

(defn new-project [project-map raw-project-map]
  (assoc project-map
    ::run-state (atom {})
    ::raw raw-project-map))

(defn get-project* [name]
  (if-let [project (@projects name)]
    project
    (throw (ex-info "Project doesn't exist" {:name name}))))

(defn load-project! [root]
  (let [path (->>  (io/file root "project.clj")
                      (.getAbsolutePath))
        project (project/read path)
        raw-project (project/read-raw path)
        ui-project (new-project project raw-project)
        name (-> ui-project :name)
        root (-> ui-project :root)]
       (swap! projects (fn [ps]
                         (when (ps name)
                           (throw (ex-info (str "Project already loaded")
                                           {:root root})))
                         (assoc ps name
                                ui-project)))
       name))


(defn unload-project! [name]
  (swap! projects dissoc name))

(defn reload-project! [name]
  (let [root (-> (get-project* name) :root)]
    (unload-project! name)
    (load-project! root)))


;; adapated from leiningen.core.eval
(defn- overridden-env
