      (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)]

      (set! (.-change-ks this) [key])
      (swap-fn assoc key val)
      this)
    (resetChild [this child-key new-val]
      (doseq [child (get child-cursors child-key)]
        (.updateCursor child new-val)))
    (notifyKeysetWatches [this removed added]
      (doseq [[key f] keyset-watches]
        (f key this removed added)))
    (updateCursor [this new-state]
      (when-not (identical? state new-state)
        (let [old-state state]
          (set! state new-state)
          (.notifyFWatches this old-state state)
          (if-let [change-ks (.-change-ks this)]
            (let [change-ks (if (keyword? change-ks)
                              [(case change-ks
