       (go-loop [outs @outs]
         (let [[v [f opts]] (first outs)]
           (when v
-            (let [signal (f state opts)]
+            (let [signal (f _ opts)]
               (if-not (nil? signal)
                 (>! (input-channel v) [id signal])
                 (warn (format "signal fn for %d returned nil, skipping..." (:id v)))))

  [] (Graph. (atom {:vertices {} :next-id 0})))

(defn eager-vertex-processor
  [{:keys [id state] :as vertex} ctx]
  (let [{:keys [collect-thresh signal-thresh]} @ctx
        in   (input-channel vertex)]
    (go-loop []
      (let [[src-id sig] (<! in)]
        (if sig

              (when (should-collect? vertex collect-thresh)
                (notify ctx [:collect id])
                (collect! vertex)
                ;;(debug (format "%d post-collection: %s" id (pr-str @vertex)))
                (when (should-signal? vertex signal-thresh)
                  (notify ctx [:signal id])
                  (signal! vertex)))
              (recur))
          #_(debug (str id " stopped")))))
    vertex))

(defn execution-result
