 
         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)
-        myp (first (relate-right model (prop (:path db)) binding))
+        myp (first (relate-right model (prop (bind :path)) binding))
         mypath (if myp (.getString (.asLiteral myp)))]
 
     (cond
-     (contains? types (db :relator))
+     (contains? types (bind :container))
+     (fn [data child resource url built-url]
+            (let [ppath (if path (.getString (.asLiteral path)))
+                  p (get (parse-uri url) ppath)
+                  projected (if (and p (res p))
+                              (if (.containsResource data (res p))
+                                (res p)))
+
+                  current (if mypath (get (parse-uri url) mypath))
+
+                  active (if mypath (= current (.getURI resource)))
+                  built-url (or (if mypath (str built-url mypath "/" (.getURI resource) "/")) built-url)]
+
+              (if ppath
+                (if projected
+                  (func
+                   (.getURI resource)
+                   (.getURI binding)
+                   active
+                   built-url
+                   meta-data
+                   (map (fn [sub-call] (sub-call data nil projected url (str built-url ppath "/" (.getURI resource) "/"))) sub-calls))
+                  "")
+                (func
+                 (.getURI resource)
+                 (.getURI binding)
+                 active
+                 built-url
+                 meta-data
+                 (map (fn [sub-call] (sub-call data nil resource url built-url)) sub-calls))
+                )))
+     (contains? types (bind :relator))
 
      (let [statement (get-bound binding model) ;; fuckery for binding
            relation-getter (fn [data resource] (relator statement data resource))]


(defn qbuild [inf uri]
  (let [root (.asResource (.getObject (.getProperty inf
                                                        (res (:root db))
                                                        (prop (:haschild db)))))
        init (qb root inf uri)

        numbered (loop [loc (z/vector-zip (flatten-seq init))

          predicate (.asResource (.getObject statement))
          pred (.getURI predicate)
          resource (res uri)
          reverse (= binder (bind :object))
          command (commander uri pred data type)
          update (query-builder command reverse)]
      (doall (map (fn [up]
