         (cond->>
          (case [(when e :+) (when a :+) (when v :+)]
            [:+  nil nil]
-           (->> (copper/read this [:ea e]) vals (apply concat))
+           (->> (store/read this [:ea e]) vals (apply concat))
            [nil :+  nil]
-           (->> (copper/read this [:av a]) vals (apply concat))
+           (->> (store/read this [:av a]) vals (apply concat))
            [:+  :+  nil]
-           (copper/read this [:ea e a])
+           (store/read this [:ea e a])
            [nil :+  :+]
-           (copper/read this [:av a v])
+           (store/read this [:av a v])
            [:+  :+  :+]
-           (->> (copper/read this [:ea e a])
+           (->> (store/read this [:ea e a])
                 (filter #(= v (.-v %)))))
          tx    (filter #(= tx (.-tx %)))
          added (filter #(= added (.-added %)))))
 
-      copper/IListen
+      store/IListen
       (-listen! [_ component path]
-        (copper/listen! db component path))
+        (store/listen! db component [path]))
       
-      copper/IRemoveDep
-      (-remove-dep! [_ component path]
-        (-remove-dep! db component path))
+      store/IRemoveDep
+      (-remove-dep! [_ component [path]]
+        (store/remove-dep! db component path))
       
-      copper/IReadable
-      (-read [this path]
-        (core/listen! this core/*component* path)
+      store/IReadable
+      (-read [this [path]]
+        (store/listen! this core/*component* path)
         (get-in @db path))
 
-      core/ITransact
-      (-transact! [_ datom _]
+      store/ITransact
+      (-transact! [_ [datom]]
         (swap! db update-in edit-queue (fn [datoms]
-                                         (core/add-to [] datoms {:datom path}))))
-
-      core/ICommit
+                                         (core/add-to [] datoms datom))))
+
+      store/ICommit
       (-commit [_]
         (swap! db (fn [state]
                     (let [edits (get-in state edit-queue)
-                          new-state (reduce (fn [v {:keys [datom]}]
+                          new-state (reduce (fn [v datom]
                                               (transact-datom state datom))
                                             state
                                             edits)]

                          (assoc-in last-edits edits)
                          (assoc-in edit-queue nil))))))

      core/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
      (-dirty? [_]
        (not (nil? (get-in @db edit-queue)))))))

(defn- update-in-sorted [map path f & args]
  (let [map (if (associative? map) map (sorted-map))

(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]))]
