 
 (defn async
   [source]
-  (let [topic (gen-topic)]
+  (let [topic source]
     (map->Signal {:init (:init source)
                   :event-emitter [source (fn [message]
                                            (when (fresh? message)
-                                             (->Event topic (:value message))))]
-                  :message-emitter [:events (event-relay topic)]})))
+                                             (:value message)))]
+                  :subscribed-topics #{topic}})))
 
 (defn mergeseq
   [sigs]

  (fresh? [_] false))

(defprotocol SignalProtocol
  (sources [s]))

(defn signal?
  [x]
  (satisfies? SignalProtocol x))

(defrecord Signal
  [init message-emitter event-emitter]
  SignalProtocol
  (sources [_]
    (into #{}
          (comp (filter identity)
                (mapcat (comp flatten vector first))
                (filter signal?))
          [message-emitter event-emitter])))

(defn- event-relay
  [topic]
  (fn [prev event]
    (if (= topic (:topic event))


(defn- build-message-mult
  [signal mult-map]
  (if-let [[tmpl msg-fn] (message-emitter signal)]
    (let [c-in (tap-template tmpl mult-map)
          c-out (chan)]
      (spawn-message-loop! (:init signal) msg-fn c-in c-out)
