         sub-calls (map (fn [child] (s-rec child model url-parts)) children) ;; make the next part of the tree
         meta-data (get-meta-data binding model)]
 
-    (cond (= type :relator)
-          (let [statement (get-bound binding model) ;; fuckery for binding
-                relation-getter (fn [data resource] (relator statement data resource))
-                child-func (:value bindable)
-                parent-func (:resource bindable)] ;; extraneous function getting]
-            (fn [data child resource url built-url]
-
-              (let [related (if child   ;; get sub-resources (a single one if partial rendering)
-                              (seq [child])
-                              (relation-getter data resource))
-                    func (if child ;; get the bound function
-                           (fn [uri bind meta vals]
-                             (let [val (first vals)]
-                               (child-func
-                                uri (:uri val) bind meta (:html val))))
-                           (fn [uri bind meta vals]
-                             (parent-func
-                              uri bind meta
-                              (map (fn [val] (child-func
-                                             uri (:uri val) bind meta (:html val))) vals))))
-                    vals (map (fn [val] {:uri (first val) :html (second val)})
-                           (map vector
-                                (map #(.toString %) related) ;; TODO this is a little sketchy
-                                (if (empty? sub-calls)
-                                  (map literalize related)
-                                  (map seq (apply map vector (map (fn [sub-call]
-                                                                    (map
-                                                                     (fn [val]
-                                                                       (sub-call data nil val url built-url))
-                                                                     related))
-                                                                  sub-calls))))))]
-
-                (func (.getURI resource) ;; apply the bound function to the thing, the binding that points at the funtion, meta-data, and the finished children (should be ordered by now).
-                      (.getURI binding)
-                      meta-data
-                      vals))))
-          (= type :projector)
+    (cond
+          (= type :relator)
 
           (let [statement (get-bound binding model) ;; fuckery for binding
                 relation-getter (fn [data resource] (relator statement data resource))
                 child-func (:value bindable)
                 parent-func (:resource bindable)
-                mypath (.getString (.asLiteral (first (relate-right model (prop (:path db)) binding))))
+                myp (first (relate-right model (prop (:path db)) binding))
+                mypath (and myp (.getString (.asLiteral myp)))
                 ]
             (fn [data child resource url built-url]
 

    :value (fn [parent uri binding meta val]
             uri)
    :update nil
    :type :projector}
   :column8
   {:display (fn [meta vals]
               (hic/html [:div.span8 vals]))

    :type :relator}

   :deleter
   {:resource (fn [uri binding active url meta vals]
                (hic/html [:a.remove-binding
                                 {:href "#"
                                  :data-uri uri
