   "Caches on endpoints.  Sends the current sum to a new subscriber,
   continues with deltas."
   [service]
-  (cached-service service (fn [cache v]
-                            (update (or cache [:is]) 1
-                                    delta/add v))))
+  (cached-service service {:accumulate
+                           (fn [cache v]
+                             #_(println ["Hybrid cache processing"
+                                         [cache v]])
+                             (update (or cache [:is]) 1
+                                     delta/add v))}))
 
 (defn compscriber
   [service]

                [m :as cache]
                (or (get subs identifier)
                    (let [ch-in (chan)
                          m (caching-mult ch-in accumulate)]
                      (subscribe (caching service this)
                                 identifier
                                 ch-in)
                      [m 0 ch-in]))
                target-step (wrap-on-close target
                                           #(cancel this target))]
            (println ["cache subscribing" identifier])
            (tap m target-step)
            (recur (assoc subs identifier (update cache 1 inc))
                   (assoc chs target [identifier target-step])))

          (unsubs-fn))))))

(defn- caching-mult
  [ch {:keys [accumulate
              mode]
       :or {mode :value}}]
  (let [tap-ch (chan)
        chs (atom #{})
        dctr (atom nil)
