 (defn bind! [data path ref binder]
   (close-channel! data path)
   (let [close-chan (chan)
-        fbc (fb->chan ref close-chan)]
+        fbc (fb->chan ref close-chan)
+        cr closer-root
+        bind-fn (fn [data path msg]
+                  (binding [closer-root cr]
+                    (binder data path msg)))]
     (save-channel-closer! data path close-chan)
     (go-loop []
       (when-let [msg (<! fbc)]
-        (binder data path msg)
+        (bind-fn data path msg)
         (recur)))
     close-chan))


(def top-stories (walk-root root [:topstories]))

(defonce channel-closers (atom {}))

(defonce type-chan?

    (fn [x] (= type-chan (type x)))))

(defn- save-channel-closer! [data path channel]
  (let [c-root (if closer-root closer-root data)]
    (swap! channel-closers assoc-in
           (conj (vec (cons c-root path)) :-closer)
           channel)))

(defn- close-channel! [data path]
  (let [c-root (if closer-root closer-root data)
        identifier (cons c-root path)]
    (when-let [closers (get-in @channel-closers identifier)]
      (walk/postwalk (fn [c]
                       (when (type-chan? c)
