                               (aput multi-change res-ch (merge res-m res)))
                             (aput multi-change res-ch (merge res-m {:status :ok})))
                        [(assoc-in state [:kvss (:name kvs)] next-kvs) nil]))]
-       (act multi-change-start actx
-         (aput multi-change-start state-ch
-               [(kvs-ident-check (:kvs-ident m) work-fn) nil]))))
+       (kvs-do actx state-ch m nil
+               (kvs-checker (:kvs-ident m) work-fn))))
 
    :scan-keys
    (make-scan-fn :keys :key kc-entry-by-key-sq)


   :sync
   (fn [actx state-ch m]
     (state-work actx state-ch m
                 (kvs-ident-check (:kvs-ident m)
                                  (fn [state kvs]
                                    [(assoc-in state [:kvss (:name kvs)]
                                               (-> kvs
                                                   (assoc :clean (:dirty kvs))
                                                   (assoc :dirty (make-kc))))
                                     {:status :ok :status-info :synced}]))))})

(defn make-kvs-mgr [actx & op-handlers-in & {:keys [cmd-ch state-ch]}]
  (let [cmd-ch (or cmd-ch (achan actx))

(defn kc-entry-by-key [kc key]
  (kc-entry-by-key-sq kc key (kc-sq-by-key kc key)))

(defn make-kvs [name uuid]
  {:name name
   :uuid uuid
   :clean (make-kc) ; Read-only.
   :dirty (make-kc) ; Mutations go here, until "persisted / made durable".
   :next-sq 1})

(defn kvs-checker [kvs-ident work-fn]
  (fn [state] ; Returns wrapper fn to check if kvs-ident is current.
    (if-let [[name uuid] kvs-ident]
      (if-let [kvs (get-in state [:kvss name])]
        (if (= uuid (:uuid kvs))
