   "Passes on n events every m seconds. Drops events when necessary."
   [n m & children]
   (part-time-fast m
-    (fn [] (ref 0))
-    (fn [sent event]
+    (fn setup [] (ref 0))
+    (fn add [sent event]
       (when-not (dosync (< n (alter sent inc)))
         (call-rescue event children)))
-    (fn [sent start end])))
+    (fn finish [sent start end])))
 
 (defn rollup
   "Invokes children with events at most n times per dt second interval. Passes

        children (if (map? options)
                   (rest children)
                   children)]
    (fn [event]
      (when
        (dosync
          (let [cur (pred event)

  ([interval default-event & children]
   (let [fill (bound-fn fill []
                (call-rescue (assoc default-event :time (unix-time)) children))
         new-deferrable (fn new-deferrable [] (every! interval
                                                      interval
                                                      fill))
         deferrable (ref (new-deferrable))]
    (fn stream [event]
      (let [d (deref deferrable)]
        (if d
          ; We have an active deferrable
