 
    This mult/tap magic happens only if the component reifies the `IGotEvent` protocol and, to some
    extend, for `IInitEventBus` protocol as well. For components that don't care about events, overhead is minimal."
-  [this]
+  [this protocols]
   (let [c (om/children this)
         {:keys [xform buf-or-n]} (merge default-config
                                         (when (satisfies? IInitEventBus c)
                                           (init-event-bus c)))
-        catch-all-handler (find-handler c ::all)]
+        catch-all-handler (find-handler c ::all protocols)]
     (impl/with-options {:buf-or-n buf-or-n}
                        (om/set-state! this
                                       ::event-buses
                                       (into {}
                                             (for [[k bus] (om/get-state this ::event-buses)]
-                                              (let [handler (compose-handlers catch-all-handler (find-handler c k))]
+                                              (let [handler (compose-handlers catch-all-handler (find-handler c k protocols))]
                                                 [k (if handler
                                                      (impl/add-fork bus handler xform)
                                                      (impl/add-leg bus xform))])))))))

           value
           options
           out-event-ch
           {::bubbling (impl/event-bus (impl/bubbling-router))})))

(defn root<
  "Use `root>` instead of om.core/root to add support for sending events from parent components to child components only."

           options
           out-event-ch
           {::bubbling (impl/event-bus (impl/bubbling-router))
            ::trickling (impl/event-bus (impl/trickling-router))}
           default-protocols)))

(defn root>
  "Use `root>` instead of om.core/root to add support for sending events from child components to parent components only.
