                 (neb/read-lock-exec*
                   next-cid
                   'morpheus.models.edge.base/extract-cid-lists
-                  direction sid vertex-id filters))))))
+                  direction sid vertex-id criteria))))))
 
 (defn get-oppisite [edge vertex-id]
   (let [{:keys [*start* *end*]} edge]

        list-ids (map :list-cid lists)]
    (dorun (map remove-list-chain list-ids))))

(defn extract-cid-lists [direction sid vertex-id filters]
  (with-cid-list
    (let [{:keys [cid-array] :as list-cell} (neb-cell/read-cell trunk hash)]
      (concat [{:cid-array cid-array

                                           types [types])))))
        params (if-not (seq params)
                 (map (fn [d] {:directions [d]}) all-dir-fields)
                 (map (fn [{:keys [type types direction directions criteria]}]
                        {:types (regular-types (or type types))
                         :directions (regular-directions (or direction directions))
                         :criteria criteria})
                      params))
        expand-params (flatten (map (fn [{:keys [directions types criteria]}]
                                      (map
                                        (fn [d]
                                          (if (seq types)
                                            (map (fn [t] {:d d :t (or t :Nil) :c criteria}) types)
                                            {:d d :t nil :c criteria}))
                                        directions))
                                    params))
        params-grouped (group-by :d expand-params)
        direction-fields (->> params-grouped (keys) (set))
        direction-items (map-on-vals
                          (fn [ps]
                            (let [item (set (map (fn [{:keys [t c]}]
                                                   (if t [t c] :Nil))
                                                 ps))]
                              (when-not (item :Nil) item)))
                          params-grouped)
