     (let [validated (validate storage ::existing-transaction transaction)]
       (if (validation/has-error? validated)
         validated
-        (let [dereferenced-base-items (process-removals
+        (let [existing (find-by-id storage (:id validation) (:transaction-date validated))
+              dereferenced-items (remove (fn [{validated-item-id :id}]
+                                           (some #(= validated-item-id
+                                                     (:id existing-item))
+                                                 (:items validated)))
+                                         (:items existing))
+              dereferenced-base-items (map #())
+              updated (update-transaction storage validated)
+              ])
+        )
+
+        #_(let [dereferenced-base-items (process-removals
                                         storage
                                         validated)
               upserted-items (->> (:items validated)

                                    (concat upserted-items
                                            dereferenced-base-items)
                                    (:transaction-date validated))
          (reload storage validated))))))

(defn- get-preceding-items
  "Returns the items that precede each item in the

                                          {:transaction-id id
                                           :transaction-date transaction-date}
                                          {:sort [[:action :desc] [:amount :desc]]})
                (mapv after-item-read)))))

(defn- append-lot-items
  [transaction storage]
