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

        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)

          (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))))
                ]
            (fn [data child resource url built-url]


    :type :relator}

   :paragraph
   {:resource (fn [uri binding active url meta vals]
                (hic/html [:p {:data-uri uri
                       :data-binding binding
                       :data-description (:description meta)}
