diff --git a/README.org b/README.org
index b5da303..d06866b 100644
--- a/README.org
+++ b/README.org
@@ -197,7 +197,8 @@ Usage:
 
 #+BEGIN_SRC clojure
   (ns test-db
-    (:require [konserve.memory :refer [connect-fs-store]]
+    (:require [#?(:clj  konserve.filestore
+                  :cljs konserve.node-filestore) :refer [connect-fs-store]]
               [konserve.core :as k]))
 
   (def my-folder "path/to/folder")
@@ -210,18 +211,17 @@ Usage:
     :END:
 
 [[https://developer.mozilla.org/en-US/docs/IndexedDB][IndexedDB]] is provided as reference implementation for
-ClojureScript browser backends.
+ClojureScript browser backends. The IndexedDB store is restricted to the async api only.
 
 Usage:
 
 #+BEGIN_SRC clojure
   (ns test-db
-    (:require [konserve.memory :refer [connect-idb-store]]
-              [konserve.core :as k])
-    (:require-macros [cljs.core.async.macros :refer [go]]))
+    (:require [clojure.core.async :refer [go]]
+              [konserve.indexeddb :refer [connect-idb-store]]
+              [konserve.core :as k]))
 
-  (def dbname "example-db")
-  (go (def my-db (<! (connect-idb-store dbname))))
+  (go (def my-idb-store (<! (connect-idb-store "example-db"))))
 #+END_SRC
 
 *** External Backends
diff --git a/bin/install b/bin/install
new file mode 100755
index 0000000..d015ba2
--- /dev/null
+++ b/bin/install
@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+
+set -o errexit
+set -o pipefail
+
+npm install
+npm install karma
+npm install karma-cljs-test
+npm install karma-chrome-launcher
diff --git a/bin/kaocha b/bin/kaocha
deleted file mode 100755
index 30ff6d7..0000000
--- a/bin/kaocha
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-
-clojure -M:test -m kaocha.runner "$@"
diff --git a/bin/run-all b/bin/run-all
index 4c549c8..4c8d363 100755
--- a/bin/run-all
+++ b/bin/run-all
@@ -3,9 +3,9 @@
 set -o errexit
 set -o pipefail
 
-./bin/run-cljstests
+./bin/run-jvm-tests
 
 echo
 echo
 
-./bin/run-unittests
+./bin/run-cljs-tests
diff --git a/bin/run-cljs-tests b/bin/run-cljs-tests
new file mode 100755
index 0000000..b6ca8a6
--- /dev/null
+++ b/bin/run-cljs-tests
@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+
+set -o errexit
+set -o pipefail
+
+echo "Running tests for node"
+rm out/node-tests.js
+shadow-cljs release node-tests
+node out/node-tests.js
+
+echo
+echo
+
+echo "Running tests for browser"
+rm target/*.js target/*.map
+shadow-cljs release ci
+karma start --single-run
diff --git a/bin/run-cljstests b/bin/run-cljstests
deleted file mode 100755
index dd3cc6e..0000000
--- a/bin/run-cljstests
+++ /dev/null
@@ -1,19 +0,0 @@
-#!/usr/bin/env bash
-
-set -o errexit
-set -o pipefail
-
-echo "Running tests for node"
-# olical version:
-clojure -M:run-cljs-tests
-# kaocha version:
-#[ -d "node_modules/ws" ] || npm install ws
-#clojure -M:test:cljs -m kaocha.runner unit-node
-
-echo
-echo
-
-echo "Running tests for browser"
-# kaocha version:
-clojure -M:test:cljs -m kaocha.runner unit-browser
-# olical version requires karma
diff --git a/bin/run-jvm-tests b/bin/run-jvm-tests
new file mode 100755
index 0000000..790af09
--- /dev/null
+++ b/bin/run-jvm-tests
@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+
+echo "Running JVM tests"
+
+TIMBRE_LEVEL=':warn' clojure -X:test
diff --git a/bin/run-unittests b/bin/run-unittests
deleted file mode 100755
index 7978b84..0000000
--- a/bin/run-unittests
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-
-echo "Running unittests"
-
-TIMBRE_LEVEL=':warn' clojure -M:test -m kaocha.runner unit
diff --git a/deps.edn b/deps.edn
index c82abed..9890f3b 100644
--- a/deps.edn
+++ b/deps.edn
@@ -9,32 +9,25 @@
         org.lz4/lz4-java {:mvn/version "1.8.0"}
         com.taoensso/timbre {:mvn/version "6.0.1"}
         ;; cljs
-        com.github.pkpkpk/cljs-node-io {:mvn/version "2.0.332"}
-        fress/fress {:mvn/version "0.4.0"}
+        com.github.pkpkpk/cljs-node-io {:mvn/version "2.0.339"}
+        com.github.pkpkpk/fress {:mvn/version "0.4.312"}
         org.clojars.mmb90/cljs-cache {:mvn/version "0.1.4"}}
- :aliases {:cljs {:extra-deps {org.clojure/clojurescript {:mvn/version "1.11.60"}
-                               thheller/shadow-cljs {:mvn/version "2.22.0"}
-                               binaryage/devtools {:mvn/version "1.0.6"}}
-                  :extra-paths ["test"]}
-           :dev {:extra-deps {criterium/criterium {:mvn/version "0.4.6"}
+ :aliases {:dev {:extra-deps {criterium/criterium {:mvn/version "0.4.6"}
                               metasoarous/oz {:mvn/version "2.0.0-alpha5"}
                               org.clojure/tools.cli {:mvn/version "1.0.214"}}
-                 :extra-paths ["benchmark/src"]}
+                 :extra-paths ["benchmark/src" "test"]}
+           :cljs {:extra-deps {org.clojure/clojurescript {:mvn/version "1.11.60"}
+                               thheller/shadow-cljs {:mvn/version "2.26.0"}}
+                  :extra-paths ["test"]}
            :benchmark {:extra-deps {metasoarous/oz {:mvn/version "2.0.0-alpha5"}
                                     org.clojure/tools.cli {:mvn/version "1.0.214"}}
                        :extra-paths ["benchmark/src"]
                        :main-opts ["-m" "benchmark.core"]}
-           :test {:extra-deps {lambdaisland/kaocha {:mvn/version "1.80.1274"}
-                               lambdaisland/kaocha-cljs {:mvn/version "1.4.130"}
-                               org.clojure/test.check {:mvn/version "1.1.1"}}
-                  :extra-paths ["test"]
-                  :main-opts ["-e" "(set! *warn-on-reflection* true)"]} 
-           :run-cljs-tests {:extra-deps {olical/cljs-test-runner {:mvn/version "3.8.0"}}
-                            :extra-paths ["test"]
-                            :main-opts ["-m" "cljs-test-runner.main" 
-                                        "-o" "target/cljs" 
-                                        "--exclude" "browser" 
-                                        "--env" "node"]}
+           :test {:extra-paths ["test"]
+                  :extra-deps {io.github.cognitect-labs/test-runner
+                               {:git/tag "v0.5.1" :git/sha "dfb30dd"}}
+                  :main-opts ["-m" "cognitect.test-runner"]
+                  :exec-fn cognitect.test-runner.api/test}
            :build  {:deps {io.github.clojure/tools.build          {:mvn/version "0.9.3"}
                            slipset/deps-deploy                    {:mvn/version "0.2.0"}
                            io.github.borkdude/gh-release-artifact {:git/sha "b946558225a7839f6a0f644834e838e190dc2262"}
@@ -46,7 +39,7 @@
                     :main-opts ["-m" "cljfmt.main" "check"]}
            :ffix {:extra-deps {cljfmt/cljfmt {:mvn/version "0.9.2"}}
                   :main-opts ["-m" "cljfmt.main" "fix"]}
-           :lint {:replace-deps {clj-kondo/clj-kondo {:mvn/version "2023.02.17"}}
+           :lint {:replace-deps {clj-kondo/clj-kondo {:mvn/version "2023.10.20"}}
                   :main-opts ["-m" "clj-kondo.main" "--lint" "src"]}
            :outdated {:extra-deps {com.github.liquidz/antq {:mvn/version "2.2.983"}}
                       :main-opts ["-m" "antq.core"]}}}
diff --git a/doc/api-walkthrough.md b/doc/api-walkthrough.md
new file mode 100644
index 0000000..c123465
--- /dev/null
+++ b/doc/api-walkthrough.md
@@ -0,0 +1,180 @@
+# Konserve API Walkthrough
+
+## The big picture
++ persist key-value pairs with schemaless data, typically serialized edn
++ keys are created via [hasch](https://github.com/replikativ/hasch) such that the keys themselves can be arbitrary edn
++ the `konserve.core` api feels just like a clojure map except it has mutable persistence behind it
++ the core functions can be used synchronously or asynchronously
++ the details of the host system are abstracted away via protocols into host store implementations. sync vs async support is host dependent.
++ konserve provides 4 built in stores
+  - konserve.filestore
+  - konserve.node-filestore
+  - konserve.indexeddb
+  - konserve.memory
++ there are many others:
+  - https://github.com/replikativ/konserve-s3
+  - https://github.com/replikativ/konserve-jdbc
+  - https://github.com/replikativ/konserve-redis
+  - https://github.com/alekcz/konserve-fire
+  - https://github.com/search?q=konserve&type=repositories&p=1
+
+<hr>
+
+## Connecting Stores
+
+```clojure
+(require '[konserve.filestore :refer [connect-fs-store]])
+
+(def store (<!! (connect-fs-store "/tmp/store")))
+
+
+
+(require '[konserve.node-filestore :refer [connect-fs-store]])
+;; node-js supports sync but no <!!
+(def store (connect-fs-store "/tmp/store" :opts {:sync? true}))
+
+
+
+;; in the browser
+(require '[konserve.indexeddb :refer [connect-idb-store]])
+
+(go
+  ;; indexeddb is async only!
+  (let [store (<! (connect-idb-store "idb-store"))]
+    ...))
+```
+
+Stores also accept var-args. Support for each entry varies per implementation
+
++ `:opts` => `{:sync? <boolean>}`
+  - This is an env map passed around by most functions internally within konserve. The only entry you should typically need to concern yourself with is `:sync?` which is used to control whether functions return channels or values
+  - an opts map is the last parameter accepted by `konserve.core` functions, but for creating stores, it must be identified by the keyword `:opts`
++ `:config` => map
+  - this map includes options for manipulating blobs in store specific ways. Very rarely should you ever need to alter the defaults
++ `:buffer-size` => number
+  - in clj this lets you control the chunk size used for writing blobs. the default is 1mb
++ `:default-serializer` => keyword
+  - the default serializer is `:FressianSerializer`, but you can override with a keyword identifying a different serializer implementation
+  - `(connect-store store-name :default-serializer :StringSerializer)` => writes string edn
+  - jvm also supports `:CBORSerializer`
+  - you can provide your own serializer by giving a map of `{:MySerializer PStoreSerializerImpl}` to `:serializers` (..see next bullet) and then referencing it via `:default-serializer :MySerializer`
+
++ `:serializers` => Map<keyword, PStoreSerializerImpl>
+  - this is where you can provide your own serializer to reference via `:default-serializer`
+  - `konserve.serializers/fressian-serializer` is a convenience function that accepts 2 maps: a map of read-handlers and a map of write-handlers and returns a fressian serializer supporting your custom types
+    - in clj the handlers are reified `org.fressian.ReadHandlers` & `org.fressian.WriteHandlers`
+      - see [https://github.com/clojure/data.fressian/wiki/Creating-custom-handlers](https://github.com/clojure/data.fressian/wiki/Creating-custom-handlers)
+    - in cljs handlers are just functions
+      - see [https://github.com/pkpkpk/fress](https://github.om/pkpkpk/fress)
+
++ `:encryptor` => `{:type :aes :key "s3cr3t"}`
+  - currently only supports `:aes` in default stores
+
++ `:compressor` => `{:type :lz4}`
+  - currently LZ4 compression is only supported on the jvm
+
+### Incognito & Records
+Konserve intercepts records and writes them as [incognito](https://github.com/replikativ/incognito) tagged literals such that the details of serialization formats are abstracted away and allowing easier interop between different formats. The `:read-handlers` and `:write-handlers` varg args are explicitly meant for working with incognito's tagged literals.
+  - `:read-handlers` expects an atom wrapping `{'symbol.for.MyRecord map->MyRecord}` for recovering records from incognito tagged literals
+  - `:write-handlers` expects an atom wrapping `{'symbol.for.MyRecord (fn [record] ..)}` for writing records as incognito tagged literals
+  - the symbols used in these maps **are not safe for clojurescript** so you should avoid using them
+
+<hr>
+
+
+## Working with data
+Once you have a store you can access it using `konserve.core` functions. By default functions are asynchronous and return channels yielding values or errors. You can override this by passing an opts map with `:sync? true`
+
+```clojure
+(require '[konserve.core :as k])
+
+(k/exists? store :false) ;=> channel<false>
+
+(<!! (k/assoc store :fruits {:parcha nil :mango nil :banana nil}))
+
+(k/exists? store :fruits {:sync? true}) ;=> true
+```
+
+You can `get` `get-in` `update` `update-in` and `dissoc` just like a clojure map.
+
+```clojure
+(k/assoc-in store [:fruits :parcha] {:color "yellow" :taste "sour" :quantity 0})
+
+(k/update-in store [:fruits :parcha :quantity] inc)
+
+(k/get-in store [:fruits :parcha :quantity]) ;=> channel<1>
+
+(k/dissoc store :fruits)
+```
+
+In the fruits example a simple keyword is the store key, but keys themselves can be arbitrary edn:
+
+```clojure
+(defn memoize-to-store-sync [f]
+  (fn [& args]
+    (if-let [result (<!! (k/get store args))]
+      result
+      (let [result (apply f args)]
+        (<!! (k/assoc store args result))
+        result))))
+
+(def memoized-fn (memoize-to-store-sync expensive-fn))
+
+(memoized-fn {:any/such #{"set"}}, [0x6F \f], 'haschable.argu/ments) ;=> channel<result>
+```
+
+## Working with binary data
+
+```clojure
+(k/bassoc store :blob blob)
+
+(k/bget store :blob
+              (fn locked-cb [{is :input-stream}]
+                (go (input-stream->byte-buffer is)))) ;=> ch<bytebuffer>
+```
+With `bassoc` binary data is written as-is without passing through serialization/encryption/compression.
+
+`bget` is probably the trickiest function in konserve. It accepts a callback function that is passed a map of `{:input-stream <host-input-stream>}`. While `locked-cb`  is running, konserve locks & holds onto underyling resources (ie file descriptors) until the function exits. You can choose to read from the input stream however you like, but rather than running side-effects within the callback, you should instead return your desired value else the lock will remain held.
+
++ when called async, the `locked-cb` should return a channel yielding the desired value that will be read from and yielded by `bget`'s channel
++ in both clojurescript stores, synchronous input streams are not possible.
++ On nodejs you can call `bget` synchronously but the locked-cb will be called with `{:blob js/Buffer}`
++ In the browser with indexedDB, the async only `bget` calls its locked-cb with `{:input-stream <readable-webstream> :offset <number>}` where offset indicates the amount of bytes to drop before reaching the desired blob start.
+  - `konserve.indexeddb/read-web-stream` can serve as a locked-cb that will yield a `Uint8Array`.
+
+## Metadata
+
+Konserve does some bookkeeping for values by storing them with metadata
+
+```clojure
+(k/get-meta store :key {:sync? true})
+;=>
+;  {:key :key
+;   :type <binary|edn>
+;   :last-write <inst>}
+```
+
+## The append log
+Konserve provides an append log for writing values quickly. These entries are a special case managed by konserve, where the sequence is stored as a linked list of blobs where each blob is a cons cell of the list. You can name the log with any key, but that key should only be written to or read from using the `append`, `log`, and `reduce-log` functions.
+
+```clojure
+(dotimes [n 6]
+  (<!! (k/append store :log n)))
+
+(k/get store :log) ;=> channel<(0 1 2 3 4 5)>
+
+(k/reduce-log store :log
+              (fn [acc n]
+                (if (even? n)
+                  (conj acc n)
+                  acc))
+              []) ;=> channel<[0 2 4]>
+```
+
+## konserve.gc
+
+`konserve.gc/sweep!` lets you prune the store based on a whitelist set of keys to keep and a timestamp cutoff before which un whitelisted entries should be deleted
+
+## konserve.cache
+
+`konserve.cache/ensure-cache` wraps a store with a lru-cache to avoid hitting external memory for frequently accessed keys
diff --git a/karma.conf.js b/karma.conf.js
new file mode 100644
index 0000000..6314a8b
--- /dev/null
+++ b/karma.conf.js
@@ -0,0 +1,15 @@
+module.exports = function (config) {
+    config.set({
+        browsers: ['ChromeHeadless'],
+        basePath: 'target',
+        files: ['ci.js'],
+        frameworks: ['cljs-test'],
+        plugins: ['karma-cljs-test', 'karma-chrome-launcher'],
+        colors: true,
+        logLevel: config.LOG_INFO,
+        client: {
+            args: ["shadow.test.karma.init"],
+            singleRun: true
+        }
+    })
+};
\ No newline at end of file
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..3c35ba0
--- /dev/null
+++ b/package.json
@@ -0,0 +1,13 @@
+{
+  "name": "CITests",
+  "version": "1.0.0",
+  "description": "Testing",
+  "devDependencies": {
+    "karma": "^6.4.2",
+    "karma-chrome-launcher": "^2.2.0",
+    "karma-cljs-test": "^0.1.0",
+    "shadow-cljs": "^2.26.0"
+  },
+  "author": "",
+  "license": "MIT"
+}
diff --git a/shadow-cljs.edn b/shadow-cljs.edn
index b1ea626..8ae3849 100644
--- a/shadow-cljs.edn
+++ b/shadow-cljs.edn
@@ -1,7 +1,32 @@
 {:deps {:aliases [:cljs]}
- :source-paths ["src"]
+ :dev-http {8021 "out/browser-tests"}
  :builds
  {:app
   {:target :browser
    :output-dir "public/js"
-   :modules {:main {:entries [konserve.core]}}}}}
+   :modules {:main {:entries [konserve.core]}}}
+
+  :node-tests ; shadow-cljs release node-tests && node out/node-tests.js
+  {:target    :node-test
+   :output-to "out/node-tests.js"
+   :ns-regexp "^(?!konserve.indexeddb-test)"
+   :compiler-options {:infer-externs true
+                      :externs ["cljs_node_io/externs.js"]
+                      :closure-warnings   {:useless-code :off}}}
+
+  :browser-tests
+  ; shadow-cljs watch :browser-tests
+  ; http://localhost:8021/
+  {:target :browser-test
+   :test-dir "out/browser-tests"
+   :ns-regexp "^(?!konserve.node-filestore-test|konserve.node-filestore)"
+   :compiler-options {:infer-externs true
+                      :closure-warnings {:useless-code :off}}}
+
+  :ci
+  {:target :karma
+   :output-to  "target/ci.js"
+   :ns-regexp "^(?!konserve.node-filestore-test|konserve.node-filestore)"
+   :compiler-options {:infer-externs true
+                      :compiler-options {:optimizations :advanced}
+                      :closure-warnings {:useless-code :off}}}}}
diff --git a/src/konserve/cache.cljc b/src/konserve/cache.cljc
index 8fdaaa3..c173191 100644
--- a/src/konserve/cache.cljc
+++ b/src/konserve/cache.cljc
@@ -9,7 +9,8 @@
             #?(:clj [clojure.core.cache :as cache]
                :cljs [cljs.cache :as cache])
             [konserve.core #?@(:clj (:refer [go-locked locked])) :as core]
-            [konserve.utils :refer [meta-update async+sync *default-sync-translation*]]
+            [konserve.utils :refer [meta-update #?(:clj async+sync) *default-sync-translation*]
+             #?@(:cljs [:refer-macros [async+sync]])]
             [taoensso.timbre :refer [trace]]
             [superv.async :refer [go-try- <?-]]
             [clojure.core.async])
diff --git a/src/konserve/core.cljc b/src/konserve/core.cljc
index c7a1716..49c1672 100644
--- a/src/konserve/core.cljc
+++ b/src/konserve/core.cljc
@@ -1,11 +1,12 @@
 (ns konserve.core
   (:refer-clojure :exclude [get get-in update update-in assoc assoc-in exists? dissoc keys])
-  (:require [clojure.core.async :refer [chan put! #?(:clj poll!)]]
+  (:require [clojure.core.async :refer [chan put! poll!]]
             [hasch.core :as hasch]
             [konserve.protocols :refer [-exists? -get-meta -get-in -assoc-in
                                         -update-in -dissoc -bget -bassoc
                                         -keys]]
-            [konserve.utils :refer [meta-update async+sync *default-sync-translation*]]
+            [konserve.utils :refer [meta-update #?(:clj async+sync) *default-sync-translation*]
+             #?@(:cljs [:refer-macros [async+sync]])]
             [superv.async :refer [go-try- <?-]]
             [taoensso.timbre :refer [trace #?(:cljs debug)]])
   #?(:cljs (:require-macros [konserve.core :refer [go-locked locked]])))
@@ -27,10 +28,11 @@
                                              (clojure.core/assoc old key c))))
                           key))))
 
-(defn wait [#?(:clj lock :cljs _)]
+(defn wait [lock]
   #?(:clj (while (not (poll! lock))
             (Thread/sleep (long (rand-int 20))))
-     :cljs (debug "WARNING: konserve lock is not active. Only use the synchronous variant with the memory store in JavaScript.")))
+     :cljs (when-not (some-> lock poll!)
+             (debug "WARNING: konserve lock is not active. Only use the synchronous variant with the memory store in JavaScript."))))
 
 #_{:clj-kondo/ignore [:clojure-lsp/unused-public-var]}
 (defmacro locked [store key & code]
@@ -246,7 +248,9 @@
   (fn [{is :input-stream}]
     (let [tmp-file (io/file \"/tmp/my-private-copy\")]
       (io/copy is tmp-file)))
-  "
+
+  When called asynchronously (by default or w/ {:sync? false}), the locked-cb
+  must synchronously return a channel."
   ([store key locked-cb]
    (bget store key locked-cb {:sync? false}))
   ([store key locked-cb opts]
diff --git a/src/konserve/indexeddb.cljs b/src/konserve/indexeddb.cljs
index 256ec32..1f47682 100644
--- a/src/konserve/indexeddb.cljs
+++ b/src/konserve/indexeddb.cljs
@@ -1,12 +1,11 @@
 (ns konserve.indexeddb
-  (:require-macros [cljs.core.async.macros :refer [go]])
-  (:require [cljs.core.async :refer [take! put! close!]]
+  (:require [clojure.core.async :refer [go take! put! close!]]
             [konserve.compressor]
             [konserve.encryptor]
             [konserve.impl.defaults :as defaults]
             [konserve.impl.storage-layout :as storage-layout]
             [konserve.serializers]
-            [konserve.utils :refer [with-promise]]))
+            [konserve.utils :refer-macros [with-promise]]))
 
 (defn connect-to-idb [db-name]
   (let [req (js/window.indexedDB.open db-name 1)]
@@ -135,11 +134,11 @@
                (put! out (ex-info "error reading blob from objectStore"
                                   {:cause res
                                    :caller 'konserve.indexeddb/read-binary}))
-               (do
-                 (locked-cb {:input-stream (.stream res)
-                             :size (.-size res)
-                             :offset (+ meta-size storage-layout/header-size)})
-                 (close! out)))))))
+               (take!
+                (locked-cb {:input-stream (.stream res)
+                            :size (.-size res)
+                            :offset (+ meta-size storage-layout/header-size)})
+                #(put! out %)))))))
 
 (defrecord ^{:doc "buf is cached data that has been read from the db,
                    & {header metadata value} are bin data to be written.
@@ -267,9 +266,37 @@
     (db-exists? db-name))
   (-sync-store [_this env] (when-not (:sync? env) (go))))
 
+(defn read-web-stream
+  "Accepts the bget locked callback arg and returns a promise-chan containing
+   a concatenated byte array with the first offset bytes dropped
+   `(k/bget store :key read-web-stream)`"
+  [{:keys [input-stream offset]}]
+  (let [reader (.getReader input-stream)
+        chunks #js[]]
+    (with-promise out
+      (let [read-chunk (fn read-chunk []
+                         (.then (.read reader)
+                                (fn [result]
+                                  (if (.-done result)
+                                    (do
+                                      (some->> (.-value result) (.push chunks))
+                                      (if (== 1 (alength chunks))
+                                        (put! out (.slice (aget chunks 0) offset))
+                                        (let [total-length (reduce + (map count chunks))
+                                              final-array (js/Uint8Array. (inc total-length))
+                                              _i (atom 0)]
+                                          (doseq [chunk (array-seq chunks)]
+                                            (.set final-array chunk @_i)
+                                            (swap! _i + (alength chunk)))
+                                          (put! out (.slice final-array offset)))))
+                                    (do
+                                      (.push chunks (.-value result))
+                                      (read-chunk))))
+                                (fn [err] (put! out err))))]
+        (read-chunk)))))
+
 (defn connect-idb-store
   "Connect to a IndexedDB backed KV store with the given db name.
-   Optional serializer, read-handlers, write-handlers.
 
    This implementation stores all values as js/Blobs in an IndexedDB
    object store instance. The object store itself is nameless, and there
@@ -288,15 +315,20 @@
    db and core.async gets into a weird state due to an unhandled error, you
    will be unable to delete the database until the vm is restarted
 
-   + As of November 2022 firefox does not support IDBFactory.databases() so
+   + As of November 2023 firefox does not support IDBFactory.databases() so
    expect list-dbs, db-exists?, & PBackingStore/-store-exists? to all throw. You
    must work around this by keeping track of each db name you intend to delete
    https://developer.mozilla.org/en-US/docs/Web/API/IDBFactory/databases#browser_compatibility
 
-   + PBackingBlob/-read-binary returns a webstream that is *not* queued to the
-   value offset in the same way that the filestore implementations are. Consumers
-   must discard the amount of bytes found in the :offset key of the locked-cb
-   arg map. See: https://developer.mozilla.org/en-US/docs/Web/API/Blob/stream"
+   + `konserve.core/bget` locked-cb arg is given a webstream that is *not* queued
+   to the value offset in the same way that the filestore implementations are.
+   See: https://developer.mozilla.org/en-US/docs/Web/API/Blob/stream
+     - consumers must discard the amount of bytes found in the :offset key of
+       the locked-cb arg map. These bytes are meta data for konserve and not
+       part of the value you are retrieving
+     - `konserve.indexeddb/read-web-stream` will accept the argument to the
+       locked-cb and return a promise-chan receiving err|bytes at the cost of
+       allocating a larger array for the chunks to be copied into"
   [db-name & {:as params}]
   (let [store-config (merge {:default-serializer :FressianSerializer
                              :compressor         konserve.compressor/null-compressor
diff --git a/src/konserve/memory.cljc b/src/konserve/memory.cljc
index d31f577..0cf1383 100644
--- a/src/konserve/memory.cljc
+++ b/src/konserve/memory.cljc
@@ -1,5 +1,6 @@
 (ns konserve.memory
-  "Address globally aggregated immutable key-value store(s)."
+  "Address globally aggregated immutable key-value store(s).
+   Does not support serialization."
   (:require [clojure.core.async :as async :refer [go <!]]
             [konserve.protocols :refer [PEDNKeyValueStore -update-in
                                         PBinaryKeyValueStore PKeyIterable]]
@@ -27,7 +28,7 @@
                   {go do}
                   (go (first (get @state key))))))
   (-update-in [_ key-vec meta-up-fn up-fn opts]
-    (let [{:keys [sync?]} opts]
+    (let [{:keys [sync? overwrite?]} opts]
       (async+sync sync?
                   {go do}
                   (go
@@ -42,10 +43,13 @@
                                                 (if rkey
                                                   (update-in data rkey up-fn)
                                                   (up-fn data))])))))
-                          new-state (update-atom state)]
-                      [(second (get new-state fkey))
-                       (second (get new-state fkey))])))))
-  (-assoc-in [this key-vec meta val opts] (-update-in this key-vec meta (fn [_] val) opts))
+                          [_ old-val] (get @state fkey)
+                          {[_ new-val] fkey} (update-atom state)]
+                      (if overwrite?
+                        [nil new-val]
+                        [old-val new-val]))))))
+  (-assoc-in [this key-vec meta val opts]
+    (-update-in this key-vec meta (fn [_] val) (assoc opts :overwrite? true)))
   (-dissoc [_ key opts]
     (let [{:keys [sync?]} opts]
       (async+sync sync?
@@ -64,8 +68,7 @@
       (async+sync sync?
                   {go do
                    <! do}
-                  (go
-                    (<! (locked-cb (second (get @state key))))))))
+                  (go (<! (locked-cb {:input-stream (second (get @state key))}))))))
   (-bassoc [_ key meta-up-fn input opts]
     (let [{:keys [sync?]} opts]
       (async+sync sync?
@@ -76,9 +79,8 @@
                            (fn [old]
                              (update old key
                                      (fn [[meta _data]]
-                                       [(meta-up-fn meta) {:input-stream input
-                                                           :size         :unknown}]))))
-                    nil))))
+                                       [(meta-up-fn meta) input]))))
+                    true))))
   PKeyIterable
   (-keys [_ opts]
     (let [{:keys [sync?]} opts]
diff --git a/src/konserve/node_filestore.cljs b/src/konserve/node_filestore.cljs
index bab7c4f..dfd670e 100644
--- a/src/konserve/node_filestore.cljs
+++ b/src/konserve/node_filestore.cljs
@@ -10,7 +10,7 @@
             [konserve.impl.defaults :as defaults]
             [konserve.impl.storage-layout :as storage-layout]
             [konserve.serializers]
-            [konserve.utils :refer [with-promise]]
+            [konserve.utils :refer-macros [with-promise]]
             [taoensso.timbre :refer [info]]))
 
 (def stream (node/require "stream"))
@@ -40,6 +40,16 @@
     (set! (.-locked this) lock)
     lock))
 
+(defn verify-read-size
+  [expected actual]
+  (when-not (== expected actual)
+    (throw (js/Error. (str "Expected " expected " bytes, but read " actual)))))
+
+(defn verify-write-size
+  [expected actual]
+  (when-not (== expected actual)
+    (throw (js/Error. (str "Expected to write " expected " bytes, but wrote " actual)))))
+
 (deftype FileChannel [path fd open? locked]
   storage-layout/PBackingBlob
   (-sync [this _env] (.force this true))
@@ -48,12 +58,12 @@
   (-read-header [_this _env]
     (let [buf (js/Buffer.alloc storage-layout/header-size)
           bytes-read (iofs/read fd buf {:position 0})]
-      (assert (== bytes-read storage-layout/header-size))
+      (verify-read-size storage-layout/header-size bytes-read)
       buf))
   (-read-meta [_this meta-size _env]
     (let [buf (js/Buffer.alloc meta-size)
           bytes-read (iofs/read fd buf {:position storage-layout/header-size})]
-      (assert (== bytes-read meta-size))
+      (verify-read-size meta-size bytes-read)
       buf))
   (-read-value [_this meta-size _env]
     (let [blob-size ^number (.-size (fs.fstatSync fd))
@@ -61,33 +71,35 @@
           buf (js/Buffer.alloc value-size)
           pos (+ meta-size storage-layout/header-size)
           bytes-read (iofs/read fd buf {:position pos :length (alength buf)})]
-      (assert (== bytes-read value-size))
+      (verify-read-size value-size bytes-read)
       buf))
   (-read-binary [this meta-size locked-cb _env]
     (let [blob-size ^number (.-size (fs.fstatSync fd))
-          pos (+ meta-size storage-layout/header-size)
-          rstream (fs.createReadStream nil #js{:fd (.-fd this) :start pos})]
-      (.on rstream "readable"
-           #(locked-cb {:input-stream rstream :size blob-size}))))
+          offset (+ meta-size storage-layout/header-size)
+          value-len (- blob-size offset)
+          blob (js/Buffer. value-len)
+          bytes-read (iofs/read (.-fd this) blob offset value-len 0)]
+      (verify-read-size value-len bytes-read)
+      (locked-cb {:blob blob})))
   (-write-header [_this header _env]
     (let [buffer (js/Buffer.from header)
           bytes-written (iofs/write fd buffer {:position 0})]
-      (assert (== bytes-written (alength header)))))
+      (verify-write-size (alength header) bytes-written)))
   (-write-meta [_this meta-arr _env]
     (let [buffer (js/Buffer.from meta-arr)
           pos storage-layout/header-size
           bytes-written (iofs/write fd buffer {:position pos})]
-      (assert (== bytes-written (alength buffer)))))
+      (verify-write-size (alength buffer) bytes-written)))
   (-write-value [_this value-arr meta-size _env]
     (let [buffer (js/Buffer.from value-arr)
           pos (+ storage-layout/header-size meta-size)
           bytes-written (iofs/write fd buffer {:position pos})]
-      (assert (== bytes-written (alength buffer)))))
+      (verify-write-size (alength buffer) bytes-written)))
   (-write-binary [_this meta-size blob _env]
     (let [buffer  (js/Buffer.from blob)
           pos     (+ storage-layout/header-size meta-size)
           bytes-written (iofs/write fd buffer {:position pos})]
-      (assert (== bytes-written (alength buffer)))))
+      (verify-write-size (alength buffer) bytes-written)))
   Object
   (force [_this _] (fs.fsyncSync fd))
   (close [this]
@@ -195,17 +207,29 @@
 
 (defn- afread-binary ;=> ch<readable|err>
   [fd meta-size locked-cb _env]
-  (go
-    (let [[?err total-size] (<! (afsize fd))]
-      (or ?err
-          (try
-            (let [opts #js{:fd fd
-                           :encoding ""
-                           :start (+ meta-size storage-layout/header-size)}
-                  rstream (fs.createReadStream nil opts)]
-              (.on rstream "readable"
-                   #(locked-cb {:input-stream rstream :size total-size})))
-            (catch js/Error e e))))))
+  (with-promise out
+    (take! (afsize fd)
+           (fn [[?err total-size]]
+             (if (some? ?err)
+               (put! out ?err)
+               (try
+                 (let [opts #js{:fd fd
+                                :encoding ""
+                                :start (+ meta-size storage-layout/header-size)
+                                :autoClose false}
+                       _readable-fired? (atom false)
+                       rstream (fs.createReadStream nil opts)]
+                   (.on rstream "readable"
+                        (fn []
+                          (when-not @_readable-fired?
+                            (reset! _readable-fired? true)
+                            (let [ret (locked-cb {:input-stream rstream :size total-size})]
+                              (take! ret (fn [res] (put! out res)))))))
+                   (.on rstream "error"
+                        (fn [err]
+                          (put! out (ex-info "error reading from stream" {:cause err})))))
+                 (catch js/Error err
+                   (put! out (ex-info "error creating readstream" {:cause err})))))))))
 
 (defn- afwrite-binary ;  => ch<?err>
   [fd meta-size blob _env]
@@ -350,6 +374,7 @@
     (.delete f)
     (try
       (sync-base parent-base)
+      nil
       (catch js/Error e
         e))))
 
@@ -498,19 +523,24 @@
       (sync-base-async base))))
 
 (defn detect-old-file-schema [& _args] (throw (js/Error "TODO detect-old-file-schema")))
-;; get-file-channel
-;; migration
 
 (defn connect-fs-store
   "Create Filestore in given path.
-  Optional serializer, read-handlers, write-handlers, buffer-size and config (for fsync) can be changed.
-  Defaults are
-  {:base           path
-   :serializer     fressian-serializer
-   :read-handlers  empty
-   :write-handlers empty
-   :buffer-size    1 MB
-   :config         config} "
+   Optional serializer, read-handlers, write-handlers, buffer-size and config (for fsync) can be changed.
+
+   + the `k/bget` callback gets different args depending on `:sync?`
+     - async bget callbacks recieve `{:input-stream <fs.readStream>}` akin to
+       the same call on the JVM filestore impl. These streams are opened to the
+       same fd that konserve is managing for the blob, so users should not call
+       destroy() or it will raise an error
+     - sync bget callbacks are called with `{:blob <js/Buffer>}`
+
+   {:base           path
+    :serializer     fressian-serializer
+    :read-handlers  empty
+    :write-handlers empty
+    :buffer-size    1 MB
+    :config         config} "
   [path & {:keys [detect-old-file-schema? ephemeral? config]
            :or {detect-old-file-schema? false
                 ephemeral? (fn [pathstr]
diff --git a/src/konserve/utils.cljc b/src/konserve/utils.cljc
index 9f783be..246928d 100644
--- a/src/konserve/utils.cljc
+++ b/src/konserve/utils.cljc
@@ -21,24 +21,23 @@
     {:key key :type type :last-write (now)}
     (clojure.core/assoc old :last-write (now))))
 
-#?(:clj
-   (defmacro async+sync
-     [sync? async->sync async-code]
-     (let [async->sync (if (symbol? async->sync)
-                         (or (resolve async->sync)
-                             (when-let [_ns (or (get-in &env [:ns :use-macros async->sync])
-                                                (get-in &env [:ns :uses async->sync]))]
-                               (resolve (symbol (str _ns) (str async->sync)))))
-                         async->sync)]
-       (assert (some? async->sync))
-       `(if ~sync?
-          ~(clojure.walk/postwalk (fn [n]
-                                    (if-not (meta n)
-                                      (async->sync n n) ;; primitives have no metadata
-                                      (with-meta (async->sync n n)
-                                        (update (meta n) :tag (fn [t] (async->sync t t))))))
-                                  async-code)
-          ~async-code))))
+(defmacro async+sync
+  [sync? async->sync async-code]
+  (let [async->sync (if (symbol? async->sync)
+                      (or (resolve async->sync)
+                          (when-let [_ns (or (get-in &env [:ns :use-macros async->sync])
+                                             (get-in &env [:ns :uses async->sync]))]
+                            (resolve (symbol (str _ns) (str async->sync)))))
+                      async->sync)]
+    (assert (some? async->sync))
+    `(if ~sync?
+       ~(clojure.walk/postwalk (fn [n]
+                                 (if-not (meta n)
+                                   (async->sync n n) ;; primitives have no metadata
+                                   (with-meta (async->sync n n)
+                                     (update (meta n) :tag (fn [t] (async->sync t t))))))
+                               async-code)
+       ~async-code)))
 
 (def ^:dynamic *default-sync-translation*
   '{go-try try
diff --git a/test/konserve/cache_test.clj b/test/konserve/cache_test.clj
deleted file mode 100644
index 8cb94c1..0000000
--- a/test/konserve/cache_test.clj
+++ /dev/null
@@ -1,67 +0,0 @@
-(ns konserve.cache-test
-  (:require [konserve.cache :as k]
-            [konserve.filestore :as fstore]
-            [clojure.core.async :refer [<!! go] :as async]
-            [clojure.test :refer [deftest testing is are]]))
-
-(deftest cache-test
-
-  (doseq [opts [{:sync? false} {:sync? true}]
-          :let [<!! (if (:sync? opts) identity <!!)]]
-    (let [_ (fstore/delete-store "/tmp/cache-store")
-          test-store (<!! (fstore/connect-fs-store "/tmp/cache-store" :opts opts))
-          store (k/ensure-cache test-store)]
-
-      (testing "Test the cache API."
-        (is (= (<!! (k/get store :foo nil opts)) nil))
-        (is (false? (<!! (k/exists? store :foo opts))))
-        (<!! (k/assoc store :foo :bar opts))
-        (is (<!! (k/exists? store :foo)))
-        (is (= (<!! (k/get store :foo nil opts))
-               :bar))
-        (<!! (k/assoc-in store [:foo] :bar2 opts))
-        (is (= :bar2 (<!! (k/get store :foo nil opts))))
-        (is (= :default
-               (<!! (k/get-in store [:fuu] :default opts))))
-        (is (= :bar2 (<!! (k/get store :foo nil opts))))
-        (is (= :default
-               (<!! (k/get-in store [:fuu] :default opts))))
-        (<!! (k/update-in store [:foo] name opts))
-        (is (= "bar2"
-               (<!! (k/get store :foo nil opts))))
-        (<!! (k/assoc-in store [:baz] {:bar 42} opts))
-        (is (= (<!! (k/get-in store [:baz :bar] nil opts))
-               42))
-        (<!! (k/update-in store [:baz :bar] inc opts))
-        (is (= (<!! (k/get-in store [:baz :bar] nil opts))
-               43))
-        (<!! (k/update-in store [:baz :bar] (fn [x] (+ x 2 3)) opts))
-        (is (= (<!! (k/get-in store [:baz :bar] nil opts))
-               48))
-        (= true (<!! (k/dissoc store :foo opts)))
-        (is (= (<!! (k/get-in store [:foo] nil opts))
-               nil))
-        (<!! (k/bassoc store :binbar (byte-array (range 10)) opts))
-        (<!! (k/bget store :binbar (fn [{:keys [input-stream]}]
-                                     (go
-                                       (is (= (map byte (slurp input-stream))
-                                              (range 10)))
-                                       true))
-                     opts))
-        (let  [list-keys (<!! (k/keys store opts))]
-          (are [x y] (= x y)
-            #{{:key :baz
-               :type :edn}
-              {:key :binbar
-               :type :binary}}
-            (->> list-keys (map #(clojure.core/dissoc % :last-write)) set)
-            true
-            (every?
-             (fn [{:keys [:last-write]}]
-               (= (type (java.util.Date.)) (type last-write)))
-             list-keys)))
-
-        (doseq [to-delete [:baz :binbar :foolog]]
-          (<!! (k/dissoc store to-delete opts)))))))
-
-
diff --git a/test/konserve/cache_test.cljs b/test/konserve/cache_test.cljs
deleted file mode 100644
index 5019153..0000000
--- a/test/konserve/cache_test.cljs
+++ /dev/null
@@ -1,70 +0,0 @@
-(ns konserve.cache-test
-  (:require-macros [cljs.core.async.macros :refer [go]])
-  (:require [cljs.core.async :refer [<! promise-chan put!]]
-            [cljs.test :refer [deftest is async]]
-            [fress.api :as fress]
-            [konserve.cache :as k]
-            [konserve.node-filestore :as fstore]))
-
-(def store-path "/tmp/cache-store")
-
-(deftest cache-PEDNKeyValueStore-test
-  (fstore/delete-store store-path)
-  (async done
-         (go
-           (let [opts {:sync? false}
-                 test-store (<! (fstore/connect-fs-store store-path :opts opts))
-                 store (k/ensure-cache test-store)]
-             (is (nil? (<! (k/get store :foo nil opts))))
-             (is (false? (<! (k/exists? store :foo opts))))
-             (is [nil :bar] (<! (k/assoc store :foo :bar opts)))
-             (is (true? (<! (k/exists? store :foo))))
-             (is (= :bar (<! (k/get store :foo nil opts))))
-             (is (= [nil :bar2] (<! (k/assoc-in store [:foo] :bar2 opts))))
-             (is (= :bar2 (<! (k/get store :foo nil opts))))
-             (is (= :default (<! (k/get-in store [:fuu] :default opts))))
-             (is (= :bar2 (<! (k/get store :foo nil opts))))
-             (is (= :default (<! (k/get-in store [:fuu] :default opts))))
-             (is (= [:bar2 "bar2"] (<! (k/update-in store [:foo] name opts))))
-             (is (= "bar2" (<! (k/get store :foo nil opts))))
-             (is (=  [nil {:bar 42}] (<! (k/assoc-in store [:baz] {:bar 42} opts))))
-             (is (= 42 (<! (k/get-in store [:baz :bar] nil opts))))
-             (is (= [{:bar 42} {:bar 43}] (<! (k/update-in store [:baz :bar] inc opts))))
-             (is (= 43 (<! (k/get-in store [:baz :bar] nil opts))))
-             (is (= [{:bar 43} {:bar 48}] (<! (k/update-in store [:baz :bar] (fn [x] (+ x 2 3)) opts))))
-             (is (= 48 (<! (k/get-in store [:baz :bar] nil opts))))
-             (is (true? (<! (k/dissoc store :foo opts))))
-             (is (nil? (<! (k/get-in store [:foo] nil opts))))
-             (done)))))
-
-(deftest cache-PBin-test
-  (fstore/delete-store store-path)
-  (async done
-         (let [opts {:sync? false}
-               data [:this/is 'some/fressian "data 😀😀😀" (js/Date.) #{true false nil}]
-               bytes (fress/write data)
-               test-data (promise-chan)
-               locked-cb (fn [{readable :input-stream}]
-                           (put! test-data (fress/read (.read readable)))
-                           (.destroy readable))]
-           (go
-             (let [store (k/ensure-cache (<! (fstore/connect-fs-store store-path :opts opts)))]
-               (is (true? (<! (k/bassoc store :key bytes opts))))
-               (<! (k/bget store :key locked-cb opts))
-               (is (= data (<! test-data)))
-               (done))))))
-
-(deftest cache-PKeyIterable-test
-  (fstore/delete-store store-path)
-  (async done
-         (go
-           (let [opts {:sync? false}
-                 store (k/ensure-cache (<! (fstore/connect-fs-store store-path :opts opts)))]
-             (is (= #{} (<! (k/keys store opts))))
-             (is (= [nil 42] (<! (k/assoc-in store [:value-blob] 42 opts))))
-             (is (true? (<! (k/bassoc store :bin-blob #js[255 255 255] opts))))
-             (let [store-keys (<! (k/keys store opts))]
-               (is (every? inst? (map :last-write store-keys)))
-               (is (= #{{:key :bin-blob :type :binary} {:key :value-blob :type :edn}}
-                      (set (map #(dissoc % :last-write) store-keys)))))
-             (done)))))
diff --git a/test/konserve/core_test.clj b/test/konserve/core_test.clj
deleted file mode 100644
index 9992250..0000000
--- a/test/konserve/core_test.clj
+++ /dev/null
@@ -1,9 +0,0 @@
-(ns konserve.core-test
-  (:require [clojure.test :refer [deftest]]
-            [clojure.core.async :refer [<!!] :as async]
-            [konserve.compliance-test :refer [compliance-test]]
-            [konserve.memory :refer [new-mem-store]]))
-
-(deftest memory-store-compliance-test
-  (compliance-test (<!! (new-mem-store))))
-
diff --git a/test/konserve/encryptor_test.cljc b/test/konserve/encryptor_test.cljc
deleted file mode 100644
index 7b8db4d..0000000
--- a/test/konserve/encryptor_test.cljc
+++ /dev/null
@@ -1,24 +0,0 @@
-(ns konserve.encryptor-test
-  (:require [clojure.test :refer [deftest]]
-            #?(:cljs [clojure.core.async :refer [go <!]])
-            [#?(:clj konserve.filestore :cljs konserve.node-filestore) :refer [connect-fs-store delete-store]]
-            [konserve.compliance-test :refer [#?(:clj compliance-test
-                                                 :cljs async-compliance-test)]]))
-
-(deftest encryptor-test
-  (let [folder "/tmp/konserve-fs-encryptor-test"
-        _      (delete-store folder)
-        store  (connect-fs-store folder
-                                 :config {:encryptor {:type :aes
-                                                      :key "s3cr3t"}}
-                                 :opts {:sync? true})]
-    #?(:clj
-       (do
-         (compliance-test store)
-         (delete-store folder))
-       :cljs
-       (cljs.test/async done
-                        (go
-                          (<! (async-compliance-test store))
-                          (delete-store folder)
-                          (done))))))
diff --git a/test/konserve/filestore_test.clj b/test/konserve/filestore_test.clj
index c075506..84dda10 100644
--- a/test/konserve/filestore_test.clj
+++ b/test/konserve/filestore_test.clj
@@ -1,10 +1,14 @@
 (ns konserve.filestore-test
   (:refer-clojure :exclude [get get-in update update-in assoc assoc-in dissoc exists? keys])
   (:require [clojure.test :refer [deftest is testing]]
-            [clojure.core.async :refer [<!! go chan put! close!] :as async]
+            [clojure.core.async :refer [<!! go chan put! close! <!] :as async]
             [konserve.core :refer [bassoc bget keys]]
             [konserve.compliance-test :refer [compliance-test]]
-            [konserve.filestore :refer [connect-fs-store delete-store]]))
+            [konserve.filestore :refer [connect-fs-store delete-store]]
+            [konserve.tests.cache :as ct]
+            [konserve.tests.encryptor :as et]
+            [konserve.tests.gc :as gct]
+            [konserve.tests.serializers :as st]))
 
 (deftest filestore-compliance-test
   (let [folder "/tmp/konserve-fs-comp-test"
@@ -89,3 +93,59 @@
       (let [store (<!! (connect-fs-store folder))]
         (is (= (<!! (keys store))
                #{}))))))
+
+#!============
+#! Cache tests
+
+(deftest cache-PEDNKeyValueStore-test
+  (delete-store "/tmp/cache-store")
+  (let [store (connect-fs-store "/tmp/cache-store" :opts {:sync? true})]
+    (<!! (ct/test-cached-PEDNKeyValueStore-async store))))
+
+(deftest cache-PKeyIterable-test
+  (delete-store "/tmp/cache-store")
+  (let [store (connect-fs-store "/tmp/cache-store" :opts {:sync? true})]
+    (<!! (ct/test-cached-PKeyIterable-async store))))
+
+(deftest cache-PBin-test
+  (delete-store "/tmp/cache-store")
+  (let [store (connect-fs-store "/tmp/cache-store" :opts {:sync? true})
+        f (fn [{:keys [input-stream]}]
+            (async/to-chan! [input-stream]))]
+    (<!! (ct/test-cached-PBin-async store f))))
+
+#!============
+#! GC tests
+
+(deftest async-gc-test
+  (delete-store "/tmp/gc-store")
+  (let [store (connect-fs-store "/tmp/gc-store" :opts {:sync? true})]
+    (<!! (gct/test-gc-async store))))
+
+#!==================
+#! Serializers tests
+
+(deftest fressian-serializer-test
+  (<!! (st/test-fressian-serializers-async "/tmp/serializers-test"
+                                           connect-fs-store
+                                           (fn [p] (go (delete-store p)))
+                                           (fn [{:keys [input-stream]}]
+                                             (async/to-chan! [input-stream])))))
+
+(deftest CBOR-serializer-test
+  (st/cbor-serializer-test "/tmp/konserve-fs-cbor-test"
+                           connect-fs-store
+                           (fn [p] (go (delete-store p)))))
+
+#!==================
+#! Encryptor tests
+
+(deftest encryptor-sync-test
+  (et/sync-encryptor-test "/tmp/encryptor-test"
+                          connect-fs-store
+                          delete-store))
+
+(deftest encryptor-async-test
+  (<!! (et/async-encryptor-test "/tmp/encryptor-test"
+                                connect-fs-store
+                                (fn [p] (go (delete-store p))))))
diff --git a/test/konserve/gc_test.clj b/test/konserve/gc_test.clj
deleted file mode 100644
index 47a068b..0000000
--- a/test/konserve/gc_test.clj
+++ /dev/null
@@ -1,45 +0,0 @@
-(ns konserve.gc-test
-  (:require [konserve.gc :refer [sweep!]]
-            [clojure.test :refer [deftest is testing]]
-            [konserve.core :as k]
-            [konserve.memory :refer [new-mem-store]]
-            [konserve.filestore :refer [connect-fs-store delete-store]]
-            [clojure.core.async :refer [<!!] :as async]))
-
-(deftest memory-store-gc-test
-  (testing "Test the GC."
-    (let [store (<!! (new-mem-store))]
-      (<!! (k/assoc store :foo :bar))
-      (<!! (k/assoc-in store [:foo] :bar2))
-      (<!! (k/assoc-in store [:foo2] :bar2))
-      (<!! (k/assoc-in store [:foo3] :bar2))
-      (<!! (async/timeout 1))
-      (let [ts        (java.util.Date.)
-            whitelist #{:baz}]
-        (<!! (k/update-in store [:foo] name))
-        (<!! (k/assoc-in store [:baz] {:bar 42}))
-        (<!! (k/update-in store [:baz :bar] inc))
-        (<!! (k/update-in store [:baz :bar] #(+ % 2 3)))
-        (<!! (k/bassoc store :binbar (byte-array (range 10))))
-        (is (= #{:foo2 :foo3} (<!! (sweep! store whitelist ts))))
-        ;it seems clock of threads are not sync.
-        #_(prn (.getTime ts) (map (fn [e] [(:key e) (-> e :konserve.core/timestamp .getTime)]) (<!! (keys store))))))))
-
-(deftest file-store-gc-test
-  (testing "Test the GC."
-    (let [folder "/tmp/konserve-gc"
-          _      (delete-store folder)
-          store  (<!! (connect-fs-store folder))]
-      (<!! (k/assoc store :foo :bar))
-      (<!! (k/assoc-in store [:foo] :bar2))
-      (<!! (k/assoc-in store [:foo2] :bar2))
-      (<!! (k/assoc-in store [:foo3] :bar2))
-      (let [ts        (java.util.Date.)
-            whitelist #{:baz}]
-        (<!! (k/update-in store [:foo] name))
-        (<!! (k/assoc-in store [:baz] {:bar 42}))
-        (<!! (k/update-in store [:baz :bar] inc))
-        (<!! (k/update-in store [:baz :bar] #(+ % 2 3)))
-        (<!! (k/bassoc store :binbar (byte-array (range 10))))
-        (is (= #{:foo2 :foo3} (<!! (sweep! store whitelist ts))))))))
-
diff --git a/test/konserve/gc_test.cljs b/test/konserve/gc_test.cljs
deleted file mode 100644
index 0bbb71e..0000000
--- a/test/konserve/gc_test.cljs
+++ /dev/null
@@ -1,47 +0,0 @@
-(ns konserve.gc-test
-  (:require [clojure.core.async :refer [<! go timeout]]
-            [cljs.test :refer [deftest testing is async]]
-            [konserve.gc :as gc]
-            [konserve.core :as k]
-            [konserve.memory :refer [new-mem-store]]
-            [konserve.node-filestore :refer [connect-fs-store delete-store]]))
-
-(deftest memory-store-gc-test
-  (async done
-         (go
-           (testing "Test the GC."
-             (let [store (<! (new-mem-store))]
-               (<! (k/assoc store :foo :bar))
-               (<! (k/assoc-in store [:foo] :bar2))
-               (<! (k/assoc-in store [:foo2] :bar2))
-               (<! (k/assoc-in store [:foo3] :bar2))
-               (<! (timeout 1))
-               (let [ts (js/Date.)
-                     whitelist #{:baz}]
-                 (<! (k/update-in store [:foo] name))
-                 (<! (k/assoc-in store [:baz] {:bar 42}))
-                 (<! (k/update-in store [:baz :bar] inc))
-                 (<! (k/update-in store [:baz :bar] #(+ % 2 3)))
-                 (<! (k/bassoc store :binbar (js/Buffer.from  (into-array (range 10)))))
-                 (is (= #{:foo2 :foo3} (<! (gc/sweep! store whitelist ts))))))
-             (done)))))
-
-(deftest file-store-gc-test
-  (async done
-         (go
-           (let [folder "/tmp/konserve-gc"
-                 _ (delete-store folder)
-                 store (<! (connect-fs-store folder))]
-             (<! (k/assoc store :foo :bar))
-             (<! (k/assoc-in store [:foo] :bar2))
-             (<! (k/assoc-in store [:foo2] :bar2))
-             (<! (k/assoc-in store [:foo3] :bar2))
-             (let [ts        (js/Date.)
-                   whitelist #{:baz}]
-               (<! (k/update-in store [:foo] name))
-               (<! (k/assoc-in store [:baz] {:bar 42}))
-               (<! (k/update-in store [:baz :bar] inc))
-               (<! (k/update-in store [:baz :bar] #(+ % 2 3)))
-               (<! (k/bassoc store :binbar (js/Buffer.from  (into-array (range 10)))))
-               (is (= #{:foo2 :foo3} (<! (gc/sweep! store whitelist ts))))))
-           (done))))
diff --git a/test/konserve/indexeddb_test.cljs b/test/konserve/indexeddb_test.cljs
index ce5ace6..967e96d 100644
--- a/test/konserve/indexeddb_test.cljs
+++ b/test/konserve/indexeddb_test.cljs
@@ -1,10 +1,14 @@
 (ns konserve.indexeddb-test
-  (:require-macros [cljs.core.async.macros :refer [go]])
-  (:require [cljs.core.async :refer [<!]]
+  (:require [clojure.core.async :refer [go <! put! take! promise-chan]]
             [cljs.test :refer-macros [deftest is testing async]]
+            [konserve.cache :as kc]
             [konserve.core :as k]
             [konserve.indexeddb :as idb]
-            [konserve.protocols :as p])
+            [konserve.protocols :as p]
+            [konserve.tests.cache :as ct]
+            [konserve.tests.encryptor :as et]
+            [konserve.tests.gc :as gct]
+            [konserve.tests.serializers :as st])
   (:import [goog userAgent]))
 
 (deftest ^:browser lifecycle-test
@@ -31,7 +35,7 @@
            (let [db-name "pednkv-test"
                  _ (<! (idb/delete-idb db-name))
                  opts {:sync? false}
-                 {backing :backing :as store} (<! (idb/connect-idb-store db-name :opts opts))]
+                 store (<! (idb/connect-idb-store db-name :opts opts))]
              (is (false? (<! (p/-exists? store :bar opts))))
              (is (= :not-found (<! (p/-get-in store [:bar] :not-found opts))))
              (is (= [nil 42] (<! (p/-assoc-in store [:bar] identity 42 opts))))
@@ -49,7 +53,7 @@
              (is (= [{::foo 100} {}] (<! (p/-update-in store [:bar] identity #(dissoc % ::foo) opts))))
              (is (true? (<! (p/-dissoc store :bar opts))))
              (is (false? (<! (p/-exists? store :bar opts))))
-             (.close backing)
+             (<! (.close (:backing store)))
              (<! (idb/delete-idb db-name))
              (done)))))
 
@@ -59,14 +63,14 @@
            (let [db-name "pkeyiterable-test"
                  _ (<! (idb/delete-idb db-name))
                  opts {:sync? false}
-                 {backing :backing :as store} (<! (idb/connect-idb-store db-name :opts opts))]
+                 store (<! (idb/connect-idb-store db-name :opts opts))]
              (is (= #{} (<! (k/keys store opts))))
              (is (= [nil 42] (<! (k/assoc-in store [:value-blob] 42 opts))))
              (is (true? (<! (k/bassoc store :bin-blob #js[255 255 255] opts))))
              (is (= #{{:key :bin-blob :type :binary} {:key :value-blob :type :edn}}
                     (set (map #(dissoc % :last-write) (<! (k/keys store opts))))))
              (is (every? inst? (map :last-write (<! (k/keys store opts)))))
-             (.close backing)
+             (<! (.close (:backing store)))
              (<! (idb/delete-idb db-name))
              (done)))))
 
@@ -76,7 +80,7 @@
            (let [db-name "append-test"
                  _ (<! (idb/delete-idb db-name))
                  opts {:sync? false}
-                 {backing :backing :as store} (<! (idb/connect-idb-store db-name :opts opts))]
+                 store (<! (idb/connect-idb-store db-name :opts opts))]
              (is (uuid? (second (<! (k/append store :foolog {:bar 42} opts)))))
              (is (uuid? (second (<! (k/append store :foolog {:bar 43} opts)))))
              (is (= '({:bar 42} {:bar 43}) (<! (k/log store :foolog opts))))
@@ -85,6 +89,75 @@
                (is (= key :foolog))
                (is (= type :append-log))
                (is (inst? last-write)))
-             (.close backing)
+             (<! (.close (:backing store)))
              (<! (idb/delete-idb db-name))
              (done)))))
+
+#!============
+#! Cache tests
+
+(deftest cache-PEDNKeyValueStore-test
+  (async done
+         (go
+           (<! (idb/delete-idb "cache-store"))
+           (let [store (<! (idb/connect-idb-store "cache-store"))]
+             (<! (ct/test-cached-PEDNKeyValueStore-async store))
+             (<! (.close (:backing store)))
+             (<! (idb/delete-idb "cache-store"))
+             (done)))))
+
+(deftest cache-PKeyIterable-test
+  (async done
+         (go
+           (<! (idb/delete-idb "cache-store"))
+           (let [store (<! (idb/connect-idb-store "cache-store"))]
+             (<! (ct/test-cached-PKeyIterable-async store))
+             (<! (.close (:backing store)))
+             (<! (idb/delete-idb "cache-store"))
+             (done)))))
+
+(deftest cache-PBin-test
+  (async done
+         (go
+           (<! (idb/delete-idb "cache-store"))
+           (let [store (<! (idb/connect-idb-store "cache-store"))]
+             (<! (ct/test-cached-PBin-async store idb/read-web-stream))
+             (<! (.close (:backing store)))
+             (<! (idb/delete-idb "cache-store"))
+             (done)))))
+
+#!============
+#! GC tests
+
+(deftest async-gc-test
+  (async done
+         (go
+           (<! (idb/delete-idb "gc-store"))
+           (let [store (<! (idb/connect-idb-store "gc-store"))]
+             (<! (gct/test-gc-async store))
+             (<! (.close (:backing store)))
+             (<! (idb/delete-idb "gc-store"))
+             (done)))))
+
+#!==================
+#! Serializers tests
+
+(deftest fressian-serializer-test
+  (async done
+         (go
+           (<! (st/test-fressian-serializers-async "serializers-test"
+                                                   idb/connect-idb-store
+                                                   idb/delete-idb
+                                                   idb/read-web-stream))
+           (done))))
+
+#!==================
+#! Encryptor tests
+
+(deftest encryptor-async-test
+  (async done
+         (go
+           (<! (et/async-encryptor-test "encryptor-test"
+                                        idb/connect-idb-store
+                                        idb/delete-idb))
+           (done))))
\ No newline at end of file
diff --git a/test/konserve/memory_test.cljc b/test/konserve/memory_test.cljc
new file mode 100644
index 0000000..7e5559f
--- /dev/null
+++ b/test/konserve/memory_test.cljc
@@ -0,0 +1,51 @@
+(ns konserve.memory-test
+  (:require [clojure.core.async :as a :refer [go <! take! #?(:clj <!!)]]
+            [clojure.test :refer [deftest #?(:cljs async)]]
+            [konserve.compliance-test :refer [#?(:clj compliance-test)
+                                              async-compliance-test]]
+            [konserve.memory :refer [new-mem-store map->MemoryStore]]
+            [konserve.tests.cache :as ct]
+            [konserve.tests.gc :as gct]))
+
+(defn connect-mem-store
+  [init-atom & {:as params opts :opts}]
+  (let [store-config (merge {:state init-atom
+                             :read-handlers (atom {})
+                             :write-handlers (atom {})
+                             :locks (atom {})}
+                            (dissoc params :config))
+        store (map->MemoryStore store-config)]
+    (if (:sync? opts) store (go store))))
+
+#?(:clj
+   (deftest memory-store-compliance-test
+     (compliance-test (<!! (new-mem-store)))))
+
+#!============
+#! Cache tests
+
+(deftest cache-PEDNKeyValueStore-test
+  (let [store (connect-mem-store (atom nil) :opts {:sync? true})]
+    #?(:clj (<!! (ct/test-cached-PEDNKeyValueStore-async store))
+       :cljs (async done (take! (ct/test-cached-PEDNKeyValueStore-async store) done)))))
+
+(deftest cache-PKeyIterable-test
+  (let [store (connect-mem-store (atom nil) :opts {:sync? true})]
+    #?(:clj  (<!! (ct/test-cached-PKeyIterable-async store))
+       :cljs (async done (take! (ct/test-cached-PKeyIterable-async store) done)))))
+
+(deftest cache-PBin-test
+  (let [store (connect-mem-store (atom nil) :opts {:sync? true})
+        f (fn [{:keys [input-stream] :as arg}]
+            (a/to-chan! [input-stream]))]
+    #?(:clj  (<!! (ct/test-cached-PBin-async store f))
+       :cljs (async done (take! (ct/test-cached-PBin-async store f) done)))))
+
+#!============
+#! GC tests
+
+(deftest async-gc-test
+  (let [store (connect-mem-store (atom nil) :opts {:sync? true})]
+    #?(:clj  (<!! (gct/test-gc-async store))
+       :cljs (async done (take! (gct/test-gc-async store) done)))))
+
diff --git a/test/konserve/node_filestore_test.cljs b/test/konserve/node_filestore_test.cljs
index 5193251..50f7bd3 100644
--- a/test/konserve/node_filestore_test.cljs
+++ b/test/konserve/node_filestore_test.cljs
@@ -1,13 +1,17 @@
 (ns konserve.node-filestore-test
-  (:require-macros [cljs.core.async.macros :refer [go]])
-  (:require [cljs.core.async :refer [<! put! chan timeout]]
+  (:require [clojure.core.async :refer [go promise-chan <! put! chan timeout to-chan!]]
             [cljs-node-io.fs :as fs]
+            [cljs-node-io.core :as io]
             [cljs.test :refer-macros [deftest is testing async use-fixtures]]
             [fress.api :as fress]
             [konserve.core :as k]
             [konserve.impl.defaults :as d]
-            [konserve.node-filestore :as filestore]
-            [konserve.protocols :as p]))
+            [konserve.node-filestore :as filestore :refer [connect-fs-store]]
+            [konserve.protocols :as p]
+            [konserve.tests.cache :as ct]
+            [konserve.tests.encryptor :as et]
+            [konserve.tests.gc :as gct]
+            [konserve.tests.serializers :as st]))
 
 (def store-path "/tmp/konserve-fs-nodejs-test")
 
@@ -15,7 +19,7 @@
 
 (deftest PEDNKeyValueStore-sync-test
   (let [opts {:sync? true}
-        store (filestore/connect-fs-store store-path :opts opts)]
+        store (connect-fs-store store-path :opts opts)]
     (and
      (is (false? (p/-exists? store :bar opts)))
      (is (= :not-found (p/-get-in store [:bar] :not-found opts)))
@@ -37,9 +41,9 @@
 
 (deftest existing-store-sync-test
   (let [opts {:sync? true}
-        store (filestore/connect-fs-store store-path :opts opts)]
+        store (connect-fs-store store-path :opts opts)]
     (is (= [nil {:a 42 :b "a string"}] (p/-assoc-in store [:my-db] identity {:a 42 :b "a string"} opts)))
-    (let [store' (filestore/connect-fs-store store-path :opts opts)]
+    (let [store' (connect-fs-store store-path :opts opts)]
       (is (= [{:a 42 :b "a string"} {:a 42 :b "a string" :c 'sym}]
              (p/-update-in store' [:my-db] identity (fn [m] (assoc m :c 'sym)) opts))))))
 
@@ -47,9 +51,9 @@
   (async done
          (go
            (let [opts {:sync? false}
-                 store (<! (filestore/connect-fs-store store-path :opts opts))]
+                 store (<! (connect-fs-store store-path :opts opts))]
              (is (= [nil {:a 42 :b "a string"}] (<! (p/-assoc-in store [:my-db] identity {:a 42 :b "a string"} opts))))
-             (let [store' (<! (filestore/connect-fs-store store-path :opts opts))]
+             (let [store' (<! (connect-fs-store store-path :opts opts))]
                (is (= [{:a 42 :b "a string"} {:a 42 :b "a string" :c 'sym}]
                       (<! (p/-update-in store' [:my-db] identity (fn [m] (assoc m :c 'sym)) opts))))
                (done))))))
@@ -58,7 +62,7 @@
   (async done
          (go
            (let [opts {:sync? false}
-                 store (<! (filestore/connect-fs-store store-path :opts opts))]
+                 store (<! (connect-fs-store store-path :opts opts))]
              (is (false? (<! (p/-exists? store :bar opts))))
              (is (= :not-found (<! (p/-get-in store [:bar] :not-found opts))))
              (is (= [nil 42] (<! (p/-assoc-in store [:bar] identity 42 opts))))
@@ -78,26 +82,23 @@
              (is (false? (<! (p/-exists? store :bar opts))))
              (done)))))
 
-; TODO what are bget semantics (stream & chan behaviors) when called on a deleted store
 (deftest PBinaryKeyValueStore-async-test
   (async done
          (let [opts {:sync? false}
                data [:this/is 'some/fressian "data 😀😀😀" (js/Date.) #{true false nil}]
                bytes (fress/write data)
-               test-data (chan)
                locked-cb (fn [{readable :input-stream}]
-                           (put! test-data (fress/read (.read readable)))
-                           (.destroy readable))]
+                           (to-chan! [(fress/read (.read readable))]))]
            (go
-             (let [store (<! (filestore/connect-fs-store store-path :opts opts))]
-               (is (true? (<! (p/-bassoc store :key identity bytes opts))))
-               (<! (p/-bget store :key locked-cb opts))
-               (is (= data (<! test-data)))
+             (let [store (<! (connect-fs-store store-path :opts opts))]
+               (and
+                (is (true? (<! (p/-bassoc store :key identity bytes opts))))
+                (is (= data (<! (p/-bget store :key locked-cb opts)))))
                (done))))))
 
 (deftest PKeyIterable-sync-test
   (let [opts {:sync? true}
-        store (filestore/connect-fs-store store-path :opts opts)]
+        store (connect-fs-store store-path :opts opts)]
     (is (= #{} (k/keys store opts)))
     (is (= [nil 42] (k/assoc-in store [:value-blob] 42 opts)))
     (is (true? (k/bassoc store :bin-blob #js[255 255 255] opts)))
@@ -108,7 +109,7 @@
   (async done
          (go
            (let [opts {:sync? false}
-                 store (<! (filestore/connect-fs-store store-path :opts opts))]
+                 store (<! (connect-fs-store store-path :opts opts))]
              (is (= #{} (<! (k/keys store opts))))
              (is (= [nil 42] (<! (k/assoc-in store [:value-blob] 42 opts))))
              (is (true? (<! (k/bassoc store :bin-blob #js[255 255 255] opts))))
@@ -119,7 +120,7 @@
 
 (deftest append-store-sync-test
   (let [opts {:sync? true}
-        store (filestore/connect-fs-store store-path :opts opts)]
+        store (connect-fs-store store-path :opts opts)]
     (k/append store :foolog {:bar 42} opts)
     (k/append store :foolog {:bar 43} opts)
     (is (= '({:bar 42} {:bar 43}) (k/log store :foolog opts)))
@@ -133,7 +134,7 @@
   (async done
          (go
            (let [opts {:sync? false}
-                 store (<! (filestore/connect-fs-store store-path :opts opts))]
+                 store (<! (connect-fs-store store-path :opts opts))]
              (is (uuid? (second (<! (k/append store :foolog {:bar 42} opts)))))
              (is (uuid? (second (<! (k/append store :foolog {:bar 43} opts)))))
              (is (= '({:bar 42} {:bar 43}) (<! (k/log store :foolog opts))))
@@ -151,7 +152,7 @@
   (async done
          (go
            (let [opts {:sync? false}
-                 store (<! (filestore/connect-fs-store store-path :opts opts))
+                 store (<! (connect-fs-store store-path :opts opts))
                  key :key
                  key-file-path (path.join store-path (d/key->store-key key))]
              (testing "no lock, writes ok"
@@ -168,3 +169,69 @@
                    (is (= [42 43] (<! op-chan)))))
                (is (nil? (<! (.close fc)))))
              (done)))))
+
+#!============
+#! Cache tests
+
+(deftest cache-PEDNKeyValueStore-test
+  (filestore/delete-store "/tmp/cache-store")
+  (async done
+         (go
+           (let [store (<! (connect-fs-store "/tmp/cache-store"))]
+             (<! (ct/test-cached-PEDNKeyValueStore-async store))
+             (done)))))
+
+(deftest cache-PKeyIterable-test
+  (filestore/delete-store "/tmp/cache-store")
+  (async done
+         (go
+           (let [store (<! (connect-fs-store "/tmp/cache-store"))]
+             (<! (ct/test-cached-PKeyIterable-async store))
+             (done)))))
+
+(deftest cache-PBin-test
+  (filestore/delete-store "/tmp/cache-store")
+  (async done
+         (go
+           (let [store (<! (connect-fs-store "/tmp/cache-store"))
+                 f (fn [{:keys [input-stream]}]
+                     (to-chan! [(.read input-stream)]))]
+             (<! (ct/test-cached-PBin-async store f))
+             (done)))))
+
+#!============
+#! GC tests
+
+(deftest async-gc-test
+  (filestore/delete-store "/tmp/gc-store")
+  (async done
+         (go
+           (let [store (<! (connect-fs-store "/tmp/gc-store"))]
+             (<! (gct/test-gc-async store))
+             (done)))))
+
+#!==================
+#! Serializers tests
+
+(deftest fressian-serializer-test
+  (async done
+         (go
+           (<! (st/test-fressian-serializers-async "/tmp/serializers-test"
+                                                   connect-fs-store
+                                                   (fn [store-name]
+                                                     (go (filestore/delete-store store-name)))
+                                                   (fn [{:keys [input-stream]}]
+                                                     (to-chan! [(.read input-stream)]))))
+           (done))))
+
+#!==================
+#! Encryptor tests
+
+(deftest encryptor-async-test
+  (async done
+         (go
+           (<! (et/async-encryptor-test "/tmp/encryptor-test"
+                                        connect-fs-store
+                                        (fn [store-name]
+                                          (go (filestore/delete-store store-name)))))
+           (done))))
\ No newline at end of file
diff --git a/test/konserve/serializers_test.clj b/test/konserve/serializers_test.clj
deleted file mode 100644
index b5b5aa0..0000000
--- a/test/konserve/serializers_test.clj
+++ /dev/null
@@ -1,51 +0,0 @@
-(ns konserve.serializers-test
-  (:require [clojure.test :refer [deftest is testing]]
-            [clojure.core.async :refer [<!!]]
-            [konserve.core :as k]
-            [konserve.serializers :refer [fressian-serializer]]
-            [konserve.filestore :refer [connect-fs-store delete-store]])
-  (:import [org.fressian.handlers WriteHandler ReadHandler]
-           (java.util Date)))
-
-(def custom-tag "java.util.Date")
-
-(def custom-read-handler
-  {custom-tag (reify ReadHandler
-                (read [_ reader _tag _component-count]
-                  (Date. ^long (.readObject reader))))})
-
-(def custom-write-handler
-  {Date {custom-tag (reify WriteHandler
-                      (write [_ writer instant]
-                        (.writeTag    writer custom-tag 1)
-                        (.writeObject writer (.getTime ^Date instant))))}})
-
-(deftest serializers-test
-  (testing "Test the custom fressian serializers functionality."
-    (let [folder "/tmp/konserve-fs-serializers-test"
-          _      (delete-store folder)
-          store  (<!! (connect-fs-store folder :serializers {:FressianSerializer (fressian-serializer custom-read-handler custom-write-handler)}))]
-      (is (= (<!! (k/get-in store [:foo]))
-             nil))
-      (<!! (k/assoc-in store [:foo] (Date.)))
-      (is (= (type (<!! (k/get-in store [:foo])))
-             Date))
-      (<!! (k/dissoc store :foo))
-      (is (= (<!! (k/get-in store [:foo]))
-             nil))
-      (delete-store folder))))
-
-(deftest cbor-serializer-test
-  (testing "Test CBOR serializer functionality."
-    (let [folder "/tmp/konserve-fs-cbor-test"
-          _      (delete-store folder)
-          store  (<!! (connect-fs-store folder :default-serializer :CBORSerializer))]
-      (is (= (<!! (k/get-in store [:foo]))
-             nil))
-      (<!! (k/assoc-in store [:foo] (Date.)))
-      (is (= (type (<!! (k/get-in store [:foo])))
-             java.time.Instant))
-      (<!! (k/dissoc store :foo))
-      (is (= (<!! (k/get-in store [:foo]))
-             nil))
-      (delete-store folder))))
diff --git a/test/konserve/serializers_test.cljs b/test/konserve/serializers_test.cljs
deleted file mode 100644
index 73d01b3..0000000
--- a/test/konserve/serializers_test.cljs
+++ /dev/null
@@ -1,39 +0,0 @@
-(ns konserve.serializers-test
-  (:require-macros [cljs.core.async.macros :refer [go]])
-  (:require   [cljs.core.async :as async :refer [<!]]
-              [cljs.test :refer-macros [deftest is async]]
-              [fress.api :as fress]
-              [konserve.core :as k]
-              [konserve.serializers :refer [fressian-serializer]]
-              [konserve.node-filestore :as filestore]))
-
-(deftype MyType [field0 field1]
-  IEquiv
-  (-equiv [_this o]
-    (and (instance? MyType o)
-         (= field0 (.-field0 o))
-         (= field1 (.-field1 o)))))
-
-(def custom-read-handler
-  {"my-type" (fn [reader _tag _field-count]
-               (let [field0 (fress.api/read-object reader)
-                     field1 (fress.api/read-object reader)]
-                 (MyType. field0 field1)))})
-
-(def custom-write-handler
-  {MyType (fn [writer o]
-            (fress.api/write-tag writer "my-type" 2)
-            (fress.api/write-object writer (.-field0 o))
-            (fress.api/write-object writer (.-field1 o)))})
-
-(deftest serializers-test
-  (async done
-         (go
-           (let [store-path "/tmp/konserve-fs-serializer-node-test"
-                 _ (filestore/delete-store store-path)
-                 ser (fressian-serializer custom-read-handler custom-write-handler)
-                 store (<! (filestore/connect-fs-store store-path :serializers {:FressianSerializer ser}))
-                 mt (MyType. :a/b "c")]
-             (is (= [nil mt] (<! (k/assoc-in store [:my-type] mt))))
-             (is (= mt (<! (k/get-in store [:my-type]))))
-             (done)))))
diff --git a/test/konserve/tests/cache.cljc b/test/konserve/tests/cache.cljc
new file mode 100644
index 0000000..c2d7921
--- /dev/null
+++ b/test/konserve/tests/cache.cljc
@@ -0,0 +1,61 @@
+(ns konserve.tests.cache
+  (:require [clojure.core.async :refer [go <! promise-chan put! take!]]
+            [clojure.test :refer [deftest is]]
+            [fress.api :as fress]
+            [konserve.cache :as kc]
+            #?(:cljs [fress.util :refer [byte-array]])))
+
+(defn test-cached-PEDNKeyValueStore-async [store]
+  (go
+    (let [store (kc/ensure-cache store)
+          opts {:sync? false}]
+      (and
+       (is (nil? (<! (kc/get store :foo nil opts))))
+       (is (false? (<! (kc/exists? store :foo opts))))
+       (is [nil :bar] (<! (kc/assoc store :foo :bar opts)))
+       (is (true? (<! (kc/exists? store :foo))))
+       (is (= :bar (<! (kc/get store :foo nil opts))))
+       (is (= [nil :bar2] (<! (kc/assoc-in store [:foo] :bar2 opts))))
+       (is (= :bar2 (<! (kc/get store :foo nil opts))))
+       (is (= :default (<! (kc/get-in store [:fuu] :default opts))))
+       (is (= :bar2 (<! (kc/get store :foo nil opts))))
+       (is (= :default (<! (kc/get-in store [:fuu] :default opts))))
+       (is (= [:bar2 "bar2"] (<! (kc/update-in store [:foo] name opts))))
+       (is (= "bar2" (<! (kc/get store :foo nil opts))))
+       (is (=  [nil {:bar 42}] (<! (kc/assoc-in store [:baz] {:bar 42} opts))))
+       (is (= 42 (<! (kc/get-in store [:baz :bar] nil opts))))
+       (is (= [{:bar 42} {:bar 43}] (<! (kc/update-in store [:baz :bar] inc opts))))
+       (is (= 43 (<! (kc/get-in store [:baz :bar] nil opts))))
+       (is (= [{:bar 43} {:bar 48}] (<! (kc/update-in store [:baz :bar] (fn [x] (+ x 2 3)) opts))))
+       (is (= 48 (<! (kc/get-in store [:baz :bar] nil opts))))
+       (is (true? (<! (kc/dissoc store :foo opts))))
+       (is (nil? (<! (kc/get-in store [:foo] nil opts))))))))
+
+(defn test-cached-PKeyIterable-async [store]
+  (go
+    (let [store (kc/ensure-cache store)
+          opts {:sync? false}]
+      (and
+       (is (= #{} (<! (kc/keys store opts))))
+       (is (= [nil 42] (<! (kc/assoc-in store [:value-blob] 42 opts))))
+       (is (true? (<! (kc/bassoc store :bin-blob (byte-array [255 255 255]) opts))))
+       (let [store-keys (<! (kc/keys store opts))]
+         (and
+          (is (every? inst? (map :last-write store-keys)))
+          (is (= #{{:key :bin-blob :type :binary} {:key :value-blob :type :edn}}
+                 (set (map #(dissoc % :last-write) store-keys))))))))))
+
+(defn test-cached-PBin-async [store locked-cb]
+  (let [store (kc/ensure-cache store)
+        data [:this/is
+              'some/fressian
+              "data 😀😀😀"
+              #?(:cljs (js/Date.) :clj (java.util.Date.))
+              #{true false nil}]
+        bytes #?(:cljs (fress/write data)
+                 :clj (.array (fress/write data)))
+        bytes-ch (promise-chan)]
+    (go
+      (and
+       (is (true? (<! (kc/bassoc store :key bytes {:sync? false}))))
+       (is (= data (fress/read (<! (kc/bget store :key locked-cb {:sync? false})))))))))
diff --git a/test/konserve/tests/encryptor.cljc b/test/konserve/tests/encryptor.cljc
new file mode 100644
index 0000000..fc3da44
--- /dev/null
+++ b/test/konserve/tests/encryptor.cljc
@@ -0,0 +1,28 @@
+(ns konserve.tests.encryptor
+  (:require [clojure.core.async :refer [go <!]]
+            [clojure.test :refer [deftest is]]
+            [konserve.compliance-test :refer
+             [#?(:clj compliance-test)
+              async-compliance-test]]
+            [superv.async :refer [<?-]]))
+
+(defn async-encryptor-test
+  [store-name create-store delete-store-async]
+  (go
+    (<! (delete-store-async store-name))
+    (let [config {:encryptor {:type :aes :key "s3cr3t"}}
+          store  (<?- (create-store store-name :config config))]
+      (<! (async-compliance-test store))
+      #?(:cljs (when (.-close (:backing store)) (<! (.close (:backing store)))))
+      (<! (delete-store-async store-name)))))
+
+#?(:clj
+   (defn sync-encryptor-test
+     [store-name create-store delete-store]
+     (delete-store store-name)
+     (let [store  (create-store store-name
+                                :config {:encryptor {:type :aes
+                                                     :key "s3cr3t"}}
+                                :opts {:sync? true})]
+       (compliance-test store)
+       (delete-store store-name))))
\ No newline at end of file
diff --git a/test/konserve/tests/gc.cljc b/test/konserve/tests/gc.cljc
new file mode 100644
index 0000000..d386e44
--- /dev/null
+++ b/test/konserve/tests/gc.cljc
@@ -0,0 +1,31 @@
+(ns konserve.tests.gc
+  "gc/sweep! is async only"
+  (:require [clojure.core.async :refer [go] :as a]
+            [clojure.test :refer [deftest is testing]]
+            #?(:cljs [fress.util :refer [byte-array]])
+            [konserve.core :as k]
+            [konserve.gc :as gc]
+            [superv.async :refer [<?-]]))
+
+(defn test-gc-async [store]
+  (go
+    (and
+     (<?- (k/assoc store :foo :bar))
+     (<?- (k/assoc-in store [:foo] :bar2))
+     (<?- (k/assoc-in store [:foo2] :bar2))
+     (<?- (k/assoc-in store [:foo3] :bar2))
+     (let [_ (a/<! (a/timeout 10))
+           ts        #?(:cljs (js/Date.) :clj (java.util.Date.))
+           whitelist #{:baz}]
+       (a/<! (a/timeout 10))
+       (and
+        (is (= [:bar2 "bar2"]        (<?- (k/update-in store [:foo] name))))
+        (is (= [nil {:bar 42}]       (<?- (k/assoc-in store  [:baz] {:bar 42}))))
+        (is (= [{:bar 42} {:bar 43}] (<?- (k/update-in store [:baz :bar] inc))))
+        (is (= [{:bar 43} {:bar 48}] (<?- (k/update-in store [:baz :bar] #(+ % 2 3)))))
+        (is (true? (<?- (k/bassoc store :binbar (byte-array (into-array (range 10)))))))
+        (is (= #{:foo :foo2 :foo3 :baz :binbar}
+               (into #{} (map :key) (<?- (k/keys store)))))
+        (is (= #{:foo2 :foo3} (<?- (gc/sweep! store whitelist ts))))
+        (is (= #{:foo :baz :binbar}
+               (into #{} (map :key) (<?- (k/keys store))))))))))
diff --git a/test/konserve/tests/serializers.cljc b/test/konserve/tests/serializers.cljc
new file mode 100644
index 0000000..1ba2e36
--- /dev/null
+++ b/test/konserve/tests/serializers.cljc
@@ -0,0 +1,187 @@
+(ns konserve.tests.serializers
+  (:require [clojure.core.async :as a :refer [<! go #?(:clj <!!)]]
+            [clojure.test :refer [is testing]]
+            [fress.api :as fress]
+            [konserve.core :as k]
+            [konserve.serializers :refer [fressian-serializer]]
+            [incognito.base #?@(:cljs [:refer [IncognitoTaggedLiteral]])])
+  #?(:clj
+     (:import [org.fressian.handlers WriteHandler ReadHandler]
+              [incognito.base IncognitoTaggedLiteral]
+              (java.util Date))))
+
+(deftype MyType [a b]
+  #?@(:clj
+      (Object
+       (equals [this other]
+               (and (instance? MyType other)
+                    (= a (.a ^MyType other))
+                    (= b (.b ^MyType other))))
+       (hashCode [this] (hash [a b])))
+      :cljs
+      (IEquiv
+       (-equiv [this other]
+               (and (instance? MyType other)
+                    (= a (.-a ^MyType other))
+                    (= b (.-b ^MyType other)))))))
+
+(defrecord MyRecord [a b])
+
+(def custom-read-handlers
+  {"my-type"
+   #?(:clj
+      (reify ReadHandler
+        (read [_ rdr _ _]
+          (MyType. (fress/read-object rdr)
+                   (fress/read-object rdr))))
+      :cljs
+      (fn [rdr _ _]
+        (MyType. (fress.api/read-object rdr)
+                 (fress.api/read-object rdr))))
+   "custom-tag"
+   #?(:clj
+      (reify ReadHandler
+        (read [_ rdr _ _]
+          (Date. ^long (.readObject rdr))))
+      :cljs
+      (fn [rdr _ _]
+        (doto (js/Date.)
+          (.setTime (fress/read-object rdr)))))
+   "my-record"
+   #?(:clj
+      (reify ReadHandler
+        (read [_ rdr _ _]
+          (MyRecord. (fress/read-object rdr)
+                     (fress/read-object rdr))))
+      :cljs
+      (fn [rdr _ _]
+        (MyRecord. (fress/read-object rdr)
+                   (fress/read-object rdr))))})
+
+(def custom-write-handlers
+  {#?(:clj Date :cljs js/Date)
+   {"custom-tag"
+    #?(:clj
+       (reify WriteHandler
+         (write [_ writer instant]
+           (fress/write-tag    writer "custom-tag" 1)
+           (fress/write-object writer (.getTime ^Date instant))))
+       :cljs
+       (fn [wrt date]
+         (fress/write-tag wrt "custom-tag" 1)
+         (fress/write-object wrt (.getTime date))))}
+   MyType {"my-type"
+           #?(:clj
+              (reify WriteHandler
+                (write [_ writer o]
+                  (fress/write-tag writer "my-type" 2)
+                  (fress/write-object writer ^MyType (.-a o))
+                  (fress/write-object writer ^MyType (.-b o))))
+              :cljs
+              (fn [writer o]
+                (fress/write-tag writer "my-type" 2)
+                (fress/write-object writer (.-a o))
+                (fress/write-object writer (.-b o))))}
+   MyRecord {"my-record"
+             #?(:clj
+                (reify WriteHandler
+                  (write [_ writer o]
+                    (fress/write-tag writer "my-record" 2)
+                    (fress/write-object writer (.-a o))
+                    (fress/write-object writer (.-b o))))
+                :cljs
+                (fn [writer o]
+                  (fress/write-tag writer "my-record" 2)
+                  (fress/write-object writer (.-a o))
+                  (fress/write-object writer (.-b o))))}})
+
+(defn- test-fressian-incognito-record-recovery
+  [store-name connect-store delete-store-async locked-cb]
+  (go
+    (testing ":read-handlers arg to connect-store let's us recover records"
+      (let [read-handlers {'konserve.tests.serializers.MyRecord map->MyRecord}
+            _ (<! (delete-store-async store-name))
+            store (<! (connect-store store-name
+                                     :read-handlers (atom read-handlers)))
+            my-record (map->MyRecord {:a 0 :b 1})]
+        (and
+         (is (nil? (<! (k/get-in store [:foo]))))
+         (is (= [nil my-record] (<! (k/assoc-in store [:foo] my-record))))
+         (testing "written as 'irecord'"
+           (let [bytes (<! (k/bget store :foo locked-cb))
+                 o (fress/read bytes)]
+             (and (is (fress/tagged-object? o))
+                  (is (= "irecord" (fress/tag o))))))
+         (is (= my-record (<! (k/get-in store [:foo])))))
+        #?(:cljs (when (.-close (:backing store)) (<! (.close (:backing store)))))
+        (<! (delete-store-async store-name))))))
+
+(defn test-fressian-serializers-async
+  "Test roundtripping custom types and records using the :FressianSerializer.
+   `locked-cb` is used to verify fressian bytes, needs to simply pass through
+   the input-stream on jvm or a full realized byte array in js"
+  [store-name connect-store delete-store-async locked-cb]
+  (go
+    (and
+     (testing ":serializers arg to connect-store"
+       (let [serializers {:FressianSerializer (fressian-serializer custom-read-handlers
+                                                                   custom-write-handlers)}
+             _ (assert (nil? (<! (delete-store-async store-name))))
+             store (<! (connect-store store-name :serializers serializers))
+             d #?(:clj (Date.) :cljs (js/Date.))
+             my-type (MyType. "a" "b")
+             my-record (map->MyRecord {:a 0 :b 1})
+             res (and
+                  (is [nil 42] (<! (k/assoc-in store [:foo] 42)))
+                  (is (= 42 (<! (k/get-in store [:foo]))))
+                  (is (= [nil d] (<! (k/assoc-in store [:foo] d))))
+                  (testing "should be written with custom-tag not built-in"
+                    (let [bytes (<! (k/bget store :foo locked-cb))
+                          o (fress/read bytes)]
+                      (and (is (fress/tagged-object? o))
+                           (is (= "custom-tag" (fress/tag o))))))
+                  (is (= d (<! (k/get-in store  [:foo]))))
+                  (is (= [nil my-type] (<! (k/assoc-in store [:foo] my-type))))
+                  (is (= my-type (<! (k/get-in store [:foo]))))
+                  (testing "custom write-handler takes precedent over incognito"
+                    (and
+                     (is (= [nil my-record] (<! (k/assoc-in store [:foo] my-record))))
+                     (let [bytes (<! (k/bget store :foo locked-cb))
+                           o (fress/read bytes)]
+                       (and (is (fress/tagged-object? o))
+                            (is (= "my-record" (fress/tag o)))))
+                     (is (= my-record (<! (k/get-in store [:foo])))))))]
+         #?(:cljs (when (.-close (:backing store)) (<! (.close (:backing store)))))
+         res))
+     (testing "records are intercepted by incognito by default"
+       (let [_ (<! (delete-store-async store-name))
+             store (<! (connect-store store-name))
+             my-record (map->MyRecord {:a 0 :b 1})
+             res (and
+                  (is (= [nil my-record] (<! (k/assoc-in store [:bar] my-record))))
+                  (testing "written as 'irecord'"
+                    (let [bytes (<! (k/bget store :bar locked-cb))
+                          o (fress/read bytes)]
+                      (and (is (fress/tagged-object? o))
+                           (is (= "irecord" (fress/tag o))))))
+                  (is (instance? IncognitoTaggedLiteral (<! (k/get-in store [:bar])))))]
+         #?(:cljs (when (.-close (:backing store)) (<! (.close (:backing store)))))
+         res))
+     #?(:clj (<! (test-fressian-incognito-record-recovery store-name connect-store delete-store-async locked-cb))
+        :cljs (when goog.DEBUG
+               ;; incognito uses reflection to get record name, will not work
+               ;; at rt w/ cljs :advanced. Need string tag statically available
+               ;; see https://github.com/pkpkpk/fress#records
+                (<! (test-fressian-incognito-record-recovery store-name connect-store delete-store-async locked-cb)))))))
+
+#?(:clj
+   (defn cbor-serializer-test [store-name connect-store delete-store-async]
+     (testing "Test CBOR serializer functionality."
+       (let [_      (<!! (delete-store-async store-name))
+             store  (<!! (connect-store store-name :default-serializer :CBORSerializer))]
+         (is (nil? (<!! (k/get-in store [:foo]))))
+         (<!! (k/assoc-in store [:foo] (Date.)))
+         (is (= java.time.Instant (type (<!! (k/get-in store [:foo])))))
+         (<!! (k/dissoc store :foo))
+         (is (nil? (<!! (k/get-in store [:foo]))))
+         (<!! (delete-store-async store-name))))))
\ No newline at end of file
diff --git a/tests.edn b/tests.edn
deleted file mode 100644
index c4d5de6..0000000
--- a/tests.edn
+++ /dev/null
@@ -1,13 +0,0 @@
-#kaocha/v1 {:tests [{:id :unit}
-                    #_{:id :unit-node ;; Throws known kaocha error
-                       :type :kaocha.type/cljs
-                       :kaocha.filter/skip-meta [:browser]
-                       :cljs/repl-env cljs.repl.node/repl-env
-                       :timeout 30000}
-                    {:id :unit-browser
-                     :type :kaocha.type/cljs
-                     :kaocha.filter/focus-meta [:browser]
-                     :cljs/repl-env cljs.repl.browser/repl-env
-                     :timeout 30000}]
-            :bindings {kaocha.type.cljs/*debug* true}
-            :reporter kaocha.report/documentation}