diff --git a/java/src/datahike/java/Datahike.java b/java/src/datahike/java/Datahike.java
index 7648a342f..a732600ea 100644
--- a/java/src/datahike/java/Datahike.java
+++ b/java/src/datahike/java/Datahike.java
@@ -50,6 +50,7 @@ public class Datahike {
     private static final IFn schemaFn = Clojure.var("datahike.api", "schema");
     private static final IFn reverseSchemaFn = Clojure.var("datahike.api", "reverse-schema");
     private static final IFn metricsFn = Clojure.var("datahike.api", "metrics");
+    private static final IFn gcStorageFn = Clojure.var("datahike.api", "gc-storage");
 
     /**
      * Forbids instances creation.
@@ -365,4 +366,23 @@ public static APersistentMap reverseSchema(Object db) {
     public static APersistentMap metrics(Object db) {
         return (APersistentMap)metricsFn.invoke(db);
     }
+
+    /**
+     * Perform garbage collection on the database
+     *
+     * @param db a database
+     */
+    public static Object gcStorage(Object db) {
+        return gcStorageFn.invoke(db);
+    }
+
+    /**
+     * Perform garbage collection on the database
+     *
+     * @param db a database
+     * @param removeBefore a date
+     */
+    public static Object gcStorage(Object db, Date removeBefore) {
+        return gcStorageFn.invoke(db, removeBefore);
+    }
 }
diff --git a/java/src/datahike/java/DatahikeTest.java b/java/src/datahike/java/DatahikeTest.java
index f86105759..7d89987a0 100644
--- a/java/src/datahike/java/DatahikeTest.java
+++ b/java/src/datahike/java/DatahikeTest.java
@@ -251,6 +251,15 @@ public void dbWith() {
         assertTrue(res.size() == 3);
     }
 
+    /* TODO: This requires a durable backend */
+    // @Test
+    // public void gcStorage() {
+    //     APersistentMap config = config();
+    //     Datahike.createDatabase(config);
+    //     Object conn = Datahike.connect(config);
+    //     Set<UUID> res = (Set<UUID>)deref(Datahike.gcStorage(conn));
+    //     assertTrue(res.size() == 0);
+    // }
 
     /**
      * Called by Datahike's Clojure tests and runs the above Junit tests.
diff --git a/libdatahike/src/datahike/impl/LibDatahike.java b/libdatahike/src/datahike/impl/LibDatahike.java
index bc273c213..e1c4c2461 100644
--- a/libdatahike/src/datahike/impl/LibDatahike.java
+++ b/libdatahike/src/datahike/impl/LibDatahike.java
@@ -279,6 +279,20 @@ public static void metrics(@CEntryPoint.IsolateThreadContext long isolateId,
         }
     }
 
+    @CEntryPoint(name = "gc_storage")
+    public static void gc_storage(@CEntryPoint.IsolateThreadContext long isolateId,
+                                 @CConst CCharPointer db_config,
+                                 long before_tx_unix_time_ms,
+                                 @CConst CCharPointer output_format,
+                                 @CConst OutputReader output_reader) {
+        try {
+            Object db = Datahike.connect(readConfig(db_config));
+            output_reader.call(toOutput(output_format, Datahike.gcStorage(db, new Date(before_tx_unix_time_ms))));
+        } catch (Exception e) {
+            output_reader.call(toException(e));
+        }
+    }
+
     // seekdatoms not supported yet because we would always realize the iterator until the end
 
     // release we do not expose connection objects yet, but create them internally on the fly
diff --git a/src/datahike/api/specification.cljc b/src/datahike/api/specification.cljc
index 932577562..a6186f804 100644
--- a/src/datahike/api/specification.cljc
+++ b/src/datahike/api/specification.cljc
@@ -1,7 +1,9 @@
 (ns datahike.api.specification
   "Shared specification for different bindings. This namespace holds all
   information such that individual bindings can be automatically derived from
-  it.")
+  it."
+  (:require [clojure.spec.alpha :as s]
+            [datahike.spec :as spec]))
 
 (defn ->url
   "Turns an API endpoint name into a URL."
@@ -850,7 +852,16 @@ Returns the key under which this listener is registered. See also [[unlisten]]."
      :doc  "Returns database metrics."
      :impl datahike.db/metrics
      :supports-remote? true
-     :referentially-transparent? true}})
+     :referentially-transparent? true}
 
-(comment
-  (map (fn [[k v]] [k (:impl v)]) api-specification))
+    gc-storage
+    {:args             (s/alt :with-date (s/cat :conn spec/SConnection :remove-before spec/time-point?)
+                              :no-date (s/cat :conn spec/SConnection))
+     :ret              set?
+     :doc "Invokes garbage collection on the store of connection by whitelisting currently known branches.
+All db snapshots on these branches before remove-before date will also be
+erased (defaults to beginning of time [no erasure]). The branch heads will
+always be retained. Return the set of removed blobs from the store."
+     :impl datahike.writer/gc-storage!
+     :supports-remote? true
+     :referentially-transparent? false}})
diff --git a/src/datahike/cli.clj b/src/datahike/cli.clj
index f92708421..8e8b82b25 100644
--- a/src/datahike/cli.clj
+++ b/src/datahike/cli.clj
@@ -257,4 +257,8 @@
 
         :metrics
         (let [out (d/metrics (load-input (first arguments)))]
-          (report (:format options) out))))))
+          (report (:format options) out))
+
+        :gc-storage
+        (let [out (d/gc-storage (load-input (first arguments)) (load-input (second arguments)))]
+          (report (:format options) out))))))
\ No newline at end of file
diff --git a/src/datahike/config.cljc b/src/datahike/config.cljc
index b782fab67..ad1c413d0 100644
--- a/src/datahike/config.cljc
+++ b/src/datahike/config.cljc
@@ -9,6 +9,11 @@
             [datahike.index :as di])
   (:import [java.net URI]))
 
+;; global
+(def ^:dynamic *schema-meta-cache-size* (env :schema-meta-cache-size 1024))
+(def ^:dynamic *schema-write-cache-max-db-count* (env :schema-write-cache-size 1024))
+
+;; per database
 (def ^:dynamic *default-index* :datahike.index/persistent-set)
 (def ^:dynamic *default-schema-flexibility* :write)
 (def ^:dynamic *default-keep-history?* true)
diff --git a/src/datahike/experimental/versioning.cljc b/src/datahike/experimental/versioning.cljc
index 0c1bd156b..3b539123f 100644
--- a/src/datahike/experimental/versioning.cljc
+++ b/src/datahike/experimental/versioning.cljc
@@ -94,11 +94,12 @@
   (parent-check parents)
   (let [store (:store db)
         cid (create-commit-id db)
-        db (db->stored (-> db
-                           (assoc-in [:config :branch] branch)
-                           (assoc-in [:meta :datahike/parents] parents)
-                           (assoc-in [:meta :datahike/commit-id] cid))
-                       true)]
+        [_schema-meta-op db] (db->stored (-> db
+                                             (assoc-in [:config :branch] branch)
+                                             (assoc-in [:meta :datahike/parents] parents)
+                                             (assoc-in [:meta :datahike/commit-id] cid))
+                                         true
+                                         true)]
     (flush-pending-writes store true)
     (k/update store :branches #(conj % branch) {:sync? true})
     (k/assoc store cid db {:sync? true})
diff --git a/src/datahike/experimental/gc.cljc b/src/datahike/gc.cljc
similarity index 83%
rename from src/datahike/experimental/gc.cljc
rename to src/datahike/gc.cljc
index e6331b9f3..2791df98e 100644
--- a/src/datahike/experimental/gc.cljc
+++ b/src/datahike/gc.cljc
@@ -1,11 +1,12 @@
-(ns datahike.experimental.gc
+(ns datahike.gc
   (:require [clojure.set :as set]
             [datahike.index.interface :refer [-mark]]
             [konserve.core :as k]
             [konserve.gc :refer [sweep!]]
             [taoensso.timbre :refer [debug trace]]
             [superv.async :refer [<? S go-try <<?]]
-            [clojure.core.async  :as async])
+            [clojure.core.async  :as async]
+            [datahike.schema-cache :as sc])
   (:import [java.util Date]))
 
 ;; meta-data does not get passed in macros
@@ -22,7 +23,8 @@
                 (if (visited to-check) ;; skip
                   (recur r visited reachable)
                   (let [{:keys                         [eavt-key avet-key aevt-key
-                                                        temporal-eavt-key temporal-avet-key temporal-aevt-key]
+                                                        temporal-eavt-key temporal-avet-key temporal-aevt-key
+                                                        schema-meta-key]
                          {:keys [datahike/parents
                                  datahike/created-at
                                  datahike/updated-at]} :meta}
@@ -32,6 +34,7 @@
                     (recur (concat r (when in-range? parents))
                            (conj visited to-check)
                            (set/union reachable #{to-check}
+                                      (when schema-meta-key #{schema-meta-key})
                                       (-mark eavt-key)
                                       (-mark aevt-key)
                                       (-mark avet-key)
@@ -42,24 +45,25 @@
                                          (-mark temporal-avet-key)))))))
                 reachable)))))
 
-(defn gc!
+(defn gc-storage!
   "Invokes garbage collection on the database by whitelisting currently known branches.
   All db snapshots on these branches before remove-before date will also be
   erased (defaults to beginning of time [no erasure]). The branch heads will
   always be retained."
-  ([db] (gc! db (Date.)))
+  ([db] (gc-storage! db (Date. 0)))
   ([db remove-before]
    (go-try S
            (let [now (Date.)
                  _ (debug "starting gc" now)
                  {:keys [config store]} db
+                 _ (sc/clear-write-cache (:store config)) ; Clear the schema write cache for this store
                  branches (<? S (k/get store :branches))
-                 _ (trace "retaining branches" branches)
+                 _ (trace  "retaining branches" branches)
                  reachable (->> branches
                                 (map #(reachable-in-branch store % remove-before config))
                                 async/merge
                                 (<<? S)
                                 (apply set/union))
                  reachable (conj reachable :branches)]
-             (trace "gc reached: " reachable)
+             (trace  "gc reached: " reachable)
              (<? S (sweep! store reachable now))))))
diff --git a/src/datahike/schema_cache.cljc b/src/datahike/schema_cache.cljc
new file mode 100644
index 000000000..234d1385d
--- /dev/null
+++ b/src/datahike/schema_cache.cljc
@@ -0,0 +1,41 @@
+(ns datahike.schema-cache
+  (:require [clojure.core.cache.wrapped :as cw]
+            [datahike.config :as dc]
+            [datahike.store :as ds]))
+
+;; Shared schema read cache across all stores
+(def schema-meta-cache (cw/lru-cache-factory {} :threshold dc/*schema-meta-cache-size*))
+
+;; LRU cache of LRU caches for write operations, one per store
+(def schema-write-caches
+  (cw/lru-cache-factory {} :threshold dc/*schema-write-cache-max-db-count*))
+
+(defn- get-or-create-write-cache [store-config]
+  (let [store-id (ds/store-identity store-config)]
+    (if (cw/has? schema-write-caches store-id)
+      (cw/lookup schema-write-caches store-id)
+      (let [new-cache (cw/lru-cache-factory {} :threshold dc/*schema-meta-cache-size*)]
+        (cw/miss schema-write-caches store-id new-cache)
+        new-cache))))
+
+(defn cache-has? [schema-meta-key]
+  (cw/has? schema-meta-cache schema-meta-key))
+
+(defn cache-lookup [schema-meta-key]
+  (cw/lookup schema-meta-cache schema-meta-key))
+
+(defn cache-miss [schema-meta-key schema-meta]
+  (cw/miss schema-meta-cache schema-meta-key schema-meta))
+
+(defn write-cache-has? [store-config schema-meta-key]
+  (let [write-cache (get-or-create-write-cache store-config)]
+    (cw/has? write-cache schema-meta-key)))
+
+(defn add-to-write-cache [store-config schema-meta-key]
+  (let [write-cache (get-or-create-write-cache store-config)]
+    (cw/miss write-cache schema-meta-key true)))
+
+(defn clear-write-cache [store-config]
+  (let [store-id (ds/store-identity store-config)]
+    (cw/evict schema-write-caches store-id)))
+
diff --git a/src/datahike/writer.cljc b/src/datahike/writer.cljc
index 5cfc59ba6..b0a14742d 100644
--- a/src/datahike/writer.cljc
+++ b/src/datahike/writer.cljc
@@ -3,9 +3,13 @@
             [taoensso.timbre :as log]
             [datahike.core]
             [datahike.writing :as w]
+            [datahike.gc :as gc]
             [datahike.tools :as dt :refer [throwable-promise get-time-ms]]
             [clojure.core.async :refer [chan close! promise-chan put! go go-loop <! >! poll! buffer timeout]])
-  (:import [clojure.lang ExceptionInfo]))
+  (:import [clojure.core.async.impl.channels ManyToManyChannel]))
+
+(defn chan? [x]
+  (instance? ManyToManyChannel x))
 
 (defprotocol PWriter
   (-dispatch! [_ arg-map] "Returns a channel that resolves when the transaction finalizes.")
@@ -28,6 +32,7 @@
 
 ;; minimum wait time between commits in ms
 ;; this reduces write pressure on the storage
+;; at the cost of higher latency
 (def ^:const DEFAULT_COMMIT_WAIT_TIME 0) ;; in ms
 
 (defn create-thread
@@ -53,10 +58,9 @@
                         (log/warn "Transaction queue buffer more than 90% full, "
                                   (count transaction-queue-buffer) "of" transaction-queue-size  " filled."
                                   "Reduce transaction frequency."))
-                      (let [old (if-not (= (:max-tx old) (:max-tx @(:wrapped-atom connection)))
-                                  (do
-                                    (log/warn "DEPRECATED. Connection was changed outside of writer.")
-                                    (assoc old :max-tx (:max-tx @(:wrapped-atom connection))))
+                      (let [;; TODO remove this after import is ported to writer API
+                            old (if-not (= (:max-tx old) (:max-tx @(:wrapped-atom connection)))
+                                  (assoc old :max-tx (:max-tx @(:wrapped-atom connection)))
                                   old)
 
                             op-fn (write-fn-map op)
@@ -77,16 +81,23 @@
                                                         :error      e})
                                               e))
                                       :error))]
-                        (if-not (= res :error)
-                          (do
-                            (when (> (count commit-queue-buffer) (/ commit-queue-size 2))
-                              (log/warn "Commit queue buffer more than 50% full, "
-                                        (count commit-queue-buffer) "of" commit-queue-size  " filled."
-                                        "Throttling transaction processing. Reduce transaction frequency and check your storage throughput.")
-                              (<! (timeout 50)))
-                            (put! commit-queue [res callback])
-                            (recur (:db-after res)))
-                          (recur old))))
+                        (cond (chan? res)
+                              ;; async op, run in parallel in background, no sequential commit handling needed
+                              (do
+                                (go (>! callback (<! res)))
+                                (recur old))
+
+                              (not= res :error)
+                              (do
+                                (when (> (count commit-queue-buffer) (/ commit-queue-size 2))
+                                  (log/warn "Commit queue buffer more than 50% full, "
+                                            (count commit-queue-buffer) "of" commit-queue-size  " filled."
+                                            "Throttling transaction processing. Reduce transaction frequency and check your storage throughput.")
+                                  (<! (timeout 50)))
+                                (put! commit-queue [res callback])
+                                (recur (:db-after res)))
+                              :else
+                              (recur old))))
                     (do
                       (close! commit-queue)
                       (log/debug "Writer thread gracefully closed")))))
@@ -121,10 +132,11 @@
                         (<! (timeout commit-wait-time))
                         (recur (<?- commit-queue)))))))))]))
 
-;; public API
-
+;; public API to internal mapping
 (def default-write-fn-map {'transact!     w/transact!
-                           'load-entities w/load-entities})
+                           'load-entities w/load-entities
+                           ;; async operations that run in background
+                           'gc-storage!   gc/gc-storage!})
 
 (defmulti create-writer
   (fn [writer-config _]
@@ -199,3 +211,13 @@
                                       :args [entities]}))]
         (deliver p tx-report)))
     p))
+
+(defn gc-storage! [conn & args]
+  (let [p (throwable-promise)
+        writer (:writer @(:wrapped-atom conn))]
+    (go
+      (let [result (<! (dispatch! writer
+                                  {:op 'gc-storage!
+                                   :args (vec args)}))]
+        (deliver p result)))
+    p))
\ No newline at end of file
diff --git a/src/datahike/writing.cljc b/src/datahike/writing.cljc
index 799bc5ba4..7fa0a731d 100644
--- a/src/datahike/writing.cljc
+++ b/src/datahike/writing.cljc
@@ -8,20 +8,19 @@
             [datahike.tools :as dt]
             [datahike.core :as core]
             [datahike.config :as dc]
+            [datahike.schema-cache :as sc]
             [konserve.core :as k]
             [taoensso.timbre :as log]
             [hasch.core :refer [uuid]]
             [superv.async :refer [go-try- <?-]]
             [clojure.core.async :refer [poll!]]
-            [konserve.utils :refer [async+sync *default-sync-translation*]]
-            [taoensso.timbre :as t]))
+            [konserve.utils :refer [async+sync *default-sync-translation*]]))
 
 ;; mapping to storage
 
 (defn stored-db? [obj]
   ;; TODO use proper schema to match?
-  (let [keys-to-check [:eavt-key :aevt-key :avet-key :schema :rschema
-                       :system-entities :ident-ref-map :ref-ident-map :config
+  (let [keys-to-check [:eavt-key :aevt-key :avet-key :config
                        :max-tx :max-eid :op-count :hash :meta]]
     (= (count (select-keys obj keys-to-check))
        (count keys-to-check))))
@@ -48,7 +47,7 @@
 
 (defn db->stored
   "Maps memory db to storage layout and flushes dirty indices."
-  [db flush?]
+  [db flush? sync?]
   (when-not (dbu/db? db)
     (dt/raise "Argument is not a database."
               {:type     :argument-is-not-a-db
@@ -56,28 +55,36 @@
   (let [{:keys [eavt aevt avet temporal-eavt temporal-aevt temporal-avet
                 schema rschema system-entities ident-ref-map ref-ident-map config
                 max-tx max-eid op-count hash meta store]} db
+        schema-meta {:schema schema
+                     :rschema rschema
+                     :system-entities system-entities
+                     :ident-ref-map ident-ref-map
+                     :ref-ident-map ref-ident-map}
+        schema-meta-key (uuid schema-meta)
         backend                                           (di/konserve-backend (:index config) store)
         not-in-memory?                                    (not= :mem (-> config :store :backend))
-        flush! (and flush? not-in-memory?)]
-    (merge
-     {:schema          schema
-      :rschema         rschema
-      :system-entities system-entities
-      :ident-ref-map   ident-ref-map
-      :ref-ident-map   ref-ident-map
-      :config          config
-      :meta            meta
-      :hash            hash
-      :max-tx          max-tx
-      :max-eid         max-eid
-      :op-count        op-count
-      :eavt-key        (cond-> eavt flush! (di/-flush backend))
-      :aevt-key        (cond-> aevt flush! (di/-flush backend))
-      :avet-key        (cond-> avet flush! (di/-flush backend))}
-     (when (:keep-history? config)
-       {:temporal-eavt-key (cond-> temporal-eavt flush! (di/-flush backend))
-        :temporal-aevt-key (cond-> temporal-aevt flush! (di/-flush backend))
-        :temporal-avet-key (cond-> temporal-avet flush! (di/-flush backend))}))))
+        flush! (and flush? not-in-memory?)
+        schema-meta-op (when-not (sc/write-cache-has? (:store config) schema-meta-key)
+                         (sc/add-to-write-cache (:store config) schema-meta-key)
+                         (k/assoc store schema-meta-key schema-meta {:sync? sync?}))]
+    (when-not (sc/cache-has? schema-meta-key)
+      (sc/cache-miss schema-meta-key schema-meta))
+    [schema-meta-op
+     (merge
+      {:schema-meta-key  schema-meta-key
+       :config          config
+       :meta            meta
+       :hash            hash
+       :max-tx          max-tx
+       :max-eid         max-eid
+       :op-count        op-count
+       :eavt-key        (cond-> eavt flush! (di/-flush backend))
+       :aevt-key        (cond-> aevt flush! (di/-flush backend))
+       :avet-key        (cond-> avet flush! (di/-flush backend))}
+      (when (:keep-history? config)
+        {:temporal-eavt-key (cond-> temporal-eavt flush! (di/-flush backend))
+         :temporal-aevt-key (cond-> temporal-aevt flush! (di/-flush backend))
+         :temporal-avet-key (cond-> temporal-avet flush! (di/-flush backend))}))]))
 
 (defn stored->db
   "Constructs in-memory db instance from stored map value."
@@ -85,28 +92,35 @@
   (let [{:keys [eavt-key aevt-key avet-key
                 temporal-eavt-key temporal-aevt-key temporal-avet-key
                 schema rschema system-entities ref-ident-map ident-ref-map
-                config max-tx max-eid op-count hash meta]
+                config max-tx max-eid op-count hash meta schema-meta-key]
          :or   {op-count 0}} stored-db
-        empty              (db/empty-db nil config store)]
-    (assoc empty
-           :max-tx max-tx
-           :max-eid max-eid
-           :config config
-           :meta meta
-           :schema schema
-           :hash hash
-           :op-count op-count
-           :eavt eavt-key
-           :aevt aevt-key
-           :avet avet-key
-           :temporal-eavt temporal-eavt-key
-           :temporal-aevt temporal-aevt-key
-           :temporal-avet temporal-avet-key
-           :rschema rschema
-           :system-entities system-entities
-           :ident-ref-map ident-ref-map
-           :ref-ident-map ref-ident-map
-           :store store)))
+        schema-meta (or (sc/cache-lookup schema-meta-key)
+                        ;; not in store in case we load an old db where the schema meta data was inline
+                        (when-let [schema-meta (k/get store schema-meta-key nil {:sync? true})]
+                          (sc/cache-miss schema-meta-key schema-meta)
+                          schema-meta))
+        empty       (db/empty-db nil config store)]
+    (merge
+     (assoc empty
+            :max-tx max-tx
+            :max-eid max-eid
+            :config config
+            :meta meta
+            :schema schema
+            :hash hash
+            :op-count op-count
+            :eavt eavt-key
+            :aevt aevt-key
+            :avet avet-key
+            :temporal-eavt temporal-eavt-key
+            :temporal-aevt temporal-aevt-key
+            :temporal-avet temporal-avet-key
+            :rschema rschema
+            :system-entities system-entities
+            :ident-ref-map ident-ref-map
+            :ref-ident-map ref-ident-map
+            :store store)
+     schema-meta)))
 
 (defn branch-heads-as-commits [store parents]
   (set (doall (for [p parents]
@@ -140,10 +154,12 @@
                       db            (-> db
                                         (assoc-in [:meta :datahike/commit-id] cid)
                                         (assoc-in [:meta :datahike/parents] parents))
-                      db-to-store   (db->stored db true)
+                      [schema-meta-op db-to-store]   (db->stored db true sync?)
                       _             (<?- (flush-pending-writes store sync?))
                       commit-log-op (k/assoc store cid db-to-store {:sync? sync?})
                       branch-op     (k/assoc store (:branch config) db-to-store {:sync? sync?})]
+                      ;; now wait for all the writes to complete
+                  (when (and schema-meta-op (not sync?)) (<?- schema-meta-op))
                   (<?- commit-log-op)
                   (<?- branch-op)
                   db)))))
@@ -202,15 +218,17 @@
           backend (di/konserve-backend (:index config) store)
           cid (create-commit-id db)
           meta (assoc meta :datahike/commit-id cid)
-          db-to-store (merge {:schema          schema
-                              :max-tx          max-tx
+          schema-meta {:schema schema
+                       :rschema rschema
+                       :system-entities system-entities
+                       :ident-ref-map ident-ref-map
+                       :ref-ident-map ref-ident-map}
+          schema-meta-key (uuid schema-meta)
+          db-to-store (merge {:max-tx          max-tx
                               :max-eid         max-eid
                               :op-count        op-count
                               :hash            hash
-                              :rschema         rschema
-                              :system-entities system-entities
-                              :ident-ref-map   ident-ref-map
-                              :ref-ident-map   ref-ident-map
+                              :schema-meta-key schema-meta-key
                               :config          (update config :initial-tx (comp not empty?))
                               :meta            meta
                               :eavt-key        (di/-flush eavt backend)
@@ -220,6 +238,11 @@
                                {:temporal-eavt-key (di/-flush temporal-eavt backend)
                                 :temporal-aevt-key (di/-flush temporal-aevt backend)
                                 :temporal-avet-key (di/-flush temporal-avet backend)}))]
+      ;;we just created the first data base in this store, so the write cache is empty
+      (k/assoc store schema-meta-key schema-meta {:sync? true})
+      (sc/add-to-write-cache (:store config) schema-meta-key)
+      (when-not (sc/cache-has? schema-meta-key)
+        (sc/cache-miss schema-meta-key schema-meta))
       (flush-pending-writes store true)
       (k/assoc store :branches #{:db} {:sync? true})
       (k/assoc store cid db-to-store {:sync? true})
@@ -233,6 +256,7 @@
           active-conns (filter (fn [[store-id _branch]]
                                  (= store-id config-store-id))
                                (keys @*connections*))]
+      (sc/clear-write-cache (:store config))
       (doseq [conn active-conns]
         (log/warn "Deleting database without releasing all connections first: " conn "."
                   "All connections will be released now, but this cannot be ensured for remote readers.")
@@ -263,10 +287,10 @@
    (-database-exists? config)))
 
 (defn transact! [old {:keys [tx-data tx-meta]}]
-  (log/debug "Transacting" (count tx-data) " objects with meta: " tx-meta)
-  (log/trace "Transaction data" tx-data)
+  (log/debug "Transacting" (count tx-data) "objects")
+  (log/trace "Transaction data" tx-data  "with meta:" tx-meta)
   (complete-db-update old (core/with old tx-data tx-meta)))
 
 (defn load-entities [old entities]
   (log/debug "Loading" (count entities) " entities.")
-  (complete-db-update old (core/load-entities-with old entities nil)))
+  (complete-db-update old (core/load-entities-with old entities nil)))
\ No newline at end of file
diff --git a/test/datahike/test/gc_test.cljc b/test/datahike/test/gc_test.cljc
index 06ee52f84..694ebfb22 100644
--- a/test/datahike/test/gc_test.cljc
+++ b/test/datahike/test/gc_test.cljc
@@ -6,7 +6,6 @@
    [superv.async :refer [<?? S]]
    [datahike.api :as d]
    [datahike.index.interface :refer [-mark]]
-   [datahike.experimental.gc :refer [gc!]]
    [datahike.experimental.versioning :refer [branch! delete-branch! merge!
                                              branch-history]]
    [konserve.core :as k]
@@ -41,16 +40,16 @@
                (d/connect cfg))
           ;; everything will fit into the root nodes of each index here
         num-roots 3
-        fresh-count (+ num-roots 3) ;; :branches + :db + cid + roots
+        fresh-count (+ num-roots 4) ;; :branches + :db + cid + roots + schema-meta
         history-count 3]
     (testing "Test initial store counts."
       (is (= 1 (count (-mark (:eavt @conn)))))
       (is (= fresh-count (count-store @conn)))
       (d/transact conn schema)
       (is (= 1 (count (-mark (:eavt @conn)))))
-      (is (= (+ 1 history-count fresh-count num-roots) (count-store @conn))))
+      (is (= (+ 2 history-count fresh-count num-roots) (count-store @conn))))
     (testing "Delete old db with roots."
-      (is (= (+ num-roots 1) (count (<?? S (gc! @conn (Date.))))))
+      (is (= (+ num-roots 2) (count (<?? S (d/gc-storage conn (Date.))))))
       (is (= (+ history-count fresh-count) (count-store @conn))))
     (testing "Try to run on dirty index and fail."
       (is (thrown-with-msg? Throwable #"Index needs to be properly flushed before marking."
@@ -62,7 +61,7 @@
     (testing "Check that we can still read the data."
       (let [new-conn (d/connect cfg)]
         (d/transact conn txs)
-        (<?? S (gc! @conn (Date.)))
+        (<?? S (d/gc-storage conn (Date.)))
         (is (= 1000 (d/q count-query @new-conn)))
         (d/release new-conn)))
     (d/release conn)))
@@ -84,12 +83,12 @@
     (testing "Check branches."
       (d/transact conn-branch1 txs)
       (d/transact conn-branch2 txs)
-      (<?? S (gc! @conn (Date.)))
+      (<?? S (d/gc-storage conn (Date.)))
       (is (nil? (d/q count-query @conn)))
       (is (= 1000 (d/q count-query @conn-branch1)))
       (is (= 1000 (d/q count-query @conn-branch2)))
       (delete-branch! conn :branch2)
-      (<?? S (gc! @conn (Date.))))
+      (<?? S (d/gc-storage conn (Date.))))
 
     (d/release conn)
     (d/release conn-branch1)
@@ -148,7 +147,7 @@
                                                (.getTime remove-before))))
                                         (concat db-history branch1-history)))
           ;; gc
-          _                (<?? S (gc! @conn remove-before))
+          _                (<?? S (d/gc-storage conn remove-before))
           history-after-gc (set (<?? S (branch-history conn)))]
       (testing "Check that newer db roots are still there and counts after gc."
         (is (set/subset? new-history history-after-gc))