                           (assoc-in last-edits edits)
                           (assoc-in edit-queue nil))))))
 
-      core/INotificationSource
+      store/INotificationSource
       (-notify-deps [_]
         (let [edits (get-in @db last-edits)
-              dep-graph (get-in @db deps)]
-          (notify-updates (map :path edits) dep-graph)))
-
-      core/IDirty
+              dep-graph (get-in @db deps)
+              ea-paths (map (fn [datom] [:ea (:e datom) (:a datom)]) edits)
+              av-paths (map (fn [datom] [:ea (:a datom) (:v datom)]) edits)]
+          (bs/notify-updates (concat ea-paths av-paths) dep-graph)))
+
+      store/IDirty
       (-dirty? [_]
-        (not (nil? (get-in @db edit-queue)))))))
+        (store/dirty? db)))))
 
 (defn- update-in-sorted [map path f & args]
   (let [map (if (associative? map) map (sorted-map))

        (cond->>
         (case [(when e :+) (when a :+) (when v :+)]
           [:+  nil nil]
           (->> (copper/read this [:ea e]) vals (apply concat))
           [nil :+  nil]
           (->> (copper/read this [:av a]) vals (apply concat))
           [:+  :+  nil]
           (copper/read this [:ea e a])
           [nil :+  :+]
           (copper/read this [:av a v])
           [:+  :+  :+]
           (->> (copper/read this [:ea e a])
                (filter #(= v (.-v %)))))
         tx    (filter #(= tx (.-tx %)))
         added (filter #(= added (.-added %)))))

      copper/IListen
      (-listen! [_ component path]
        (copper/listen! db component path))
      
      copper/IRemoveDep
      (-remove-dep! [_ component path]
        (-remove-dep! db component path))
      
      copper/IReadable
      (-read [this path]
        (core/listen! this core/*component* path)
        (get-in @db path))

      core/ITransact
      (-transact! [_ datom _]
        (swap! db update-in edit-queue (fn [datoms]
                                         (core/add-to [] datoms {:datom path}))))

      core/ICommit
      (-commit [_]
        (swap! db (fn [state]
                    (let [edits (get-in state edit-queue)
                          new-state (reduce (fn [v {:keys [datom]}]
                                              (transact-datom state datom))
                                            state
                                            edits)]

(defn- op->datoms [db [op e a v] tx]
  (case op
    :db/add
      (if (= :many (store/read db [:schema a :cardinality]))
        (when (empty? (-search db [e a v]))
          [(datom e a v tx true)])
        (if-let [old-datom (first (-search db [e a]))]
