      (set! (.-register-dep-fn reactive) (make-register-dep reactive))
      reactive)))
 
-(defn- keyset [coll]
+(defn coll-keyset [coll]
   (cond (map? coll)
         (keys coll)
 

                        (when descendant-ks
                          (set! (.-change-ks cur) descendant-ks))
                        (.updateCursor cur new-val))
                      ;; check for key set change
                      ))))
              (set! (.-change-key this) nil))
            (cond keyset-watches
                  (let [old-keys (keyset old-state)
                        new-keys (keyset state)
                        [removed added both] (diff-set (set old-keys) (set new-keys))]
                    (when (or (not (empty? removed)) (not (empty? added)))
                      ;; notify key set change
                      )
                    (doseq [rx removed]
                      (.notifyChild rx nil))
                    (doseq [ra added]
                      (.notifyChild ra (get state ra)))
                    (doseq [rc both]
                      (when-let [cursors (get child-cursors rc)]
                        (when-let [cur (first cursors)]

                          new-val (get state ckey)]
                      (when-not (identical? old-val new-val)
                        (doseq [cur cursors]
                          (.updateCursor cur new-val))))))))))
    (rawDeref [this]
      (when (.-dirty this)
        (.updateCursor this (get-fn)))
