diff --git a/.github/workflows/build_test.yml b/.github/workflows/build_test.yml
index e08415a3..37e21952 100644
--- a/.github/workflows/build_test.yml
+++ b/.github/workflows/build_test.yml
@@ -25,5 +25,3 @@ jobs:
           cli: latest
           lein: latest
       - run: ./script/test_clj.sh
-#     - run: ./script/test_cljs.sh
-#     - run: ./script/test_js.sh
diff --git a/bench/dbval/bench/bench.cljc b/bench/dbval/bench/bench.clj
similarity index 60%
rename from bench/dbval/bench/bench.cljc
rename to bench/dbval/bench/bench.clj
index 2d08240e..fe82f25d 100644
--- a/bench/dbval/bench/bench.cljc
+++ b/bench/dbval/bench/bench.clj
@@ -1,7 +1,6 @@
 (ns dbval.bench.bench
   (:require
-   #?(:clj [clj-async-profiler.core :as clj-async-profiler]))
-  #?(:cljs (:require-macros dbval.bench.bench)))
+   [clj-async-profiler.core :as clj-async-profiler]))
 
 ; Measure time
 
@@ -11,13 +10,11 @@
 (def ^:dynamic *batch*     10)
 (def ^:dynamic *profile*   false)
 
-#?(:cljs (defn ^number now [] (js/performance.now))
-   :clj  (defn now ^double [] (/ (System/nanoTime) 1000000.0)))
+(defn now ^double [] (/ (System/nanoTime) 1000000.0))
 
-#?(:clj
-   (defmacro dotime
-     "Runs form duration, returns average time (ms) per iteration"
-     [duration & body]
+(defmacro dotime
+  "Runs form duration, returns average time (ms) per iteration"
+  [duration & body]
      `(let [start-t# (now)
             end-t#   (+ ~duration start-t#)]
         (loop [iterations# *batch*]
@@ -25,17 +22,13 @@
           (let [now# (now)]
             (if (< now# end-t#)
               (recur (+ *batch* iterations#))
-              (double (/ (- now# start-t#) iterations#))))))))
-
-(defn- if-cljs [env then else]
-  (if (:ns env) then else))
+              (double (/ (- now# start-t#) iterations#)))))))
 
 (defn median [xs]
   (nth (sort xs) (quot (count xs) 2)))
 
 (defn to-fixed [n places]
-  #?(:cljs (.toFixed n places)
-     :clj  (String/format java.util.Locale/ROOT (str "%." places "f") (to-array [(double n)]))))
+  (String/format java.util.Locale/ROOT (str "%." places "f") (to-array [(double n)])))
 
 (defn round [n]
   (cond
@@ -53,30 +46,22 @@
     (str s (apply str (repeat (- l (count s)) " ")))
     s))
 
-#?(:clj
-   (defmacro bench
-     "Runs for *wramup-ms* + *bench-ms*, returns median time (ms) per iteration"
-     [title & body]
-     (let [[title body] (if (string? title)
-                         [title body]
-                         ["unknown-bench" (cons title body)])]
-       (if-cljs &env
-         `(let [_#     (dotime *warmup-ms* ~@body)
-                times# (mapv
-                         (fn [_#]
-                           (dotime *bench-ms* ~@body))
-                         (range *samples*))]
-            {:mean-ms (median times#)})
-         `(let [_#      (dotime *warmup-ms* ~@body)
-                _#      (when *profile* (clj-async-profiler/start {}))
-                times#  (mapv
-                          (fn [_#]
-                            (dotime *bench-ms* ~@body))
-                          (range *samples*))
-                file#   (when *profile* (clj-async-profiler/stop {:title ~title}))]
-            (cond->
-              {:mean-ms (median times#)}
-              file# (assoc :file (.getAbsolutePath ^java.io.File file#))))))))
+(defmacro bench
+  "Runs for *warmup-ms* + *bench-ms*, returns median time (ms) per iteration"
+  [title & body]
+  (let [[title body] (if (string? title)
+                       [title body]
+                       ["unknown-bench" (cons title body)])]
+    `(let [_#      (dotime *warmup-ms* ~@body)
+           _#      (when *profile* (clj-async-profiler/start {}))
+           times#  (mapv
+                     (fn [_#]
+                       (dotime *bench-ms* ~@body))
+                     (range *samples*))
+           file#   (when *profile* (clj-async-profiler/stop {:title ~title}))]
+       (cond->
+         {:mean-ms (median times#)}
+         file# (assoc :file (.getAbsolutePath ^java.io.File file#))))))
 
 ;; test dbs
 
@@ -138,15 +123,23 @@
           y (range depth)
           :let [from (+ (* x (inc depth)) y)
                 to   (+ (* x (inc depth)) y 1)]]
-      [{:db/id   (inc from)
+      [{:db/id   (str (inc from))
         :name    "Ivan"
-        :follows (inc to)}
-       {:db/id   (inc to)
+        :follows (str (inc to))}
+       {:db/id   (str (inc to))
         :name    "Ivan"}])))
 
 (def people (repeatedly random-man))
 
+(def *people1k
+  "Dataset for transaction benchmarks: every iteration replays all
+   transactions against a fresh store, so the count stays small."
+  (delay
+    (shuffle
+      (take 1000 people))))
+
 (def *people20k
+  "Dataset for query benchmarks: the db is built once and only read."
   (delay
     (shuffle
       (take 20000 people))))
diff --git a/bench/dbval/bench/datascript.cljc b/bench/dbval/bench/run.clj
similarity index 52%
rename from bench/dbval/bench/datascript.cljc
rename to bench/dbval/bench/run.clj
index 4037c080..8fa552f8 100644
--- a/bench/dbval/bench/datascript.cljc
+++ b/bench/dbval/bench/run.clj
@@ -1,10 +1,18 @@
-(ns dbval.bench.datascript
+(ns dbval.bench.run
+  "Benchmarks for dbval.
+
+   Two kinds of benchmarks:
+
+   - Transaction benchmarks (`add-*`, `init`, `retract-5`) replay all
+     transactions against a fresh store on every iteration, because a db
+     snapshot cannot be transacted against once its store has moved on.
+     They use the small `*people1k` dataset and run with `*batch*` 1.
+     Note: every iteration creates a temporary SQLite file.
+
+   - Query/read benchmarks build a store once and only read from it."
   (:require
    [dbval.core :as d]
-   [dbval.bench.bench :as bench]
-   #?(:clj [jsonista.core :as jsonista])))
-
-#?(:cljs (enable-console-print!))
+   [dbval.bench.bench :as bench]))
 
 (def schema
   {:id      {:db/unique :db.unique/identity}
@@ -12,106 +20,133 @@
              :db/cardinality :db.cardinality/many}
    :alias   {:db/cardinality :db.cardinality/many}})
 
-(def empty-db (d/empty-db schema))
-
-(def *db100k
+(def *db20k
   (delay
     (d/db-with (d/empty-db schema) @bench/*people20k)))
 
 (defn wide-db [depth width]
-  (d/db-with empty-db (bench/wide-db 1 depth width)))
+  (d/db-with (d/empty-db schema) (bench/wide-db 1 depth width)))
 
 (defn long-db [depth width]
-  (d/db-with empty-db (bench/long-db depth width)))
+  (d/db-with (d/empty-db schema) (bench/long-db depth width)))
+
+;; transactions
 
 (defn bench-add-1 []
-  (bench/bench
-    (reduce
-      (fn [db p]
-        (-> db
-          (d/db-with [[:db/add (:db/id p) :name      (:name p)]])
-          (d/db-with [[:db/add (:db/id p) :last-name (:last-name p)]])
-          (d/db-with [[:db/add (:db/id p) :sex       (:sex p)]])
-          (d/db-with [[:db/add (:db/id p) :age       (:age p)]])
-          (d/db-with [[:db/add (:db/id p) :salary    (:salary p)]])))
-      empty-db
-      @bench/*people20k)))
+  (binding [bench/*batch* 1]
+    (bench/bench "add-1"
+      (reduce
+        (fn [db p]
+          (-> db
+            (d/db-with [[:db/add (:db/id p) :name      (:name p)]])
+            (d/db-with [[:db/add (:db/id p) :last-name (:last-name p)]])
+            (d/db-with [[:db/add (:db/id p) :sex       (:sex p)]])
+            (d/db-with [[:db/add (:db/id p) :age       (:age p)]])
+            (d/db-with [[:db/add (:db/id p) :salary    (:salary p)]])))
+        (d/empty-db schema)
+        @bench/*people1k))))
 
 (defn bench-add-5 []
-  (bench/bench
-    (reduce
-      (fn [db p]
-        (d/db-with db [p]))
-      empty-db
-      @bench/*people20k)))
+  (binding [bench/*batch* 1]
+    (bench/bench "add-5"
+      (reduce
+        (fn [db p]
+          (d/db-with db [p]))
+        (d/empty-db schema)
+        @bench/*people1k))))
 
 (defn bench-add-all []
-  (bench/bench
-    (d/db-with
-      empty-db
-      @bench/*people20k)))
+  (binding [bench/*batch* 1]
+    (bench/bench "add-all"
+      (d/db-with
+        (d/empty-db schema)
+        @bench/*people1k))))
 
 (defn bench-init []
-  (let [datoms (into []
-                 (for [p @bench/*people20k
-                       :let [id (#?(:clj Integer/parseInt :cljs js/parseInt) (:db/id p))]
+  (let [eids   (into {}
+                 (map (fn [p] [(:db/id p) (random-uuid)]))
+                 @bench/*people1k)
+        datoms (into []
+                 (for [p @bench/*people1k
+                       :let [id (eids (:db/id p))]
                        [k v] p
-                       :when (not= k :db/id)]
+                       :when (not= k :db/id)
+                       ;; explode cardinality-many values into datoms,
+                       ;; like transacting the map would
+                       v (if (sequential? v) v [v])]
                    (d/datom id k v)))]
-    (bench/bench
-      (d/init-db datoms))))
+    (binding [bench/*batch* 1]
+      (bench/bench "init"
+        (d/init-db datoms)))))
+
+(defn bench-retract-5 []
+  ;; includes rebuilding the store: a snapshot cannot be re-retracted once
+  ;; its store has moved on
+  (binding [bench/*batch* 1]
+    (bench/bench "retract-5"
+      (let [db   (d/db-with (d/empty-db schema) @bench/*people1k)
+            eids (->> (d/datoms db :aevt :name) (map :e) (shuffle))]
+        (reduce (fn [db eid] (d/db-with db [[:db.fn/retractEntity eid]])) db eids)))))
+
+;; reads
+
+(def *eids1k
+  (delay
+    (->> (d/datoms @*db20k :aevt :full-name)
+      (map :e)
+      (shuffle)
+      (take 1000)
+      (vec))))
 
 (defn bench-find-datoms []
-  (bench/bench
-    (doseq [id (range 9000 11000)]
-      (-> (d/datoms @*db100k :eavt id :full-name)
-        first
-        :v))))
+  (let [db   @*db20k
+        eids @*eids1k]
+    (bench/bench "find-datoms"
+      (doseq [id eids]
+        (-> (d/datoms db :eavt id :full-name)
+          first
+          :v)))))
 
 (defn bench-find-datom []
-  (bench/bench
-    (doseq [id (range 9000 11000)]
-      (-> (d/find-datom @*db100k :eavt id :full-name)
-        :v))))
-
-(defn bench-retract-5 []
-  (let [db   (d/db-with empty-db @bench/*people20k)
-        eids (->> (d/datoms db :aevt :name) (map :e) (shuffle))]
-    (bench/bench
-      (reduce (fn [db eid] (d/db-with db [[:db.fn/retractEntity eid]])) db eids))))
+  (let [db   @*db20k
+        eids @*eids1k]
+    (bench/bench "find-datom"
+      (doseq [id eids]
+        (-> (d/find-datom db :eavt id :full-name)
+          :v)))))
 
 (defn bench-q1 []
-  (bench/bench
+  (bench/bench "q1"
     (d/q '[:find ?e
            :where [?e :name "Ivan"]]
-      @*db100k)))
+      @*db20k)))
 
 (defn bench-q2 []
-  (bench/bench
+  (bench/bench "q2"
     (d/q '[:find ?e ?a
            :where [?e :name "Ivan"]
                   [?e :age ?a]]
-      @*db100k)))
+      @*db20k)))
 
 (defn bench-q3 []
-  (bench/bench
+  (bench/bench "q3"
     (d/q '[:find ?e ?a
            :where [?e :name "Ivan"]
                   [?e :age ?a]
                   [?e :sex :male]]
-      @*db100k)))
+      @*db20k)))
 
 (defn bench-q4 []
-  (bench/bench
+  (bench/bench "q4"
     (d/q '[:find ?e ?l ?a
            :where [?e :name "Ivan"]
                   [?e :last-name ?l]
                   [?e :age ?a]
                   [?e :sex :male]]
-      @*db100k)))
+      @*db20k)))
 
 (defn bench-q5-shortcircuit []
-  (bench/bench
+  (bench/bench "q5-shortcircuit"
     (d/q '[:find ?e ?n ?l ?a ?s ?al
            :in $ ?n ?a
            :where [?e :name ?n]
@@ -119,24 +154,26 @@
                   [?e :last-name ?l]
                   [?e :sex ?s]
                   [?e :alias ?al]]
-      @*db100k
+      @*db20k
       "Anastasia"
       35)))
 
 (defn bench-qpred1 []
-  (bench/bench
+  (bench/bench "qpred1"
     (d/q '[:find ?e ?s
            :where [?e :salary ?s]
                   [(> ?s 50000)]]
-      @*db100k)))
+      @*db20k)))
 
 (defn bench-qpred2 []
-  (bench/bench
+  (bench/bench "qpred2"
     (d/q '[:find ?e ?s
            :in   $ ?min_s
            :where [?e :salary ?s]
                   [(> ?s ?min_s)]]
-      @*db100k 50000)))
+      @*db20k 50000)))
+
+;; pull
 
 (def *pull-db
   (delay
@@ -147,28 +184,30 @@
             (assoc
               (select-keys entity [:name])
               :follows (mapv f (:follows entity))))]
-    (bench/bench
+    (bench/bench "pull-one-entities"
       (f (d/entity @*pull-db [:id 1])))))
 
 (defn bench-pull-one []
-  (bench/bench
-    (d/pull @*pull-db [:name {:follows '...}] 1)))
+  (bench/bench "pull-one"
+    (d/pull @*pull-db [:name {:follows '...}] [:id 1])))
 
 (defn bench-pull-many-entities []
   (let [f (fn f [entity]
             (assoc
               (select-keys entity [:db/id :last-name :alias :sex :age :salary])
               :follows (mapv f (:follows entity))))]
-    (bench/bench
+    (bench/bench "pull-many-entities"
       (f (d/entity @*pull-db [:id 1])))))
 
 (defn bench-pull-many []
-  (bench/bench
-    (d/pull @*pull-db [:db/id :last-name :alias :sex :age :salary {:follows '...}] 1)))
+  (bench/bench "pull-many"
+    (d/pull @*pull-db [:db/id :last-name :alias :sex :age :salary {:follows '...}] [:id 1])))
 
 (defn bench-pull-wildcard []
-  (bench/bench
-    (d/pull @*pull-db ['* {:follows '...}] 1)))
+  (bench/bench "pull-wildcard"
+    (d/pull @*pull-db ['* {:follows '...}] [:id 1])))
+
+;; rules
 
 (defn bench-rules [db]
   (d/q '[:find ?e ?e2
@@ -183,49 +222,31 @@
 
 (defn bench-rules-wide-3x3 []
   (let [db (wide-db 3 3)]
-    (bench/bench (bench-rules db))))
+    (bench/bench "rules-wide-3x3" (bench-rules db))))
 
 (defn bench-rules-wide-5x3 []
   (let [db (wide-db 5 3)]
-    (bench/bench (bench-rules db))))
+    (bench/bench "rules-wide-5x3" (bench-rules db))))
 
 (defn bench-rules-wide-7x3 []
   (let [db (wide-db 7 3)]
-    (bench/bench (bench-rules db))))
+    (bench/bench "rules-wide-7x3" (bench-rules db))))
 
 (defn bench-rules-wide-4x6 []
   (let [db (wide-db 4 6)]
-    (bench/bench (bench-rules db))))
+    (bench/bench "rules-wide-4x6" (bench-rules db))))
 
 (defn bench-rules-long-10x3 []
   (let [db (long-db 10 3)]
-    (bench/bench (bench-rules db))))
+    (bench/bench "rules-long-10x3" (bench-rules db))))
 
 (defn bench-rules-long-30x3 []
   (let [db (long-db 30 3)]
-    (bench/bench (bench-rules db))))
+    (bench/bench "rules-long-30x3" (bench-rules db))))
 
 (defn bench-rules-long-30x5 []
   (let [db (long-db 30 5)]
-    (bench/bench (bench-rules db))))
-
-(def *serialize-db 
-  (delay
-    (d/db-with empty-db
-      (take 300000 bench/people))))
-
-#?(:clj
-   (def mapper
-     (com.fasterxml.jackson.databind.ObjectMapper.)))
-
-(defn bench-freeze []
-  (bench/bench
-    (-> @*serialize-db (d/serializable) #?(:clj (jsonista/write-value-as-string mapper) :cljs js/JSON.stringify))))
-
-(defn bench-thaw []
-  (let [json (-> @*serialize-db (d/serializable) #?(:clj (jsonista/write-value-as-string mapper) :cljs js/JSON.stringify))]
-    (bench/bench
-      (-> json #?(:clj (jsonista/read-value mapper) :cljs js/JSON.parse) d/from-serializable))))
+    (bench/bench "rules-long-30x5" (bench-rules db))))
 
 (def benches
   {"add-1"              bench-add-1
@@ -253,18 +274,16 @@
    "rules-wide-4x6"     bench-rules-wide-4x6
    "rules-long-10x3"    bench-rules-long-10x3
    "rules-long-30x3"    bench-rules-long-30x3
-   "rules-long-30x5"    bench-rules-long-30x5
-   "freeze"             bench-freeze
-   "thaw"               bench-thaw})
+   "rules-long-30x5"    bench-rules-long-30x5})
 
 (defn ^:export -main
-  "clj -A:bench -M -m dbval.bench.datascript [--profile] (add-1 | add-5 | ...)*"
+  "./script/bench.sh [--profile] (add-1 | add-5 | ...)*"
   [& args]
   (let [args     (or args ())
         profile? (.contains ^java.util.List args "--profile")
         args     (remove #{"--profile"} args)
         names    (or (not-empty args) (sort (keys benches)))
-        _        (apply println #?(:clj "CLJ:" :cljs "CLJS:") names)
+        _        (apply println "Benchmarks:" names)
         longest  (last (sort-by count names))]
     (binding [bench/*profile* profile?]
       (doseq [name names
@@ -275,42 +294,6 @@
             (println
               (bench/right-pad name (count longest))
               " "
-              (bench/left-pad (bench/round mean-ms) 6) "ms/op"
+              (bench/left-pad (bench/round mean-ms) 8) "ms/op"
               " " (or file ""))))))
-    #?(:clj (shutdown-agents))))
-
-(comment
-  (require 'dbval.bench.datascript :reload-all)
-
-  (bench-add-1)
-  (bench-add-5)
-  (bench-add-all)
-  (bench-init)
-  (bench-retract-5)
-  (bench-q1)
-  (bench-q2)
-  (bench-q3)
-  (bench-q4)
-  (bench-q5-shortcircuit)
-  (bench-qpred1)
-  (bench-qpred2)
-  (bench-pull-one-entities)
-  (bench-pull-one)
-  (bench-pull-many-entities)
-  (bench-pull-many)
-  (bench-pull-all)
-  (binding [bench/*profile* true]
-    (bench-pull-one))
-  (binding [bench/*profile* true]
-    (bench-pull-many))
-  (binding [bench/*profile* true]
-    (bench-pull-all))
-  (bench-rules-wide-3x3)
-  (bench-rules-wide-5x3)
-  (bench-rules-wide-7x3)
-  (bench-rules-wide-4x6)
-  (bench-rules-long-10x3)
-  (bench-rules-long-30x3)
-  (bench-rules-long-30x5)
-  (bench-freeze)
-  (bench-thaw))
+    (shutdown-agents)))
diff --git a/bench_datomic/dbval/bench/datomic.clj b/bench_datomic/dbval/bench/datomic.clj
deleted file mode 100644
index 37fbb6ef..00000000
--- a/bench_datomic/dbval/bench/datomic.clj
+++ /dev/null
@@ -1,220 +0,0 @@
-(ns dbval.bench.datomic
-  (:require
-   [clojure.string :as str]
-   [datomic.api :as d]
-   [dbval.bench.bench :as bench]))
-
-;; tests
-
-(defn- schema-attr [name type & {:as args}]
-  (merge
-    {:db/id          (d/tempid :db.part/db)
-     :db/ident       name
-     :db/valueType   type
-     :db/cardinality :db.cardinality/one
-     :db.install/_attribute :db.part/db}
-    args))
-
-(defn new-conn
-  ([] (new-conn "bench"))
-  ([name]
-    (let [url (str "datomic:mem://" name)]
-      (d/delete-database url)
-      (d/create-database url)
-      (let [conn (d/connect url)]
-        @(d/transact conn
-          [(schema-attr :id        :db.type/long, :db/unique :db.unique/identity)
-           (schema-attr :name      :db.type/string)
-           (schema-attr :last-name :db.type/string)
-           (schema-attr :full-name :db.type/string)
-           (schema-attr :sex       :db.type/keyword)
-           (schema-attr :age       :db.type/long)
-           (schema-attr :salary    :db.type/long)
-           (schema-attr :alias     :db.type/string, :db/cardinality :db.cardinality/many)
-           (schema-attr :follows   :db.type/ref, :db/cardinality :db.cardinality/many)])
-        conn))))
-
-(defn db-with [conn tx-data]
-  (-> conn
-      (d/transact tx-data)
-      deref
-      :db-after))
-
-(def *db100k
-  (delay
-    (db-with (new-conn "db100k") @bench/*people20k)))
-
-(defn tempid [i]
-  (d/tempid :db.part/user (- i)))
-
-(defn bench-add-1 []
-  (bench/bench
-    (let [conn (new-conn)]
-      (doseq [p @bench/*people20k]
-        (let [report @(d/transact conn [[:db/add "p" :name (:name p)]])
-              id     (get (:tempids report) "p")]
-          @(d/transact conn [[:db/add id :last-name (:last-name p)]])
-          @(d/transact conn [[:db/add id :sex       (:sex p)]])
-          @(d/transact conn [[:db/add id :age       (:age p)]])
-          @(d/transact conn [[:db/add id :salary    (:salary p)]]))))))
-
-(defn bench-add-5 []
-  (bench/bench
-    (let [conn (new-conn)]
-      (doseq [p @bench/*people20k]
-        @(d/transact conn [p])))))
-
-(defn bench-add-all []
-  (bench/bench
-    (let [conn (new-conn)]
-      @(d/transact conn @bench/*people20k))))
-
-(defn bench-retract-5 []
-  (bench/bench
-    (let [conn (new-conn)
-          db   (db-with conn @bench/*people20k)
-          eids (->> (d/datoms db :aevt :name) (map :e) (shuffle))]
-      (doseq [eid eids]
-        @(d/transact conn [[:db.fn/retractEntity eid]])))))
-
-(defn bench-q1 []
-  (bench/bench
-    (d/q '[:find ?e
-           :where [?e :name "Ivan"]]
-      @*db100k)))
-
-(defn bench-q2 []
-  (bench/bench
-    (d/q '[:find ?e ?a
-           :where [?e :name "Ivan"]
-                  [?e :age ?a]]
-      @*db100k)))
-
-(defn bench-q3 []
-  (bench/bench
-    (d/q '[:find ?e ?a
-           :where [?e :name "Ivan"]
-                  [?e :age ?a]
-                  [?e :sex :male]]
-      @*db100k)))
-
-(defn bench-q4 []
-  (bench/bench
-    (d/q '[:find ?e ?l ?a
-           :where [?e :name "Ivan"]
-                  [?e :last-name ?l]
-                  [?e :age ?a]
-                  [?e :sex :male]]
-      @*db100k)))
-
-(defn bench-qpred1 []
-  (bench/bench
-    (d/q '[:find ?e ?s
-           :where [?e :salary ?s]
-                  [(> ?s 50000)]]
-      @*db100k)))
-
-(defn bench-qpred2 []
-  (bench/bench
-    (d/q '[:find ?e ?s
-           :in   $ ?min_s
-           :where [?e :salary ?s]
-                  [(> ?s ?min_s)]]
-      @*db100k 50000)))
-
-(def *pull-db
-  (delay
-    (db-with (new-conn "pull-db") (bench/wide-db 1 4 5))))
-
-(defn bench-pull-one []
-  @*pull-db
-  (bench/bench
-    (d/pull @*pull-db [:name {:follows '...}] [:id 1])))
-
-(defn bench-pull-one-entities []
-  @*pull-db
-  (let [f (fn f [entity]
-            (assoc
-              (select-keys entity [:name])
-              :follows (mapv f (:follows entity))))]
-    (bench/bench
-      (f (d/entity @*pull-db [:id 1])))))
-
-(defn bench-pull-many []
-  @*pull-db
-  (bench/bench
-    (d/pull @*pull-db [:db/id :last-name :alias :sex :age :salary {:follows '...}] [:id 1])))
-
-(defn bench-pull-many-entities []
-  @*pull-db
-  (let [f (fn f [entity]
-            (assoc
-              (select-keys entity [:db/id :last-name :alias :sex :age :salary])
-              :follows (mapv f (:follows entity))))]
-    (bench/bench
-      (f (d/entity @*pull-db [:id 1])))))
-
-(defn bench-pull-wildcard []
-  @*pull-db
-  (bench/bench
-    (d/pull @*pull-db ['* {:follows '...}] [:id 1])))
-
-(def benches
-  {"add-1"              bench-add-1
-   "add-5"              bench-add-5
-   "add-all"            bench-add-all
-   "retract-5"          bench-retract-5
-   "q1"                 bench-q1
-   "q2"                 bench-q2
-   "q3"                 bench-q3
-   "q4"                 bench-q4
-   "qpred1"             bench-qpred1
-   "qpred2"             bench-qpred2
-   "pull-one"           bench-pull-one
-   "pull-one-entities"  bench-pull-one-entities
-   "pull-many"          bench-pull-many
-   "pull-many-entities" bench-pull-many-entities
-   "pull-wildcard"      bench-pull-wildcard})
-
-(defn -main
-  "clj -A:bench:datomic -M -m dbval.bench.datomic [--profile] (add-1 | add-5 | ...)*"
-  [& args]
-  (let [profile? (.contains (or args ()) "--profile")
-        args     (remove #{"--profile"} args)
-        names    (or (not-empty args) (sort (keys benches)))
-        _        (apply println "Datomic:" names)
-        longest  (last (sort-by count names))]
-    (binding [bench/*profile* profile?]
-      (doseq [name names
-              :let [fn (benches name)]]
-        (if (nil? fn)
-          (println
-            (bench/right-pad name (count longest))
-            " ---")
-          (let [{:keys [mean-ms file]} (fn)]
-            (println
-              (bench/right-pad name (count longest))
-              " "
-              (bench/left-pad (bench/round mean-ms) 6) "ms/op"
-              " " (or file ""))))))
-    (shutdown-agents)))
-
-(comment
-  (-main)
-  (clojure.pprint/pprint (bench/wide-db 1 2 2))
-
-  (bench-add-1)
-  (bench-add-5)
-  (bench-add-all)
-  (bench-retract-5)
-  (bench-q1)
-  (bench-q2)
-  (bench-q3)
-  (bench-q4)
-  (bench-qpred1)
-  (bench-qpred2)
-  (bench-pull-one)
-  (bench-pull-one-entities)
-  (bench-pull-many)
-  (bench-pull-many-entities)
-  (bench-pull-wildcard))
\ No newline at end of file
diff --git a/deps.edn b/deps.edn
index 2a57f6d1..569483d5 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,8 +1,5 @@
 {:deps
- {persistent-sorted-set/persistent-sorted-set {:mvn/version "0.3.0"}
-  io.github.tonsky/extend-clj {:mvn/version "0.1.0"}
-  org.foundationdb/fdb-java {:mvn/version "7.3.47"}
-  com.taoensso/nippy {:mvn/version "3.6.0"}
+ {org.foundationdb/fdb-java {:mvn/version "7.3.47"}
   org.xerial/sqlite-jdbc {:mvn/version "3.47.1.0"}
   com.yetanalytics/colossal-squuid {:mvn/version "0.1.5"
                                     :exclusions
@@ -12,12 +9,7 @@
   }
   
  :aliases
- {:cljs
-  {:extra-paths ["test"]
-   :extra-deps
-   {org.clojure/clojurescript {:mvn/version "1.11.132"}}}
-  
-  :1.9
+ {:1.9
   {:override-deps
    {org.clojure/clojure {:mvn/version "1.9.0"}}}
   
@@ -38,10 +30,7 @@
    :jvm-opts    ["-ea" "-Ddbval.debug" "-Dclojure.main.report=stderr" "-Djdk.attach.allowAttachSelf"]
    :extra-deps
    {io.github.tonsky/duti      {:git/sha "e36d65296a4f9758664309ec35b00887e88c405a"}
-    metosin/jsonista           {:mvn/version "0.3.3"}
-    cheshire/cheshire          {:mvn/version "5.10.0"}
-    com.cognitect/transit-clj  {:mvn/version "1.0.324"}
-    com.cognitect/transit-cljs {:mvn/version "0.8.269"}}}
+    com.cognitect/transit-clj  {:mvn/version "1.0.324"}}}
 
   :bench
   {:extra-paths ["bench"]
@@ -50,10 +39,4 @@
               "-Djdk.attach.allowAttachSelf"
               "-XX:+DebugNonSafepoints"]
    :extra-deps
-   {metosin/jsonista {:mvn/version "0.3.3"}
-    io.github.tonsky/duti {:git/sha "e36d65296a4f9758664309ec35b00887e88c405a"}}}
-
-  :datomic
-  {:extra-paths ["bench_datomic" "test_datomic"]
-   :extra-deps
-   {com.datomic/peer {:mvn/version "1.0.6735"}}}}}
+   {io.github.tonsky/duti {:git/sha "e36d65296a4f9758664309ec35b00887e88c405a"}}}}}
diff --git a/dev/user.clj b/dev/user.clj
index 3b1ed25f..051f2109 100644
--- a/dev/user.clj
+++ b/dev/user.clj
@@ -11,7 +11,7 @@
   duti/-main)
 
 (defn test-all []
-  (duti/test #"dbval\.test\.(?!cljs).*"))
+  (duti/test #"dbval\.test\..*"))
 
 (defn -test-main [_]
-  (duti/test-exit #"dbval\.test\.(?!cljs).*"))
+  (duti/test-exit #"dbval\.test\..*"))
diff --git a/release-js/README.md b/release-js/README.md
deleted file mode 100644
index 30029370..00000000
--- a/release-js/README.md
+++ /dev/null
@@ -1,16 +0,0 @@
-# DataScript
-
-An immutable in-memory database and Datalog query engine for JS engines.
-
-DataScript is meant to run inside the browser. It is cheap to create, quick to query and ephemeral. You create a database on page load, put some data in it, track changes, do queries and forget about it when the user closes the page.
-
-DataScript databases are immutable and based on persistent data structures. In fact, they’re more like data structures than databases (think Hashmap). Unlike querying a real SQL DB, when you query DataScript, it all comes down to a Hashmap lookup. Or series of lookups. Or array iteration. There’s no particular overhead to it. You put a little data in it, it’s fast. You put in a lot of data, well, at least it has indexes. That should do better than you filtering an array by hand anyway. The thing is really lightweight.
-
-The intention with DataScript is to be a basic building block in client-side applications that needs to track a lot of state during their lifetime. There’s a lot of benefits:
-
-- Central, uniform approach to manage all application state. Clients working with state become decoupled and independent: rendering, server sync, undo/redo do not interfere with each other.
-- Immutability simplifies things even in a single-threaded browser environment. Keep track of app state evolution, rewind to any point in time, always render consistent state, sync in background without locking anybody.
-- Datalog query engine to answer non-trivial questions about current app state.
-- Structured format to track data coming in and out of DB. Datalog queries can be run against it too.
-
-For more info, check out [project page](https://github.com/tonsky/datascript)
diff --git a/release-js/package.json b/release-js/package.json
deleted file mode 100644
index d8ec7724..00000000
--- a/release-js/package.json
+++ /dev/null
@@ -1,46 +0,0 @@
-{
-  "name": "datascript",
-  "version": "1.7.5",
-  "description": "Immutable in-memory triplestore with Datalog queries",
-  "homepage": "https://github.com/tonsky/datascript",
-  "author": "Nikita Prokopov (https://github.com/tonsky)",
-  "keywords": [
-    "data",
-    "database",
-    "triplestore",
-    "datalog",
-    "persistent",
-    "immutable",
-    "clojure",
-    "clojurescript"
-  ],
-  "contributors": [
-    "Nikita Prokopov (https://github.com/tonsky)",
-    "David Thomas Hume (https://github.com/dthume)",
-    "montyxcantsin (https://github.com/montyxcantsin)",
-    "Ben Fleis (https://github.com/benfleis)",
-    "Gijs Stuurman (https://github.com/thegeez)",
-    "Yevgeny Armor (https://github.com/izirku)",
-    "Kevin Lynagh (https://github.com/lynaghk)",
-    "Bobby Calderwood (https://github.com/bobby)"
-  ],
-  "bugs": {
-    "url": "https://github.com/tonsky/datascript/issues"
-  },
-  "licenses": [
-    {
-      "type": "EPL",
-      "url": "https://github.com/tonsky/datascript/blob/master/LICENSE"
-    }
-  ],
-  "main": "./datascript.js",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/tonsky/datascript.git"
-  },
-  "engines": {
-      "node": ">=0.8.22"
-  },
-  "dependencies": {},
-  "files": ["datascript.js"]
-}
diff --git a/release-js/test_include_amd.html b/release-js/test_include_amd.html
deleted file mode 100644
index 8a959ba0..00000000
--- a/release-js/test_include_amd.html
+++ /dev/null
@@ -1,24 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>DataScript AMD load test</title>
-  </head>
-  <body>
-    <h1>DataScript AMD load test</h1>
-    <p id='output'>Check the browser console for errors and output.</p>
-    
-    <script src="http://requirejs.org/docs/release/2.1.15/minified/require.js"></script>
-    <script>
-      require(['datascript'], function(d) {
-        console.log("DataScript loaded using a require.js");
-        var conn = d.create_conn();
-        d.transact(conn, [[":db/add", -1, "name", "Ivan"]]);
-        var res = d.q("[:find ?e ?v :where [?e \"name\" ?v]]", d.db(conn));
-        var res_str = JSON.stringify(res);
-        document.getElementById('output').innerHTML = res_str;
-        console.log(res_str); // => [[1, "Ivan"]]
-      });
-    </script>
-
-  </body>
-</html>
diff --git a/release-js/test_include_node.js b/release-js/test_include_node.js
deleted file mode 100644
index a5680bd9..00000000
--- a/release-js/test_include_node.js
+++ /dev/null
@@ -1,6 +0,0 @@
-var d = require('./datascript');
-var conn = d.create_conn();
-d.transact(conn, [[":db/add", -1, "name", "Ivan"]]);
-var res = d.q("[:find ?e ?v :where [?e \"name\" ?v]]", d.db(conn));
-var res_str = JSON.stringify(res);
-console.log(res_str); // => [[1, "Ivan"]]
diff --git a/release-js/test_include_script.html b/release-js/test_include_script.html
deleted file mode 100644
index ff40563e..00000000
--- a/release-js/test_include_script.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>DataScript script tag load test</title>
-
-  </head>
-  <body>
-    <h1>DataScript script tag load test</h1>
-    <p id='output'>Check the browser console for errors and output.</p>
-    
-    <script src="datascript.js"></script>
-    <script>
-      if (datascript) {
-        console.log("DataScript loaded using a script tag");
-        
-        var d = datascript;
-        var conn = d.create_conn();
-        d.transact(conn, [[":db/add", -1, "name", "Ivan"]]);
-        var res = d.q("[:find ?e ?v :where [?e \"name\" ?v]]", d.db(conn));
-        var res_str = JSON.stringify(res);
-        document.getElementById('output').innerHTML = res_str;
-        console.log(res_str); // => [[1, "Ivan"]]
-      }
-    </script>
-  </body>
-</html>
diff --git a/release-js/wrap_bare.sh b/release-js/wrap_bare.sh
deleted file mode 100755
index 05a3204c..00000000
--- a/release-js/wrap_bare.sh
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/bin/sh
-
-set -e
-
-(cat release-js/wrapper.prefix; cat release-js/datascript.bare.js; cat release-js/wrapper.suffix) > release-js/datascript.js
-
-echo "Packed release-js/datascript.js"
diff --git a/release-js/wrapper.prefix b/release-js/wrapper.prefix
deleted file mode 100644
index 27de4a46..00000000
--- a/release-js/wrapper.prefix
+++ /dev/null
@@ -1,43 +0,0 @@
-/**
- * Datascript v1.7.5
- *
- * Copyright 2014-2021 Nikita Prokopov
- *
- * Licensed under Eclipse Public License;
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * https://github.com/tonsky/datascript/blob/master/LICENSE
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-(function (definition) {
-    // This file will function properly as a <script> tag, or a module
-    // using CommonJS and NodeJS or RequireJS module formats. In
-    // Common/Node/RequireJS, the module exports the mori API and when
-    // executed as a simple <script>, it creates a mori global
-    // instead.
-
-    // Wrapper gratefully adapted from:
-    // https://github.com/kriskowal/q/blob/v1/q.js
-    // https://github.com/swannodette/mori/blob/master/support/wrapper.js
-
-    // CommonJS
-    if (typeof exports === "object") {
-        module.exports = definition();
-
-    // RequireJS
-    } else if (typeof define === "function" && define.amd) {
-        define(definition);
-
-    // <script>
-    } else {
-        datascript = definition();
-    }
-})(function () {
-    return function () {
diff --git a/release-js/wrapper.suffix b/release-js/wrapper.suffix
deleted file mode 100644
index fa415aad..00000000
--- a/release-js/wrapper.suffix
+++ /dev/null
@@ -1,6 +0,0 @@
-
-        ;return this.datascript.js;
-
-    }.call({});
-
-});
diff --git a/script/bench.sh b/script/bench.sh
new file mode 100755
index 00000000..cd34ae1b
--- /dev/null
+++ b/script/bench.sh
@@ -0,0 +1,4 @@
+#!/bin/bash
+cd "`dirname $0`/.."
+
+clojure -A:bench -M -m dbval.bench.run $@
diff --git a/script/bench_all.sh b/script/bench_all.sh
deleted file mode 100755
index a29736c4..00000000
--- a/script/bench_all.sh
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/bin/bash
-cd "`dirname $0`/.."
-
-./script/bench_clj.sh $@
-./script/bench_cljs.sh $@
-./script/bench_datomic.sh $@
\ No newline at end of file
diff --git a/script/bench_clj.sh b/script/bench_clj.sh
deleted file mode 100755
index 7f0a6ca9..00000000
--- a/script/bench_clj.sh
+++ /dev/null
@@ -1,4 +0,0 @@
-#!/bin/bash
-cd "`dirname $0`/.."
-
-clojure -A:bench -M -m dbval.bench.datascript $@
\ No newline at end of file
diff --git a/script/bench_cljs.js b/script/bench_cljs.js
deleted file mode 100755
index 6a86a502..00000000
--- a/script/bench_cljs.js
+++ /dev/null
@@ -1,12 +0,0 @@
-#! node
-
-global.performance = {
-  now: function () {
-         var t = process.hrtime();
-         return t[0] * 1000 + t[1] / 1000000;
-       }
-}
-
-require("../target/dbval.js");
-
-dbval.bench.dbval._main(...process.argv.slice(2));
\ No newline at end of file
diff --git a/script/bench_cljs.sh b/script/bench_cljs.sh
deleted file mode 100755
index 10834147..00000000
--- a/script/bench_cljs.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/bin/bash
-cd "`dirname $0`/.."
-
-lein with-profile +bench cljsbuild once bench
-node script/bench_cljs.js $@
\ No newline at end of file
diff --git a/script/bench_datomic.sh b/script/bench_datomic.sh
deleted file mode 100755
index 9a6b3525..00000000
--- a/script/bench_datomic.sh
+++ /dev/null
@@ -1,4 +0,0 @@
-#!/bin/bash
-cd "`dirname $0`/.."
-
-clojure -A:bench:datomic -M -m dbval.bench.datomic $@
\ No newline at end of file
diff --git a/script/test_all.sh b/script/test_all.sh
deleted file mode 100755
index 9c438de5..00000000
--- a/script/test_all.sh
+++ /dev/null
@@ -1,10 +0,0 @@
-#!/bin/bash
-set -o nounset -o pipefail
-cd "`dirname $0`/.."
-
-EXIT=0
-./script/test_clj.sh || EXIT=$((EXIT + $?))
-./script/test_cljs.sh || EXIT=$((EXIT + $?))
-./script/test_js.sh || EXIT=$((EXIT + $?))
-./script/test_datomic.sh || EXIT=$((EXIT + $?))
-exit $EXIT
\ No newline at end of file
diff --git a/script/test_cljs.js b/script/test_cljs.js
deleted file mode 100644
index 3d1f0780..00000000
--- a/script/test_cljs.js
+++ /dev/null
@@ -1,32 +0,0 @@
-#! node
-
-var fs = require('fs'),
-    vm = require('vm');
-
-global.performance = { now: function () {
-  var t = process.hrtime();
-  return t[0] * 1000 + t[1] / 1000000;
-} }
-
-global.goog = {};
-
-global.CLOSURE_IMPORT_SCRIPT = function(src) {
-  require('./target/none/goog/' + src);
-  return true;
-};
-
-function nodeGlobalRequire(file) {
-  vm.runInThisContext.call(global, fs.readFileSync(file), file);
-}
-
-if (fs.existsSync("./target/none")) {
-  nodeGlobalRequire('./target/none/goog/base.js');
-  nodeGlobalRequire('./target/none/cljs_deps.js');
-  goog.require('datascript.test');
-} else
-  nodeGlobalRequire('./target/datascript.js');
-
-var res = datascript.test.test_cljs();
-
-if (res.fail + res.error > 0)
-  process.exit(1);
diff --git a/script/test_cljs.sh b/script/test_cljs.sh
deleted file mode 100755
index 363c50b4..00000000
--- a/script/test_cljs.sh
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/bin/bash
-set -o errexit -o nounset -o pipefail
-cd "`dirname $0`/.."
-
-lein with-profile test cljsbuild once advanced
-node script/test_cljs.js
\ No newline at end of file
diff --git a/script/test_datomic.sh b/script/test_datomic.sh
deleted file mode 100755
index 16200ffd..00000000
--- a/script/test_datomic.sh
+++ /dev/null
@@ -1,4 +0,0 @@
-#!/bin/zsh -euo pipefail
-cd "`dirname $0`/.."
-
-clj -A:datomic -M -m test-datomic.pull-api
\ No newline at end of file
diff --git a/script/test_js.js b/script/test_js.js
deleted file mode 100644
index abe6f3a9..00000000
--- a/script/test_js.js
+++ /dev/null
@@ -1,23 +0,0 @@
-#! node
-
-var fs = require('fs'),
-    vm = require('vm');
-
-global.performance = { now: function () {
-  var t = process.hrtime();
-  return t[0] * 1000 + t[1] / 1000000;
-} }
-
-global.goog = {};
-
-function nodeGlobalRequire(file) {
-  vm.runInThisContext.call(global, fs.readFileSync(file), file);
-}
-
-nodeGlobalRequire('./release-js/datascript.js');
-
-var tests_js = require('../test/js/tests.js');
-var res = tests_js.test_all();
-
-if (res.fail + res.error > 0)
-  process.exit(1);
diff --git a/script/test_js.sh b/script/test_js.sh
deleted file mode 100755
index e70b080f..00000000
--- a/script/test_js.sh
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/bin/bash
-set -o errexit -o nounset -o pipefail
-cd "`dirname $0`/.."
-
-lein with-profile test cljsbuild once release
-node script/test_js.js
\ No newline at end of file
diff --git a/src/dbval/arrays.clj b/src/dbval/arrays.clj
new file mode 100644
index 00000000..b7d1b5ab
--- /dev/null
+++ b/src/dbval/arrays.clj
@@ -0,0 +1,19 @@
+(ns ^:no-doc dbval.arrays
+  "Object-array helpers. Replaces me.tonsky.persistent-sorted-set.arrays,
+   which was dbval's last use of the persistent-sorted-set library."
+  (:refer-clojure :exclude [array? make-array aget aset aclone]))
+
+(defn array? [x]
+  (some-> ^Object x class .isArray))
+
+(defn make-array ^objects [n]
+  (object-array n))
+
+(defn aget [^objects a ^long i]
+  (clojure.core/aget a i))
+
+(defn aset [^objects a ^long i v]
+  (clojure.core/aset a i v))
+
+(defn aclone ^objects [^objects a]
+  (clojure.core/aclone a))
diff --git a/src/dbval/built_ins.cljc b/src/dbval/built_ins.clj
similarity index 98%
rename from src/dbval/built_ins.cljc
rename to src/dbval/built_ins.clj
index 2ef2141e..e3774f5f 100644
--- a/src/dbval/built_ins.cljc
+++ b/src/dbval/built_ins.clj
@@ -33,7 +33,7 @@
 (defn- and-fn [& args]
   (reduce (fn [a b]
             (if b b (reduced b))) true args))
-            
+
 (defn- or-fn [& args]
   (reduce (fn [a b]
             (if b (reduced b) b)) nil args))
@@ -124,7 +124,7 @@
     (/ sum (count coll))))
 
 (defn- aggregate-stddev [coll]
-  (#?(:cljs js/Math.sqrt :clj Math/sqrt) (aggregate-variance coll)))
+  (Math/sqrt (aggregate-variance coll)))
 
 (defn- aggregate-min
   ([coll]
diff --git a/src/dbval/conn.clj b/src/dbval/conn.clj
new file mode 100644
index 00000000..accfaac2
--- /dev/null
+++ b/src/dbval/conn.clj
@@ -0,0 +1,122 @@
+(ns dbval.conn
+  (:require
+    [dbval.db :as db])
+  (:import
+       [dbval.db DB FilteredDB]))
+
+(defn- current-db
+  "Derives the current database value from the underlying store. All
+   transacted state lives in the store, so the connection only has to attach
+   the latest transaction id to its in-memory db template (schema, caches,
+   storage connection)."
+  [{:keys [db]}]
+  (let [max-tx (db/q-max-tx db)]
+    (if (= max-tx (db/basis-tx db))
+      db
+      (db/with-max-tx db max-tx))))
+
+;; A connection is not a state container: the store is the single source of
+;; truth and `deref` derives the current database value from it. The `state`
+;; atom only holds process-local context: the db template (schema, caches,
+;; storage connection) and the listeners.
+;;
+;; Deliberately not an atom (`IAtom`): the previous implementation ran the
+;; side-effecting, committing transaction inside `swap!`, so a concurrent
+;; `:db` swap (e.g. `reset-schema!`) could fail the CAS and make `swap!`
+;; re-run the transaction — committing it twice. Writes are serialized with
+;; `locking` instead.
+(deftype Conn [state]
+  clojure.lang.IDeref
+       (deref [this]
+         ;; lock so that a deref never observes another thread's uncommitted
+         ;; transaction through the shared storage connection
+         (locking this
+           (current-db @state))))
+
+(defn conn? [conn]
+  (instance? Conn conn))
+
+(defn- make-conn [db]
+  (->Conn (atom {:db        db
+                 :listeners {}})))
+
+(defn- conn-state [conn]
+  (.-state ^Conn conn))
+
+(defn ^:no-doc listeners [conn]
+  (:listeners @(conn-state conn)))
+
+(defn with
+  ([db tx-data] (with db tx-data nil))
+  ([db tx-data tx-meta]
+   {:pre [(db/db? db)]}
+   (let [q-max-tx (db/q-max-tx db)
+         max-tx   (db/basis-tx db)]
+     ;; Check that the storage hasn't been modified since this db snapshot was created.
+     ;; q-max-tx is the latest tx in storage, max-tx is what this snapshot sees.
+     ;; If q-max-tx > max-tx, storage has been modified.
+     (when (pos? (compare q-max-tx max-tx))
+       (throw (ex-info "underlying tuple store has already been modified"
+                       {:max-tx max-tx
+                        :q-max-tx q-max-tx}))))
+   (if (instance? FilteredDB db)
+     (throw (ex-info "Filtered DB cannot be modified" {:error :transaction/filtered}))
+     (db/transact-tx-data (db/->TxReport db db [] {} tx-meta) tx-data))))
+
+(defn ^DB db-with
+  "Applies transaction to an immutable db value, returning new immutable db value. Same as `(:db-after (with db tx-data))`."
+  [db tx-data]
+  {:pre [(db/db? db)]}
+  (:db-after (with db tx-data)))
+
+(defn conn-from-db [db]
+  {:pre [(db/db? db)]}
+  (make-conn db))
+
+(defn conn-from-datoms
+  ([datoms]
+   (conn-from-db (db/init-db datoms nil {})))
+  ([datoms schema]
+   (conn-from-db (db/init-db datoms schema {})))
+  ([datoms schema opts]
+   (conn-from-db (db/init-db datoms schema opts))))
+
+(defn create-conn
+  ([]
+   (conn-from-db (db/empty-db nil {})))
+  ([schema]
+   (conn-from-db (db/empty-db schema {})))
+  ([schema opts]
+   (conn-from-db (db/empty-db schema opts))))
+
+(defn transact!
+  ([conn tx-data]
+   (transact! conn tx-data nil))
+  ([conn tx-data tx-meta]
+   {:pre [(conn? conn)]}
+   (locking conn
+     ;; the db value is derived from the store under the write lock, so the
+     ;; snapshot check in `with` always sees the latest transaction id
+     (let [report (with @conn tx-data tx-meta)]
+       (doseq [[_ callback] (listeners conn)]
+         (callback report))
+       report))))
+
+(defn reset-schema! [conn schema]
+  {:pre [(conn? conn)]}
+  (locking conn
+    (let [db (db/with-schema @conn schema)]
+      (swap! (conn-state conn) assoc :db db)
+      db)))
+
+(defn listen!
+  ([conn callback]
+   (listen! conn (rand) callback))
+  ([conn key callback]
+   {:pre [(conn? conn)]}
+   (swap! (conn-state conn) update :listeners assoc key callback)
+   key))
+
+(defn unlisten! [conn key]
+  {:pre [(conn? conn)]}
+  (swap! (conn-state conn) update :listeners dissoc key))
diff --git a/src/dbval/conn.cljc b/src/dbval/conn.cljc
deleted file mode 100644
index 8431efd9..00000000
--- a/src/dbval/conn.cljc
+++ /dev/null
@@ -1,109 +0,0 @@
-(ns dbval.conn
-  (:require
-    [dbval.db :as db #?@(:cljs [:refer [DB FilteredDB]])]
-    [extend-clj.core :as extend]
-    )
-  #?(:clj
-     (:import
-       [dbval.db DB FilteredDB])))
-
-(extend/deftype-atom Conn [atom]
-  (deref-impl [this]
-    (:db @atom))
-  (compare-and-set-impl [this oldv newv]
-    (compare-and-set!
-      atom
-      (assoc @atom :db oldv)
-      (assoc @atom :db newv))))
-
-(defn- make-conn [opts]
-  (->Conn (atom opts)))
-
-(defn with
-  ([db tx-data] (with db tx-data nil))
-  ([db tx-data tx-meta]
-   {:pre [(db/db? db)]}
-   (let [q-max-tx (db/q-max-tx db)
-         max-tx   (:max-tx db)]
-     ;; Check that the storage hasn't been modified since this db snapshot was created.
-     ;; q-max-tx is the latest tx in storage, max-tx is what this snapshot sees.
-     ;; If q-max-tx > max-tx, storage has been modified.
-     (when (pos? (compare q-max-tx max-tx))
-       (throw (ex-info "underlying tuple store has already been modified"
-                       {:max-tx max-tx
-                        :q-max-tx q-max-tx}))))
-   (if (instance? FilteredDB db)
-     (throw (ex-info "Filtered DB cannot be modified" {:error :transaction/filtered}))
-     (db/transact-tx-data (db/->TxReport db db [] {} tx-meta) tx-data))))
-
-(defn ^DB db-with
-  "Applies transaction to an immutable db value, returning new immutable db value. Same as `(:db-after (with db tx-data))`."
-  [db tx-data]
-  {:pre [(db/db? db)]}
-  (:db-after (with db tx-data)))
-
-(defn conn? [conn]
-  (and
-    #?(:clj  (instance? clojure.lang.IDeref conn)
-       :cljs (satisfies? cljs.core/IDeref conn))
-    (if-some [db @conn]
-      (db/db? db)
-      true)))
-
-(defn conn-from-db [db]
-  {:pre [(db/db? db)]}
-  (make-conn {:db db}))
-
-(defn conn-from-datoms
-  ([datoms]
-   (conn-from-db (db/init-db datoms nil {})))
-  ([datoms schema]
-   (conn-from-db (db/init-db datoms schema {})))
-  ([datoms schema opts]
-   (conn-from-db (db/init-db datoms schema opts))))
-
-(defn create-conn
-  ([]
-   (conn-from-db (db/empty-db nil {})))
-  ([schema]
-   (conn-from-db (db/empty-db schema {})))
-  ([schema opts]
-   (conn-from-db (db/empty-db schema opts))))
-
-(defn ^:no-doc -transact! [conn tx-data tx-meta]
-  {:pre [(conn? conn)]}
-  (let [*report (volatile! nil)]
-    (swap! conn
-      (fn [db]
-        (let [r (with db tx-data tx-meta)]
-          (vreset! *report r)
-          (:db-after r))))
-    @*report))
-
-(defn transact!
-  ([conn tx-data]
-   (transact! conn tx-data nil))
-  ([conn tx-data tx-meta]
-   {:pre [(conn? conn)]}
-   (locking conn
-     (let [report (-transact! conn tx-data tx-meta)]
-       (doseq [[_ callback] (:listeners @(:atom conn))]
-         (callback report))
-       report))))
-
-(defn reset-schema! [conn schema]
-  {:pre [(conn? conn)]}
-  (let [db (swap! conn db/with-schema schema)]
-    db))
-
-(defn listen!
-  ([conn callback]
-   (listen! conn (rand) callback))
-  ([conn key callback]
-   {:pre [(conn? conn)]}
-   (swap! (:atom conn) update :listeners assoc key callback)
-   key))
-
-(defn unlisten! [conn key]
-  {:pre [(conn? conn)]}
-  (swap! (:atom conn) update :listeners dissoc key))
diff --git a/src/dbval/core.cljc b/src/dbval/core.clj
similarity index 85%
rename from src/dbval/core.cljc
rename to src/dbval/core.clj
index 495731ad..673ecaca 100644
--- a/src/dbval/core.cljc
+++ b/src/dbval/core.clj
@@ -1,20 +1,18 @@
 (ns dbval.core
   (:refer-clojure :exclude [filter])
   (:require
-    [#?(:cljs cljs.reader :clj clojure.edn) :as edn]
+    [clojure.edn :as edn]
     [dbval.conn :as conn]
-    [dbval.db :as db #?@(:cljs [:refer [Datom DB FilteredDB]])]
-    #?(:clj [dbval.pprint])
+    [dbval.db :as db]
+    [dbval.pprint]
     [dbval.pull-api :as dp]
     [dbval.query :as dq]
     [dbval.impl.entity :as de]
-    [dbval.util :as util]
-    [me.tonsky.persistent-sorted-set :as set])
-  #?(:clj
-     (:import
+    [dbval.util :as util])
+  (:import
        [dbval.db Datom DB FilteredDB]
        [dbval.impl.entity Entity]
-       [java.util UUID])))
+       [java.util UUID]))
 
 (def ^:const ^:no-doc tx0 
   db/tx0)
@@ -27,10 +25,10 @@
        :doc "Retrieves an entity by its id from database. Entities are lazy map-like structures to navigate Dbval database content.
 
              For `eid` pass entity id or lookup attr:
-             
+
                  (entity db 1)
                  (entity db [:unique-attr :value])
-            
+
              If entity does not exist, `nil` is returned:
 
                  (entity db 100500) ; => nil
@@ -40,7 +38,7 @@
                  (entity db 1) ; => {:db/id 1}
 
              Entity attributes can be lazily accessed through key lookups:
-             
+
                  (:attr (entity db 1)) ; => :value
                  (get (entity db 1) :attr) ; => :value
 
@@ -57,13 +55,13 @@
 
                  (:_ref (entity db 2)) ; => [{:db/id 1}]
                  (:ns/_ref (entity db 2)) ; => [{:db/id 1}]
-             
+
              Reverse reference lookup returns sequence of entities unless attribute is marked as `:db/isComponent`:
 
                  (:_component-ref (entity db 2)) ; => {:db/id 1}
 
              Entity gotchas:
-               
+
              - Entities print as map, but are not exactly maps (they have compatible get interface though).
              - Entities are effectively immutable “views” into a particular version of a database.
              - Entities retain reference to the whole database.
@@ -134,7 +132,7 @@
     :doc "Executes a datalog query. See [docs.datomic.com/on-prem/query.html](https://docs.datomic.com/on-prem/query.html).
 
           Usage:
-          
+
           ```
           (q '[:find ?value
                :where [_ :likes ?value]]
@@ -150,7 +148,7 @@
   "Creates an empty database with an optional schema.
 
    Usage:
-   
+
    ```
    (empty-db) ; => #dbval/DB {:schema {}, :datoms []}
 
@@ -158,14 +156,11 @@
    ; => #dbval/DB {:schema {:likes {:db/cardinality :db.cardinality/many}}
    ;                    :datoms []}
    ```
-   
+
    Options are:
-   
-   :branching-factor <int>, default 512. B-tree max node length
-   :ref-type         :strong | :soft | :weak, default :soft. How will nodes that are already
-                     stored on disk be referenced. Soft or weak means they might be unloaded
-                     from memory under memory pressure and later fetched from storage again.
-   :storage          <IStorage>. Will be used to store this db later with `(d/store db)`"
+
+   :db-file <string>  Path to the SQLite file backing this database.
+                      Defaults to a fresh temporary file."
   ([]
    (db/empty-db nil {}))
   ([schema]
@@ -208,6 +203,12 @@
        :doc "Returns a schema of a database."}
   schema db/-schema)
 
+(def ^{:arglists '([db])
+       :doc "Returns the transaction id (the basis) up to which this database value sees the store.
+
+             Database values are opaque handles that hash and compare by reference identity (like Datomic databases). To compare two snapshots of the same store, compare their `basis-tx`."}
+  basis-tx db/basis-tx)
+
 
 ; Filtered db
 
@@ -218,7 +219,7 @@
 
 (defn filter
   "Returns a view over database that has same interface but only includes datoms for which the `(pred db datom)` is true. Can be applied multiple times.
-   
+
    Filtered DB gotchas:
 
    - All operations on filtered database are proxied to original DB, then filter pred is applied.
@@ -231,8 +232,8 @@
     (let [^FilteredDB fdb db
           orig-pred (.-pred fdb)
           orig-db   (.-unfiltered-db fdb)]
-      (FilteredDB. orig-db #(and (orig-pred %) (pred orig-db %)) (atom 0)))
-    (FilteredDB. db #(pred db %) (atom 0))))
+      (FilteredDB. orig-db #(and (orig-pred %) (pred orig-db %))))
+    (FilteredDB. db #(pred db %))))
 
 
 ; Changing DB
@@ -266,17 +267,17 @@
        ;     #dbval/Datom [1 :likes \"fries\"]
        ;     #dbval/Datom [1 :likes \"pizza\"]
        ;     #dbval/Datom [1 :name \"Ivan\"])
-  
+
        ; find all datoms for entity id == 1 and attribute == :likes (any values)
        ; sorted by value
        (datoms db :eavt 1 :likes)
        ; => (#dbval/Datom [1 :likes \"fries\"]
        ;     #dbval/Datom [1 :likes \"pizza\"])
-       
+
        ; find all datoms for entity id == 1, attribute == :likes and value == \"pizza\"
        (datoms db :eavt 1 :likes \"pizza\")
        ; => (#dbval/Datom [1 :likes \"pizza\"])
-  
+
        ; find all datoms for attribute == :likes (any entity ids and values)
        ; sorted by entity id, then value
        (datoms db :aevt :likes)
@@ -285,13 +286,13 @@
        ;     #dbval/Datom [2 :likes \"candy\"]
        ;     #dbval/Datom [2 :likes \"pie\"]
        ;     #dbval/Datom [2 :likes \"pizza\"])
-  
+
        ; find all datoms that have attribute == `:likes` and value == `\"pizza\"` (any entity id)
        ; `:likes` must be a unique attr, reference or marked as `:db/index true`
        (datoms db :avet :likes \"pizza\")
        ; => (#dbval/Datom [1 :likes \"pizza\"]
        ;     #dbval/Datom [2 :likes \"pizza\"])
-  
+
        ; find all datoms sorted by entity id, then attribute, then value
        (datoms db :eavt) ; => (...)
 
@@ -299,24 +300,24 @@
 
        ; get all values of :db.cardinality/many attribute
        (->> (datoms db :eavt eid attr) (map :v))
-  
+
        ; lookup entity ids by attribute value
        (->> (datoms db :avet attr value) (map :e))
-  
+
        ; find all entities with a specific attribute
        (->> (datoms db :aevt attr) (map :e))
-  
+
        ; find “singleton” entity by its attr
        (->> (datoms db :aevt attr) first :e)
-  
+
        ; find N entities with lowest attr value (e.g. 10 earliest posts)
        (->> (datoms db :avet attr) (take N))
-  
+
        ; find N entities with highest attr value (e.g. 10 latest posts)
        (->> (datoms db :avet attr) (reverse) (take N))
 
    Gotchas:
-   
+
    - Index lookup is usually more efficient than doing a query with a single clause.
    - Resulting iterator is calculated in constant time and small constant memory overhead.
    - Iterator supports efficient `first`, `next`, `reverse`, `seq` and is itself a sequence.
@@ -358,12 +359,12 @@
        ;     #dbval/Datom [2 :likes \"candy\"]
        ;     #dbval/Datom [2 :likes \"pie\"]
        ;     #dbval/Datom [2 :likes \"pizza\"])
-  
+
        (seek-datoms db :eavt 2) 
        ; => (#dbval/Datom [2 :likes \"candy\"]
        ;     #dbval/Datom [2 :likes \"pie\"]
        ;     #dbval/Datom [2 :likes \"pizza\"])
-  
+
        ; no datom [2 :likes \"fish\"], so starts with one immediately following such in index
        (seek-datoms db :eavt 2 :likes \"fish\")
        ; => (#dbval/Datom [2 :likes \"pie\"]
@@ -384,11 +385,11 @@
 
 (defn index-range
   "Returns part of `:avet` index between `[_ attr start]` and `[_ attr end]` in AVET sort order.
-  
+
    Same properties as [[datoms]].
-   
+
    `attr` must be a reference, unique attribute or marked as `:db/index true`.
-   
+
    Usage:
 
        (index-range db :likes \"a\" \"zzzzzzzzz\")
@@ -397,13 +398,13 @@
        ;     #dbval/Datom [2 :likes \"pie\"]
        ;     #dbval/Datom [1 :likes \"pizza\"]
        ;     #dbval/Datom [2 :likes \"pizza\"])
-        
+
        (index-range db :likes \"egg\" \"pineapple\")
        ; => (#dbval/Datom [1 :likes \"fries\"]
        ;     #dbval/Datom [2 :likes \"pie\"])
-           
+
    Useful patterns:
-     
+
        ; find all entities with age in a specific range (inclusive)
        (->> (index-range db :age 18 60) (map :e))"
   [db attr start end]
@@ -425,20 +426,20 @@
   conn/conn-from-datoms)
 
 (def ^{:arglists '([] [schema] [schema opts])} create-conn
-  "Creates a mutable reference (a “connection”) to an empty immutable database.
+  "Creates a “connection” to an empty database.
 
-   Connections are lightweight in-memory structures (~atoms) with direct support of transaction listeners ([[listen!]], [[unlisten!]]) and other handy Dbval APIs ([[transact!]], [[reset-conn!]], [[db]]).
+   A connection is a lightweight handle to the underlying storage — not a state container. It supports transaction listeners ([[listen!]], [[unlisten!]]) and [[transact!]].
+
+   To access the current immutable DB value, deref: `@conn`. The value is derived from the storage on every deref, so it also reflects transactions that did not go through this connection's [[transact!]] (e.g. [[db-with]] on a db value backed by the same storage connection).
 
-   To access underlying immutable DB value, deref: `@conn`.
-   
    For list of options, see [[empty-db]].
-   
+
    If you specify `:storage` option, conn will be stored automatically after each transaction"
   conn/create-conn)
 
 (def ^{:arglists '([conn tx-data] [conn tx-data tx-meta])} transact!
-  "Applies transaction the underlying database value and atomically updates connection reference to point to the result of that transaction, new db value.
-  
+  "Applies transaction to the connection's underlying storage and commits it. The new db value is visible via `@conn` afterwards.
+
    Returns transaction report, a map:
 
        {:db-before ...      ; db value before transaction
@@ -447,56 +448,56 @@
         :tempids   {...}    ; map of tempid from tx-data => assigned entid in db-after
         :tx-meta   tx-meta} ; the exact value you passed as `tx-meta`
 
-  Note! `conn` will be updated in-place and is not returned from [[transact!]].
-  
+  Note! [[transact!]] returns the transaction report, not the new db value — deref `conn` for that.
+
   Usage:
 
       ; add a single datom to an existing entity (1)
       (transact! conn [[:db/add 1 :name \"Ivan\"]])
-  
+
       ; retract a single datom
       (transact! conn [[:db/retract 1 :name \"Ivan\"]])
-  
+
       ; retract single entity attribute
       (transact! conn [[:db.fn/retractAttribute 1 :name]])
-  
+
       ; ... or equivalently (since Datomic changed its API to support this):
       (transact! conn [[:db/retract 1 :name]])
-      
+
       ; retract all entity attributes (effectively deletes entity)
       (transact! conn [[:db.fn/retractEntity 1]])
-  
+
       ; create a new entity (`-1`, as any other negative value, is a tempid
       ; that will be replaced with Dbval to a next unused eid)
       (transact! conn [[:db/add -1 :name \"Ivan\"]])
-  
+
       ; check assigned id (here `*1` is a result returned from previous `transact!` call)
       (def report *1)
       (:tempids report) ; => {-1 296}
-  
+
       ; check actual datoms inserted
       (:tx-data report) ; => [#dbval/Datom [296 :name \"Ivan\"]]
-  
+
       ; tempid can also be a string
       (transact! conn [[:db/add \"ivan\" :name \"Ivan\"]])
       (:tempids *1) ; => {\"ivan\" 297}
-  
+
       ; reference another entity (must exist)
       (transact! conn [[:db/add -1 :friend 296]])
-  
+
       ; create an entity and set multiple attributes (in a single transaction
       ; equal tempids will be replaced with the same yet unused entid)
       (transact! conn [[:db/add -1 :name \"Ivan\"]
                        [:db/add -1 :likes \"fries\"]
                        [:db/add -1 :likes \"pizza\"]
                        [:db/add -1 :friend 296]])
-  
+
       ; create an entity and set multiple attributes (alternative map form)
       (transact! conn [{:db/id  -1
                         :name   \"Ivan\"
                         :likes  [\"fries\" \"pizza\"]
                         :friend 296}])
-      
+
       ; update an entity (alternative map form). Can’t retract attributes in
       ; map form. For cardinality many attrs, value (fish in this example)
       ; will be added to the list of existing values
@@ -509,7 +510,7 @@
                         :name   \"Oleg\"
                         :friend {:db/id -2
                                  :name \"Sergey\"}}])
-                                 
+
       ; reverse attribute name can be used if you want created entity to become
       ; a value in another entity reference
       (transact! conn [{:db/id  -1
@@ -529,9 +530,9 @@
 (def ^{:arglists '([conn callback] [conn key callback])} listen!
   "Listen for changes on the given connection. Whenever a transaction is applied to the database via [[transact!]], the callback is called
    with the transaction report. `key` is any opaque unique value.
-   
+
    Idempotent. Calling [[listen!]] with the same key twice will override old callback with the new value.
-   
+
    Returns the key under which this listener is registered. See also [[unlisten!]]."
   conn/listen!)
 
@@ -550,43 +551,19 @@
   data-readers {'dbval/Datom db/datom-from-reader
                 'dbval/DB    db/db-from-reader})
 
-#?(:cljs
-   (doseq [[tag cb] data-readers] (edn/register-tag-parser! tag cb)))
-
 
 ;; UUID-based ID generation
 
 (def gen-id
   "Generates a random UUID for use as an entity id.
    Call as (gen-id) to get a new UUID."
-  #?(:clj  #(java.util.UUID/randomUUID)
-     :cljs #(random-uuid)))
+  #(java.util.UUID/randomUUID))
 
 ;; Datomic compatibility layer
 
-(defn tempid
-  "Allocates and returns a unique temporary id. Returns a random UUID, or :db/current-tx for the tx partition.
-
-   Exists for Datomic API compatibility. Prefer using (gen-id) or UUIDs directly."
-  ([part]
-   (if (= part :db.part/tx)
-     :db/current-tx
-     (gen-id)))
-  ([part x]
-   (if (= part :db.part/tx)
-     :db/current-tx
-     x)))
-
-(defn resolve-tempid
-  "Does a lookup in tempids map, returning the UUID that was assigned to a tempid.
-
-   Exists for Datomic API compatibility. Prefer using map lookup directly if possible."
-  [_db tempids tempid]
-  (get tempids tempid))
-
 (defn ^DB db
   "Returns the underlying immutable database value from a connection.
-   
+
    Exists for Datomic API compatibility. Prefer using `@conn` directly if possible."
   [conn]
   {:pre [(conn? conn)]}
@@ -594,65 +571,30 @@
 
 (defn transact
   "Same as [[transact!]], but returns an immediately realized future.
-  
+
    Exists for Datomic API compatibility. Prefer using [[transact!]] if possible."
   ([conn tx-data] (transact conn tx-data nil))
   ([conn tx-data tx-meta]
    {:pre [(conn? conn)]}
    (let [res (transact! conn tx-data tx-meta)]
-     #?(:cljs
-        (reify
-          IDeref
-          (-deref [_] res)
-          IDerefWithTimeout
-          (-deref-with-timeout [_ _ _] res)
-          IPending
-          (-realized? [_] true))
-        :clj
-        (reify
+     (reify
           clojure.lang.IDeref
           (deref [_] res)
           clojure.lang.IBlockingDeref
           (deref [_ _ _] res)
           clojure.lang.IPending
-          (isRealized [_] true))))))
+          (isRealized [_] true)))))
 
 
 ;; ersatz future without proper blocking
-#?(:cljs
-   (defn- future-call [f]
-     (let [res      (atom nil)
-           realized (atom false)]
-       (js/setTimeout #(do (reset! res (f)) (reset! realized true)) 0)
-       (reify
-         IDeref
-         (-deref [_] @res)
-         IDerefWithTimeout
-         (-deref-with-timeout [_ _ timeout-val] (if @realized @res timeout-val))
-         IPending
-         (-realized? [_] @realized)))))
+
 
 (defn transact-async
   "In CLJ, calls [[transact!]] on a future thread pool, returning immediately.
-  
+
    In CLJS, just calls [[transact!]] and returns a realized future."
   ([conn tx-data] (transact-async conn tx-data nil))
   ([conn tx-data tx-meta]
    {:pre [(conn? conn)]}
    (future-call #(transact! conn tx-data tx-meta))))
 
-
-;; squuid
-
-(def ^{:arglists '([] [msec])} squuid
-  "Generates a UUID that grow with time. Such UUIDs will always go to the end  of the index and that will minimize insertions in the middle.
-  
-   Consist of 64 bits of current UNIX timestamp (in seconds) and 64 random bits (2^64 different unique values per second)."
-  util/squuid)
-
-(def ^{:arglists '([uuid])} squuid-time-millis
-  "Returns time that was used in [[squuid]] call, in milliseconds, rounded to the closest second."
-  util/squuid-time-millis)
-
-(defn settings [db]
-  (set/settings (:eavt db)))
diff --git a/src/dbval/datafy.cljc b/src/dbval/datafy.clj
similarity index 87%
rename from src/dbval/datafy.cljc
rename to src/dbval/datafy.clj
index 9e0e8c4a..30aa3a25 100644
--- a/src/dbval/datafy.cljc
+++ b/src/dbval/datafy.clj
@@ -8,9 +8,9 @@
 (declare datafy-entity-seq)
 
 (defn- navize-pulled-entity [db-val pulled-entity]
-  (let [ref-attrs (:db.type/ref (:rschema db-val))
+  (let [ref-attrs (db/-attrs-by db-val :db.type/ref)
         ref-rattrs (set (map db/reverse-ref ref-attrs))
-        many-attrs (:db.cardinality/many (:rschema db-val))]
+        many-attrs (db/-attrs-by db-val :db.cardinality/many)]
     (with-meta pulled-entity
       {`cp/nav (fn [coll k v]
                  (cond
@@ -34,7 +34,7 @@
   dbval.impl.entity.Entity
   (datafy [this]
     (let [db (.-db this)
-          ref-attrs (:db.type/ref (:rschema db))
+          ref-attrs (db/-attrs-by db :db.type/ref)
           ref-rattrs (set (map db/reverse-ref ref-attrs))
           pull-pattern (into ["*"] ref-rattrs)]
       (navize-pulled-entity db (dp/pull db pull-pattern (:db/id this))))))
diff --git a/src/dbval/db.cljc b/src/dbval/db.clj
similarity index 76%
rename from src/dbval/db.cljc
rename to src/dbval/db.clj
index fd2e803f..6b49c0d8 100644
--- a/src/dbval/db.cljc
+++ b/src/dbval/db.clj
@@ -1,33 +1,24 @@
 (ns ^:no-doc dbval.db
   (:require
-    #?(:cljs [goog.array :as garray])
-    [clojure.walk]
+
     [clojure.data]
     [clojure.edn :as edn]
     [clojure.string :as str]
     [clojure.java.io :as io]
-    #?(:clj [dbval.inline :refer [update]])
+    [dbval.inline :refer [update]]
     [dbval.lru :as lru]
     [dbval.util :as util]
-    [me.tonsky.persistent-sorted-set :as set]
-    [me.tonsky.persistent-sorted-set.arrays :as arrays]
-    [taoensso.nippy :as nippy]
+    [dbval.arrays :as arrays]
     [com.yetanalytics.squuid :as squuid])
-  #?(:clj (:import clojure.lang.IFn$OOL))
-  #?(:cljs (:require-macros [dbval.db :refer [case-tree combine-cmp defn+ defcomp defrecord-updatable int-compare validate-attr validate-val]]))
-  (:refer-clojure :exclude [seqable? #?(:clj update)]))
 
-#?(:clj (set! *warn-on-reflection* true))
+  (:refer-clojure :exclude [seqable? update]))
+
+(set! *warn-on-reflection* true)
 
 (declare transact-tx-data)
 
 ;; ----------------------------------------------------------------------------
 
-#?(:cljs
-   (do
-     (def Exception js/Error)
-     (def IllegalArgumentException js/Error)
-     (def UnsupportedOperationException js/Error)))
 
 ;; tx0 is the nil UUID, used as a minimum bound for transaction ID comparisons
 ;; Squuids are time-ordered, so this will always be less than any real tx ID
@@ -46,181 +37,43 @@
 
 ;; ----------------------------------------------------------------------------
 
-(defn #?@(:clj  [^Boolean seqable?]  
-          :cljs [^boolean seqable?])
+(defn ^Boolean seqable?
   [x]
   (and (not (string? x))
-    #?(:cljs (or (cljs.core/seqable? x)
-               (arrays/array? x))
-       :clj  (or (seq? x)
+    (or (seq? x)
                (instance? clojure.lang.Seqable x)
                (nil? x)
                (instance? Iterable x)
                (arrays/array? x)
-               (instance? java.util.Map x)))))
-
-;; ----------------------------------------------------------------------------
-;; macros and funcs to support writing defrecords and updating
-;; (replacing) builtins, i.e., Object/hashCode, IHashEq hasheq, etc.
-;; code taken from prismatic:
-;;  https://github.com/Prismatic/schema/commit/e31c419c56555c83ef9ee834801e13ef3c112597
-;;
-
-(defn- cljs-env?
-  "Take the &env from a macro, and tell whether we are expanding into cljs."
-  [env]
-  (boolean (:ns env)))
-
-#?(:clj
-   (defmacro if-cljs
-     "Return then if we are generating cljs code and else for Clojure code.
-     https://groups.google.com/d/msg/clojurescript/iBY5HaQda4A/w1lAQi9_AwsJ"
-     [then else]
-     (if (cljs-env? &env) then else)))
-
-#?(:clj
-   (defn patch-tag [meta cljs-env?]
-     (if cljs-env?
-       meta
-       (condp = (:tag meta)
-         'boolean (assoc meta :tag java.lang.Boolean)
-         'number  (assoc meta :tag clojure.core$long)
-         meta))))
-
-#?(:clj
-   (defmacro defn+
-     "CLJS really don't like :declared metadata on vars (generates less
-      efficient code), but it needs it to skip warnings. So we redefine
-      first with ^:declared and empty implementation, and then immediately
-      redefine again without ^:declared. This way both `declare` and `defn+`
-      versions have no ^:declared meta, thus allowing CLJS to generate direct
-      invocations and see type hints."
-     [name & rest]
-     (let [name'    (vary-meta name patch-tag (cljs-env? &env))
-           arglists (if (vector? (first rest))
-                      [(first rest)]
-                      (map #(list (first %)) rest))]
-       (if (cljs-env? &env)
-         `(do
-            (defn ~(vary-meta name' assoc :declared true) ~@arglists)
-            (defn ~name' ~@rest))
-         `(defn ~name' ~@rest)))))
+               (instance? java.util.Map x))))
 
 (defn combine-hashes [x y]
-  #?(:clj  (clojure.lang.Util/hashCombine x y)
-     :cljs (hash-combine x y)))
-
-#?(:clj
-   (defn- get-sig [method]
-     ;; expects something like '(method-symbol [arg arg arg] ...)
-     ;; if the thing matches, returns [fully-qualified-symbol arity], otherwise nil
-     (and (sequential? method)
-       (symbol? (first method))
-       (vector? (second method))
-       (let [sym (first method)
-             ns  (or (some->> sym resolve meta :ns str) "clojure.core")]
-         [(symbol ns (name sym)) (-> method second count)]))))
-
-#?(:clj
-   (defn- dedupe-interfaces [deftype-form]
-     ;; get the interfaces list, remove any duplicates, similar to remove-nil-implements in potemkin
-     ;; verified w/ deftype impl in compiler:
-     ;; (deftype* tagname classname [fields] :implements [interfaces] :tag tagname methods*)
-     (let [[deftype* tagname classname fields implements interfaces & rest] deftype-form]
-       (when (or (not= deftype* 'deftype*) (not= implements :implements))
-         (throw (IllegalArgumentException. "deftype-form mismatch")))
-       (list* deftype* tagname classname fields implements (vec (distinct interfaces)) rest))))
-
-#?(:clj
-   (defn- make-record-updatable-clj [name fields & impls]
-     (let [impl-map (->> impls (map (juxt get-sig identity)) (filter first) (into {}))
-           body     (macroexpand-1 (list* 'defrecord name fields impls))]
-       (clojure.walk/postwalk
-         (fn [form]
-           (if (and (sequential? form) (= 'deftype* (first form)))
-             (->> form
-               dedupe-interfaces
-               (remove (fn [method]
-                         (when-some [impl (-> method get-sig impl-map)]
-                           (not= method impl)))))
-             form))
-         body))))
-
-#?(:clj
-   (defn- make-record-updatable-cljs [name fields & impls]
-     `(do
-        (defrecord ~name ~fields)
-        (extend-type ~name ~@impls))))
-
-#?(:clj
-   (defmacro defrecord-updatable [name fields & impls]
-     `(if-cljs
-        ~(apply make-record-updatable-cljs name fields impls)
-        ~(apply make-record-updatable-clj  name fields impls))))
+  (clojure.lang.Util/hashCombine x y))
 
 ;; ----------------------------------------------------------------------------
 
-#?(:clj  (declare hash-datom)
-   :cljs (defn ^number hash-datom [d]))
+(declare hash-datom)
 
-#?(:clj  (declare equiv-datom)
-   :cljs (defn ^boolean equiv-datom [d o]))
+(declare equiv-datom)
 
-#?(:clj  (declare seq-datom)
-   :cljs (defn seq-datom [d]))
+(declare seq-datom)
 
-#?(:clj  (declare nth-datom)
-   :cljs (defn nth-datom ([d i]) ([d i not-found])))
+(declare nth-datom)
 
-#?(:clj  (declare assoc-datom)
-   :cljs (defn assoc-datom [d k v]))
+(declare assoc-datom)
 
-#?(:clj  (declare val-at-datom)
-   :cljs (defn val-at-datom [d k not-found]))
+(declare val-at-datom)
 
 (defprotocol IDatom
   (datom-tx [this])
-  (datom-added [this])
-  (datom-get-idx [this])
-  (datom-set-idx [this value]))
+  (datom-added [this]))
 
-(deftype Datom #?(:clj [e a v tx added ^:unsynchronized-mutable ^int idx ^:unsynchronized-mutable ^int _hash]
-                  :cljs [e a v tx added ^:mutable ^number idx ^:mutable ^number _hash])
+(deftype Datom [e a v tx added ^:unsynchronized-mutable ^int _hash]
   IDatom
   (datom-tx [d] tx)
   (datom-added [d] added)
-  (datom-get-idx [_] idx)
-  (datom-set-idx [_ value] (set! idx (int value)))
-
-  #?@(:cljs
-      [IHash
-       (-hash [d] (if (zero? _hash)
-                    (set! _hash (hash-datom d))
-                    _hash))
-       IEquiv
-       (-equiv [d o] (and (instance? Datom o) (equiv-datom d o)))
-
-       ISeqable
-       (-seq [d] (seq-datom d))
-
-       ILookup
-       (-lookup [d k] (val-at-datom d k nil))
-       (-lookup [d k nf] (val-at-datom d k nf))
-
-       IIndexed
-       (-nth [this i] (nth-datom this i))
-       (-nth [this i not-found] (nth-datom this i not-found))
-        
-       IAssociative
-       (-assoc [d k v] (assoc-datom d k v))
-
-       IPrintWithWriter
-       (-pr-writer [d writer opts]
-         (pr-sequential-writer writer pr-writer
-           "#dbval/Datom [" " " "]"
-           opts [(.-e d) (.-a d) (.-v d) (datom-tx d) (datom-added d)]))]
-      :clj
-      [Object
+
+  Object
        (hashCode [d]
          (if (zero? _hash)
            (let [h (int (hash-datom d))]
@@ -240,7 +93,7 @@
        (empty [d] (throw (UnsupportedOperationException. "empty is not supported on Datom")))
        (count [d] 5)
        (cons [d [k v]] (assoc-datom d k v))
-        
+
        clojure.lang.Indexed
        (nth [this i]           (nth-datom this i))
        (nth [this i not-found] (nth-datom this i not-found))
@@ -252,33 +105,32 @@
        clojure.lang.Associative
        (entryAt [d k] (some->> (val-at-datom d k nil) (clojure.lang.MapEntry k)))
        (containsKey [e k] (#{:e :a :v :tx :added} k))
-       (assoc [d k v] (assoc-datom d k v))]))
+       (assoc [d k v] (assoc-datom d k v)))
 
-#?(:cljs (goog/exportSymbol "dbval.db.Datom" Datom))
 
 (defn ^Datom datom
-  ([e a v] (Datom. e a v tx0 true 0 0))
-  ([e a v tx] (Datom. e a v tx true 0 0))
-  ([e a v tx added] (Datom. e a v tx (boolean added) 0 0)))
+  ([e a v] (Datom. e a v tx0 true 0))
+  ([e a v tx] (Datom. e a v tx true 0))
+  ([e a v tx added] (Datom. e a v tx (boolean added) 0)))
 
 (defn datom? [x] (instance? Datom x))
 
-(defn+ ^:private hash-datom [^Datom d]
+(defn- hash-datom [^Datom d]
   (-> (hash (.-e d))
     (combine-hashes (hash (.-a d)))
     (combine-hashes (hash (.-v d)))))
 
-(defn+ ^:private equiv-datom [^Datom d ^Datom o]
+(defn- equiv-datom [^Datom d ^Datom o]
   (and (= (.-e d) (.-e o))
     (= (.-a d) (.-a o))
     (= (.-v d) (.-v o))))
 
-(defn+ ^:private seq-datom [^Datom d]
+(defn- seq-datom [^Datom d]
   (list (.-e d) (.-a d) (.-v d) (datom-tx d) (datom-added d)))
 
 ;; keep it fast by duplicating for both keyword and string cases
 ;; instead of using sets or some other matching func
-(defn+ ^:private val-at-datom [^Datom d k not-found]
+(defn- val-at-datom [^Datom d k not-found]
   (cond
     (keyword? k)
     (case k
@@ -288,7 +140,7 @@
       :tx    (datom-tx d)
       :added (datom-added d)
       not-found)
-    
+
     (string? k)
     (case k
       "e"     (.-e d)
@@ -297,11 +149,11 @@
       "tx"    (datom-tx d)
       "added" (datom-added d)
       not-found)
-    
+
     :else
     not-found))
 
-(defn+ ^:private nth-datom
+(defn- nth-datom
   ([^Datom d ^long i]
    (case i
      0 (.-e d)
@@ -309,8 +161,7 @@
      2 (.-v d)
      3 (datom-tx d)
      4 (datom-added d)
-     #?(:clj  (throw (IndexOutOfBoundsException.))
-        :cljs (throw (js/Error. (str "Datom/-nth: Index out of bounds: " i))))))
+     (throw (IndexOutOfBoundsException.))))
   ([^Datom d ^long i not-found]
    (case i
      0 (.-e d)
@@ -320,7 +171,7 @@
      4 (datom-added d)
      not-found)))
 
-(defn+ ^:private ^Datom assoc-datom [^Datom d k v]
+(defn- ^Datom assoc-datom [^Datom d k v]
   (case k
     :e     (datom v       (.-a d) (.-v d) (datom-tx d) (datom-added d))
     :a     (datom (.-e d) v       (.-v d) (datom-tx d) (datom-added d))
@@ -335,85 +186,40 @@
 (defn ^Datom datom-from-reader [vec]
   (apply datom vec))
 
-#?(:clj
-   (defmethod print-method Datom [^Datom d, ^java.io.Writer w]
+(defmethod print-method Datom [^Datom d, ^java.io.Writer w]
      (.write w (str "#dbval/Datom "))
      (binding [*out* w]
-       (pr [(.-e d) (.-a d) (.-v d) (datom-tx d) (datom-added d)]))))
+       (pr [(.-e d) (.-a d) (.-v d) (datom-tx d) (datom-added d)])))
 
 ;; ----------------------------------------------------------------------------
 ;; datom cmp macros/funcs
 ;;
 
-#?(:clj
-   (defmacro combine-cmp [& comps]
-     (loop [comps (reverse comps)
-            res   (num 0)]
-       (if (not-empty comps)
-         (recur
-           (next comps)
-           `(let [c# ~(first comps)]
-              (if (== 0 c#)
-                ~res
-                c#)))
-         res))))
-
-#?(:clj
-   (defn- -case-tree [queries variants]
-     (if queries
-       (let [v1 (take (/ (count variants) 2) variants)
-             v2 (drop (/ (count variants) 2) variants)]
-         (list 'if (first queries)
-           (-case-tree (next queries) v1)
-           (-case-tree (next queries) v2)))
-       (first variants))))
-
-#?(:clj
-   (defmacro case-tree [qs vs]
-     (-case-tree qs vs)))
-
-(defn cmp
-  #?(:clj
-     {:inline
-      (fn [x y]
-        `(let [x# ~x y# ~y]
-           (if (nil? x#) 0 (if (nil? y#) 0 (long (compare x# y#))))))})
-  ^long [x y]
-  (if (nil? x) 0 (if (nil? y) 0 (long (compare x y)))))
-
 (defn class-identical?
-  #?(:clj  {:inline (fn [x y] `(identical? (class ~x) (class ~y)))})
+  {:inline (fn [x y] `(identical? (class ~x) (class ~y)))}
   [x y]
-  #?(:clj  (identical? (class x) (class y))
-     :cljs (identical? (type x) (type y))))
+  (identical? (class x) (class y)))
 
-#?(:clj
-   (defn class-name
+(defn class-name
      {:inline
       (fn [x]
         `(let [^Object x# ~x]
            (if (nil? x#) x# (.getName (. x# (getClass))))))}
-     ^String [^Object x] (if (nil? x) x (.getName (. x (getClass))))))
+     ^String [^Object x] (if (nil? x) x (.getName (. x (getClass)))))
 
 (defn class-compare
   ^long [x y]
-  #?(:clj  (long (compare (class-name x) (class-name y)))
-     :cljs (garray/defaultCompare (type->str (type x)) (type->str (type y)))))
+  (long (compare (class-name x) (class-name y))))
 
-#?(:clj
-   (defmacro int-compare [x y]
-     `(if-cljs
-        (- ~x ~y)
-        (long (Integer/compare ~x ~y)))))
+(defmacro int-compare [x y]
+  `(long (Integer/compare ~x ~y)))
 
 (defn ihash
   {:inline (fn [x] `(. clojure.lang.Util (hasheq ~x)))}
   ^long [x]
-  #?(:clj  (. clojure.lang.Util (hasheq x))
-     :cljs (hash x)))
+  (. clojure.lang.Util (hasheq x)))
 
-#?(:clj  (declare value-compare)
-   :cljs (defn ^number value-compare [x y]))
+(declare value-compare)
 
 (defn- seq-compare [xs ys]
   (let [cx (count xs)
@@ -421,10 +227,10 @@
     (cond
       (< cx cy)
       -1
-      
+
       (> cx cy)
       1
-      
+
       :else
       (loop [xs xs
              ys ys]
@@ -435,206 +241,65 @@
             (cond
               (and (nil? x) (nil? y))
               (recur (next xs) (next ys))
-                
+
               (nil? x)
               -1
-                
+
               (nil? y)
               1
-                
+
               :else
               (let [v (value-compare x y)]
                 (if (= v 0)
                   (recur (next xs) (next ys))
                   v)))))))))
 
-(defn+ ^number value-compare [x y]
+(defn value-compare [x y]
   (try
     (cond
       (= x y) 0
       (and (sequential? x) (sequential? y)) (seq-compare x y)
-      #?@(:clj  [(instance? Number x)       (clojure.lang.Numbers/compare x y)])
-      #?@(:clj  [(instance? Comparable x)   (.compareTo ^Comparable x y)]
-          :cljs [(satisfies? IComparable x) (-compare x y)])
+      (instance? Number x)       (clojure.lang.Numbers/compare x y)
+      (instance? Comparable x)   (.compareTo ^Comparable x y)
       (not (class-identical? x y)) (class-compare x y)
-      #?@(:cljs [(or (number? x) (string? x) (array? x) (true? x) (false? x)) (garray/defaultCompare x y)])
+
       :else (int-compare (ihash x) (ihash y)))
-    (catch #?(:clj ClassCastException :cljs js/Error) e
+    (catch ClassCastException e
       (if (not (class-identical? x y))
         (class-compare x y)
         (throw e)))))
 
-(defn value-cmp
-  #?(:clj
-     {:inline
-      (fn [x y]
-        `(let [x# ~x y# ~y]
-           (if (nil? x#) 0 (if (nil? y#) 0 (value-compare x# y#)))))})
-  ^long [x y]
-  (if (nil? x)
-    0
-    (if (nil? y)
-      0
-      (value-compare x y))))
-
-;; Slower cmp-* fns allows for datom fields to be nil.
-;; Such datoms come from slice method where they are used as boundary markers.
-
-#?(:clj
-   (defmacro defcomp [sym [arg1 arg2] & body]
-     (let [a1 (with-meta arg1 {})
-           a2 (with-meta arg2 {})]
-       `(if-cljs
-          (defn ~sym [~arg1 ~arg2]
-            ~@body)
-          (def ~sym
-            (reify
-              java.util.Comparator
-              (compare [_# ~a1 ~a2]
-                (let [~arg1 ~arg1 ~arg2 ~arg2]
-                  ~@body))
-              clojure.lang.IFn
-              (invoke [this# ~a1 ~a2]
-                (.compare this# ~a1 ~a2))
-              IFn$OOL
-              (invokePrim [this# ~a1 ~a2]
-                (.compare this# ~a1 ~a2))))))))
-
-(defcomp cmp-datoms-eavt ^long [^Datom d1, ^Datom d2]
-  (combine-cmp
-    (int-compare (.-e d1) (.-e d2))
-    (cmp (.-a d1) (.-a d2))
-    (value-cmp (.-v d1) (.-v d2))
-    (int-compare (datom-tx d1) (datom-tx d2))))
-
-(defcomp cmp-datoms-aevt ^long [^Datom d1, ^Datom d2]
-  (combine-cmp
-    (cmp (.-a d1) (.-a d2))
-    (int-compare (.-e d1) (.-e d2))
-    (value-cmp (.-v d1) (.-v d2))
-    (int-compare (datom-tx d1) (datom-tx d2))))
-
-(defcomp cmp-datoms-avet ^long [^Datom d1, ^Datom d2]
-  (combine-cmp
-    (cmp (.-a d1) (.-a d2))
-    (value-cmp (.-v d1) (.-v d2))
-    (int-compare (.-e d1) (.-e d2))
-    (int-compare (datom-tx d1) (datom-tx d2))))
-
-;; fast versions without nil checks
-
-(defn- cmp-attr-quick
-  #?(:clj
-     {:inline
-      (fn [a1 a2]
-        `(long (.compareTo ~(with-meta a1 {:tag "Comparable"}) ~a2)))})
-  ^long [a1 a2]
-  ;; either both are keywords or both are strings
-  #?(:cljs
-     (if (keyword? a1)
-       (-compare a1 a2)
-       (garray/defaultCompare a1 a2))
-     :clj
-     (.compareTo ^Comparable a1 a2)))
-
-(defcomp cmp-datoms-eav-quick ^long [^Datom d1, ^Datom d2]
-  (combine-cmp
-    (int-compare (.-e d1) (.-e d2))
-    (cmp-attr-quick (.-a d1) (.-a d2))
-    (value-compare (.-v d1) (.-v d2))))
-
-(defcomp cmp-datoms-eavt-quick ^long [^Datom d1, ^Datom d2]
-  (combine-cmp
-    (int-compare (.-e d1) (.-e d2))
-    (cmp-attr-quick (.-a d1) (.-a d2))
-    (value-compare (.-v d1) (.-v d2))
-    (int-compare (datom-tx d1) (datom-tx d2))))
-
-(defcomp cmp-datoms-aevt-quick ^long [^Datom d1, ^Datom d2]
-  (combine-cmp
-    (cmp-attr-quick (.-a d1) (.-a d2))
-    (int-compare (.-e d1) (.-e d2))
-    (value-compare (.-v d1) (.-v d2))
-    (int-compare (datom-tx d1) (datom-tx d2))))
-
-(defcomp cmp-datoms-avet-quick ^long [^Datom d1, ^Datom d2]
-  (combine-cmp
-    (cmp-attr-quick (.-a d1) (.-a d2))
-    (value-compare (.-v d1) (.-v d2))
-    (int-compare (.-e d1) (.-e d2))
-    (int-compare (datom-tx d1) (datom-tx d2))))
-
-(defn- diff-sorted [a b cmp]
-  (loop [only-a []
-         only-b []
-         both   []
-         a      a
-         b      b]
-    (cond
-      (empty? a) [(not-empty only-a) (not-empty (into only-b b)) (not-empty both)]
-      (empty? b) [(not-empty (into only-a a)) (not-empty only-b) (not-empty both)]
-      :else
-      (let [first-a (first a)
-            first-b (first b)
-            diff (try
-                   (cmp first-a first-b)
-                   (catch #?(:clj ClassCastException :cljs js/Error) _
-                     :incomparable))]
-        (cond
-          (= diff :incomparable) (recur (conj only-a first-a) (conj only-b first-b) both                (next a) (next b))
-          (== diff 0)            (recur only-a                only-b                (conj both first-a) (next a) (next b))
-          (< diff 0)             (recur (conj only-a first-a) only-b                both                (next a) b)
-          (> diff 0)             (recur only-a                (conj only-b first-b) both                a        (next b)))))))
-
 ;; ----------------------------------------------------------------------------
 
-#?(:clj  (declare hash-db)
-   :cljs (defn ^number hash-db [db]))
-
-#?(:clj  (declare hash-fdb)
-   :cljs (defn ^number hash-fdb [db]))
+(declare db-conn)
 
-#?(:clj  (declare equiv-db)
-   :cljs (defn ^boolean equiv-db [db other]))
+(declare indexing?)
 
-#?(:clj  (declare restore-db)
-   :cljs (defn restore-db [keys]))
 
-#?(:clj  (declare indexing?)
-   :cljs (defn ^boolean indexing? [db attr]))
+(declare resolve-datom)
 
-#?(:cljs (defn pr-db [db w opts]))
+(declare components->pattern)
 
-#?(:clj  (declare resolve-datom)
-   :cljs (defn resolve-datom [db e a v t default-e default-tx]))
+(declare resolve-datom*)
 
-#?(:clj  (declare components->pattern)
-   :cljs (defn components->pattern [db index c0 c1 c2 c3 default-e default-tx]))
-
-#?(:clj  (declare resolve-datom*)
-   :cljs (defn resolve-datom* [db e a v t default-e default-tx]))
-
-#?(:clj  (declare components->pattern*)
-   :cljs (defn components->pattern* [db index c0 c1 c2 c3 default-e default-tx]))
+(declare components->pattern*)
 
 ;;;;;;;;;; Fast validation
 
-#?(:clj
-   (defmacro validate-attr [attr at]
+(defmacro validate-attr [attr at]
      `(let [attr# ~attr]
         (when-not (or
                     (keyword? attr#)
                     (string? attr#))
           (let [at# ~at]
             (util/raise "Bad entity attribute " attr# " at " at# ", expected keyword or string"
-              {:error :transact/syntax, :attribute attr#, :context at#}))))))
+              {:error :transact/syntax, :attribute attr#, :context at#})))))
 
-#?(:clj
-   (defmacro validate-val [v at]
+(defmacro validate-val [v at]
      `(when (nil? ~v)
         (let [at# ~at]
           (util/raise "Cannot store nil as a value at " at#
-            {:error :transact/syntax, :value nil, :context at#})))))
+            {:error :transact/syntax, :value nil, :context at#}))))
 
 ;;;;;;;;;; Searching
 
@@ -663,33 +328,14 @@
 
 ;; ----------------------------------------------------------------------------
 
-(defn db-transient [db]
-  (-> db
-    (update :eavt transient)
-    (update :aevt transient)
-    (update :avet transient)))
-
-(defn db-persistent! [db]
-  (-> db
-    (update :eavt persistent!)
-    (update :aevt persistent!)
-    (update :avet persistent!)))
-
-#?(:clj
-   (defn vpred [v]
-     (cond
-       (string? v)  (fn [x] (if (string? x) (.equals ^String v x) false))
-       (int? v)     (fn [x] (if (int? x) (= (long v) (long x)) false))
-       (keyword? v) (fn [x] (.equals ^Object v x))
-       (nil? v)     (fn [x] (nil? x))
-       :else        (fn [x] (= v x)))))
-
 (defn ^com.apple.foundationdb.tuple.Tuple tuple
   "Turns the `components` into a `com.apple.foundationdb.tuple.Tuple`."
   [& components]
-  (.addAll (com.apple.foundationdb.tuple.Tuple.)
-           ^java.util.List
-           components))
+  ;; & rest args are nil when empty, but addAll requires a List;
+  ;; empty tuples occur when an empty vector is stored as a value
+  (let [^java.util.List components (or components ())]
+    (.addAll (com.apple.foundationdb.tuple.Tuple.)
+             components)))
 
 (defn serialize-tuple
   [x]
@@ -697,8 +343,7 @@
     (or (keyword? x)
         (symbol? x)
         (string? x)
-        #?(:clj (instance? java.util.Date x)
-           :cljs false))
+        (instance? java.util.Date x))
     (pr-str x)
 
     (sequential? x)
@@ -715,8 +360,7 @@
         (keyword? v)
         (symbol? v)
         (string? v)
-        #?(:clj (instance? java.util.Date v)
-           :cljs false))
+        (instance? java.util.Date v))
     (pr-str v)
 
     (sequential? v)
@@ -788,7 +432,7 @@
     (edn/read-string v)
     (if (tuple? db attr)
       (deserialize-tuple v)
-      (if (get-in db [:schema attr :db/tupleAttrs])
+      (if (-> (-schema db) (get attr) :db/tupleAttrs)
         (deserialize-tuple v)
         v))))
 
@@ -855,14 +499,6 @@
                       {:tuple tuple}
                       e)))))
 
-(defn case-pick
-  [case datom]
-  (into []
-        (map (fn [component]
-               (get datom
-                    (keyword component))))
-        case))
-
 (declare slice)
 
 (defn datoms-filter
@@ -1030,7 +666,7 @@
   [{:keys [db ^bytes begin ^bytes end reverse]}]
   (reify java.lang.Iterable
     (iterator [_]
-      (let [^java.sql.Connection conn (:conn db)
+      (let [^java.sql.Connection conn (db-conn db)
             ^java.sql.PreparedStatement stmt
             (.prepareStatement conn
                                (str "select k from dbval where k >= ? and k < ?"
@@ -1074,33 +710,13 @@
           (remove [_]
             (throw (UnsupportedOperationException. "remove not supported"))))))))
 
-(defrecord-updatable DB [schema max-tx rschema pull-patterns pull-attrs hash
-                         #?@(:clj [db-file conn])]
-  #?@(:cljs
-      [IHash                (-hash  [db]        (hash-db db))
-       IEquiv               (-equiv [db other]  (equiv-db db other))
-       IReversible          (-rseq  [db]        (-rseq (.-eavt db)))
-       ICounted             (-count [db]        (count (.-eavt db)))
-       IEmptyableCollection (-empty [db]        (-> (restore-db
-                                                      {:schema  (.-schema db)
-                                                       :rschema (.-rschema db)
-                                                       :eavt    (empty (.-eavt db))
-                                                       :aevt    (empty (.-aevt db))
-                                                       :avet    (empty (.-avet db))})
-                                                  (with-meta (meta db))))
-       IPrintWithWriter     (-pr-writer [db w opts] (pr-db db w opts))
-       IEditableCollection  (-as-transient [db] (db-transient db))
-       ITransientCollection (-conj! [db key] (throw (ex-info "dbval.DB/conj! is not supported" {})))
-       (-persistent! [db] (db-persistent! db))]
-
-      :clj
-      [Object               (hashCode [db]      (hash-db db))
-       clojure.lang.IHashEq (hasheq [db]        (hash-db db))
-       clojure.lang.IEditableCollection
-       (asTransient [db] (db-transient db))
-       clojure.lang.ITransientCollection
-       (conj [db key] (throw (ex-info "dbval.DB/conj! is not supported" {})))
-       (persistent [db] (db-persistent! db))])
+;; An opaque handle to a database value, like Datomic's Db: it hashes and
+;; compares by reference identity. To compare two snapshots, compare
+;; `basis-tx` (and know which store they came from) — content-based value
+;; semantics would have to realize a potentially larger-than-memory database.
+(deftype DB [schema max-tx rschema pull-patterns pull-attrs
+             db-file conn]
+
 
   IDB
   (-schema [db] (.-schema db))
@@ -1109,9 +725,6 @@
   ISearch
   (-search [db pattern]
     (let [[e a v tx] pattern
-          pred       #?(:clj  (vpred v)
-                        :cljs #(= v %))
-          multival?  (contains? (-attrs-by db :db.cardinality/many) a)
           index (pattern->order db
                                 pattern)
           [begin end] (apply tuple-range
@@ -1130,7 +743,7 @@
        (comp (map (bytes-to-datoms-xf db))
              (filter (fn [datom]
                        (uuid<= (:tx datom)
-                               (:max-tx db))))
+                               max-tx)))
              datoms-filter
              (filter (partial datom=
                               [e a v tx])))
@@ -1162,7 +775,7 @@
        (comp (map (bytes-to-datoms-xf db))
                (filter (fn [datom]
                          (uuid<= (:tx datom)
-                                 (:max-tx db))))
+                                 max-tx)))
                datoms-filter
                (filter (partial datom=
                                 [e a v tx])))
@@ -1192,7 +805,7 @@
        (comp (map (bytes-to-datoms-xf db))
              (filter (fn [datom]
                        (uuid<= (:tx datom)
-                               (:max-tx db))))
+                               max-tx)))
              datoms-filter)
        (slice {:db db
                :begin begin
@@ -1221,7 +834,7 @@
        (comp (map (bytes-to-datoms-xf db))
              (filter (fn [datom]
                        (uuid<= (:tx datom)
-                               (:max-tx db))))
+                               max-tx)))
              datoms-filter-reverse)
        (slice {:db db
                :begin begin
@@ -1247,7 +860,7 @@
        (comp (map (bytes-to-datoms-xf db))
              (filter (fn [datom]
                        (uuid<= (:tx datom)
-                               (:max-tx db))))
+                               max-tx)))
              datoms-filter)
        (slice {:db db
                :begin begin
@@ -1258,7 +871,7 @@
 
   ;; Implemented only to throw: without this extension `clojure.data/diff`
   ;; would fall back to its default map implementation and diff the DB
-  ;; record's fields (:conn, :max-tx, :hash, ...), silently producing
+  ;; record's fields (:conn, :max-tx, ...), silently producing
   ;; nonsense.
   clojure.data/Diff
   (diff-similar [a b]
@@ -1266,58 +879,20 @@
              "clojure.data/diff is not supported on dbval databases, since it would realize both databases entirely in memory"))))
 
 (defn db? [x]
-  #?(:clj
-     (or
+  (or
        (and x
          (instance? dbval.db.ISearch x)
          (instance? dbval.db.IIndexAccess x)
          (instance? dbval.db.IDB x))
        (and (satisfies? ISearch x)
          (satisfies? IIndexAccess x)
-         (satisfies? IDB x)))
-     :cljs
-     (and (satisfies? ISearch x)
-       (satisfies? IIndexAccess x)
-       (satisfies? IDB x))))
+         (satisfies? IDB x))))
 
 ;; ----------------------------------------------------------------------------
-(defrecord-updatable FilteredDB [unfiltered-db pred hash]
-  #?@(:cljs
-      [IHash                (-hash  [db]        (hash-fdb db))
-       IEquiv               (-equiv [db other]  (equiv-db db other))
-       ICounted             (-count [db]        (count (-datoms db :eavt nil nil nil nil)))
-       IPrintWithWriter     (-pr-writer [db w opts] (pr-db db w opts))
-
-       IEmptyableCollection (-empty [_]         (throw (js/Error. "-empty is not supported on FilteredDB")))
-
-       ILookup              (-lookup ([_ _]     (throw (js/Error. "-lookup is not supported on FilteredDB")))
-                              ([_ _ _]   (throw (js/Error. "-lookup is not supported on FilteredDB"))))
+;; Like DB, an opaque handle: reference identity only.
+(deftype FilteredDB [unfiltered-db pred]
 
 
-       IAssociative         (-contains-key? [_ _] (throw (js/Error. "-contains-key? is not supported on FilteredDB")))
-       (-assoc [_ _ _]       (throw (js/Error. "-assoc is not supported on FilteredDB")))]
-
-      :clj
-      [Object               (hashCode [db]      (hash-fdb db))
-
-       clojure.lang.IHashEq (hasheq [db]        (hash-fdb db))
-
-       clojure.lang.IPersistentCollection
-       (count [db]         (count (-datoms db :eavt nil nil nil nil)))
-       (equiv [db o]       (equiv-db db o))
-       (cons [db [k v]]    (throw (UnsupportedOperationException. "cons is not supported on FilteredDB")))
-       (empty [db]         (throw (UnsupportedOperationException. "empty is not supported on FilteredDB")))
-
-       clojure.lang.ILookup (valAt [db k]       (throw (UnsupportedOperationException. "valAt/2 is not supported on FilteredDB")))
-       (valAt [db k nf]    (throw (UnsupportedOperationException. "valAt/3 is not supported on FilteredDB")))
-       clojure.lang.IKeywordLookup (getLookupThunk [db k]
-                                     (throw (UnsupportedOperationException. "getLookupThunk is not supported on FilteredDB")))
-
-       clojure.lang.Associative
-       (containsKey [e k]  (throw (UnsupportedOperationException. "containsKey is not supported on FilteredDB")))
-       (entryAt [db k]     (throw (UnsupportedOperationException. "entryAt is not supported on FilteredDB")))
-       (assoc [db k v]     (throw (UnsupportedOperationException. "assoc is not supported on FilteredDB")))])
-
   IDB
   (-schema [db]
     (-schema (.-unfiltered-db db)))
@@ -1347,6 +922,27 @@
     (.-unfiltered-db ^FilteredDB db)
     db))
 
+(defn basis-tx
+  "Returns the transaction id (the basis) up to which this database value
+   sees the store. Since db values are opaque handles that compare by
+   reference identity, comparing two snapshots of the same store means
+   comparing their `basis-tx`."
+  [db]
+  (.-max-tx (unfiltered-db db)))
+
+(defn ^:no-doc ^java.sql.Connection db-conn
+     "The JDBC connection of the store backing this database value."
+     [db]
+     (.-conn (unfiltered-db db)))
+
+(defn ^:no-doc ^DB with-max-tx
+  "Copy of `db` with a different basis. Low-level; a db value normally gets
+   its basis from the store (see `dbval.conn`) or a transaction."
+  [^DB db max-tx]
+  (DB. (.-schema db) max-tx (.-rschema db)
+              (.-pull-patterns db) (.-pull-attrs db)
+              (.-db-file db) (.-conn db)))
+
 ;; ----------------------------------------------------------------------------
 
 (defn attr->properties [k v]
@@ -1479,7 +1075,7 @@
                 (tuple-from-bytes)
                 (second))
         tx0)))
-  
+
 (defn ^DB empty-db [schema opts]
   {:pre [(or (nil? schema) (map? schema))]}
   (validate-schema schema)
@@ -1492,18 +1088,14 @@
         conn ^java.sql.Connection (get-sqlite-connection {:db-file db-file})
         _ (create-table! conn)
         _ (.commit conn)
-        db (map->DB
-            {:schema        schema
-             :max-tx        tx0
-             :rschema       (rschema (merge implicit-schema schema))
-             :db-file       db-file
-             :conn          conn
-             :pull-patterns (lru/cache 100)
-             :pull-attrs    (lru/cache 100)
-             :hash          (atom 0)})]
-    (assoc db
-           :max-tx
-           (q-max-tx db))))
+        db (DB. schema
+                tx0
+                (rschema (merge implicit-schema schema))
+                (lru/cache 100)
+                (lru/cache 100)
+                db-file
+                conn)]
+    (with-max-tx db (q-max-tx db))))
 
 (defrecord TxReport [db-before db-after tx-data tempids tx-meta])
 
@@ -1537,71 +1129,18 @@
     (db-transact db
                  (datoms->tx datoms))))
 
-(defn+ ^DB restore-db [{:keys [schema max-tx eavt aevt avet] :as keys}]
-  (map->DB
-    {:schema        schema
-     :max-tx        (or max-tx tx0)
-     :rschema       (or (:rschema keys)
-                      (rschema (merge implicit-schema schema)))
-     :eavt          eavt
-     :aevt          aevt
-     :avet          avet
-     :pull-patterns (lru/cache 100)
-     :pull-attrs    (lru/cache 100)
-     :hash          (atom 0)}))
-
-(defn with-schema [db schema]
+(defn ^DB with-schema [^DB db schema]
   {:pre [(db? db) (or (nil? schema) (map? schema))]}
-  (assoc db
-    :schema        schema
-    :rschema       (rschema (merge implicit-schema schema))
-    :pull-patterns (lru/cache 100)
-    :pull-attrs    (lru/cache 100)
-    :hash          (atom 0)))
-
-(defn- equiv-db-index [x y]
-  (loop [xs (seq x)
-         ys (seq y)]
-    (cond
-      (nil? xs) (nil? ys)
-      (= (first xs) (first ys)) (recur (next xs) (next ys))
-      :else false)))
-
-(defn+ ^:private ^number hash-db [^DB db]
-  (let [h @(.-hash db)]
-    (if (zero? h)
-      (reset! (.-hash db) (combine-hashes (hash (.-schema db))
-                            (hash-unordered-coll (-datoms db :eavt nil nil nil nil))))
-      h)))
-
-(defn+ ^:private ^number hash-fdb [^FilteredDB db]
-  (let [h @(.-hash db)
-        datoms (or (-datoms db :eavt nil nil nil nil) #{})]
-    (if (zero? h)
-      (let [datoms (or (-datoms db :eavt nil nil nil nil) #{})]
-        (reset! (.-hash db) (combine-hashes (hash (-schema db))
-                              (hash-unordered-coll datoms))))
-      h)))
-
-(defn+ ^:private ^boolean equiv-db [db other]
-  (and (or (instance? DB other) (instance? FilteredDB other))
-    (= (-schema db) (-schema other))
-    (equiv-db-index (-datoms db :eavt nil nil nil nil) (-datoms other :eavt nil nil nil nil))))
-
-#?(:cljs
-   (defn+ pr-db [db w opts]
-     (-write w "#dbval/DB {")
-     (-write w ":schema ")
-     (pr-writer (-schema db) w opts)
-     (-write w ", :datoms ")
-     (pr-sequential-writer w
-       (fn [d w opts]
-         (pr-sequential-writer w pr-writer "[" " " "]" opts [(.-e d) (.-a d) (.-v d) (datom-tx d)]))
-       "[" " " "]" opts (-datoms db :eavt nil nil nil nil))
-     (-write w "}")))
-
-#?(:clj
-   (do
+  (DB. schema
+                (.-max-tx db)
+                (rschema (merge implicit-schema schema))
+                (lru/cache 100)
+                (lru/cache 100)
+                (.-db-file db)
+                (.-conn db)))
+
+
+(do
      (defn pr-db [db, ^java.io.Writer w]
        (.write w (str "#dbval/DB {"))
        (.write w ":schema ")
@@ -1612,20 +1151,18 @@
        (.write w "]}"))
 
      (defmethod print-method DB [db w] (pr-db db w))
-     (defmethod print-method FilteredDB [db w] (pr-db db w))))
+     (defmethod print-method FilteredDB [db w] (pr-db db w)))
 
 (defn db-from-reader [{:keys [schema datoms]}]
   (init-db (map (fn [[e a v tx]] (datom e a v tx)) datoms) schema {}))
 
 ;; ----------------------------------------------------------------------------
 
-#?(:clj  (declare entid-strict)
-   :cljs (defn ^number entid-strict [db eid]))
+(declare entid-strict)
 
-#?(:clj  (declare ref?)
-   :cljs (defn ^boolean ref? [db attr]))
+(declare ref?)
 
-(defn+ resolve-datom [db e a v t default-e default-tx]
+(defn resolve-datom [db e a v t default-e default-tx]
   (when (some? a)
     (validate-attr a (list 'resolve-datom 'db e a v t)))
   (datom
@@ -1636,13 +1173,13 @@
       v)
     (if (some? t) (entid-strict db t) default-tx)))
 
-(defn+ components->pattern [db index c0 c1 c2 c3 default-e default-tx]
+(defn components->pattern [db index c0 c1 c2 c3 default-e default-tx]
   (case index
     :eavt (resolve-datom db c0 c1 c2 c3 default-e default-tx)
     :aevt (resolve-datom db c1 c0 c2 c3 default-e default-tx)
     :avet (resolve-datom db c2 c0 c1 c3 default-e default-tx)))
 
-(defn+ resolve-datom* [db e a v t]
+(defn resolve-datom* [db e a v t]
   (when (some? a)
     (validate-attr a (list 'resolve-datom 'db e a v t)))
   [(when (some? e) (entid-strict db e))
@@ -1652,7 +1189,7 @@
      v)
    (when (some? t) (entid-strict db t))])
 
-(defn+ components->pattern* [db index c0 c1 c2 c3]
+(defn components->pattern* [db index c0 c1 c2 c3]
   (case index
     :eavt (resolve-datom* db c0 c1 c2 c3)
     :aevt (resolve-datom* db c1 c0 c2 c3)
@@ -1664,44 +1201,42 @@
 
 ;; ----------------------------------------------------------------------------
 
-(defrecord TxReport [db-before db-after tx-data tempids tx-meta])
-
-(defn+ ^boolean is-attr? [db attr property]
+(defn is-attr? [db attr property]
   (contains? (-attrs-by db property) attr))
 
-(defn+ ^boolean multival? [db attr]
+(defn multival? [db attr]
   (is-attr? db attr :db.cardinality/many))
 
-(defn+ ^boolean multi-value? [db attr value]
+(defn multi-value? [db attr value]
   (and
     (is-attr? db attr :db.cardinality/many)
     (or
       (arrays/array? value)
       (and (coll? value) (not (map? value))))))
 
-(defn+ ^boolean ref? [db attr]
+(defn ref? [db attr]
   (is-attr? db attr :db.type/ref))
 
-(defn+ ^boolean component? [db attr]
+(defn component? [db attr]
   (is-attr? db attr :db/isComponent))
 
-(defn+ ^boolean indexing? [db attr]
+(defn indexing? [db attr]
   (is-attr? db attr :db/index))
 
-(defn+ ^boolean tuple? [db attr]
+(defn tuple? [db attr]
   (is-attr? db attr :db.type/tuple))
 
-(defn+ ^boolean tuple-source? [db attr]
+(defn tuple-source? [db attr]
   (is-attr? db attr :db/attrTuples))
 
-(defn+ ^boolean reverse-ref? [attr]
+(defn reverse-ref? [attr]
   (cond
     (keyword? attr)
     (= \_ (nth (name attr) 0))
-    
+
     (string? attr)
     (boolean (re-matches #"(?:([^/]+)/)?_([^/]+)" attr))
-   
+
     :else
     (util/raise "Bad attribute type: " attr ", expected keyword or string"
       {:error :transact/syntax, :attribute attr})))
@@ -1718,7 +1253,7 @@
       (if (= \_ (nth name 0))
         (if ns (str ns "/" (subs name 1)) (subs name 1))
         (if ns (str ns "/_" name) (str "_" name))))
-   
+
     :else
     (util/raise "Bad attribute type: " attr ", expected keyword or string"
       {:error :transact/syntax, :attribute attr})))
@@ -1755,7 +1290,7 @@
     (some
       (fn [[tuple idx]]
         (when (is-attr? db tuple :db.unique/identity)
-          (let [tuple-attrs (get-in db [:schema tuple :db/tupleAttrs])
+          (let [tuple-attrs (-> (-schema db) (get tuple) :db/tupleAttrs)
                 allocated   (get tempids temp-e)
                 components  (map-indexed
                                (fn [i component]
@@ -1769,7 +1304,7 @@
               (tuple-existing-entity db tuple components)))))
       tuples)))
 
-(defn+ entid [db eid]
+(defn entid [db eid]
   {:pre [(db? db)]}
   (cond
     (uuid? eid)
@@ -1796,7 +1331,6 @@
         :else
         (-> (-datoms db :avet attr value nil nil) first :e)))
 
-    #?@(:cljs [(array? eid) (recur db (array-seq eid))])
 
     (keyword? eid)
     (-> (-datoms db :avet :db/ident eid nil nil) first :e)
@@ -1805,17 +1339,17 @@
     (util/raise "Expected UUID or lookup ref for entity id, got " eid
       {:error :entity-id/syntax, :entity-id eid})))
 
-(defn+ ^boolean eid-exists? [db eid]
+(defn eid-exists? [db eid]
   (= eid (-> (-seek-datoms db :eavt eid nil nil nil) first :e)))
 
-(defn+ ^number entid-strict [db eid]
+(defn entid-strict [db eid]
   (or
     (entid db eid)
     (util/raise "Nothing found for entity id " eid
       {:error :entity-id/missing
        :entity-id eid})))
 
-(defn+ ^number entid-some [db eid]
+(defn entid-some [db eid]
   (when (some? eid)
     (entid-strict db eid)))
 
@@ -2123,22 +1657,13 @@
   [_db]
   (random-uuid))
 
-#?(:clj
-   (defn- ^Boolean tx-id?
+(defn- ^Boolean tx-id?
      [e]
      (or (identical? :db/current-tx e)
        (.equals ":db/current-tx" e) ;; for dbval.js interop
        (.equals "datomic.tx" e)
        (.equals "dbval.tx" e)))
 
-   :cljs
-   (defn- ^boolean tx-id?
-     [e]
-     (or (= e :db/current-tx)
-       (= e ":db/current-tx") ;; for dbval.js interop
-       (= e "datomic.tx")
-       (= e "dbval.tx"))))
-
 (defn- allocate-eid
   "Simplified allocate-eid for UUID-based IDs.
    Only tracks :db/current-tx in tempids map."
@@ -2181,7 +1706,7 @@
   [db]
   (reify clojure.lang.IReduceInit
     (reduce [_ rf init]
-      (let [conn ^java.sql.Connection (:conn db)]
+      (let [conn ^java.sql.Connection (db-conn db)]
         (with-open [stmt (.prepareStatement conn "SELECT k FROM dbval ORDER BY k")
                     rs (.executeQuery stmt)]
           (loop [state init]
@@ -2191,7 +1716,7 @@
 
 (defn with-datom [db ^Datom datom]
   (validate-datom db datom)
-  (let [conn ^java.sql.Connection (:conn db)
+  (let [conn ^java.sql.Connection (db-conn db)
         stmt ^java.sql.PreparedStatement (.prepareStatement
                                            conn
                                            "INSERT OR IGNORE INTO dbval (k) VALUES (?)")
@@ -2201,16 +1726,14 @@
                  (set-add! stmt (datom-tuple db :eavt datom))
                  (set-add! stmt (datom-tuple db :aevt datom))
                  (cond-> indexing? (set-add! stmt (datom-tuple db :avet datom)))
-                 (set-add! stmt (datom-tuple db :teav datom))
-                 (assoc :hash (atom 0)))
+                 (set-add! stmt (datom-tuple db :teav datom)))
              (if-some [removing (some-> (fsearch db [(.-e datom) (.-a datom) (.-v datom)])
                                         (retract-datom (:tx datom)))]
                (-> db
                    (set-add! stmt (datom-tuple db :eavt removing))
                    (set-add! stmt (datom-tuple db :aevt removing))
                    (cond-> indexing? (set-add! stmt (datom-tuple db :avet removing)))
-                   (set-add! stmt (datom-tuple db :teav removing))
-                   (assoc :hash (atom 0)))
+                   (set-add! stmt (datom-tuple db :teav removing)))
                db))]
     (.executeBatch stmt)
     (.close stmt)
@@ -2367,12 +1890,12 @@
     (not (or (arrays/array? vs)
            (and (coll? vs) (not (map? vs)))))
     [vs]
-    
+
     ;; probably lookup ref
     (and (= (count vs) 2)
       (is-attr? db (first vs) :db.unique/identity))
     [vs]
-    
+
     :else vs))
 
 (defn- explode [db entity]
@@ -2431,27 +1954,7 @@
               (filter (fn [^Datom d] (component? db (.-a d))))
               (map (fn [^Datom d] [:db.fn/retractEntity (.-v d)]))) datoms))
 
-#?(:clj  (declare transact-tx-data-impl)
-   :cljs (defn transact-tx-data-impl [initial-report initial-es]))
-
-#?(:clj
-   (defn- rollback-report!
-     "Rolls the JDBC connection back to the transaction start before a retry.
-      Ensures tuple writes and schema mutations are cleared prior to re-running."
-     [report]
-     (when-let [conn (some-> report :db-after :conn)]
-       (try
-         (.rollback ^java.sql.Connection conn)
-         (.setAutoCommit ^java.sql.Connection conn false)
-         (catch Throwable t
-           (throw (ex-info "Failed to rollback transaction for retry"
-                           {:error :transact/retry}
-                           t))))))
-   :cljs
-   (defn ^:private rollback-report!
-     "No-op placeholder for CLJS where transactions are in-memory."
-     [report]
-     report))
+(declare transact-tx-data-impl)
 
 (def builtin-fn?
   #{:db.fn/call
@@ -2485,7 +1988,7 @@
   ;; Just clean up internal keys.
   (dissoc report ::tx-redundant))
 
-(defn+ transact-tx-data-impl [initial-report initial-es]
+(defn transact-tx-data-impl [initial-report initial-es]
   (let [initial-report' initial-report
         has-tuples?     (not (empty? (-attrs-by (:db-after initial-report) :db.type/tuple)))
         initial-es'     (if has-tuples?
@@ -2497,7 +2000,7 @@
       (util/cond+
         (empty? es)
         (-> report
-          (update :db-after assoc :max-tx (current-tx report))
+          (update :db-after with-max-tx (current-tx report))
           (update :tempids assoc :db/current-tx (current-tx report)))
 
         :let [[entity & entities] es]
@@ -2544,13 +2047,13 @@
                                :conflict {:db/id old-eid}})))
               (recur (allocate-eid report old-eid id)
                 (cons (assoc entity :db/id id) entities)))
-           
+
             ;; lookup-ref => resolved | error
             (sequential? old-eid)
             (let [id (entid-strict db old-eid)]
               (recur report
                 (cons (assoc entity :db/id id) entities)))
-           
+
             ;; upserted => explode | error
             :let [[entity' upserts] (resolve-upserts db entity)
                   upserted-eid      (validate-upserts db entity' upserts)]
@@ -2560,13 +2063,13 @@
               (-> report
                 (allocate-eid old-eid upserted-eid))
               (concat (explode db (assoc entity' :db/id upserted-eid)) entities))
-           
+
             ;; UUID or nil => explode
             (or
               (uuid? old-eid)
               (nil? old-eid))
             (recur report (concat (explode db entity) entities))
-           
+
             ;; trash => error
             :else
             (util/raise "Expected UUID or lookup ref for :db/id, got " old-eid
@@ -2580,7 +2083,7 @@
                   fn-result (apply f db args)
                   {:keys [tx-data id-map]} (assign-entity-ids db fn-result)]
               (recur (update report :tempids merge id-map) (concat tx-data entities)))
-            
+
             (and (keyword? op)
               (not (builtin-fn? op)))
             (if-some [ident (entid db op)]
@@ -2593,7 +2096,7 @@
                     {:error :transact/syntax, :operation :db.fn/call, :tx-data entity})))
               (util/raise "Can't find entity for transaction fn " op
                 {:error :transact/syntax, :operation :db.fn/call, :tx-data entity}))
-            
+
             (or (= op :db.fn/cas)
               (= op :db/cas))
             (let [[_ e a ov nv] entity
@@ -2646,12 +2149,12 @@
               (not e-exists?))
             ;; Upsert: redirect this entity to the existing one
             (recur (allocate-eid report e existing-eid) (cons [op existing-eid a v] entities))
-            
+
             (and
               (not (::internal (meta entity)))
               (tuple? db a))
             ;; allow transacting in tuples if they fully match already existing values
-            (let [tuple-attrs   (get-in db [:schema a :db/tupleAttrs])
+            (let [tuple-attrs   (-> (-schema db) (get a) :db/tupleAttrs)
                   queued-value (get-in report [::queued-tuples e a])]
               (if queued-value
                 (if (and
@@ -2713,7 +2216,7 @@
 
             :else
             (util/raise "Unknown operation at " entity ", expected :db/add, :db/retract, :db.fn/call, :db.fn/retractAttribute, :db.fn/retractEntity or an ident corresponding to an installed transaction function (e.g. {:db/ident <keyword> :db/fn <Ifn>}, usage of :db/ident requires {:db/unique :db.unique/identity} in schema)" {:error :transact/syntax, :operation op, :tx-data entity})))
-       
+
         (datom? entity)
         (let [[e a v tx added] entity]
           (if added
@@ -2757,11 +2260,11 @@
                     (assoc ::tx-id tx-id)
                     ;; Set max-tx to current tx-id so datoms added during this
                     ;; transaction are visible when searching for duplicates
-                    (update :db-after assoc :max-tx tx-id))
+                    (update :db-after with-max-tx tx-id))
         {:keys [tx-data id-map]} (assign-entity-ids (:db-before report') es)
         ;; Pre-populate tempids with the tempid -> UUID mapping
         report'' (update report' :tempids merge id-map)
-        conn ^java.sql.Connection (:conn (:db-after report''))]
+        conn ^java.sql.Connection (db-conn (:db-after report''))]
     (try
       (let [result (with-transaction conn
                      (transact-tx-data-impl report'' tx-data))]
diff --git a/src/dbval/externs.js b/src/dbval/externs.js
deleted file mode 100644
index dfad4564..00000000
--- a/src/dbval/externs.js
+++ /dev/null
@@ -1,31 +0,0 @@
-var dbval = {};
-dbval.db = {};
-
-/**
- * @constructor
- */
-dbval.db.Datom = function() {};
-dbval.db.Datom.prototype.e;
-dbval.db.Datom.prototype.a;
-dbval.db.Datom.prototype.v;
-dbval.db.Datom.prototype.tx;
-dbval.db.Datom.prototype.idx;
-
-dbval.impl = {};
-dbval.impl.entity = {};
-
-/**
- * @constructor
- */
-dbval.impl.entity.Entity = function() {};
-dbval.impl.entity.Entity.prototype.db;
-dbval.impl.entity.Entity.prototype.eid;
-dbval.impl.entity.Entity.prototype.keys      = function() {};
-dbval.impl.entity.Entity.prototype.entries   = function() {};
-dbval.impl.entity.Entity.prototype.values    = function() {};
-dbval.impl.entity.Entity.prototype.has       = function() {};
-dbval.impl.entity.Entity.prototype.get       = function() {};
-dbval.impl.entity.Entity.prototype.forEach   = function() {};
-dbval.impl.entity.Entity.prototype.key_set   = function() {};
-dbval.impl.entity.Entity.prototype.entry_set = function() {};
-dbval.impl.entity.Entity.prototype.value_set = function() {};
diff --git a/src/dbval/impl/entity.cljc b/src/dbval/impl/entity.clj
similarity index 56%
rename from src/dbval/impl/entity.cljc
rename to src/dbval/impl/entity.clj
index 40936bd8..9f13d983 100644
--- a/src/dbval/impl/entity.cljc
+++ b/src/dbval/impl/entity.clj
@@ -1,6 +1,6 @@
 (ns ^:no-doc dbval.impl.entity
   (:refer-clojure :exclude [keys get])
-  (:require [#?(:cljs cljs.core :clj clojure.core) :as c]
+  (:require [clojure.core :as c]
     [dbval.db :as db]))
 
 (declare entity ->Entity equiv-entity lookup-entity touch hash-entity)
@@ -33,102 +33,9 @@
       (reduce #(conj %1 (entity db (:e %2))) #{} datoms))
     not-found))
 
-#?(:cljs
-   (defn- multival->js [val]
-     (when val (to-array val))))
-
-#?(:cljs
-   (defn- js-seq [e]
-     (touch e)
-     (for [[a v] @(.-cache e)]
-       (if (db/multival? (.-db e) a)
-         [a (multival->js v)]
-         [a v]))))
-
-#?(:cljs
-  (unchecked-set (.-prototype ES6Iterator) cljs.core/ITER_SYMBOL
-     (fn []
-       (this-as this# this#))))
-
-#?(:cljs
-  (unchecked-set (.-prototype ES6EntriesIterator) cljs.core/ITER_SYMBOL
-     (fn []
-       (this-as this# this#))))
 
 (deftype Entity [db eid touched cache]
-  #?@(:cljs
-      [Object
-       (toString [this]
-         (pr-str* this))
-       (equiv [this other]
-         (equiv-entity this other))
-
-       ;; js/map interface
-       (keys [this]
-         (es6-iterator (c/keys this)))
-       (entries [this]
-         (es6-entries-iterator (js-seq this)))
-       (values [this]
-         (es6-iterator (map second (js-seq this))))
-       (has [this attr]
-         (not (nil? (.get this attr))))
-       (get [this attr]
-         (if (= attr ":db/id")
-           eid
-           (if (db/reverse-ref? attr)
-             (-> (-lookup-backwards db eid (db/reverse-ref attr) nil)
-               multival->js)
-             (cond-> (lookup-entity this attr)
-               (db/multival? db attr) multival->js))))
-       (forEach [this f]
-         (doseq [[a v] (js-seq this)]
-           (f v a this)))
-       (forEach [this f use-as-this]
-         (doseq [[a v] (js-seq this)]
-           (.call f use-as-this v a this)))
-
-       ;; js fallbacks
-       (key_set   [this] (to-array (c/keys this)))
-       (entry_set [this] (to-array (map to-array (js-seq this))))
-       (value_set [this] (to-array (map second (js-seq this))))
-
-       IEquiv
-       (-equiv [this o] (equiv-entity this o))
-
-       IHash
-       (-hash [this]
-         (hash-entity this))
-
-       ISeqable
-       (-seq [this]
-         (touch this)
-         (seq @cache))
-
-       ICounted
-       (-count [this]
-         (touch this)
-         (count @cache))
-
-       ILookup
-       (-lookup [this attr]           (lookup-entity this attr nil))
-       (-lookup [this attr not-found] (lookup-entity this attr not-found))
-
-       IAssociative
-       (-contains-key? [this k]
-         (not= ::nf (lookup-entity this k ::nf)))
-
-       IFn
-       (-invoke [this k]
-         (lookup-entity this k))
-       (-invoke [this k not-found]
-         (lookup-entity this k not-found))
-
-       IPrintWithWriter
-       (-pr-writer [_ writer opts]
-         (-pr-writer (assoc @cache :db/id eid) writer opts))]
-
-      :clj
-      [Object
+  Object
        (toString [e]      (pr-str (assoc @cache :db/id eid)))
        (hashCode [e]      (hash-entity e))
        (equals [e o]      (equiv-entity e o))
@@ -152,18 +59,13 @@
 
        clojure.lang.IFn
        (invoke [e k]      (lookup-entity e k))
-       (invoke [e k not-found] (lookup-entity e k not-found))]))
+       (invoke [e k not-found] (lookup-entity e k not-found)))
 
 (defn entity? [x] (instance? Entity x))
 
-#?(:cljs
-  (unchecked-set (.-prototype Entity) cljs.core/ITER_SYMBOL
-     (fn []
-       (this-as this# (.entries this#)))))
 
-#?(:clj
-   (defmethod print-method Entity [e, ^java.io.Writer w]
-     (.write w (str e))))
+(defmethod print-method Entity [e, ^java.io.Writer w]
+     (.write w (str e)))
 
 (defn- equiv-entity [^Entity this that]
   (and
@@ -175,7 +77,7 @@
   (db/combine-hashes
     (hash (.-eid e))
     ;; A hash compatible with `identical?`. Consistent with `=`.
-    (#?(:clj System/identityHashCode :cljs goog/getUid) (.-db e))))
+    (System/identityHashCode (.-db e))))
 
 (defn- lookup-entity
   ([this attr] (lookup-entity this attr nil))
@@ -222,4 +124,3 @@
         (vreset! (.-touched e) true)))
     e))
 
-#?(:cljs (goog/exportSymbol "dbval.impl.entity.Entity" Entity))
diff --git a/src/dbval/js.cljs b/src/dbval/js.cljs
deleted file mode 100644
index 8c7646d7..00000000
--- a/src/dbval/js.cljs
+++ /dev/null
@@ -1,165 +0,0 @@
-(ns ^:no-doc dbval.js
-  (:refer-clojure :exclude [filter])
-  (:require
-    [cljs.reader]
-    [goog.object :as go]
-    [clojure.walk :as walk]
-    [dbval.conn :as conn]
-    [dbval.core :as d]
-    ))
-
-;; Conversions
-
-(defn- keywordize [s]
-  (if (and (string? s) (= (subs s 0 1) ":"))
-    (keyword (subs s 1))
-    s))
-
-(defn- schema->clj [schema]
-  (->> (js->clj schema)
-    (reduce-kv
-      (fn [m k v] (assoc m k (walk/postwalk keywordize v))) {})))
-
-(declare entities->clj)
-
-(defn- entity-map->clj [e]
-  (walk/postwalk
-    (fn [form]
-      (if (and (map? form) (contains? form ":db/id"))
-        (-> form
-          (dissoc ":db/id")
-          (assoc  :db/id (get form ":db/id")))
-        form))
-    e))
-
-(defn- entity->clj [e]
-  (cond
-    (map? e)
-    (entity-map->clj e)
-
-    (= (first e) ":db.fn/call")
-    (let [[_ f & args] e]
-      (concat [:db.fn/call (fn [& args] (entities->clj (apply f args)))] args))
-
-    (sequential? e)
-    (let [[op & entity] e]
-      (concat [(keywordize op)] entity))))
-
-(defn- entities->clj [entities]
-  (->> (js->clj entities)
-    (map entity->clj)))
-
-(defn- tempids->js [tempids]
-  (let [obj (js-obj)]
-    (doseq [[k v] tempids]
-      (go/set obj (str k) v))
-    obj))
-
-(defn- tx-report->js [report]
-  #js {:db_before (:db-before report)
-       :db_after  (:db-after report)
-       :tx_data   (->> (:tx-data report) into-array)
-       :tempids   (tempids->js (:tempids report))
-       :tx_meta   (:tx-meta report)})
-
-(defn js->Datom [d]
-  (if (array? d)
-    (d/datom (aget d 0) (aget d 1) (aget d 2) (or (aget d 3) d/tx0) (or (aget d 4) true))
-    (d/datom (.-e d) (.-a d) (.-v d) (or (.-tx d) d/tx0) (or (.-added d) true))))
-
-(defn- pull-result->js
-  [result]
-  (->> result
-    (walk/postwalk #(if (keyword? %) (str %) %))
-    clj->js))
-
-;; Public API
-
-(defn ^:export empty_db [& [schema]]
-  (d/empty-db (schema->clj schema)))
-
-(defn ^:export init_db [datoms & [schema]]
-  (d/init-db (map js->Datom datoms) (schema->clj schema)))
-
-(defn ^:export q [query & sources]
-  (let [query   (cljs.reader/read-string query)
-        results (apply d/q query sources)]
-    (clj->js results)))
-
-(defn ^:export pull [db pattern eid]
-  (let [pattern (cljs.reader/read-string pattern)
-        eid (js->clj eid)
-        results (d/pull db pattern eid)]
-    (pull-result->js results)))
-
-(defn ^:export pull_many [db pattern eids]
-  (let [pattern (cljs.reader/read-string pattern)
-        eids (js->clj eids)
-        results (d/pull-many db pattern eids)]
-    (pull-result->js results)))
-
-(defn ^:export db_with [db entities]
-  (d/db-with db (entities->clj entities)))
-
-(defn ^:export entity [db eid]
-  (d/entity db (js->clj eid)))
-
-(def ^:export touch d/touch)
-(def ^:export entity_db d/entity-db)
-(def ^:export filter d/filter)
-(def ^:export is_filtered d/is-filtered)
-
-(defn ^:export create_conn [& [schema]]
-  (d/create-conn (schema->clj schema)))
-
-(def ^:export conn_from_db d/conn-from-db)
-
-(defn ^:export conn_from_datoms
-  ([datoms]        (conn_from_db (init_db datoms)))
-  ([datoms schema] (conn_from_db (init_db datoms schema))))
-
-(defn ^:export db [conn] @conn)
-
-(defn ^:export transact [conn entities & [tx-meta]]
-  (let [entities (entities->clj entities)
-        report   (-> (conn/-transact! conn entities tx-meta)
-                   tx-report->js)]
-    (doseq [[_ callback] (:listeners @(:atom conn))]
-      (callback report))
-    report))
-
-(defn ^:export reset_conn [conn db & [tx-meta]]
-  (let [report #js {:db_before @conn
-                    :db_after  db
-                    :tx_data   (into-array
-                                 (concat
-                                   (map #(assoc % :added false) (d/datoms @conn :eavt))
-                                   (d/datoms db :eavt)))
-                    :tx_meta   tx-meta}]
-    (reset! conn db)
-    (doseq [[_ callback] (:listeners @(:atom conn))]
-      (callback report))
-    db))
-
-(def ^:export listen d/listen!)
-(def ^:export unlisten d/unlisten!)
-
-(defn ^:export resolve_tempid [tempids tempid]
-  (go/get tempids (str tempid)))
-
-(defn ^:export datoms [db index & components]
-  (->> (apply d/datoms db (keywordize index) components)
-    into-array))
-
-(defn ^:export seek_datoms [db index & components]
-  (->> (apply d/seek-datoms db (keywordize index) components)
-    into-array))
-
-(defn ^:export index_range [db attr start end]
-  (into-array (d/index-range db attr start end)))
-
-(defn ^:export squuid []
-  (str (d/squuid)))
-
-(defn ^:export squuid_time_millis [uuid]
-  (d/squuid-time-millis (cljs.core/uuid uuid)))
diff --git a/src/dbval/lru.cljc b/src/dbval/lru.clj
similarity index 76%
rename from src/dbval/lru.cljc
rename to src/dbval/lru.clj
index 885241c3..2de30ee3 100644
--- a/src/dbval/lru.cljc
+++ b/src/dbval/lru.clj
@@ -2,26 +2,14 @@
 
 (declare assoc-lru cleanup-lru)
 
-#?(:cljs
-   (deftype LRU [key-value gen-key key-gen gen limit]
-     IAssociative
-     (-assoc [this k v] (assoc-lru this k v))
-     (-contains-key? [_ k] (-contains-key? key-value k))
-     ILookup
-     (-lookup [_ k]    (-lookup key-value k nil))
-     (-lookup [_ k nf] (-lookup key-value k nf))
-     IPrintWithWriter
-     (-pr-writer [_ writer opts]
-       (-pr-writer key-value writer opts)))
-   :clj
-   (deftype LRU [^clojure.lang.Associative key-value gen-key key-gen gen limit]
+(deftype LRU [^clojure.lang.Associative key-value gen-key key-gen gen limit]
      clojure.lang.ILookup
      (valAt [_ k]           (.valAt key-value k))
      (valAt [_ k not-found] (.valAt key-value k not-found))
      clojure.lang.Associative
      (containsKey [_ k] (.containsKey key-value k))
      (entryAt [_ k]     (.entryAt key-value k))
-     (assoc [this k v]  (assoc-lru this k v))))
+     (assoc [this k v]  (assoc-lru this k v)))
 
 (defn assoc-lru [^LRU lru k v]
   (let [key-value (.-key-value lru)
diff --git a/src/dbval/parser.cljc b/src/dbval/parser.clj
similarity index 99%
rename from src/dbval/parser.cljc
rename to src/dbval/parser.clj
index 5eb76060..b70497df 100644
--- a/src/dbval/parser.cljc
+++ b/src/dbval/parser.clj
@@ -1,6 +1,6 @@
 (ns ^:no-doc dbval.parser
   (:refer-clojure :exclude [distinct?])
-  #?(:cljs (:require-macros [dbval.parser :refer [deftrecord]]))
+
   (:require
     [clojure.set :as set]
     [dbval.db :as db]
@@ -15,8 +15,7 @@
   (-collect-vars [_ acc])
   (-postwalk     [_ f]))
 
-#?(:clj
-   (defmacro deftrecord
+(defmacro deftrecord
      "Augment all dbval.parser/ records with default implementation of ITraversable"
      [tagname fields & rest]
      (let [f    (gensym "f")
@@ -35,7 +34,7 @@
           (~'-collect-vars [_# ~acc]
             ;; [x y z] -> (collect-vars-acc (collect-vars-acc (collect-vars-acc acc x) y) z)
             ~(reduce #(list 'dbval.parser/collect-vars-acc %1 %2) acc fields))
-          ~@rest))))
+          ~@rest)))
 
 (defn of-size? [form size]
   (and (sequential? form)
@@ -133,7 +132,6 @@
     (Variable. form)))
 
 
-
 ;; fn-arg = (variable | constant | src-var)
 
 (defn parse-fn-arg [form]
@@ -434,7 +432,7 @@
     (if-let [source* (parse-src-var (first form))]
       [source* (next form)]
       [(DefaultSrc.) form])))
-      
+
 (defn parse-pattern [form]
   (when-let [[source* next-form] (take-source form)]
     (when-let [pattern* (parse-seq parse-pattern-el next-form)]
@@ -499,7 +497,7 @@
 
 (defn- collect-vars [form]
   (collect-vars-acc [] form))
-    
+
 (defn collect-vars-distinct [form]
   (vec (distinct (collect-vars form))))
 
@@ -735,7 +733,7 @@
                (count)))
     (util/raise "Only one of :keys/:syms/:strs must be present"
       {:error :parser/query, :form form}))
-  
+
   (let [in-vars    (collect-vars (:qin q))
         in-sources (collect #(instance? SrcVar %) (:qin q))
         in-rules   (collect #(instance? RulesVar %) (:qin q))]
@@ -744,19 +742,19 @@
                 (distinct? in-rules))
       (util/raise "Vars used in :in should be distinct"
         {:error :parser/query, :form form})))
-  
+
   (let [with-vars (collect-vars (:qwith q))]
     (when-not (distinct? with-vars)
       (util/raise "Vars used in :with should be distinct"
         {:error :parser/query, :form form})))
-  
+
   (let [in-sources    (collect #(instance? SrcVar %) (:qin q) #{})
         where-sources (collect #(instance? SrcVar %) (:qwhere q) #{})
         unknown       (set/difference where-sources in-sources)]
     (when-not (empty? unknown)
       (util/raise "Where uses unknown source vars: " (mapv :symbol unknown)
         {:error :parser/query, :vars unknown, :form form})))
-  
+
   (let [rule-exprs (collect #(instance? RuleExpr %) (:qwhere q))
         rules-vars (collect #(instance? RulesVar %) (:qin q))]
     (when (and (not (empty? rule-exprs))
diff --git a/src/dbval/pull_api.cljc b/src/dbval/pull_api.clj
similarity index 92%
rename from src/dbval/pull_api.cljc
rename to src/dbval/pull_api.clj
index 17c993b9..79a1e8b4 100644
--- a/src/dbval/pull_api.cljc
+++ b/src/dbval/pull_api.clj
@@ -2,32 +2,30 @@
   (:require
     [clojure.string :as str]
     [dbval.pull-parser :as dpp]
-    [dbval.db :as db #?@(:cljs [:refer [DB]])]
+    [dbval.db :as db]
     [dbval.lru :as lru]
-    [dbval.util :as util]
-    [me.tonsky.persistent-sorted-set :as set])
-  #?(:clj
-     (:import
+    [dbval.util :as util])
+  (:import
        [clojure.lang ISeq]
        [dbval.db Datom DB]
-       [dbval.pull_parser PullAttr PullPattern])))
+       [dbval.pull_parser PullAttr PullPattern]))
 
 (declare pull-impl attrs-frame ref-frame ->ReverseAttrsFrame)
 
-(defn- first-seq [#?(:clj ^ISeq xs :cljs ^seq xs)]
+(defn- first-seq [^ISeq xs]
   (if (nil? xs)
     nil
-    #?(:clj (.first xs) :cljs (-first xs))))
+    (.first xs)))
 
-(defn- next-seq [#?(:clj ^ISeq xs :cljs ^seq xs)]
+(defn- next-seq [^ISeq xs]
   (if (nil? xs)
     nil
-    #?(:clj (.next xs) :cljs (-next xs))))
+    (.next xs)))
 
-(defn- conj-seq [#?(:clj ^ISeq xs :cljs ^seq xs) x]
+(defn- conj-seq [^ISeq xs x]
   (if (nil? xs)
     (list x)
-    #?(:clj (.cons xs x) :cljs (-conj xs x))))
+    (.cons xs x)))
 
 (defn- assoc-some! [m k v]
   (if (nil? v) m (assoc! m k v)))
@@ -75,7 +73,7 @@
 
         :else
         (recur (conj! acc (.-v datom)) (next-seq datoms)))))
-  
+
   (-str [this]
     (str "MultivalAttrFrame<attr=" (attr-str attr) ">")))
 
@@ -89,7 +87,7 @@
       pattern
       attr
       (next-seq datoms)))
-  
+
   (-run [this context]
     (util/cond+
       :let [^Datom datom (first-seq datoms)]
@@ -109,7 +107,7 @@
 
       :else
       [this (ref-frame context seen recursion-limits pattern attr id)]))
-  
+
   (-str [this]
     (str "MultivalAttrFrame<attr=" (attr-str attr) ">")))
 
@@ -164,8 +162,8 @@
         (recur acc (first-seq attrs) (next-seq attrs) datoms)
 
         ;; default
-        (and datom-ahead? (some? (#?(:clj .-default :cljs :default) attr)))
-        (recur (assoc! acc (.-as attr) (#?(:clj .-default :cljs :default) attr)) (first-seq attrs) (next-seq attrs) datoms)
+        (and datom-ahead? (some? (.-default attr)))
+        (recur (assoc! acc (.-as attr) (.-default attr)) (first-seq attrs) (next-seq attrs) datoms)
 
         ;; xform
         datom-ahead?
@@ -192,7 +190,7 @@
           (first-seq attrs)
           (next-seq attrs)
           (next-seq datoms)))))
-  
+
   (-str [this]
     (str "AttrsFrame<id=" id ", attr=" (attr-str attr) ", attrs=" (str/join " " (map attr-str attrs)) ">")))
 
@@ -207,7 +205,7 @@
       (first-seq attrs)
       (next-seq attrs)
       id))
-  
+
   (-run [this context]
     (loop [acc   acc
            attr  attr
@@ -224,8 +222,8 @@
 
         :do (visit context :db.pull/reverse nil name id)
 
-        (and (empty? datoms) (some? (#?(:clj .-default :cljs :default) attr)))
-        (recur (assoc! acc (.-as attr) (#?(:clj .-default :cljs :default) attr)) (first-seq attrs) (next-seq attrs))
+        (and (empty? datoms) (some? (.-default attr)))
+        (recur (assoc! acc (.-as attr) (.-default attr)) (first-seq attrs) (next-seq attrs))
 
         (empty? datoms)
         (recur acc (first-seq attrs) (next-seq attrs))
@@ -237,7 +235,7 @@
         :else
         [(ReverseAttrsFrame. seen recursion-limits acc pattern attr attrs id)
          (MultivalRefAttrFrame. seen recursion-limits (transient []) pattern attr datoms)])))
-  
+
   (-str [this]
     (str "ReverseAttrsFrame<id=" id ", attr=" (attr-str attr) ", attrs=" (str/join " " (map attr-str attrs)) ">")))
 
@@ -275,7 +273,7 @@
         datoms (util/cond+
                  (and (.-wildcard? pattern) (instance? DB db))
                  (seq (db/-datoms db :eavt id nil nil nil))
-                 
+
                  (.-wildcard? pattern)
                  (db/-search db [id])
 
@@ -284,7 +282,7 @@
 
                  :let [from (.-name ^PullAttr (.-first-attr pattern))
                        to   (.-name ^PullAttr (.-last-attr pattern))]
-                 
+
                  (instance? DB db)
                  (take-while (fn [datom]
                                (and (= (:e datom)
diff --git a/src/dbval/pull_parser.cljc b/src/dbval/pull_parser.clj
similarity index 99%
rename from src/dbval/pull_parser.cljc
rename to src/dbval/pull_parser.clj
index d9edc8f5..bd5cdb29 100644
--- a/src/dbval/pull_parser.cljc
+++ b/src/dbval/pull_parser.clj
@@ -67,9 +67,9 @@
     (when (fn? sym-or-fn)
       sym-or-fn)
     (get built-ins/query-fns sym-or-fn)
-    #?(:clj (when (namespace sym-or-fn)
+    (when (namespace sym-or-fn)
               (when-some [v (requiring-resolve sym-or-fn)]
-                @v)))
+                @v))
     (util/raise "Can't resolve symbol " sym-or-fn {:error :parser/pull, :fragment sym-or-fn})))
 
 (defn parse-attr-expr [db attr-spec]
@@ -188,11 +188,11 @@
                       result
                       attr-spec)]
         (recur (next pattern) result'))
-        
+
       :let [pull-attr (parse-attr-spec db attr-spec)]
 
       (nil? pull-attr)
       (check false "attr-name | attr-expr | map-spec | *" attr-spec)
-      
+
       :else
       (recur (next pattern) (conj-attr result pull-attr)))))
diff --git a/src/dbval/query.cljc b/src/dbval/query.clj
similarity index 92%
rename from src/dbval/query.cljc
rename to src/dbval/query.clj
index b4c7097c..d6abdbc2 100644
--- a/src/dbval/query.cljc
+++ b/src/dbval/query.clj
@@ -1,27 +1,24 @@
 (ns ^:no-doc dbval.query
   (:require
-    [#?(:cljs cljs.reader :clj clojure.edn) :as edn]
+    [clojure.edn :as edn]
     [clojure.set :as set]
     [clojure.string :as str]
     [clojure.walk :as walk]
     [dbval.built-ins :as built-ins]
     [dbval.db :as db]
-    [me.tonsky.persistent-sorted-set.arrays :as da]
+    [dbval.arrays :as da]
     [dbval.lru :as lru]
     [dbval.impl.entity :as de]
-    [dbval.parser :as dp #?@(:cljs [:refer [BindColl BindIgnore BindScalar BindTuple Constant
-                                                 FindColl FindRel FindScalar FindTuple PlainSymbol
-                                                 RulesVar SrcVar Variable]])]
+    [dbval.parser :as dp ]
     [dbval.pull-api :as dpa]
     [dbval.util :as util])
-  #?(:clj
-     (:import
+  (:import
        [clojure.lang ILookup LazilyPersistentVector]
        [dbval.parser BindColl BindIgnore BindScalar BindTuple
         Constant FindColl FindRel FindScalar FindTuple PlainSymbol
-        RulesVar SrcVar Variable])))
+        RulesVar SrcVar Variable]))
 
-#?(:clj (set! *warn-on-reflection* true))
+(set! *warn-on-reflection* true)
 
 ;; ----------------------------------------------------------------------------
 
@@ -41,13 +38,12 @@
 ;; or [(Datom. 2 "Oleg" 1 55) ...]
 (defrecord Relation [attrs tuples])
 
-#?(:clj
-   (defmethod print-method Relation [r, ^java.io.Writer w]
+(defmethod print-method Relation [r, ^java.io.Writer w]
      (.write w "#Relation{:attrs ")
      (.write w (pr-str (:attrs r)))
      (.write w ", :tuples [")
      (.write w (str/join " " (map seq (:tuples r))))
-     (.write w "]}")))
+     (.write w "]}"))
 
 
 ;; Utilities
@@ -100,10 +96,9 @@
 
 ;; Relation algebra
 
-#?(:clj (set! *unchecked-math* true))
+(set! *unchecked-math* true)
 
-#?(:clj
-   (defn join-tuples [t1 ^{:tag "[[Ljava.lang.Object;"} idxs1
+(defn join-tuples [t1 ^{:tag "[[Ljava.lang.Object;"} idxs1
                       t2 ^{:tag "[[Ljava.lang.Object;"} idxs2]
      (let [l1  (alength idxs1)
            l2  (alength idxs2)
@@ -115,17 +110,8 @@
          (dotimes [i l2] (aset res (+ l1 i) (get ^objects t2 (aget idxs2 i))))
          (dotimes [i l2] (aset res (+ l1 i) (get t2 (aget idxs2 i)))))
        res))
-   :cljs
-   (defn join-tuples [t1 idxs1
-                      t2 idxs2]
-     (let [l1  (alength idxs1)
-           l2  (alength idxs2)
-           res (da/make-array (+ l1 l2))]
-       (dotimes [i l1] (aset res i (da/aget t1 (aget idxs1 i))))
-       (dotimes [i l2] (aset res (+ l1 i) (da/aget t2 (aget idxs2 i))))
-       res)))
 
-#?(:clj (set! *unchecked-math* false))
+(set! *unchecked-math* false)
 
 (defn- sum-rel* [attrs-a tuples-a attrs-b tuples-b]
   (let [idxb->idxa (vec (for [[sym idx-b] attrs-b]
@@ -136,7 +122,7 @@
                     (fn [acc tuple-b]
                       (let [tuple' (da/make-array tlen)]
                         (doseq [[idx-b idx-a] idxb->idxa]
-                          (aset tuple' idx-a (#?(:cljs da/aget :clj get) tuple-b idx-b)))
+                          (aset tuple' idx-a (get tuple-b idx-b)))
                         (conj! acc tuple')))
                     (transient (vec tuples-a))
                     tuples-b))]
@@ -202,11 +188,11 @@
   BindIgnore
   (in->rel [_ _]
     (prod-rel))
-  
+
   BindScalar
   (in->rel [binding value]
     (Relation. {(get-in binding [:variable :symbol]) 0} [(into-array [value])]))
-  
+
   BindColl
   (in->rel [binding coll]
     (cond
@@ -219,7 +205,7 @@
       (->> coll
         (map #(in->rel (:binding binding) %))
         (reduce sum-rel))))
-  
+
   BindTuple
   (in->rel [binding coll]
     (cond
@@ -275,10 +261,9 @@
       (if (int? idx)
         (let [idx (int idx)]
           (fn contained-int-getter-fn [tuple]
-            (let [eid #?(:cljs (da/aget tuple idx)
-                         :clj (if (.isArray (.getClass ^Object tuple))
+            (let [eid (if (.isArray (.getClass ^Object tuple))
                                 (aget ^objects tuple idx)
-                                (nth tuple idx)))]
+                                (nth tuple idx))]
               (cond
                 (uuid? eid)       eid ;; quick path to avoid fn call
                 (sequential? eid) (db/entid *implicit-source* eid)
@@ -286,8 +271,7 @@
                 :else             eid))))
         ;; If the index is not an int?, the target can never be an array
         (fn contained-getter-fn [tuple]
-          (let [eid #?(:cljs (da/aget tuple idx)
-                       :clj (.valAt ^ILookup tuple idx))]
+          (let [eid (.valAt ^ILookup tuple idx)]
             (cond
               (uuid? eid)       eid ;; quick path to avoid fn call
               (sequential? eid) (db/entid *implicit-source* eid)
@@ -296,38 +280,32 @@
       (if (int? idx)
         (let [idx (int idx)]
           (fn int-getter [tuple]
-            #?(:cljs (da/aget tuple idx)
-               :clj (if (.isArray (.getClass ^Object tuple))
+            (if (.isArray (.getClass ^Object tuple))
                       (aget ^objects tuple idx)
-                      (nth tuple idx)))))
+                      (nth tuple idx))))
         ;; If the index is not an int?, the target can never be an array
         (fn getter [tuple]
-          #?(:cljs (da/aget tuple idx)
-             :clj (.valAt ^ILookup tuple idx)))))))
+          (.valAt ^ILookup tuple idx))))))
 
 (defn tuple-key-fn
   [attrs common-attrs]
   (let [n (count common-attrs)]
     (if (== n 1)
       (getter-fn attrs (first common-attrs))
-      (let [^objects getters-arr #?(:clj (into-array Object common-attrs)
-                                    :cljs (into-array common-attrs))]
+      (let [^objects getters-arr (into-array Object common-attrs)]
         (loop [i 0]
           (if (< i n)
             (do
               (aset getters-arr i (getter-fn attrs (aget getters-arr i)))
               (recur (unchecked-inc i)))
-            #?(:clj
-               (fn [tuple]
+            (fn [tuple]
                  (let [^objects arr (make-array Object n)]
                    (loop [i 0]
                      (if (< i n)
                        (do
                          (aset arr i ((aget getters-arr i) tuple))
                          (recur (unchecked-inc i)))
-                       (LazilyPersistentVector/createOwning arr)))))
-               :cljs (fn [tuple]
-                       (list* (.map getters-arr #(% tuple)))))))))))
+                       (LazilyPersistentVector/createOwning arr)))))))))))
 
 (defn -group-by
   [f init coll]
@@ -364,7 +342,7 @@
                         tuples2
                         (reduce (fn outer [acc tuple2]
                                   (let [key (key-fn2 tuple2)]
-                                    (if-some [tuples1 #?(:clj (hash key) :cljs (get hash key))]
+                                    (if-some [tuples1 (hash key)]
                                       (reduce (fn inner [acc tuple1]
                                                 (conj! acc (join-tuples tuple1 keep-idxs1 tuple2 keep-idxs2)))
                                         acc tuples1)
@@ -393,7 +371,7 @@
       (when-some [tuple (first (:tuples rel))]
         (when (nil? (fnext (:tuples rel)))
           (let [idx (get (:attrs rel) pattern-el)]
-            (#?(:cljs da/aget :clj get) tuple idx)))))))
+            (get tuple idx)))))))
 
 (defn substitute-constants [context pattern]
   (mapv #(or (substitute-constant context %) %) pattern))
@@ -466,7 +444,7 @@
 (defn- context-resolve-val [context sym]
   (when-some [rel (rel-with-attr context sym)]
     (when-some [tuple (first (:tuples rel))]
-      (#?(:cljs da/aget :clj get) tuple ((:attrs rel) sym)))))
+      (get tuple ((:attrs rel) sym)))))
 
 (defn- rel-contains-attrs? [rel attrs]
   (some #(contains? (:attrs rel) %) attrs))
@@ -491,28 +469,26 @@
           (da/aset static-args i arg))))
     ;; CLJS `apply` + `vector` will hold onto mutable array of arguments directly
     ;; issue-262
-    (if #?(:clj  false
-           :cljs (identical? f vector))
+    (if false
       (fn [tuple]
         ;; TODO raise if not all args are bound
         (let [args (da/aclone static-args)]
           (dotimes [i len]
             (when-some [tuple-idx (aget tuples-args i)]
-              (let [v (#?(:cljs da/aget :clj get) tuple tuple-idx)]
+              (let [v (get tuple tuple-idx)]
                 (da/aset args i v))))
           (apply f args)))
       (fn [tuple]
         ;; TODO raise if not all args are bound
         (dotimes [i len]
           (when-some [tuple-idx (aget tuples-args i)]
-            (let [v (#?(:cljs da/aget :clj get) tuple tuple-idx)]
+            (let [v (get tuple tuple-idx)]
               (da/aset static-args i v))))
         (apply f static-args)))))
 
 (defn- resolve-sym [sym]
-  #?(:cljs nil
-     :clj (when (namespace sym)
-            (when-some [v (resolve sym)] @v))))
+  (when (namespace sym)
+            (when-some [v (resolve sym)] @v)))
 
 (defn filter-by-pred [context clause]
   (let [[[f & args]] clause
@@ -736,31 +712,31 @@
      (do
        (check-bound (bound-vars context) (filter free-var? (nfirst clause)) clause)
        (filter-by-pred context clause))
-     
+
      [[symbol? '*] '_] ;; function [(fn ?a ?b) ?res]
      (do
        (check-bound (bound-vars context) (filter free-var? (nfirst clause)) clause)
        (bind-by-fn context clause))
-     
+
      [source? '*] ;; source + anything
      (let [[source-sym & rest] clause]
        (binding [*implicit-source* (get (:sources context) source-sym)]
          (-resolve-clause context rest clause)))
-     
+
      '[or *] ;; (or ...)
      (let [[_ & branches] clause
            _        (check-free-same (bound-vars context) branches clause)
            contexts (map #(resolve-clause context %) branches)
            rels     (map #(reduce hash-join (:rels %)) contexts)]
        (assoc (first contexts) :rels [(reduce sum-rel rels)]))
-     
+
      '[or-join [[*] *] *] ;; (or-join [[req-vars] vars] ...)
      (let [[_ [req-vars & vars] & branches] clause
            bound (bound-vars context)]
        (check-bound bound req-vars orig-clause)
        (check-free-subset bound vars branches)
        (recur context (list* 'or-join (concat req-vars vars) branches) clause))
-     
+
      '[or-join [*] *] ;; (or-join [vars] ...)
      (let [[_ vars & branches] clause
            vars         (set vars)
@@ -770,11 +746,11 @@
            rels         (map #(reduce hash-join (:rels %)) contexts)
            sum-rel      (reduce sum-rel rels)]
        (update context :rels collapse-rels sum-rel))
-     
+
      '[and *] ;; (and ...)
      (let [[_ & clauses] clause]
        (reduce resolve-clause context clauses))
-     
+
      '[not *] ;; (not ...)
      (let [[_ & clauses] clause
            bound            (bound-vars context)
@@ -789,7 +765,7 @@
                               (util/single (:rels context'))
                               (reduce hash-join (:rels negation-context)))]
        (assoc context' :rels [negation]))
-     
+
      '[not-join [*] *] ;; (not-join [vars] ...)
      (let [[_ vars & clauses] clause
            bound            (bound-vars context)
@@ -802,7 +778,7 @@
                               (util/single (:rels context'))
                               (reduce hash-join (:rels negation-context)))]
        (assoc context' :rels [negation]))
-     
+
      '[*] ;; pattern
      (let [source   *implicit-source*
            pattern' (resolve-pattern-lookup-refs source clause)
@@ -841,24 +817,18 @@
   (->Eduction
     (comp
       (map
-        (fn [#?(:cljs t1
-                :clj ^{:tag "[[Ljava.lang.Object;"} t1)]
+        (fn [^{:tag "[[Ljava.lang.Object;"} t1]
           (->Eduction
             (map
               (fn [t2]
                 (let [res (aclone t1)]
-                  #?(:clj
-                     (if (.isArray (.getClass ^Object t2))
+                  (if (.isArray (.getClass ^Object t2))
                        (dotimes [i len]
                          (when-some [idx (aget ^objects copy-map i)]
                            (aset res i (aget ^objects t2 idx))))
                        (dotimes [i len]
                          (when-some [idx (aget ^objects copy-map i)]
                            (aset res i (get t2 idx)))))
-                     :cljs
-                     (dotimes [i len]
-                       (when-some [idx (aget ^objects copy-map i)]
-                         (aset res i (da/aget ^objects t2 idx)))))
                   res)))
             (:tuples rel))))
       cat)
@@ -871,16 +841,16 @@
   ([acc rels symbols]
    (util/cond+
      :let [rel (first rels)]
- 
+
      (nil? rel) acc
- 
+
      ;; one empty rel means final set has to be empty
      (empty? (:tuples rel)) []
- 
+
      :let [keep-attrs (select-keys (:attrs rel) symbols)]
- 
+
      (empty? keep-attrs) (recur acc (next rels) symbols)
- 
+
      :let [copy-map (to-array (map #(get keep-attrs %) symbols))
            len      (count symbols)]
 
diff --git a/src/dbval/query_v3.cljc b/src/dbval/query_v3.cljc
deleted file mode 100644
index de0c5861..00000000
--- a/src/dbval/query_v3.cljc
+++ /dev/null
@@ -1,975 +0,0 @@
-(ns ^:no-doc dbval.query-v3
-  (:require
-    [clojure.set :as set]
-    [dbval.built-ins :as built-ins]
-    [dbval.core :as d]
-    [dbval.db :as db]
-    [dbval.query :as dq]
-    [dbval.lru :as lru]
-    [me.tonsky.persistent-sorted-set.arrays :as da]
-    [dbval.parser :as dp #?@(:cljs [:refer [BindColl BindIgnore BindScalar BindTuple
-                                                 Constant DefaultSrc Pattern RulesVar SrcVar Variable
-                                                 Not Or And Predicate PlainSymbol]])]
-    [dbval.util :as util])
-  #?(:clj
-     (:import 
-       [dbval.parser
-        BindColl BindIgnore BindScalar BindTuple
-        Constant DefaultSrc Pattern RulesVar SrcVar Variable
-        Not Or And Predicate PlainSymbol]
-       [clojure.lang     IReduceInit Counted]
-       [dbval.db  Datom])))
-
-(declare resolve-clauses collect-rel-xf collect-to)
-
-(def ^:const lru-cache-size 100)
-
-(defn mapa [f coll]
-  (to-array (map f coll)))
-
-(defn arange [start end]
-  (to-array (range start end)))
-
-(defn subarr [arr start end]
-  (da/acopy arr start end (da/make-array (- end start)) 0))
-
-(defn concatv [& xs]
-  (into [] cat xs))
-
-(defn zip
-  ([a b] (map vector a b))
-  ([a b & rest] (apply map vector a b rest)))
-
-(defn has? [coll el]
-  (some #(= el %) coll))
-
-(defprotocol NativeColl
-  (-native-coll [_]))
-
-(defn native-coll [xs]
-  (if (satisfies? NativeColl xs)
-    (-native-coll xs)
-    xs))
-
-(defn fast-map []
-  #?(:clj
-     (let [m (java.util.HashMap.)]
-       (reify
-         NativeColl
-         (-native-coll [_] m)
-         
-         clojure.lang.IEditableCollection
-         (asTransient [this] this)
-         
-         clojure.lang.ITransientAssociative
-         (assoc [this k v] (.put m k v) this)
-         
-         clojure.lang.ITransientCollection
-         (persistent [this] this)
-         
-         clojure.lang.IPersistentCollection
-         clojure.lang.Counted
-         (count [_] (.size m))
-         
-         clojure.lang.ILookup
-         (valAt [_ k] (.get m k))
-         (valAt [_ k nf] (or (.get m k) nf))))
-     :cljs {}))
-
-(defn fast-arr []
-  #?(:clj
-     (let [l (java.util.ArrayList.)]
-       (reify
-         NativeColl
-         (-native-coll [_] l)
-         
-         clojure.lang.IEditableCollection
-         (asTransient [this] this)
-         
-         clojure.lang.ITransientCollection
-         (conj [this v] (.add l v) this)
-         (persistent [this] this)
-         
-         clojure.lang.IPersistentCollection
-         clojure.lang.Counted
-         (count [_] (.size l))
-         
-         clojure.lang.IReduceInit
-         (reduce [_ f s]
-           (loop [i   0
-                  res s]
-             (if (< i (.size l))
-               (recur (inc i) (f res (.get l i)))
-               res)))))
-     :cljs
-     (let [arr (da/array)]
-       (reify
-         NativeColl
-         (-native-coll [_] arr)
-         
-         IEditableCollection
-         (-as-transient [this] this)
-         
-         ITransientCollection
-         (-conj! [this v] (.push arr v) this)
-         (-persistent! [this] this)
-         
-         ICounted
-         (-count [_] (alength arr))
-         
-         IReduce
-         (-reduce [_ f s]
-           (loop [i   0
-                  res s]
-             (if (< i (alength arr))
-               (recur (inc i) (f res (aget arr i)))
-               res)))))))
-
-(defn fast-set []
-  #?(:clj
-     (let [set (java.util.HashSet.)]
-       (reify
-         NativeColl
-         (-native-coll [_] set)
-         
-         clojure.lang.IEditableCollection
-         (asTransient [this] this)
-         
-         clojure.lang.ITransientCollection
-         (conj [this v] (.add set v) this)
-         (persistent [this] this)
-         
-         clojure.lang.IPersistentCollection
-         clojure.lang.IPersistentSet
-         (contains [_ k] (.contains set k))
-
-         clojure.lang.Counted
-         (count [_] (.size set))
-         
-         clojure.lang.IReduceInit
-         (reduce [_ f s]
-           (let [iter (.iterator set)]
-             (loop [acc s]
-               (if (.hasNext iter)
-                 (recur (f acc (.next iter)))
-                 acc))))))
-     :cljs #{}))
-
-;; (defrecord Context [rels consts sources rules default-source-symbol])
-
-(def empty-context {:empty? true})
-
-(defprotocol IRelation
-  (-project    [_ syms])
-  (-alter-coll [_ f])
-  (-symbols    [_])
-  (-arity      [_])
-  (-fold       [_ f init])
-  (-size       [_])
-  (-getter     [_ symbol])
-  (-indexes    [_ symbols])
-  (-copy-tuple [_ tuple idxs target target-idxs])
-  (-union      [_ rel]))
-
-;; (defn- #?@(:clj  [^long hash-arr]
-;;            :cljs [^number  hash-arr]) [arr]
-;;   (let [count (int (da/alength arr))]
-;;     (loop [n         (int 0)
-;;            hash-code (int 1)]
-;;       (if (== n count)
-;;         (mix-collection-hash hash-code n)
-;;         (recur (inc n)
-;;                #?(:clj  (unchecked-add-int
-;;                           (unchecked-multiply-int 31 hash-code)
-;;                           (hash (da/aget arr n)))
-;;                   :cljs (bit-or (+ (imul 31 hash-code)
-;;                                    (hash (da/aget arr n)))
-;;                                 0)))))))
-
-;; (declare equiv-tuple)
-
-;; (deftype Tuple [arr hash]  
-;;   #?@(
-;;     :cljs [
-;;       Object (equiv  [this other] (equiv-tuple this other))
-;;       IHash  (-hash  [_]          hash)
-;;       IEquiv (-equiv [this other] (equiv-tuple this other)) ]
-;;     :clj [
-;;       Object
-;;       (hashCode [_]
-;;         (java.util.Arrays/hashCode ^{:tag "[[Ljava.lang.Object;"} arr))
-;;       (equals   [this other]
-;;         (java.util.Arrays/equals ^{:tag "[[Ljava.lang.Object;"} arr
-;;                                  ^{:tag "[[Ljava.lang.Object;"} (.-arr ^Tuple other)))
-;;     ]))
-
-;; (defn equiv-tuple [^Tuple t ^Tuple o]
-;;   (boolean
-;;     (and
-;;       (== (da/alength (.-arr t))
-;;           (da/alength (.-arr o)))
-;;       (loop [i 0]
-;;         (cond
-;;           (== i (da/alength (.-arr t))) true
-;;           (not= (da/aget (.-arr t) i) (da/aget (.-arr o) i)) false
-;;           :else (recur (inc i)))))))
-
-;; (defn tuple [arr]
-;;   (->Tuple arr (hash-arr arr)))
-
-;;; ArrayRelation
-
-(defn pr-rel [rel ^java.io.Writer w]
-  (doto w
-    (.write "#")
-    (.write #?(:clj  (.getSimpleName ^Class (class rel))
-               :cljs (str (type rel))))
-    (.write "{:symbols ")
-    (.write (pr-str (-symbols rel)))
-    (.write ", :coll ")
-    (.write (pr-str (persistent! (-fold rel #(conj! %1 (seq %2)) (transient [])))))
-    (.write "}")))
-
-(deftype ArrayRelation [offset-map coll]
-  IRelation
-  (-project [_ syms]
-    (ArrayRelation. (select-keys offset-map syms) coll))
-  (-alter-coll [_ f]
-    (ArrayRelation. offset-map (f coll)))
-  (-symbols [_] (keys offset-map))
-  (-arity   [_] (count offset-map))
-  (-fold [_ f init] (reduce f init coll))
-  (-size [_] (count coll))
-  (-getter [_ symbol]
-    (let [idx (offset-map symbol)]
-      (fn [tuple]
-        (da/aget tuple idx))))
-  (-indexes [_ syms]
-    (mapa offset-map syms))
-  (-copy-tuple [_ tuple idxs target target-idxs]
-    (dotimes [i (da/alength idxs)]
-      (da/aset target (da/aget target-idxs i) (da/aget tuple (da/aget idxs i)))))
-  (-union [_ rel]
-    (assert (instance? ArrayRelation rel))
-    (assert (= offset-map (:offset-map rel)))
-    (ArrayRelation. offset-map (concat coll (:coll rel)))))
-
-#?(:clj
-   (defmethod print-method ArrayRelation [rel w]
-     (pr-rel rel w)))
-
-(defn array-rel [symbols coll]
-  (->ArrayRelation (zipmap symbols (range)) coll))
-
-
-;;; CollRelation
-
-(deftype CollRelation [offset-map coll]
-  IRelation
-  (-project [_ syms]
-    (CollRelation. (select-keys offset-map syms) coll))
-  (-alter-coll [_ f]
-    (CollRelation. offset-map (f coll)))
-  (-symbols [_]        (keys offset-map))
-  (-arity   [_]        (count offset-map))
-  (-fold    [_ f init] (reduce f init coll))
-  (-size    [_]        (count coll)) ;; (if (instance? Iter coll) (btset/est-count coll) (count coll))
-  (-getter  [_ symbol]
-    (let [idx (offset-map symbol)]
-      (fn [tuple]
-        (nth tuple idx))))
-  (-indexes [_ syms]
-    (mapa offset-map syms))
-  (-copy-tuple [_ tuple idxs target target-idxs]
-    (dotimes [i (da/alength idxs)]
-      (da/aset target (da/aget target-idxs i) (nth tuple (da/aget idxs i)))))
-  (-union [_ rel]
-    (assert (instance? CollRelation rel))
-    (assert (= offset-map (:offset-map rel)))
-    (CollRelation. offset-map (concat coll (:coll rel)))))
-
-(defn coll-rel [symbols coll]
-  (let [offset-map (reduce-kv
-                     (fn [acc e i]
-                       (cond
-                         (instance? BindScalar e)
-                         (assoc acc (get-in e [:variable :symbol]) i)
-                         (instance? Variable e)
-                         (assoc acc (:symbol e) i)
-                         (and (symbol? e)
-                           (not= '_ e))
-                         (assoc acc e i)
-                         :else acc))
-                     {}
-                     (zipmap symbols (range)))]
-    (->CollRelation offset-map coll)))
-
-#?(:clj
-   (defmethod print-method CollRelation [rel w]
-     (pr-rel rel w)))
-
-
-;;; ProdRelation
-
-;; (deftype ProdRelation [rel1 rel2]  
-;;   IRelation
-;;   (-symbols [_] (concatv (-symbols rel1) (-symbols rel2)))
-;;   (-arity   [_] (+ (-arity rel1) (-arity rel2)))
-;;   (-fold [_ f init]
-;;     (-fold rel1
-;;            (fn [acc t1]
-;;              (-fold rel2
-;;                     (fn [acc t2]
-;;                       (f acc (da/array t1 t2)))
-;;                     acc))
-;;             init))
-
-;;   (-size [_]
-;;     (* (-size rel1) (-size rel2)))
-;;   (-getter [_ symbol]
-;;     (if (some #{symbol} (-symbols rel1))
-;;       (let [getter (-getter rel1 symbol)]
-;;         (fn [tuple]
-;;           (getter (da/aget tuple 0))))
-;;       (let [getter (-getter rel2 symbol)]
-;;         (fn [tuple]
-;;           (getter (da/aget tuple 1))))))
-;;   (-indexes [_ syms]
-;;     (let [[syms1 syms2] (split-with (set (-symbols rel1)) syms)]
-;;       [(-indexes rel1 syms1)
-;;        (count syms1)
-;;        (-indexes rel2 syms2)
-;;        (count syms2)]))
-;;   (-copy-tuple [_ tuple idxs target target-idxs]
-;;     (let [[idxs1 arity1 idxs2 arity2] idxs
-;;           target-idxs1 (subarr target-idxs 0 arity1)
-;;           target-idxs2 (subarr target-idxs arity1 (da/alength target-idxs))]
-;;       (-copy-tuple rel1 (da/aget tuple 0) idxs1 target target-idxs1)
-;;       (-copy-tuple rel2 (da/aget tuple 1) idxs2 target target-idxs2))))
-
-;; (def prod-rel ->ProdRelation)
-
-
-;;; SingletonRelation
-
-(deftype SingletonRelation []
-  IRelation
-  (-symbols    [_] [])
-  (-arity      [_] 0)
-  (-fold       [_ f init] (f init (to-array [])))
-  (-size       [_] 1)
-  (-indexes    [_ _] (to-array []))
-  (-copy-tuple [_ _ _ _ _]))
-
-(def singleton-rel ->SingletonRelation)
-
-;;; cartesian product
-
-(defn- join-tuples [rel1 t1 idxs1
-                    rel2 t2 idxs2
-                    arity
-                    target-idxs1 target-idxs2]
-  (let [arr (da/make-array arity)]
-    (-copy-tuple rel1 t1 idxs1 arr target-idxs1)
-    (-copy-tuple rel2 t2 idxs2 arr target-idxs2)
-    arr))
-
-(defn product [rel1 rel2]
-  (let [idxs1  (-indexes rel1 (-symbols rel1))
-        idxs2  (-indexes rel2 (-symbols rel2))
-        arity1 (-arity rel1)
-        arity2 (-arity rel2)
-        arity  (+ arity1 arity2)
-        target-idxs1 (arange 0 arity1)
-        target-idxs2 (arange arity1 arity)
-        coll   (-fold rel1
-                 (fn [acc t1]
-                   (-fold rel2
-                     (fn [acc t2]
-                       (conj! acc (join-tuples rel1 t1 idxs1
-                                    rel2 t2 idxs2
-                                    arity
-                                    target-idxs1
-                                    target-idxs2)))
-                     acc))
-                 (fast-arr))]
-    (array-rel
-      (concatv (-symbols rel1) (-symbols rel2))
-      (persistent! coll))))
-
-(defn product-all [rels]
-  (reduce product rels)) ;; TODO check for empty rels
-
-
-;; hash-join
-
-(defn- key-fn [rel syms]
-  (let [arity (count syms)]
-    (if (== arity 1)
-      (-getter rel (first syms))
-      (let [idxs        (-indexes rel syms)
-            target-idxs (arange 0 arity)]
-        (fn [t]
-          (let [arr (da/make-array arity)]
-            (-copy-tuple rel t idxs arr target-idxs)
-            (vec arr)))))))
-
-(defn hash-map-rel [rel syms]
-  (let [key-fn (key-fn rel syms)]
-    (->>
-      (-fold rel
-        (fn [hash t]
-          (let [key (key-fn t)
-                old (get hash key)]
-            (if (nil? old)
-              (assoc! hash key (conj! (fast-arr) t))
-              (do (conj! old t) hash))))
-        (transient (fast-map)))
-      (persistent!))))
-
-(defn hash-join [rel1 hash1 join-syms rel2]
-  (let [syms1       (-symbols rel1)
-        syms2       (-symbols rel2)
-        keep-syms2  (remove (set syms1) syms2)
-        key-fn2     (key-fn rel2 join-syms)
-        idxs1       (-indexes rel1 syms1)
-        idxs2       (-indexes rel2 keep-syms2)
-        full-syms   (concatv syms1 keep-syms2)
-        arity1      (count syms1)
-        arity2      (count keep-syms2)
-        arity       (+ arity1 arity2)
-        target-idxs1 (arange 0 arity1)
-        target-idxs2 (arange arity1 arity)
-        
-        coll        (-fold rel2 ;; iterate over rel2
-                      (fn [acc t2]
-                        (let [tuples1 (get hash1 (key-fn2 t2))]
-                          (if (nil? tuples1)
-                            acc
-                            (reduce (fn [acc t1]
-                                      (conj! acc (join-tuples rel1 t1 idxs1
-                                                   rel2 t2 idxs2
-                                                   arity
-                                                   target-idxs1
-                                                   target-idxs2)))
-                              acc (persistent! tuples1)))))
-                      (fast-arr))]
-    (array-rel full-syms (persistent! coll))))
-
-
-;; Bindings
-
-(defn- bind! [tuples binding source indexes]
-  (condp instance? binding
-
-    BindIgnore
-    tuples
-
-    BindScalar
-    (let [symbol (get-in binding [:variable :symbol])
-          idx    (get indexes symbol)]
-      (run! #(da/aset % idx source) tuples)
-      tuples)
-
-    BindColl
-    (if (not (db/seqable? source))
-      (util/raise "Cannot bind value " source " to collection " (dp/source binding)
-        {:error :query/binding, :value source, :binding (dp/source binding)})
-      (let [inner-binding (:binding binding)]
-        (case (count source)
-          0 []
-          1 (bind! tuples inner-binding (first source) indexes)
-          (into [] ;; TODO fast-arr
-            (comp (map #(bind! tuples inner-binding % indexes))
-              cat
-              (map da/aclone))
-            source))))
-
-    BindTuple
-    (let [bindings (:bindings binding)]
-      (when-not (db/seqable? source)
-        (util/raise "Cannot bind value " source " to tuple " (dp/source binding)
-          {:error :query/binding, :value source, :binding (dp/source binding)}))
-      (when (< (count source) (count bindings))
-        (util/raise "Not enough elements in a collection " source " to bind tuple " (dp/source binding)
-          {:error :query/binding, :value source, :binding (dp/source binding)}))
-      (reduce (fn [ts [b s]]
-                (bind! ts b s indexes))
-        tuples
-        (zip bindings source)))
-    
-    :else
-    (util/raise "Unknown binding form " (dp/source binding)
-      {:error :query/binding, :value source, :binding (dp/source binding)})))
-
-(defn bind [binding source]
-  (let [syms    (map :symbol (dp/collect-vars-distinct binding))
-        indexes (zipmap syms (range))
-        tuples  (bind! [(da/make-array (count syms))] binding source indexes)]
-    (array-rel syms tuples)))
-
-(defn- rel->consts [rel]
-  {:pre [(== (-size rel) 1)]}
-  (let [tuple (-fold rel (fn [_ t] t) nil)]
-    (into {}
-      (map #(vector % ((-getter rel %) tuple)) (-symbols rel)))))
-
-(defn- resolve-in [context [binding value]]
-  (cond
-    (and (instance? BindScalar binding)
-      (instance? SrcVar (:variable binding)))
-    (update-in context [:sources] assoc (get-in binding [:variable :symbol]) value)
-    ;;     (and (instance? BindScalar binding)
-    ;;          (instance? RulesVar (:variable binding)))
-    ;;       (assoc context :rules (parse-rules value))
-    :else
-    (let [rel (bind binding value)]
-      (if (== 1 (-size rel))
-        (update-in context [:consts] merge (rel->consts rel))
-        (update-in context [:rels] conj rel)))))
-
-(defn resolve-ins [context bindings values]
-  (when (not= (count bindings) (count values))
-    (util/raise "Wrong number of arguments for bindings " (mapv dp/source bindings)
-      ", " (count bindings) " required, " (count values) " provided"
-      {:error :query/binding, :binding (mapv dp/source bindings)}))
-  (reduce resolve-in context (zip bindings values)))
-
-
-;;; Resolution
-
-(defprotocol IClause
-  (-resolve-clause [clause context]))
-
-(defn get-source [context source]
-  (let [symbol (cond
-                 (instance? SrcVar source)     (:symbol source)
-                 (instance? DefaultSrc source) (:default-source-symbol context)
-                 :else (util/raise "Source expected, got " source))]
-    (or (get (:sources context) symbol)
-      (util/raise "Source " symbol " is not defined"
-        {:error :query/where, :symbol symbol}))))
-    
-
-;; Patterns
-
-(defn resolve-pattern-db [db clause]
-  ;; TODO optimize with bound attrs min/max values here
-  (let [pattern        (:pattern clause)
-        search-pattern (mapv #(when (instance? Constant %) (:value %)) pattern)
-        datoms         (db/-search db search-pattern)]
-    (coll-rel (:pattern clause) datoms)))
-
-(defn- matches-pattern? [idxs tuple] ;; TODO handle repeated vars
-  ;;   (when-not (db/seqable? tuple)
-  ;;     (util/raise "Cannot match pattern " (dp/source clause) " because tuple is not a collection: " tuple
-  ;;            {:error :query/where, :value tuple, :binding (dp/source clause)}))
-  ;;   (when (< (count tuple) (count (:pattern clause)))
-  ;;     (util/raise "Not enough elements in a relation tuple " tuple " to match " (dp/source clause)
-  ;;            {:error :query/where, :value tuple, :binding (dp/source clause)}))
-  (reduce-kv
-    (fn [_ i v]
-      (if (not= (nth tuple i) v) ;; nth?
-        (reduced false)
-        true))
-    true
-    idxs))
-
-(defn resolve-pattern-coll [coll clause]
-  (when-not (db/seqable? coll)
-    (util/raise "Cannot match by pattern " (dp/source clause) " because source is not a collection: " coll
-      {:error :query/where, :value coll, :binding (dp/source clause)}))
-  (let [pattern (:pattern clause)
-        idxs    (->> (map #(when (instance? Constant %1) [%2 (:value %1)]) pattern (range))
-                  (remove nil?)
-                  (into {}))
-        data    (filter #(matches-pattern? idxs %) coll)]
-    (coll-rel pattern data)))
-
-(defn clause-syms [clause]
-  (into #{} (map :symbol) (dp/collect #(instance? Variable %) clause #{})))
-
-(defn substitute-constants [clause context]
-  (let [syms   (clause-syms clause)
-        consts (:consts context)]
-    (if (some #(contains? consts %) syms)
-      (dp/postwalk
-        clause
-        (fn [form]
-          (if (instance? Variable form)
-            (let [sym (:symbol form)]
-              (if-let [subs (get (:consts context) (:symbol form))]
-                (Constant. subs)
-                form))
-            form)))
-      clause)))
-
-(defn related-rels [context syms]
-  (let [syms (set syms)]
-    (->> (:rels context)
-      (filter #(some syms (-symbols %))))))
-
-(defn extract-rels [context syms]
-  (let [syms      (set syms)
-        rels      (:rels context)
-        related?  #(some syms (-symbols %))
-        related   (filter related? rels)]
-    (if (empty? related)
-      [nil context]
-      (let [unrelated (remove related? rels)]
-        [related (assoc context :rels unrelated)]))))
-
-(defn join-unrelated [context rel]
-  (case (long (-size rel))
-    0 empty-context
-    1 (update context :consts merge (rel->consts rel))
-    (update context :rels conj rel)))
-
-(defn hash-join-rel [context rel]
-  (if (== 0 (-size rel))
-    empty-context
-    (let [syms                    (set (-symbols rel))
-          [related-rels context*] (extract-rels context syms)]
-      (if (empty? related-rels)
-        (join-unrelated context rel)
-        (let [related-rel (product-all related-rels)
-              join-syms   (set/intersection syms (set (-symbols related-rel)))
-              hash        (hash-map-rel related-rel join-syms)
-              ;; TODO choose between hash-join and lookup-join
-              rel*        (hash-join related-rel hash join-syms rel)]
-          (join-unrelated context* rel*))))))
-
-(defn resolve-pattern [context clause]
-  (let [clause* (substitute-constants clause context)
-        rel     (let [source (get-source context (:source clause))]
-                  (if (satisfies? db/ISearch source)
-                    (resolve-pattern-db   source clause*)
-                    (resolve-pattern-coll source clause*)))]
-    (hash-join-rel context rel)))
-
-(defn project-rel [rel syms]
-  (let [rel-syms (set (-symbols rel))
-        syms     (set syms)]
-    (cond
-      (set/subset? rel-syms syms) rel
-      (empty? (set/intersection rel-syms syms)) nil
-      :else (-project rel syms))))
-
-(defn project-context [context syms]
-  (assoc context
-    :consts (select-keys (:consts context) syms)
-    :rels   (into []
-              (comp (map #(project-rel % syms))
-                (remove nil?))
-              (:rels context))))
-
-(defn collect-opt
-  "Collects values if only one symbol, vecs if many (compatible with key-fn)"
-  [context syms]
-  (if (== 1 (count syms))
-    (let [sym (first syms)]
-      (if-let [val (get (:consts context) sym)]
-        (into (fast-set) [val])
-        (let [rel    (first (related-rels context [sym]))
-              getter (-getter rel sym)]
-          (->> (fast-set)
-            (transient)
-            (-fold rel
-              (fn [set tuple]
-                (conj! set (getter tuple))))
-            (persistent!)))))
-    (collect-to context syms (fast-set) [(map vec)])))
-
-(defn subtract-from-rel [rel syms exclude-key-set]
-  (let [key-fn1 (key-fn rel syms)
-        pred    (fn [t1] (contains? exclude-key-set (key-fn1 t1)))]
-    (-alter-coll rel #(into (fast-arr) (remove pred) %))))
-
-(defn subtract-contexts [context1 context2 syms]
-  (if (:empty? context2) ;; empty context2 means there’s nothing to subtract
-    context1
-    ;; ignoring constants inherited from context1
-    (let [syms* (set/difference syms (keys (:consts context1)))]
-      (if (empty? syms*) ;; join happened by constants only
-        empty-context    ;; context2 is not-empty, meaning it satisfied constans,
-        ;; meaning we proved constants in context1 do not match
-        (let [[rels1 context1*] (extract-rels context1 syms*)
-              rel1              (product-all rels1)
-              set2              (collect-opt context2 syms*)
-              rel1*             (subtract-from-rel rel1 syms* set2)]
-          (join-unrelated context1* rel1*))))))
-
-(defn upd-default-source [context clause]
-  (let [source (:source clause)]
-    (if (instance? SrcVar source)
-      (assoc context :default-source-symbol (:symbol source))
-      context)))
-
-(defn check-bound [context syms form]
-  (let [context-syms (-> #{}
-                       (into (keys (:consts context)))
-                       (into (mapcat -symbols) (:rels context))
-                       (into (keys (:sources context))))]
-    (when-not (set/subset? syms context-syms)
-      (let [missing (set/difference (set syms) context-syms)]
-        (throw (ex-info (str "Insufficient bindings: " missing " not bound in " form)
-                 {:error :query/where
-                  :form  form
-                  :vars  missing}))))))
-                           
-
-(defn resolve-not [context clause]
-  (let [{:keys [source vars clauses]} clause
-        syms      (into #{} (map :symbol) vars)
-        _         (check-bound context syms (dp/source clause))
-        context*  (-> context
-                    (project-context syms) ;; sub-context will only see symbols Not is joined by
-                    (upd-default-source clause)
-                    (resolve-clauses clauses))]
-    (subtract-contexts context context* syms)))
-
-(defn resolve-or [context clause]
-  (let [{:keys [source rule-vars clauses]} clause
-        {:keys [required free]}            rule-vars
-        _    (check-bound context (map :symbol required) (dp/source clause))
-        syms (into #{} (map :symbol) (concat required free))
-        context*  (-> context
-                    (project-context syms)
-                    (upd-default-source clause))
-        contexts  (->> clauses
-                    (map #(-resolve-clause % context*))
-                    (remove :empty?))]
-    (if (empty? contexts)
-      empty-context ;; everything resolved to empty rel, short-circuit
-      (let [non-consts (set/difference syms (set (keys (:consts context))))]
-        (if (empty? non-consts)
-          context ;; join was by constants only, nothing changes
-          (let [arrays (map #(collect-to % non-consts (fast-arr)) contexts)
-                rel    (array-rel non-consts (into (first arrays) cat (next arrays)))]
-            (hash-join-rel context rel)))))))
-
-(defn collect-args! [context args target form]
-  (let [consts  (:consts context)
-        sources (:sources context)]
-    (doseq [[arg i] (zip args (range))
-            :let [sym (:symbol arg)]]
-      (cond
-        (instance? Variable arg)
-        (when (contains? consts sym)
-          (da/aset target i (get consts sym)))
-        (instance? SrcVar arg)
-        (if (contains? sources sym)
-          (da/aset target i (get sources sym))
-          (throw (ex-info (str "Unbound source variable: " sym " in " form)
-                   { :error :query/where, :form form, :var sym})))
-        (instance? Constant arg)
-        (da/aset target i (:value arg))))))
-
-(defn get-f [context fun form]
-  (let [sym (:symbol fun)]
-    (if (instance? PlainSymbol fun)
-      (or (get built-ins/query-fns sym)
-        (throw (ex-info (str "Unknown built-in " sym " in " form)
-                 {:error :query/where, :form form, :var sym})))
-      (or (get (:consts context) sym) ;; variable then
-        (throw (ex-info (str "Unknown function " sym " in " form)
-                 {:error :query/where, :form form, :var sym}))))))
-
-(defn resolve-predicate [context clause]
-  (let [{fun :fn, args :args} clause
-        form      (dp/source clause)
-        f         (get-f context fun form)
-        args-arr  (da/make-array (count args))
-        _         (collect-args! context args args-arr form)
-        consts    (:consts context)
-        sym+idx   (for [[arg i] (zip args (range))
-                        :when   (instance? Variable arg)
-                        :let    [sym (:symbol arg)]
-                        :when   (not (contains? consts sym))]
-                    [sym i])
-        args-syms (map first sym+idx)
-        args-idxs (mapa second sym+idx)
-        _         (check-bound context args-syms form)]
-    (if (empty? args-syms) ;; only constants
-      (if (apply f (vec args-arr))
-        context
-        empty-context)
-      (let [[rels context*] (extract-rels context args-syms)]
-        (if (== 1 (count rels))
-          (let [rel  (first rels)
-                idxs (-indexes rel args-syms)
-                pred (fn [tuple]
-                       (-copy-tuple rel tuple idxs args-arr args-idxs)
-                       (apply f (vec args-arr)))
-                rel* (-alter-coll rel #(filterv pred %))]
-            (join-unrelated context* rel*))
-          (let [prod-syms    (mapcat -symbols rels)
-                prod-sym+idx (zip prod-syms (range))
-                xfs          (map #(collect-rel-xf prod-sym+idx %) rels)
-                prod-rel     (array-rel prod-syms [])
-
-                idxs         (-indexes prod-rel args-syms)
-                pred         (fn [tuple]
-                               (-copy-tuple prod-rel tuple idxs args-arr args-idxs)
-                               (apply f (vec args-arr)))
-
-                array        (into (fast-arr)
-                               (apply comp (concat xfs [(filter pred)]))
-                               [(da/make-array (count prod-syms))])
-                prod-rel*    (array-rel prod-syms array)]
-            (join-unrelated context* prod-rel*)))))))
-
-
-(extend-protocol IClause
-  Pattern
-  (-resolve-clause [clause context]
-    (resolve-pattern context clause))
-  Not
-  (-resolve-clause [clause context]
-    (resolve-not context clause))
-  Or
-  (-resolve-clause [clause context]
-    (resolve-or context clause))
-  And
-  (-resolve-clause [clause context]
-    (resolve-clauses context (:clauses clause)))
-  Predicate
-  (-resolve-clause [clause context]
-    (resolve-predicate context clause)))
-
-(defn println-context [context]
-  (print "{:rels")
-  (if (empty? (:rels context))
-    (println "  []")
-    (doseq [rel (:rels context)]
-      (println " " rel)))
-  (println "  :consts" (:consts context) "}"))
-    
-
-(defn resolve-clauses [context clauses]
-  (reduce (fn [context clause]
-            (let [context* (-resolve-clause clause context)]
-              (if (:empty? context*)
-                (reduced context*)
-                (do
-                  ;;                   (println (dp/source clause) "=>")
-                  ;;                   (println-context context*)
-                  context*))))
-    context clauses))
-
-(defn collect-consts [syms-indexed specimen consts]
-  (doseq [[sym i] syms-indexed]
-    (when (contains? consts sym)
-      (let [val (get consts sym)]
-        (da/aset specimen i val)))))
-
-        
-(defn collect-rel-xf [syms-indexed rel]
-  (let [sym+idx     (for [[sym i] syms-indexed
-                          :when (has? (-symbols rel) sym)]
-                      [sym i])
-        idxs        (-indexes rel (map first sym+idx))
-        target-idxs (mapa second sym+idx)]
-    (fn [rf]
-      (fn
-        ([] (rf))
-        ([result] (rf result))
-        ([result specimen]
-         (-fold rel
-           (fn [acc tuple]
-             (let [t (da/aclone specimen)]
-               (-copy-tuple rel tuple idxs t target-idxs)
-               (rf acc t)))
-           result))))))
-
-(defn collect-to
-  ([context syms acc]
-   (collect-to context syms acc [] (da/make-array (count syms))))
-  ([context syms acc xfs]
-   (collect-to context syms acc xfs (da/make-array (count syms))))
-  ([context syms acc xfs specimen]
-   ;; TODO don't collect if array-rel and matches symbols
-   (if (:empty? context)
-     acc
-     (let [syms-indexed (vec (zip syms (range)))
-           _            (collect-consts syms-indexed specimen (:consts context))
-           related-rels (related-rels context syms)
-           xfs          (-> (map #(collect-rel-xf syms-indexed %) related-rels)
-                          (concat xfs))]
-       (into acc (apply comp xfs) [specimen])))))
-
-
-;; Query
-
-(def query-cache (lru/cache lru-cache-size))
-
-(defn q [q & inputs]
-  (let [parsed-q (lru/-get query-cache q #(dp/parse-query q))
-        context  {:rels    []
-                  :consts  {}
-                  :sources {}
-                  :rules   {}
-                  :default-source-symbol '$}
-        context  (resolve-ins context (:qin parsed-q) inputs)
-        context  (resolve-clauses context (:qwhere parsed-q))
-        syms     (concat (dp/find-vars (:qfind parsed-q))
-                   (map :symbol (:qwith parsed-q)))]
-    (native-coll (collect-to context syms (fast-set) [(map vec)]))))
-
-
-(comment
-  (t/test-ns 'dbval.test.query-v3)
-
-  (let [query   '[:find  ?lid ?status ?starttime ?endtime (min ?paid) (distinct ?studentinfo) ?lgid
-                  :in    $ ?tid ?week ?list
-                  :where [?lid :lesson/teacherid ?tid]
-                  [?lid :lesson/week ?week]
-                  [?lid :lesson/lessongroupid ?lgid]
-                  [?eid :enrollment/lessongroup_id ?lgid]
-                  [?eid :enrollment/student_id ?sid]
-                  [?iid :invoice/enrollment_id ?eid]
-                  [?sid :student/firstname ?fname]
-                  [?sid :student/lastname ?lname]
-                  [?iid :invoice/paid ?paid]
-                  [?lid :lesson/status ?status]
-                  [?lid :lesson/starttime ?starttime]
-                  [?lid :lesson/endtime ?endtime]
-                  [(?list ?sid ?fname ?lname) ?studentinfo]]
-        parsed (dp/parse-query query)]
-    (perf/minibench "postwalk"
-      (dp/postwalk parsed identity))
-    (perf/minibench "parse-query"
-      (dp/parse-query query))
-    (perf/minibench "substitute-constants"
-      (substitute-constants (first (:where parsed)) {:consts {'?tid 7}})))
-
-  (defn random-man []
-    {:name      (rand-nth ["Ivan" "Petr" "Sergei" "Oleg" "Yuri" "Dmitry" "Fedor" "Denis"])
-     :last-name (rand-nth ["Ivanov" "Petrov" "Sidorov" "Kovalev" "Kuznetsov" "Voronoi"])
-     :sex       (rand-nth [:male :female])
-     :age       (rand-int 10)
-     :salary    (rand-int 100000)})
-
-  (defn bench [name q & args]
-    (println "\n---\n")
-    (perf/minibench (str "OLD " name) (apply d/q q args))
-    (perf/minibench (str "NEW " name) (apply dbval.query-v3/q q args))
-    nil)
-
-  (do
-    #_(require '[dbval.query-v3 :as q] :reload)
-
-    (def db (d/db-with (d/empty-db) (repeatedly 10000 random-man)))
-
-    (bench "q2 const"
-      '[:find  ?e
-        :where [?e :name "Ivan"]
-        [?e :age 1]]
-      db)
-
-    #_(bench "q2 const in"
-        '[:find ?e
-          :in $ ?n
-          :where [?e :name "Ivan"]
-          [?e :age ?n]]
-        db 1)))
diff --git a/src/dbval/util.cljc b/src/dbval/util.clj
similarity index 59%
rename from src/dbval/util.cljc
rename to src/dbval/util.clj
index f9b24964..85e9063c 100644
--- a/src/dbval/util.cljc
+++ b/src/dbval/util.clj
@@ -1,38 +1,32 @@
 (ns dbval.util
   (:refer-clojure :exclude [find])
-  #?(:clj
-     (:import
-       [java.util UUID])))
+  )
 
 (def ^:dynamic *debug*
   false)
 
-#?(:clj
-   (defmacro log [& body]
+(defmacro log [& body]
      (when (System/getProperty "dbval.debug")
        `(when *debug*
-          (println ~@body)))))
+          (println ~@body))))
 
-#?(:clj
-   (defmacro raise [& fragments]
+(defmacro raise [& fragments]
      (let [msgs (butlast fragments)
            data (last fragments)]
-       `(throw (ex-info (str ~@(map (fn [m#] (if (string? m#) m# (list 'pr-str m#))) msgs)) ~data)))))
+       `(throw (ex-info (str ~@(map (fn [m#] (if (string? m#) m# (list 'pr-str m#))) msgs)) ~data))))
 
-#?(:clj
-   (def ^:private ^:dynamic *if+-syms))
-  
-#?(:clj
-   (defn- if+-rewrite-cond-impl [cond]
+(def ^:private ^:dynamic *if+-syms)
+
+(defn- if+-rewrite-cond-impl [cond]
      (clojure.core/cond
        (empty? cond)
        true
-    
+
        (and
          (= :let (first cond))
          (empty? (second cond)))
        (if+-rewrite-cond-impl (nnext cond))
-    
+
        (= :let (first cond))
        (let [[var val & rest] (second cond)
              sym                (gensym)]
@@ -43,29 +37,26 @@
                :let
                (cons rest
                  (nnext cond))))))
-    
+
        :else
        (list 'and
          (first cond)
-         (if+-rewrite-cond-impl (next cond))))))
+         (if+-rewrite-cond-impl (next cond)))))
 
-#?(:clj
-   (defn- if+-rewrite-cond [cond]
+(defn- if+-rewrite-cond [cond]
      (binding [*if+-syms (volatile! [])]
-       [(if+-rewrite-cond-impl cond) @*if+-syms])))
+       [(if+-rewrite-cond-impl cond) @*if+-syms]))
 
-#?(:clj
-   (defn- flatten-1 [xs]
+(defn- flatten-1 [xs]
      (vec
-       (mapcat identity xs))))
+       (mapcat identity xs)))
 
-#?(:clj
-   (defmacro if+
+(defmacro if+
      "Allows sharing local variables between condition and then clause.
-      
+
       Use `:let [...]` form (not nested!) inside `and` condition and its bindings
       will be visible in later `and` clauses and inside `then` branch:
-      
+
         (if+ (and
                (= 1 2)
                ;; same :let syntax as in doseq/for
@@ -73,10 +64,10 @@
                      y (+ x 4)]
                ;; x and y visible downstream
                (> y x))
-          
+
           ;; then: x and y visible here!
           (+ x y 5)
-          
+
           ;; else: no x or y
           6)"
      [cond then else]
@@ -95,70 +86,21 @@
                         [binding (list 'deref sym)]))
                 ~then)
               ~else)))
-       (list 'if cond then else))))
+       (list 'if cond then else)))
 
-#?(:clj
-   (defmacro cond+ [& clauses]
+(defmacro cond+ [& clauses]
      (when-some [[test expr & rest] clauses]
        (case test
          :do   `(do ~expr (util/cond+ ~@rest))
          :let  `(let ~expr (util/cond+ ~@rest))
          :some `(or ~expr (util/cond+ ~@rest))
-         `(util/if+ ~test ~expr (util/cond+ ~@rest))))))
+         `(util/if+ ~test ~expr (util/cond+ ~@rest)))))
 
-#?(:clj
-   (defmacro some-of
+(defmacro some-of
      ([] nil)
      ([x] x)
      ([x & more]
-      `(let [x# ~x] (if (nil? x#) (some-of ~@more) x#)))))
-
-(defn- rand-bits [pow]
-  (rand-int (bit-shift-left 1 pow)))
-
-#?(:cljs
-   (defn- to-hex-string [n l]
-     (let [s (.toString n 16)
-           c (count s)]
-       (cond
-         (> c l) (subs s 0 l)
-         (< c l) (str (apply str (repeat (- l c) "0")) s)
-         :else   s))))
-
-(defn squuid
-  ([]
-   (squuid #?(:clj  (System/currentTimeMillis)
-              :cljs (.getTime (js/Date.)))))
-  ([msec]
-   #?(:clj
-      (let [uuid     (UUID/randomUUID)
-            time     (int (/ msec 1000))
-            high     (.getMostSignificantBits uuid)
-            low      (.getLeastSignificantBits uuid)
-            new-high (bit-or (bit-and high 0x00000000FFFFFFFF)
-                       (bit-shift-left time 32))]
-        (UUID. new-high low))
-      :cljs
-      (uuid
-        (str
-          (-> (int (/ msec 1000))
-            (to-hex-string 8))
-          "-" (-> (rand-bits 16) (to-hex-string 4))
-          "-" (-> (rand-bits 16) (bit-and 0x0FFF) (bit-or 0x4000) (to-hex-string 4))
-          "-" (-> (rand-bits 16) (bit-and 0x3FFF) (bit-or 0x8000) (to-hex-string 4))
-          "-" (-> (rand-bits 16) (to-hex-string 4))
-          (-> (rand-bits 16) (to-hex-string 4))
-          (-> (rand-bits 16) (to-hex-string 4)))))))
-
-(defn squuid-time-millis
-  "Returns time that was used in [[squuid]] call, in milliseconds, rounded to the closest second."
-  [uuid]
-  #?(:clj (-> (.getMostSignificantBits ^UUID uuid)
-            (bit-shift-right 32)
-            (* 1000))
-     :cljs (-> (subs (str uuid) 0 8)
-             (js/parseInt 16)
-             (* 1000))))
+      `(let [x# ~x] (if (nil? x#) (some-of ~@more) x#))))
 
 (defn distinct-by [f coll]
   (->>
diff --git a/src/deps.cljs b/src/deps.cljs
deleted file mode 100644
index 8d7a00dd..00000000
--- a/src/deps.cljs
+++ /dev/null
@@ -1 +0,0 @@
-{:externs ["dbval/externs.js"]}
diff --git a/test/dbval/test.cljc b/test/dbval/test.clj
similarity index 73%
rename from test/dbval/test.cljc
rename to test/dbval/test.clj
index 27204e32..6d50bb81 100644
--- a/test/dbval/test.cljc
+++ b/test/dbval/test.clj
@@ -1,9 +1,8 @@
 (ns dbval.test
   (:require
     [clojure.test :as t :refer [is are deftest testing]]
-    #?(:clj [clojure.java.shell :as sh])
     dbval.test.core
-   
+
     dbval.test.components
     dbval.test.conn
     dbval.test.db
@@ -32,7 +31,6 @@
     dbval.test.query-pull
     dbval.test.query-return-map
     dbval.test.query-rules
-    dbval.test.query-v3
     dbval.test.transact
     dbval.test.tuples
     dbval.test.validation
@@ -43,13 +41,4 @@
 (defn ^:export test-clj []
   (dbval.test.core/wrap-res #(t/run-all-tests #"dbval\..*")))
 
-(defn ^:export test-cljs []
-  (dbval.test.core/wrap-res #(t/run-all-tests #"dbval\..*")))
 
-#?(:clj
-   (defn test-node [& args]
-     (let [res (apply sh/sh "node" "test_node.js" args)]
-       (println (:out res))
-       (binding [*out* *err*]
-         (println (:err res)))
-       (System/exit (:exit res)))))
diff --git a/test/dbval/test/cljs.cljc b/test/dbval/test/cljs.cljc
deleted file mode 100644
index cf6284da..00000000
--- a/test/dbval/test/cljs.cljc
+++ /dev/null
@@ -1,29 +0,0 @@
-(ns dbval.test.cljs
-  (:require
-    [clojure.string :as str]
-    [cljs.test :as t])
-  #?(:cljs
-     (:require-macros
-       [dbval.test.cljs])))
-
-; The dbval.test.cljs namespace exists only for the side
-; effect of extending the cljs.test/assert-expr multimethod.
-
-; This has to be done on the clj side of cljs compilation, and
-; so we have a separate namespace that is only loaded by cljs
-; via a :require-macros clause in dbval.test.core. This
-; means we have a clj namespace that should only be loaded by
-; cljs compilation.
-
-#?(:clj
-   (defmethod t/assert-expr 'thrown-msg? [menv msg form]
-     (let [[_ match & body] form]
-       `(try
-          ~@body
-          (t/do-report {:type :fail, :message ~msg, :expected '~form, :actual nil})
-          (catch :default e#
-            (let [m# (.-message e#)]
-              (if (= ~match m#)
-                (t/do-report {:type :pass, :message ~msg, :expected '~form, :actual e#})
-                (t/do-report {:type :fail, :message ~msg, :expected '~form, :actual e#}))
-              e#))))))
\ No newline at end of file
diff --git a/test/dbval/test/components.cljc b/test/dbval/test/components.clj
similarity index 99%
rename from test/dbval/test/components.cljc
rename to test/dbval/test/components.clj
index c8242770..ed73b913 100644
--- a/test/dbval/test/components.cljc
+++ b/test/dbval/test/components.clj
@@ -8,8 +8,6 @@
 
 (t/use-fixtures :once tdc/no-namespace-maps)
 
-#?(:cljs
-   (def Throwable js/Error))
 
 (deftest test-components
   (is (thrown-msg? "Bad attribute specification for :profile: {:db/isComponent true} should also have {:db/valueType :db.type/ref}"
diff --git a/test/dbval/test/conn.clj b/test/dbval/test/conn.clj
new file mode 100644
index 00000000..978a0dee
--- /dev/null
+++ b/test/dbval/test/conn.clj
@@ -0,0 +1,83 @@
+(ns dbval.test.conn
+  (:require
+    [clojure.test :as t :refer [is are deftest testing]]
+    [dbval.core :as d]
+    [dbval.db :as db]
+    [dbval.test.core :as tdc]))
+
+(def schema
+  {:aka {:db/cardinality :db.cardinality/many}})
+
+;; Use a fixed UUID for deterministic testing
+(def test-eid #uuid "11111111-1111-1111-1111-111111111111")
+
+(def datoms
+  #{(d/datom test-eid :age  17)
+    (d/datom test-eid :name "Ivan")})
+
+(deftest test-ways-to-create-conn
+  (let [conn (d/create-conn)]
+    (is (= #{} (set (d/datoms @conn :eavt))))
+    (is (= nil (d/schema @conn))))
+
+  (let [conn (d/create-conn schema)]
+    (is (= #{} (set (d/datoms @conn :eavt))))
+    (is (= schema (d/schema @conn))))
+
+  (let [conn (d/conn-from-datoms datoms)]
+    (is (= datoms (set (d/datoms @conn :eavt))))
+    (is (= nil (d/schema @conn))))
+
+  (let [conn (d/conn-from-datoms datoms schema)]
+    (is (= datoms (set (d/datoms @conn :eavt))))
+    (is (= schema (d/schema @conn))))
+
+  (let [conn (d/conn-from-db (d/init-db datoms))]
+    (is (= datoms (set (d/datoms @conn :eavt))))
+    (is (= nil (d/schema @conn))))
+
+  (let [conn (d/conn-from-db (d/init-db datoms schema))]
+    (is (= datoms (set (d/datoms @conn :eavt))))
+    (is (= schema (d/schema @conn)))))
+
+(deftest test-conn-is-not-an-atom
+  ;; the store is the single source of truth; the conn is a handle, not a
+  ;; state container, so it deliberately does not support swap!/reset!
+  (let [conn (d/create-conn)]
+    (is (d/conn? conn))
+    (is (not (instance? clojure.lang.IAtom conn)))
+    (is (not (d/conn? (atom nil))))))
+
+(deftest test-deref-derives-value-from-store
+  ;; deref queries the store for the latest transaction id, so it also sees
+  ;; transactions that did not go through this conn's transact!
+  (let [conn (d/create-conn)
+        db1  @conn]
+    (d/db-with db1 [{:name "Ivan"}])
+    (is (= ["Ivan"] (mapv :v (d/datoms @conn :aevt :name))))))
+
+(deftest test-with-rejects-stale-snapshot
+  ;; a db value whose store has been modified since the snapshot was taken
+  ;; cannot be transacted against
+  (let [conn (d/create-conn)
+        db1  @conn]
+    (d/db-with db1 [{:name "Ivan"}])
+    (is (thrown-msg? "underlying tuple store has already been modified"
+          (d/db-with db1 [{:name "Oleg"}])))))
+
+(deftest test-transact!-not-repeated-by-concurrent-conn-update
+     ;; regression: `-transact!` used to run the (side-effecting, committing)
+     ;; transaction inside `swap!`; a concurrent update of the conn state
+     ;; (e.g. `reset-schema!`) could fail the CAS and make `swap!` re-run the
+     ;; transaction — committing it twice under two different tx ids
+     (let [conn        (d/create-conn)
+           transacting (future
+                         (d/transact! conn
+                           [[:db.fn/call (fn [_db]
+                                           (Thread/sleep 100)
+                                           [{:x "hello"}])]]))]
+       (Thread/sleep 30)
+       (d/reset-schema! conn {:y {:db/index true}})
+       @transacting
+       (is (= ["hello"] (mapv :v (d/datoms @conn :aevt :x))))
+       (is (= {:y {:db/index true}} (d/schema @conn)))))
diff --git a/test/dbval/test/conn.cljc b/test/dbval/test/conn.cljc
deleted file mode 100644
index 18de69bd..00000000
--- a/test/dbval/test/conn.cljc
+++ /dev/null
@@ -1,41 +0,0 @@
-(ns dbval.test.conn
-  (:require
-    [clojure.test :as t :refer [is are deftest testing]]
-    [dbval.core :as d]
-    [dbval.db :as db]
-    [dbval.test.core :as tdc]))
-
-(def schema
-  {:aka {:db/cardinality :db.cardinality/many}})
-
-;; Use a fixed UUID for deterministic testing
-(def test-eid #uuid "11111111-1111-1111-1111-111111111111")
-
-(def datoms
-  #{(d/datom test-eid :age  17)
-    (d/datom test-eid :name "Ivan")})
-
-(deftest test-ways-to-create-conn
-  (let [conn (d/create-conn)]
-    (is (= #{} (set (d/datoms @conn :eavt))))
-    (is (= nil (:schema @conn))))
-
-  (let [conn (d/create-conn schema)]
-    (is (= #{} (set (d/datoms @conn :eavt))))
-    (is (= schema (:schema @conn))))
-
-  (let [conn (d/conn-from-datoms datoms)]
-    (is (= datoms (set (d/datoms @conn :eavt))))
-    (is (= nil (:schema @conn))))
-
-  (let [conn (d/conn-from-datoms datoms schema)]
-    (is (= datoms (set (d/datoms @conn :eavt))))
-    (is (= schema (:schema @conn))))
-
-  (let [conn (d/conn-from-db (d/init-db datoms))]
-    (is (= datoms (set (d/datoms @conn :eavt))))
-    (is (= nil (:schema @conn))))
-
-  (let [conn (d/conn-from-db (d/init-db datoms schema))]
-    (is (= datoms (set (d/datoms @conn :eavt))))
-    (is (= schema (:schema @conn)))))
diff --git a/test/dbval/test/core.cljc b/test/dbval/test/core.clj
similarity index 52%
rename from test/dbval/test/core.cljc
rename to test/dbval/test/core.clj
index 3139eead..5cae768b 100644
--- a/test/dbval/test/core.cljc
+++ b/test/dbval/test/core.clj
@@ -6,44 +6,20 @@
     [cognitect.transit :as transit]
     [dbval.core :as d]
     [dbval.impl.entity :as de]
-    [dbval.db :as db :refer [defrecord-updatable]]
-    #?(:cljs [dbval.test.cljs])))
+    [dbval.db :as db]
+    ))
 
-#?(:cljs
-   (enable-console-print!))
 
 ;; Added special case for printing ex-data of ExceptionInfo
-#?(:cljs
-   (defmethod t/report [::t/default :error] [m]
-     (t/inc-report-counter! :error)
-     (println "\nERROR in" (t/testing-vars-str m))
-     (when (seq (:testing-contexts (t/get-current-env)))
-       (println (t/testing-contexts-str)))
-     (when-let [message (:message m)] (println message))
-     (println "expected:" (pr-str (:expected m)))
-     (print "  actual: ")
-     (let [actual (:actual m)]
-       (cond
-         (instance? ExceptionInfo actual)
-         (println (.-stack actual) "\n" (pr-str (ex-data actual)))
-         (instance? js/Error actual)
-         (println (.-stack actual))
-         :else
-         (prn actual)))))
 
-#?(:cljs (def test-summary (atom nil)))
-#?(:cljs (defmethod t/report [::t/default :end-run-tests] [m]
-           (reset! test-summary (dissoc m :type))))
 
 (defn wrap-res [f]
-  #?(:cljs (do (f) (clj->js @test-summary))
-     :clj  (let [res (f)]
+  (let [res (f)]
              (when (pos? (+ (:fail res) (:error res)))
-               (System/exit 1)))))
+               (System/exit 1))))
 
 ;; utils
-#?(:clj
-   (defmethod t/assert-expr 'thrown-msg? [msg form]
+(defmethod t/assert-expr 'thrown-msg? [msg form]
      (let [[_ match & body] form]
        `(try ~@body
           (t/do-report {:type :fail, :message ~msg, :expected '~form, :actual nil})
@@ -52,7 +28,7 @@
               (if (= ~match m#)
                 (t/do-report {:type :pass, :message ~msg, :expected '~form, :actual e#})
                 (t/do-report {:type :fail, :message ~msg, :expected '~form, :actual e#})))
-            e#)))))
+            e#))))
 
 (defn entity-map [db e]
   (when-let [entity (d/entity db e)]
@@ -64,36 +40,25 @@
 (defn all-datoms [db]
   (into #{} (map (juxt :e :a :v)) (d/datoms db :eavt)))
 
-#?(:clj
-   (defn no-namespace-maps [t]
+(defn no-namespace-maps [t]
      (binding [*print-namespace-maps* false]
        (t)))
-   :cljs
-   (def no-namespace-maps {:before #(set! *print-namespace-maps* false)}))
 
 (defn transit-write [o type]
-  #?(:clj
-     (with-open [os (java.io.ByteArrayOutputStream.)]
+  (with-open [os (java.io.ByteArrayOutputStream.)]
        (let [writer (transit/writer os type)]
          (transit/write writer o)
-         (.toByteArray os)))
-     :cljs
-     (transit/write (transit/writer type) o)))
+         (.toByteArray os))))
 
 (defn transit-write-str [o]
-  #?(:clj (String. ^bytes (transit-write o :json) "UTF-8")
-     :cljs (transit-write o :json)))
+  (String. ^bytes (transit-write o :json) "UTF-8"))
 
 (defn transit-read [s type]
-  #?(:clj
-     (with-open [is (java.io.ByteArrayInputStream. s)]
-       (transit/read (transit/reader is type)))
-     :cljs
-     (transit/read (transit/reader type) s)))
+  (with-open [is (java.io.ByteArrayInputStream. s)]
+       (transit/read (transit/reader is type))))
 
 (defn transit-read-str [s]
-  #?(:clj  (transit-read (.getBytes ^String s "UTF-8") :json)
-     :cljs (transit-read s :json)))
+  (transit-read (.getBytes ^String s "UTF-8") :json))
 
 ;; Core tests
 
@@ -106,10 +71,8 @@
         db (:db-after tx)
         ivan-id (get (:tempids tx) "ivan")
         petr-id (get (:tempids tx) "petr")]
-    (is (= #{:schema :max-tx :rschema :pull-patterns :pull-attrs :hash :db-file :conn}
-          (set (keys db))))
-    (is (map? db))
-    (is (seqable? (:eavt db)))
+    ;; db values are opaque handles (deftype), not maps
+    (is (not (map? db)))
     (is (= (set (d/datoms db :eavt))
           #{(d/datom ivan-id :aka "IV")
             (d/datom ivan-id :aka "Terrible")
diff --git a/test/dbval/test/datafy.cljc b/test/dbval/test/datafy.clj
similarity index 100%
rename from test/dbval/test/datafy.cljc
rename to test/dbval/test/datafy.clj
diff --git a/test/dbval/test/db.clj b/test/dbval/test/db.clj
new file mode 100644
index 00000000..185fe207
--- /dev/null
+++ b/test/dbval/test/db.clj
@@ -0,0 +1,54 @@
+(ns dbval.test.db
+  (:require
+    [clojure.data]
+    [clojure.test :as t :refer [is are deftest testing]]
+    [dbval.core :as d]
+    [dbval.db :as db]
+    [dbval.test.core]))
+
+;; regression for the removal of the content-based `hash-db`: db values are
+;; opaque handles (like Datomic databases) that hash and compare by reference
+;; identity — content-based value semantics would have to realize a
+;; potentially larger-than-memory database. Snapshots of the same store are
+;; compared via `basis-tx`.
+(deftest test-db-value-identity
+  (let [conn (d/create-conn)
+        db1  @conn
+        db2  (d/db-with db1 [{:name "Ivan"}])]
+    (testing "db values are not maps"
+      (is (not (map? db1)))
+      (is (nil? (:max-tx db1))))
+
+    (testing "reference identity"
+      (is (= db1 db1))
+      (is (not= db1 db2))
+      ;; equal content is not enough: both databases are empty,
+      ;; but they are distinct handles (to distinct stores)
+      (is (not= @(d/create-conn) @(d/create-conn))))
+
+    (testing "snapshots are compared via basis-tx"
+      (is (= (d/basis-tx db1) (d/basis-tx db1)))
+      (is (pos? (compare (d/basis-tx db2) (d/basis-tx db1)))))))
+
+
+(deftest test-empty-vector-value
+  ;; regression: storing an empty vector NPEd in `tuple` — the & rest args
+  ;; are nil for zero components, but Tuple.addAll requires a List
+  (let [tx (d/with (d/empty-db) [{:db/id "e1" :path []}])
+        e1 (get (:tempids tx) "e1")
+        db (:db-after tx)]
+    (is (= [[]] (mapv :v (d/datoms db :eavt e1 :path))))))
+
+(deftest test-diff
+  ;; clojure.data/diff is deliberately unsupported: dbval databases may not
+  ;; fit into memory, and a diff would have to realize both sides entirely.
+  ;; The DB record still extends clojure.data/Diff, but only to throw —
+  ;; otherwise diff would fall back to clojure.data's default map
+  ;; implementation and diff the record's fields.
+  (let [tx1 (d/with (d/empty-db) [{:db/id "e1" :a 1 :b 2}])
+        db1 (:db-after tx1)
+        e1 (get (:tempids tx1) "e1")
+        db2 (d/db-with db1 [[:db/retract e1 :b 2]
+                            [:db/add e1 :c 3]])]
+    (is (thrown-msg? "clojure.data/diff is not supported on dbval databases, since it would realize both databases entirely in memory"
+          (clojure.data/diff db1 db2)))))
diff --git a/test/dbval/test/db.cljc b/test/dbval/test/db.cljc
deleted file mode 100644
index c3dad61a..00000000
--- a/test/dbval/test/db.cljc
+++ /dev/null
@@ -1,57 +0,0 @@
-(ns dbval.test.db
-  (:require
-    [clojure.data]
-    [clojure.test :as t :refer [is are deftest testing]]
-    [dbval.core :as d]
-    [dbval.db :as db :refer [defrecord-updatable]]
-    [dbval.test.core]))
-
-;;
-;; verify that defrecord-updatable works with compiler/core macro configuration
-;; define dummy class which redefines hash, could produce either
-;; compiler or runtime error
-;;
-(defrecord-updatable HashBeef [x]
-  #?@(:cljs [IHash                (-hash  [hb] 0xBEEF)]
-      :clj  [clojure.lang.IHashEq (hasheq [hb] 0xBEEF)]))
-
-(deftest test-defrecord-updatable
-  (is (= 0xBEEF (-> (map->HashBeef {:x :ignored}) hash))))
-
-
-;; whitebox test to confirm that hash cache caches
-(deftest test-db-hash-cache
-  (let [db (d/empty-db)]
-    (is (= 0         @(.-hash db)))
-    (let [h (hash db)]
-      (is (= h @(.-hash db))))))
-
-(defn- now []
-  #?(:clj  (System/currentTimeMillis)
-     :cljs (.getTime (js/Date.))))
-
-(deftest test-uuid
-  (let [now-ms (loop []
-                 (let [ts (now)]
-                   (if (> (mod ts 1000) 900) ;; sleeping over end of a second
-                     (recur)
-                     ts)))
-        now    (int (/ now-ms 1000))]
-    (is (= (* 1000 now) (d/squuid-time-millis (d/squuid))))
-    (is (not= (d/squuid) (d/squuid)))
-    (is (= (subs (str (d/squuid)) 0 8)
-          (subs (str (d/squuid)) 0 8)))))
-
-(deftest test-diff
-  ;; clojure.data/diff is deliberately unsupported: dbval databases may not
-  ;; fit into memory, and a diff would have to realize both sides entirely.
-  ;; The DB record still extends clojure.data/Diff, but only to throw —
-  ;; otherwise diff would fall back to clojure.data's default map
-  ;; implementation and diff the record's fields.
-  (let [tx1 (d/with (d/empty-db) [{:db/id "e1" :a 1 :b 2}])
-        db1 (:db-after tx1)
-        e1 (get (:tempids tx1) "e1")
-        db2 (d/db-with db1 [[:db/retract e1 :b 2]
-                            [:db/add e1 :c 3]])]
-    (is (thrown-msg? "clojure.data/diff is not supported on dbval databases, since it would realize both databases entirely in memory"
-          (clojure.data/diff db1 db2)))))
diff --git a/test/dbval/test/entity.cljc b/test/dbval/test/entity.clj
similarity index 99%
rename from test/dbval/test/entity.cljc
rename to test/dbval/test/entity.clj
index 07d9f38d..63800602 100644
--- a/test/dbval/test/entity.cljc
+++ b/test/dbval/test/entity.clj
@@ -5,9 +5,8 @@
     [dbval.core :as d]
     [dbval.db :as db]
     [dbval.test.core :as tdc])
-  #?(:clj
-     (:import
-       [clojure.lang ExceptionInfo])))
+  (:import
+       [clojure.lang ExceptionInfo]))
 
 (t/use-fixtures :once tdc/no-namespace-maps)
 
diff --git a/test/dbval/test/explode.cljc b/test/dbval/test/explode.clj
similarity index 99%
rename from test/dbval/test/explode.cljc
rename to test/dbval/test/explode.clj
index d20ce003..0fa9b7d9 100644
--- a/test/dbval/test/explode.cljc
+++ b/test/dbval/test/explode.clj
@@ -5,9 +5,6 @@
     [dbval.db :as db]
     [dbval.test.core :as tdc]))
 
-#?(:cljs
-   (def Throwable
-     js/Error))
 
 (deftest test-explode
   (doseq [coll [["Devil" "Tupen"]
@@ -228,4 +225,4 @@
                  :where [?e :name ?parent]
                  [?e :comp ?c]
                  [?c :name ?child]] db)))))
- 
+
diff --git a/test/dbval/test/filter.cljc b/test/dbval/test/filter.clj
similarity index 89%
rename from test/dbval/test/filter.cljc
rename to test/dbval/test/filter.clj
index 999752cb..2d1cacd5 100644
--- a/test/dbval/test/filter.cljc
+++ b/test/dbval/test/filter.clj
@@ -65,12 +65,15 @@
       (is (= (map :v (d/datoms (d/filter db remove-pass) :aevt :password))
             [])))
 
-    (testing "hash"
-      (is (= (hash (d/db-with db [[:db.fn/retractEntity ivan]]))
-            (hash (d/filter db remove-ivan))))
-      (is (= (hash empty-db)
-            (hash (d/filter empty-db (constantly true)))
-            (hash (d/filter db (constantly false)))))))
+    (testing "hash and equality"
+      ;; content-based hashing was removed together with `hash-db`:
+      ;; db values (filtered or not) compare by reference identity
+      (let [filtered (d/filter db remove-ivan)]
+        (is (= filtered filtered))
+        (is (= (hash filtered) (hash filtered)))
+        (is (not= filtered db))
+        ;; a fresh `filter` call creates a new predicate closure
+        (is (not= filtered (d/filter db remove-ivan))))))
 
   (testing "double filtering"
     (let [tx       (d/with (d/empty-db {:name {:db/unique :db.unique/identity}})
diff --git a/test/dbval/test/ident.cljc b/test/dbval/test/ident.clj
similarity index 100%
rename from test/dbval/test/ident.cljc
rename to test/dbval/test/ident.clj
diff --git a/test/dbval/test/index.cljc b/test/dbval/test/index.clj
similarity index 100%
rename from test/dbval/test/index.cljc
rename to test/dbval/test/index.clj
diff --git a/test/dbval/test/issues.cljc b/test/dbval/test/issues.clj
similarity index 96%
rename from test/dbval/test/issues.cljc
rename to test/dbval/test/issues.clj
index cd9dd0ab..13f2ed98 100644
--- a/test/dbval/test/issues.cljc
+++ b/test/dbval/test/issues.clj
@@ -15,8 +15,7 @@
              db)
           #{["A" ["A"]] ["B" ["B"]]}))))
 
-#?(:clj
-   (deftest ^{:doc "Can't pprint filtered db"}
+(deftest ^{:doc "Can't pprint filtered db"}
      issue-330
      (let [base     (-> (ds/empty-db {:aka {:db/cardinality :db.cardinality/many}})
                       (ds/db-with [{:db/id -1
@@ -25,7 +24,7 @@
                                     :aka   ["Max Otto von Stierlitz", "Jack Ryan"]}]))
            filtered (ds/filter base (constantly true))]
        (t/is (= (with-out-str (clojure.pprint/pprint base))
-               (with-out-str (clojure.pprint/pprint filtered)))))))
+               (with-out-str (clojure.pprint/pprint filtered))))))
 
 (deftest ^{:doc "Can't diff databases with different types of the same attribute"}
   issue-369
diff --git a/test/dbval/test/listen.cljc b/test/dbval/test/listen.clj
similarity index 100%
rename from test/dbval/test/listen.cljc
rename to test/dbval/test/listen.clj
diff --git a/test/dbval/test/lookup_refs.cljc b/test/dbval/test/lookup_refs.clj
similarity index 99%
rename from test/dbval/test/lookup_refs.cljc
rename to test/dbval/test/lookup_refs.clj
index 4a6bb7bc..6307ce4f 100644
--- a/test/dbval/test/lookup_refs.cljc
+++ b/test/dbval/test/lookup_refs.clj
@@ -4,9 +4,8 @@
     [dbval.core :as d]
     [dbval.db :as db]
     [dbval.test.core :as tdc])
-  #?(:clj
-     (:import
-       [clojure.lang ExceptionInfo])))
+  (:import
+       [clojure.lang ExceptionInfo]))
 
 (deftest test-lookup-refs
   (let [tx (d/with (d/empty-db {:name  {:db/unique :db.unique/identity}
diff --git a/test/dbval/test/lru.cljc b/test/dbval/test/lru.clj
similarity index 100%
rename from test/dbval/test/lru.cljc
rename to test/dbval/test/lru.clj
diff --git a/test/dbval/test/parser.cljc b/test/dbval/test/parser.clj
similarity index 93%
rename from test/dbval/test/parser.cljc
rename to test/dbval/test/parser.clj
index d3c3cae2..ea75c617 100644
--- a/test/dbval/test/parser.cljc
+++ b/test/dbval/test/parser.clj
@@ -5,42 +5,41 @@
     [dbval.db :as db]
     [dbval.parser :as dp]
     [dbval.test.core :as tdc])
-  #?(:clj
-     (:import
-       [clojure.lang ExceptionInfo])))
+  (:import
+       [clojure.lang ExceptionInfo]))
 
 (deftest bindings
   (are [form res] (= (dp/parse-binding form) res)
     '?x
     (dp/->BindScalar (dp/->Variable '?x))
-       
+
     '_
     (dp/->BindIgnore)
-       
+
     '[?x ...]
     (dp/->BindColl (dp/->BindScalar (dp/->Variable '?x)))
-       
+
     '[?x]
     (dp/->BindTuple [(dp/->BindScalar (dp/->Variable '?x))])
-       
+
     '[?x ?y]
     (dp/->BindTuple [(dp/->BindScalar (dp/->Variable '?x)) (dp/->BindScalar (dp/->Variable '?y))])
-       
+
     '[_ ?y]
     (dp/->BindTuple [(dp/->BindIgnore) (dp/->BindScalar (dp/->Variable '?y))])
-       
+
     '[[_ [?x ...]] ...]
     (dp/->BindColl
       (dp/->BindTuple [(dp/->BindIgnore)
                        (dp/->BindColl
                          (dp/->BindScalar (dp/->Variable '?x)))]))
-       
+
     '[[?a ?b ?c]]
     (dp/->BindColl
       (dp/->BindTuple [(dp/->BindScalar (dp/->Variable '?a))
                        (dp/->BindScalar (dp/->Variable '?b))
                        (dp/->BindScalar (dp/->Variable '?c))])))
-       
+
   (is (thrown-with-msg? ExceptionInfo #"Cannot parse binding"
         (dp/parse-binding :key))))
 
@@ -48,7 +47,7 @@
   (are [form res] (= (dp/parse-in form) res)
     '[?x]
     [(dp/->BindScalar (dp/->Variable '?x))]
-       
+
     '[$ $1 % _ ?x]
     [(dp/->BindScalar (dp/->SrcVar '$))
      (dp/->BindScalar (dp/->SrcVar '$1))
@@ -62,13 +61,13 @@
        (dp/->BindTuple [(dp/->BindIgnore)
                         (dp/->BindColl
                           (dp/->BindScalar (dp/->Variable '?x)))]))])
-  
+
   (is (thrown-with-msg? ExceptionInfo #"Cannot parse binding"
         (dp/parse-in ['?x :key]))))
 
 (deftest with
   (is (= (dp/parse-with '[?x ?y])
         [(dp/->Variable '?x) (dp/->Variable '?y)]))
-  
+
   (is (thrown-with-msg? ExceptionInfo #"Cannot parse :with clause"
         (dp/parse-with '[?x _]))))
diff --git a/test/dbval/test/parser_find.cljc b/test/dbval/test/parser_find.clj
similarity index 98%
rename from test/dbval/test/parser_find.cljc
rename to test/dbval/test/parser_find.clj
index 1bf9b64b..dbe33227 100644
--- a/test/dbval/test/parser_find.cljc
+++ b/test/dbval/test/parser_find.clj
@@ -6,9 +6,6 @@
     [dbval.parser :as dp]
     [dbval.test.core :as tdc]))
 
-#?(:cljs
-   (def Throwable
-     js/Error))
 
 (deftest test-parse-find
   (is (= (dp/parse-find '[?a ?b])
diff --git a/test/dbval/test/parser_query.cljc b/test/dbval/test/parser_query.clj
similarity index 90%
rename from test/dbval/test/parser_query.cljc
rename to test/dbval/test/parser_query.clj
index d17e7286..273f190d 100644
--- a/test/dbval/test/parser_query.cljc
+++ b/test/dbval/test/parser_query.clj
@@ -5,9 +5,8 @@
     [dbval.db :as db]
     [dbval.parser :as dp]
     [dbval.test.core :as tdc])
-  #?(:clj
-     (:import
-       [clojure.lang ExceptionInfo])))
+  (:import
+       [clojure.lang ExceptionInfo]))
 
 (deftest validation
   (are [q msg] (thrown-msg? msg (dp/parse-query q))
@@ -16,30 +15,30 @@
 
     '[:find ?e :with ?f :where [?e]]
     "Query for unknown vars: [?f]"
-       
+
     '[:find ?e ?x ?t :in ?x :where [?e]]
     "Query for unknown vars: [?t]"
-       
+
     '[:find ?x ?e :with ?y ?e :where [?x ?e ?y]]
     ":find and :with should not use same variables: [?e]"
-       
+
     '[:find ?e :in $ $ ?x :where [?e]]
     "Vars used in :in should be distinct"
-       
+
     '[:find ?e :in ?x $ ?x :where [?e]]
     "Vars used in :in should be distinct"
 
     '[:find ?e :in $ % ?x % :where [?e]]
     "Vars used in :in should be distinct"
-       
+
     '[:find ?n :with ?e ?f ?e :where [?e ?f ?n]]
     "Vars used in :with should be distinct"
-       
+
     '[:find ?x :where [$1 ?x]]
     "Where uses unknown source vars: [$1]"
-       
+
     '[:find ?x :in $1 :where [$2 ?x]]
     "Where uses unknown source vars: [$2]"
-       
+
     '[:find ?e :where (rule ?e)]
     "Missing rules var '%' in :in"))
diff --git a/test/dbval/test/parser_return_map.cljc b/test/dbval/test/parser_return_map.clj
similarity index 97%
rename from test/dbval/test/parser_return_map.cljc
rename to test/dbval/test/parser_return_map.clj
index 50935b1b..f3749a3d 100644
--- a/test/dbval/test/parser_return_map.cljc
+++ b/test/dbval/test/parser_return_map.clj
@@ -6,9 +6,6 @@
     [dbval.db :as db]
     [dbval.test.core :as tdc]))
 
-#?(:cljs
-   (def Throwable
-     js/Error))
 
 (deftest test-parse-return-map
   (is (= (:qreturn-map (dp/parse-query '[:find ?a ?b :keys x y :where [?a ?b]]))
diff --git a/test/dbval/test/parser_rules.cljc b/test/dbval/test/parser_rules.clj
similarity index 96%
rename from test/dbval/test/parser_rules.cljc
rename to test/dbval/test/parser_rules.clj
index 2aaef44d..3110c0fd 100644
--- a/test/dbval/test/parser_rules.cljc
+++ b/test/dbval/test/parser_rules.clj
@@ -5,9 +5,8 @@
     [dbval.db :as db]
     [dbval.parser :as dp]
     [dbval.test.core :as tdc])
-  #?(:clj
-     (:import
-       [clojure.lang ExceptionInfo])))
+  (:import
+       [clojure.lang ExceptionInfo]))
 
 (deftest clauses
   (are [form res] (= (set (dp/parse-rules form)) res)
@@ -30,17 +29,17 @@
         [(dp/->RuleBranch
            (dp/->RuleVars [(dp/->Variable '?x)] [(dp/->Variable '?y)])
            [(dp/->Pattern (dp/->DefaultSrc) [(dp/->Placeholder)])])])}
-       
+
     '[[(rule [?x ?y] ?a ?b)
        [_]]]
     #{(dp/->Rule
         (dp/->PlainSymbol 'rule)
-        
+
         [(dp/->RuleBranch
            (dp/->RuleVars [(dp/->Variable '?x) (dp/->Variable '?y)]
              [(dp/->Variable '?a) (dp/->Variable '?b)])
            [(dp/->Pattern (dp/->DefaultSrc) [(dp/->Placeholder)])])])}
-       
+
     '[[(rule [?x])
        [_]]]
     #{(dp/->Rule
@@ -57,7 +56,7 @@
 
   (is (thrown-with-msg? ExceptionInfo #"Rule variables should be distinct"
         (dp/parse-rules '[[(rule ?x ?y ?x) [_]]])))
-  
+
   (is (thrown-with-msg? ExceptionInfo #"Rule variables should be distinct"
         (dp/parse-rules '[[(rule [?x ?y] ?z ?x) [_]]]))))
 
@@ -77,7 +76,7 @@
          (dp/->RuleBranch
            (dp/->RuleVars nil [(dp/->Variable '?x)])
            [(dp/->Pattern (dp/->DefaultSrc) [(dp/->Constant :c)])])])}
-       
+
     '[[(rule ?x)
        [:a]
        [:b]]
@@ -94,14 +93,14 @@
         [(dp/->RuleBranch
            (dp/->RuleVars nil [(dp/->Variable '?x)])
            [(dp/->Pattern (dp/->DefaultSrc) [(dp/->Constant :c)])])])})
-  
+
   (is (thrown-with-msg? ExceptionInfo #"Rule branch should have clauses"
         (dp/parse-rules '[[(rule ?x)]])))
-  
+
   (is (thrown-with-msg? ExceptionInfo #"Arity mismatch"
         (dp/parse-rules '[[(rule ?x) [_]]
                           [(rule ?x ?y) [_]]])))
-  
+
   (is (thrown-with-msg? ExceptionInfo #"Arity mismatch"
         (dp/parse-rules '[[(rule ?x) [_]]
                           [(rule [?x]) [_]]]))))  
diff --git a/test/dbval/test/parser_where.cljc b/test/dbval/test/parser_where.clj
similarity index 97%
rename from test/dbval/test/parser_where.cljc
rename to test/dbval/test/parser_where.clj
index b2d93d80..80fc15de 100644
--- a/test/dbval/test/parser_where.cljc
+++ b/test/dbval/test/parser_where.clj
@@ -5,21 +5,20 @@
     [dbval.db :as db]
     [dbval.parser :as dp]
     [dbval.test.core :as tdc])
-  #?(:clj
-     (:import
-       [clojure.lang ExceptionInfo])))
+  (:import
+       [clojure.lang ExceptionInfo]))
 
 (deftest pattern
   (are [clause pattern] (= (dp/parse-clause clause) pattern)
     '[?e ?a ?v]
     (dp/->Pattern (dp/->DefaultSrc) [(dp/->Variable '?e) (dp/->Variable '?a) (dp/->Variable '?v)])
-    
+
     '[_ ?a _ _]
     (dp/->Pattern (dp/->DefaultSrc) [(dp/->Placeholder) (dp/->Variable '?a) (dp/->Placeholder) (dp/->Placeholder)])
-       
+
     '[$x _ ?a _ _]
     (dp/->Pattern (dp/->SrcVar '$x) [(dp/->Placeholder) (dp/->Variable '?a) (dp/->Placeholder) (dp/->Placeholder)])
-       
+
     '[$x _ :name ?v]
     (dp/->Pattern (dp/->SrcVar '$x) [(dp/->Placeholder) (dp/->Constant :name) (dp/->Variable '?v)])
 
@@ -36,10 +35,10 @@
   (are [clause res] (= (dp/parse-clause clause) res)
     '[(pred ?a 1)]
     (dp/->Predicate (dp/->PlainSymbol 'pred) [(dp/->Variable '?a) (dp/->Constant 1)])
-       
+
     '[(pred)]
     (dp/->Predicate (dp/->PlainSymbol 'pred) [])
-  
+
     '[(?custom-pred ?a)]
     (dp/->Predicate (dp/->Variable '?custom-pred) [(dp/->Variable '?a)])))
 
@@ -47,10 +46,10 @@
   (are [clause res] (= (dp/parse-clause clause) res)
     '[(fn ?a 1) ?x]
     (dp/->Function (dp/->PlainSymbol 'fn) [(dp/->Variable '?a) (dp/->Constant 1)] (dp/->BindScalar (dp/->Variable '?x)))
-       
+
     '[(fn) ?x]
     (dp/->Function (dp/->PlainSymbol 'fn) [] (dp/->BindScalar (dp/->Variable '?x)))
-       
+
     '[(?custom-fn) ?x]
     (dp/->Function (dp/->Variable '?custom-fn) [] (dp/->BindScalar (dp/->Variable '?x)))
 
@@ -61,13 +60,13 @@
   (are [clause res] (= (dp/parse-clause clause) res)
     '(friends ?x ?y)
     (dp/->RuleExpr (dp/->DefaultSrc) (dp/->PlainSymbol 'friends) [(dp/->Variable '?x) (dp/->Variable '?y)])
-  
+
     '(friends "Ivan" _)
     (dp/->RuleExpr (dp/->DefaultSrc) (dp/->PlainSymbol 'friends) [(dp/->Constant "Ivan") (dp/->Placeholder)])
 
     '($1 friends ?x ?y)
     (dp/->RuleExpr (dp/->SrcVar '$1) (dp/->PlainSymbol 'friends) [(dp/->Variable '?x) (dp/->Variable '?y)])
-    
+
     '(friends something)
     (dp/->RuleExpr (dp/->DefaultSrc) (dp/->PlainSymbol 'friends) [(dp/->Constant 'something)]))
 
@@ -96,13 +95,13 @@
        (dp/->Pattern
          (dp/->DefaultSrc)
          [(dp/->Variable '?x) (dp/->Placeholder) (dp/->Variable '?y)])])
-       
+
     '($1 not [?x])
     (dp/->Not
       (dp/->SrcVar '$1)
       [(dp/->Variable '?x)]
       [(dp/->Pattern (dp/->DefaultSrc) [(dp/->Variable '?x)])])
-       
+
     '(not-join [?e ?y]
        [?e :follows ?x]
        [?x _ ?y])
@@ -115,7 +114,7 @@
        (dp/->Pattern
          (dp/->DefaultSrc)
          [(dp/->Variable '?x) (dp/->Placeholder) (dp/->Variable '?y)])])
-       
+
     '($1 not-join [?e] [?e :follows ?x])
     (dp/->Not
       (dp/->SrcVar '$1)
@@ -123,16 +122,16 @@
       [(dp/->Pattern
          (dp/->DefaultSrc)
          [(dp/->Variable '?e) (dp/->Constant :follows) (dp/->Variable '?x)])]))
-    
+
   (is (thrown-with-msg? ExceptionInfo #"Join variables should not be empty"
         (dp/parse-clause '(not-join [] [?y]))))
-  
+
   (is (thrown-with-msg? ExceptionInfo #"Join variables should not be empty"
         (dp/parse-clause '(not [_]))))
-  
+
   (is (thrown-with-msg? ExceptionInfo #"Cannot parse 'not-join' clause"
         (dp/parse-clause '(not-join [?x]))))
-  
+
   (is (thrown-with-msg? ExceptionInfo #"Cannot parse 'not' clause"
         (dp/parse-clause '(not)))))
 
@@ -158,7 +157,7 @@
        (dp/->Pattern
          (dp/->DefaultSrc)
          [(dp/->Variable '?e) (dp/->Constant :friend) (dp/->Variable '?x)])])
-       
+
     '(or
        [?e :follows ?x]
        (and
@@ -177,13 +176,13 @@
           (dp/->Pattern
             (dp/->DefaultSrc)
             [(dp/->Variable '?x) (dp/->Constant :friend) (dp/->Variable '?e)])])])
-       
+
     '($1 or [?x])
     (dp/->Or
       (dp/->SrcVar '$1)
       (dp/->RuleVars nil [(dp/->Variable '?x)])
       [(dp/->Pattern (dp/->DefaultSrc) [(dp/->Variable '?x)])])
-       
+
     '(or-join [?e]
        [?e :follows ?x]
        [?e :friend ?y])
@@ -196,7 +195,7 @@
        (dp/->Pattern
          (dp/->DefaultSrc)
          [(dp/->Variable '?e) (dp/->Constant :friend) (dp/->Variable '?y)])])
-       
+
     '(or-join [[?e]]
        (and [?e :follows ?x]
          [?e :friend ?y]))
@@ -210,7 +209,7 @@
           (dp/->Pattern
             (dp/->DefaultSrc)
             [(dp/->Variable '?e) (dp/->Constant :friend) (dp/->Variable '?y)])])])
-       
+
     '($1 or-join [[?e] ?x]
        [?e :follows ?x])
     (dp/->Or
@@ -219,15 +218,15 @@
       [(dp/->Pattern
          (dp/->DefaultSrc)
          [(dp/->Variable '?e) (dp/->Constant :follows) (dp/->Variable '?x)])]))
-  
+
   (is (thrown-with-msg? ExceptionInfo #"Cannot parse rule-vars"
         (dp/parse-clause '(or-join [] [?y]))))
-  
+
   (is (thrown-with-msg? ExceptionInfo #"Join variables should not be empty"
         (dp/parse-clause '(or [_]))))
-  
+
   (is (thrown-with-msg? ExceptionInfo #"Cannot parse 'or-join' clause"
         (dp/parse-clause '(or-join [?x]))))
-  
+
   (is (thrown-with-msg? ExceptionInfo #"Cannot parse 'or' clause"
         (dp/parse-clause '(or)))))
diff --git a/test/dbval/test/pull_api.cljc b/test/dbval/test/pull_api.clj
similarity index 100%
rename from test/dbval/test/pull_api.cljc
rename to test/dbval/test/pull_api.clj
diff --git a/test/dbval/test/pull_parser.cljc b/test/dbval/test/pull_parser.clj
similarity index 98%
rename from test/dbval/test/pull_parser.cljc
rename to test/dbval/test/pull_parser.clj
index f28f4e22..84a74df3 100644
--- a/test/dbval/test/pull_parser.cljc
+++ b/test/dbval/test/pull_parser.clj
@@ -92,7 +92,7 @@
     ; xform
     [[:normal :xform 'inc]] (pattern :attrs [(attr :normal :xform inc)])
     [[:normal :xform inc]] (pattern :attrs [(attr :normal :xform inc)])
-    #?@(:clj [[[:normal :xform 'dbval.db/datom?]] (pattern :attrs [(attr :normal :xform db/datom?)])])
+    [[:normal :xform 'dbval.db/datom?]] (pattern :attrs [(attr :normal :xform db/datom?)])
 
     ; combined
     ['(:multival :limit 100 :default :xyz :as :other :xform inc)] (pattern :attrs [(attr :multival, :multival? true, :default :xyz, :limit 100, :as :other, :xform inc)])
@@ -107,12 +107,12 @@
     ['(default (:multival :limit 100) :xyz)] (pattern :attrs [(attr :multival, :multival? true, :default :xyz, :limit 100)])
     ['(((limit :multival 100) :default :xyz))] (pattern :attrs [(attr :multival, :multival? true, :default :xyz, :limit 100)])
     ['(((default :multival :xyz) :limit 100))] (pattern :attrs [(attr :multival, :multival? true, :default :xyz, :limit 100)])
-    
+
     ; repeated
     [:multival [:multival :default :xyz] [:multival :limit 100]] (pattern :attrs [(attr :multival, :multival? true, :limit 100)])
     [:ref {:ref '...}] (pattern :attrs [(attr :ref, :ref? true, :pattern nil, :recursive? true, :recursion-limit nil)])
     [{:ref '...} :ref] (pattern :attrs [(attr :ref, :ref? true)])
-    
+
     ; map spec
     [{:ref [:normal]}]                    (pattern :attrs [(attr :ref, :ref? true, :pattern (pattern :attrs [(attr :normal)]))])
     [{:_ref [:normal]}]                   (pattern :reverse-attrs [(attr :ref, :as :_ref, :ref? true, :reverse? true, :pattern (pattern :attrs [(attr :normal)]))])
@@ -138,7 +138,7 @@
 
       ; attr-expr
       ['(:multival :limit)] "Expected even number of opts, got: (:multival :limit)"
-      
+
       ; limit
       ['(limit :multival)] "Expected ['limit attr-name (positive-number | nil)], got: (limit :multival)"
       ['(:normal :limit 100)] "Expected limit attribute having :db.cardinality/many, got: :normal"      
diff --git a/test/dbval/test/query.cljc b/test/dbval/test/query.clj
similarity index 99%
rename from test/dbval/test/query.cljc
rename to test/dbval/test/query.clj
index dc9e3683..ff053fa4 100644
--- a/test/dbval/test/query.cljc
+++ b/test/dbval/test/query.clj
@@ -4,9 +4,8 @@
     [dbval.core :as d]
     [dbval.db :as db]
     [dbval.test.core :as tdc])
-  #?(:clj
-     (:import
-       [clojure.lang ExceptionInfo])))
+  (:import
+       [clojure.lang ExceptionInfo]))
 
 (deftest test-joins
   (let [tx (d/with (d/empty-db)
@@ -113,7 +112,7 @@
             #{[e1 "ivan@mail.ru"]
               [e2 "petr@gmail.com"]
               [e3 "ivan@mail.ru"]})))
-    
+
     (testing "Query without DB"
       (is (= (d/q '[:find ?a ?b
                     :in   ?a ?b]
@@ -182,7 +181,7 @@
                 [2 :name "Petr"]]
                [])
             #{})))
-    
+
     (testing "Placeholders"
       (is (= (d/q '[:find ?x ?z
                     :in [?x _ ?z]]
@@ -192,7 +191,7 @@
                     :in [[?x _ ?z]]]
                [[:x :y :z] [:a :b :c]])
             #{[:x :z] [:a :c]})))
-    
+
     (testing "Error reporting"
       (is (thrown-with-msg? ExceptionInfo #"Cannot bind value :a to tuple \[\?a \?b\]"
             (d/q '[:find ?a ?b :in [?a ?b]] :a)))
@@ -200,7 +199,7 @@
             (d/q '[:find ?a :in [?a ...]] :a)))
       (is (thrown-with-msg? ExceptionInfo #"Not enough elements in a collection \[:a\] to bind tuple \[\?a \?b\]"
             (d/q '[:find ?a ?b :in [?a ?b]] [:a]))))))
-        
+
 (deftest test-nested-bindings
   (is (= (d/q '[:find  ?k ?v
                 :in    [[?k ?v] ...]
diff --git a/test/dbval/test/query_aggregates.cljc b/test/dbval/test/query_aggregates.clj
similarity index 95%
rename from test/dbval/test/query_aggregates.cljc
rename to test/dbval/test/query_aggregates.clj
index 2bc52e7e..8403a22b 100644
--- a/test/dbval/test/query_aggregates.cljc
+++ b/test/dbval/test/query_aggregates.clj
@@ -34,7 +34,7 @@
                     :in   [[?monster ?heads]]]
                monsters)
             [[6 1 3 4 2]])))
-    
+
     (testing "Min and max are using comparator instead of default compare"
       ;; Wrong: using js '<' operator
       ;; (apply min [:a/b :a-/b :a/c]) => :a-/b
@@ -71,7 +71,7 @@
                             :in [?x ...]]
                        [10 15 20 35 75]))
             20)))
-    
+
     (testing "variance aggregate"
       (is (= (ffirst (d/q '[:find (variance ?x)
                             :in [?x ...]]
@@ -88,15 +88,14 @@
       (let [data   [[:red 1]  [:red 2] [:red 3] [:red 4] [:red 5]
                     [:blue 7] [:blue 8]]
             result #{[:red [5 4 3 2 1]] [:blue [8 7]]}]
-        
+
         (is (= (set (d/q '[:find ?color (aggregate ?agg ?x)
                            :in   [[?color ?x]] ?agg]
                       data
                       sort-reverse))
               result))
-        
-        #?(:clj
-           (is (= (set (d/q '[:find ?color (dbval.test.query-aggregates/sort-reverse ?x)
+
+        (is (= (set (d/q '[:find ?color (dbval.test.query-aggregates/sort-reverse ?x)
                               :in   [[?color ?x]]]
                          data))
-                 result)))))))
+                 result))))))
diff --git a/test/dbval/test/query_find_specs.cljc b/test/dbval/test/query_find_specs.clj
similarity index 100%
rename from test/dbval/test/query_find_specs.cljc
rename to test/dbval/test/query_find_specs.clj
diff --git a/test/dbval/test/query_fns.cljc b/test/dbval/test/query_fns.clj
similarity index 98%
rename from test/dbval/test/query_fns.cljc
rename to test/dbval/test/query_fns.clj
index 609d2b51..778b43c7 100644
--- a/test/dbval/test/query_fns.cljc
+++ b/test/dbval/test/query_fns.clj
@@ -4,9 +4,8 @@
     [dbval.core :as d]
     [dbval.db :as db]
     [dbval.test.core :as tdc])
-  #?(:clj
-     (:import
-       [clojure.lang ExceptionInfo])))
+  (:import
+       [clojure.lang ExceptionInfo]))
 
 (deftest test-query-fns
   (testing "predicate without free variables"
@@ -339,10 +338,9 @@
 (defn sample-query-fn []
   42)
 
-#?(:clj
-   (deftest test-symbol-resolution
+(deftest test-symbol-resolution
      (is (= 42 (d/q '[:find ?x .
-                      :where [(dbval.test.query-fns/sample-query-fn) ?x]])))))
+                      :where [(dbval.test.query-fns/sample-query-fn) ?x]]))))
 
 (deftest test-issue-445
   (let [tx (d/with (d/empty-db {:name {:db/unique :db.unique/identity}})
diff --git a/test/dbval/test/query_not.cljc b/test/dbval/test/query_not.clj
similarity index 98%
rename from test/dbval/test/query_not.cljc
rename to test/dbval/test/query_not.clj
index 06d0e19f..05ed7427 100644
--- a/test/dbval/test/query_not.cljc
+++ b/test/dbval/test/query_not.clj
@@ -4,9 +4,8 @@
     [dbval.core :as d]
     [dbval.db :as db]
     [dbval.test.core :as tdc])
-  #?(:clj
-     (:import
-       [clojure.lang ExceptionInfo])))
+  (:import
+       [clojure.lang ExceptionInfo]))
 
 (def *test-db
   (delay
diff --git a/test/dbval/test/query_or.cljc b/test/dbval/test/query_or.clj
similarity index 99%
rename from test/dbval/test/query_or.cljc
rename to test/dbval/test/query_or.clj
index 7d73c35f..ce3f9e94 100644
--- a/test/dbval/test/query_or.cljc
+++ b/test/dbval/test/query_or.clj
@@ -4,9 +4,8 @@
     [dbval.core :as d]
     [dbval.db :as db]
     [dbval.test.core :as tdc])
-  #?(:clj
-     (:import
-       [clojure.lang ExceptionInfo])))
+  (:import
+       [clojure.lang ExceptionInfo]))
 
 ;; Use string tempids and capture the mapping
 (def *test-db
diff --git a/test/dbval/test/query_pull.cljc b/test/dbval/test/query_pull.clj
similarity index 100%
rename from test/dbval/test/query_pull.cljc
rename to test/dbval/test/query_pull.clj
diff --git a/test/dbval/test/query_return_map.cljc b/test/dbval/test/query_return_map.clj
similarity index 99%
rename from test/dbval/test/query_return_map.cljc
rename to test/dbval/test/query_return_map.clj
index a36fda31..99cbf0c4 100644
--- a/test/dbval/test/query_return_map.cljc
+++ b/test/dbval/test/query_return_map.clj
@@ -43,4 +43,3 @@
            @*test-db)
         {:n "Ivan" :a 25})))
 
-
diff --git a/test/dbval/test/query_rules.cljc b/test/dbval/test/query_rules.clj
similarity index 98%
rename from test/dbval/test/query_rules.cljc
rename to test/dbval/test/query_rules.clj
index bdbe8c72..f6a5fbb1 100644
--- a/test/dbval/test/query_rules.cljc
+++ b/test/dbval/test/query_rules.clj
@@ -16,7 +16,7 @@
              '[[(follow ?x ?y)
                 [?x :follow ?y]]])
           #{[1 2] [2 3] [3 4] [2 4] [5 3] [4 6]}))
-    
+
     (testing "Joining regular clauses with rule"
       (is (= (d/q '[:find ?y ?x
                     :in $ %
@@ -27,7 +27,7 @@
                '[[(rule ?a ?b)
                   [?a :follow ?b]]])
             #{[3 2] [6 4] [4 2]})))
-    
+
     (testing "Rule context is isolated from outer context"
       (is (= (d/q '[:find ?x
                     :in $ %
@@ -122,7 +122,7 @@
                   [(?pred ?e2)]]]
                even?)
             #{[4 6] [2 4]})))
-    
+
     (testing "Using built-ins inside rule"
       (is (= (d/q '[:find ?x ?y
                     :in $ %
@@ -198,8 +198,7 @@
 ; due to propagation of a relation with duplicate tuples during rule solving
 (deftest test-rule-performance-on-larger-datasets
   (let [now     (fn []
-                  #?(:clj  (/ (System/nanoTime) 1000000.0)
-                     :cljs (js/performance.now)))
+                  (/ (System/nanoTime) 1000000.0))
         inline  (fn [db]
                   (d/q '[:find ?e
                          :where [?e :item/status ?status]
diff --git a/test/dbval/test/query_v3.cljc b/test/dbval/test/query_v3.cljc
deleted file mode 100644
index 7df9b85d..00000000
--- a/test/dbval/test/query_v3.cljc
+++ /dev/null
@@ -1,23 +0,0 @@
-(ns dbval.test.query-v3
-  (:require
-    [clojure.test :as t :refer [is are deftest testing]]
-    [dbval.core :as d]
-    [dbval.db :as db]
-    [dbval.query-v3 :as dq]
-    [dbval.test.core :as tdc])
-  #?(:clj
-     (:import
-       [clojure.lang ExceptionInfo])))
-
-(deftest test-validation
-  (are [q ins msg] (thrown-with-msg? ExceptionInfo msg (apply dq/q q ins))
-    '[:find ?a :in $ ?a]          [0]   #"Wrong number of arguments for bindings \[\$ \?a\], 2 required, 1 provided"
-    '[:find ?a :in $ :where [?a]] [0 1] #"Wrong number of arguments for bindings \[\$\], 1 required, 2 provided"
-    '[:find ?a :where [?a]]       [0 1] #"Wrong number of arguments for bindings \[\$\], 1 required, 2 provided"
-
-    '[:find ?a :where [?a 1]]     [:a]  #"Cannot match by pattern \[\?a 1\] because source is not a collection: :a"))
-       
-#_(deftest test-query
-    (is (= (dq/q '[:find ?a :where [?a ?a]]
-             [[1 2] [3 3] [4 5] [6 6]])
-          #{[3] [6]})))
diff --git a/test/dbval/test/transact.cljc b/test/dbval/test/transact.clj
similarity index 99%
rename from test/dbval/test/transact.cljc
rename to test/dbval/test/transact.clj
index e8cd57cd..2dee5428 100644
--- a/test/dbval/test/transact.cljc
+++ b/test/dbval/test/transact.clj
@@ -196,7 +196,7 @@
           db' (d/db-with db [[:db/retract e2 :employed? false]])]
       (is (= [(db/datom e2 :employed? true)]
              (vec (d/datoms db' :eavt e2 :employed?)))))))
-  
+
 (deftest test-retract-fns-not-found
   (let [schema {:name {:db/unique :db.unique/identity}}
         setup (fn []
@@ -260,7 +260,7 @@
     (is (= (:weight (d/entity @conn e1)) 300))
     (d/transact! conn [[:db/cas e1 :weight 300 400]])
     (is (= (:weight (d/entity @conn e1)) 400))
-    (is (thrown-with-msg? #?(:clj Exception :cljs js/Error)
+    (is (thrown-with-msg? Exception
                           #":db.fn/cas failed on datom .* :weight 400.*, expected 200"
           (d/transact! conn [[:db.fn/cas e1 :weight 200 210]]))))
 
@@ -270,7 +270,7 @@
     (d/transact! conn [[:db/add e1 :label :y]])
     (d/transact! conn [[:db.fn/cas e1 :label :y :z]])
     (is (= (:label (d/entity @conn e1)) #{:x :y :z}))
-    (is (thrown-with-msg? #?(:clj Exception :cljs js/Error)
+    (is (thrown-with-msg? Exception
                           #":db.fn/cas failed on datom .* :label .*, expected :s"
           (d/transact! conn [[:db.fn/cas e1 :label :s :t]]))))
 
@@ -279,7 +279,7 @@
         e1 (get (:tempids tx1) "e1")]
     (d/transact! conn [[:db.fn/cas e1 :age nil 42]])
     (is (= (:age (d/entity @conn e1)) 42))
-    (is (thrown-with-msg? #?(:clj Exception :cljs js/Error)
+    (is (thrown-with-msg? Exception
                           #":db.fn/cas failed on datom .* :age 42.*, expected nil"
           (d/transact! conn [[:db.fn/cas e1 :age nil 4711]]))))
 
diff --git a/test/dbval/test/tuples.cljc b/test/dbval/test/tuples.clj
similarity index 99%
rename from test/dbval/test/tuples.cljc
rename to test/dbval/test/tuples.clj
index e65848a4..f84011d2 100644
--- a/test/dbval/test/tuples.cljc
+++ b/test/dbval/test/tuples.clj
@@ -2,10 +2,10 @@
   (:require
     [clojure.test :as t :refer [is are deftest testing]]
     [dbval.core :as d]
+    [dbval.db :as db]
     [dbval.test.core :as tdc])
-  #?(:clj
-     (:import
-       [clojure.lang ExceptionInfo])))
+  (:import
+       [clojure.lang ExceptionInfo]))
 
 (deftest test-schema
   (let [db (d/empty-db
@@ -14,14 +14,14 @@
               :session+student {:db/tupleAttrs [:session :student]
                                 :db/valueType :db.type/tuple}})]
     (is (= #{:year+session :semester+course+student :session+student}
-          (:db.type/tuple (:rschema db))))
+          (db/-attrs-by db :db.type/tuple)))
 
     (is (= {:year     {:year+session 0}
             :session  {:year+session 1, :session+student 0}
             :semester {:semester+course+student 0}
             :course   {:semester+course+student 1}
             :student  {:semester+course+student 2, :session+student 1}}
-          (:db/attrTuples (:rschema db))))
+          (db/-attrs-by db :db/attrTuples)))
 
     (is (thrown-msg? ":t2 :db/tupleAttrs can't depend on another tuple attribute: :t1"
           (d/empty-db {:t1 {:db/tupleAttrs [:a :b]}
diff --git a/test/dbval/test/upsert.cljc b/test/dbval/test/upsert.clj
similarity index 99%
rename from test/dbval/test/upsert.cljc
rename to test/dbval/test/upsert.clj
index e9112b3d..c9f66213 100644
--- a/test/dbval/test/upsert.cljc
+++ b/test/dbval/test/upsert.clj
@@ -5,9 +5,6 @@
     [dbval.db :as db]
     [dbval.test.core :as tdc]))
 
-#?(:cljs
-   (def Throwable
-     js/Error))
 
 (deftest test-upsert
   (let [schema  {:name  {:db/unique      :db.unique/identity}
diff --git a/test/dbval/test/validation.cljc b/test/dbval/test/validation.clj
similarity index 98%
rename from test/dbval/test/validation.cljc
rename to test/dbval/test/validation.clj
index 1fba49cd..0287cfe1 100644
--- a/test/dbval/test/validation.cljc
+++ b/test/dbval/test/validation.clj
@@ -4,9 +4,6 @@
     [dbval.core :as d]
     [dbval.test.core :as tdc]))
 
-#?(:cljs
-   (def Throwable
-     js/Error))
 
 (deftest test-with-validation
   (let [db* (fn []
diff --git a/test/js/tests.js b/test/js/tests.js
deleted file mode 100644
index 1ecd001c..00000000
--- a/test/js/tests.js
+++ /dev/null
@@ -1,584 +0,0 @@
-var _ = require("./underscore-1.6.0.min.js");
-
-var passed = 0, failures = 0, asserts = 0, errors = 0;
-
-function eq_set(s1, s2) {
-  return _.every(s1, function(e1) { return _.find(s2, function(e2) { return _.isEqual(e1, e2); }) != undefined })
-      && _.every(s2, function(e2) { return _.find(s1, function(e1) { return _.isEqual(e1, e2); }) != undefined });
-}
-
-function maybe_to_datom(d) {
-  if (Array.isArray(d))
-    return {"e": d[0], "a": d[1], "v": d[2], "tx": d[3] > 0 ? d[3] : -d[3]};
-  else
-    return d;
-}
-
-function cmp_datoms(d1, d2) {
-  if (d1 == null) return d2 == null;
-  if (d2 == null) return false;
-  d1 = maybe_to_datom(d1);
-  d2 = maybe_to_datom(d2);
-  return d1.e == d2.e && d1.a == d2.a && _.isEqual(d1.v, d2.v) && d1.tx == d2.tx && d1.added == d2.added;
-}
-
-function assert_eq_datoms(expected, got, message) {
-  asserts++;
-  if(! _.every(_.zip(expected, got), function(dd) { return cmp_datoms(dd[0], dd[1]); }) ) {
-    errors--;
-    failures++;
-    throw (message || "Assertion failed") + ": expected: " + JSON.stringify(expected) + ", got: " + JSON.stringify(got);
-  }
-}
-
-function assert_eq(expected, got, message) {
-  asserts++;
-  if (!_.isEqual(expected, got)) {
-    errors--;
-    failures++;
-    throw (message || "Assertion failed") + ": expected: " + JSON.stringify(expected) + ", got: " + JSON.stringify(got);
-  }
-}
-
-function assert_ident(expected, got, message) {
-  asserts++;
-  if (expected !== got) {
-    errors--;
-    failures++;
-    throw (message || "Assertion failed") + ": expected: " + JSON.stringify(expected) + ", got: " + JSON.stringify(got);
-  }
-}
-
-function assert_eq_set(expected, got, message) {
-  asserts++;
-  if (!eq_set(expected, got)) {
-    errors--;
-    failures++;
-    throw (message || "Assertion failed") + ": expected: " + JSON.stringify(expected) + ", got: " + JSON.stringify(got);
-  }
-}
-
-function assert_eq_refs(expected, got, message) {
-  var got_ids = _.map(got, function(e) { return e.get(":db/id"); });
-  assert_eq_set(expected, got_ids);
-}
-
-function assert_eq_iter_set(expected, got, message) {
-  var got_arr = [];
-  // ECMAScript 6 iterators
-  // for (let v of got) { 
-  //   got_arr.push(v);
-  // }
-  var i = got.next();
-  while (!i.done) {
-    got_arr.push(i.value);
-    i = got.next();
-  }
-  assert_eq_set(expected, got_arr, message);
-}
-
-function test_fns(fns) {
-  for(var i in fns) {
-    try {
-      fns[i]();
-      passed++;
-      console.log("[ OK ] " + fns[i].name);
-    } catch(e) {
-      console.error(fns[i].name + ":", e);
-      errors++;
-      console.error("[ FAIL ] " + fns[i].name);
-    }
-  }
-  
-  console.log("Ran " + fns.length + " tests containing " + asserts + " assertions.");
-  console.log("Testing complete: " + failures + " failures, " + errors + " errors."); 
-  
-  return { fail:  failures,
-           error: errors,
-           test:  fns.length,
-           pass:  asserts - failures - errors };
-}
-
-
-///--------- TESTS ---------
-
-
-var d = require("../../release-js/datascript.js");
-var tx0 = 0x20000000; // we just know it, alright?
-
-function test_db_with() {
-  var db = d.empty_db();
-  var db1 = d.db_with(db, [[":db/add", 1, "name", "Ivan"],
-                           [":db/add", 1, "age", 17]]);
-  var db2 = d.db_with(db1, [{":db/id": 2,
-                             "name": "Igor",
-                             "age": 35}]);
-  var q = '[:find ?n ?a :where [?e "name" ?n] [?e "age" ?a]]'; 
-  assert_eq_set([["Ivan", 17]], d.q(q, db1));
-  assert_eq_set([["Ivan", 17], ["Igor", 35]], d.q(q, db2));
-}
-
-function test_nested_maps() {
-  var q = '[:find ?e ?a ?v :where [?e ?a ?v]]';
-  
-  var db0 = d.empty_db({"profile": {":db/valueType": ":db.type/ref"},
-                        "friend": {":db/valueType": ":db.type/ref",
-                                   ":db/cardinality": ":db.cardinality/many"}});
-  var db = d.db_with(db0, [{"name": "Igor", "profile": {"email": "@2"} }]);
-  assert_eq_set([[1, "name", "Igor"], [1, "profile", 2], [2, "email", "@2"]], d.q(q, db));
-
-  db = d.db_with(db0, [{":db/id": 1, "name": "Igor"},
-                       {":db/id": 2, "name": "Oleg", "profile": {":db/id": 1}}]);
-  assert_eq_set([[1, "name", "Igor"], [2, "name", "Oleg"], [2, "profile", 1]], d.q(q, db));
-
-  db = d.db_with(db0, [{":db/id": 1, "name": "Igor"},
-                       {":db/id": 2, "name": "Ivan"},
-                       {":db/id": 3, "name": "Oleg", "friend": [{":db/id": 1}, {":db/id": 2}]}]);
-  assert_eq_set([[1, "name", "Igor"], [2, "name", "Ivan"], [3, "friend", 1], [3, "friend", 2], [3, "name", "Oleg"]], d.q(q, db));
-  
-  db = d.db_with(db0, [{"email": "@2", "_profile": {"name": "Igor"}}]);
-  assert_eq_set([[1, "email", "@2"], [2, "name", "Igor"], [2, "profile", 1]], d.q(q, db));
-  
-  db0 = d.empty_db({"user/profile": {":db/valueType": ":db.type/ref"}});
-  db = d.db_with(db0, [{"name": "Igor", "user/profile": {"email": "@2"} }]);
-  assert_eq_set([[1, "name", "Igor"], [1, "user/profile", 2], [2, "email", "@2"]], d.q(q, db));
-  
-  db = d.db_with(db0, [{"email": "@2", "user/_profile": {"name": "Igor"}}]);
-  assert_eq_set([[1, "email", "@2"], [2, "name", "Igor"], [2, "user/profile", 1]], d.q(q, db));
-}
-
-function test_init_db() {
-  var q = '[:find ?n ?a ?tx :where [?e "name" ?n ?tx] [?e "age" ?a]]'; 
-  var db_ok = function(db) {
-    assert_eq_set([["Ivan", 17, tx0],
-                   ["Igor", 35, tx0+1]],
-                  d.q(q, db));
-  };
-  db_ok(d.init_db([[1, "name", "Ivan"],
-                   [1, "age", 17],
-                   [2, "name", "Igor", tx0+1],
-                   [2, "age", 35, tx0+1]]));
-  db_ok(d.init_db([{e: 1, a: "name", v: "Ivan"},
-                   {e: 1, a: "age", v: 17},
-                   {e: 2, a: "name", v: "Igor", tx: tx0+1},
-                   {e: 2, a: "age", v: 35, tx: tx0+1}]));
-  var db = d.init_db([[1, "aka", "X"],
-                      [1, "aka", "Y"]],
-                     {"aka": {":db/cardinality": ":db.cardinality/many"}});
-  assert_eq_set(["X", "Y"], d.q('[:find [?aka ...] :where [_ "aka" ?aka]]', db));
-}
-
-function test_dbfn_call() {
-  var dbfn = function(db, e, n, a) { 
-    return [[":db/add", e, "name", n],
-            [":db/add", e, "age", a]]; 
-  }
-  var db = d.db_with(d.empty_db(), [[":db.fn/call", dbfn, 1, "Ilya", 44]]);
-  var q = '[:find ?n ?a :where [?e "name" ?n] [?e "age" ?a]]'; 
-  assert_eq_set([["Ilya", 44]], d.q(q, db));
-}
-
-function test_schema() {
-  var schema = {"aka": {":db/cardinality": ":db.cardinality/many"}};
-  var db = d.db_with(d.empty_db(schema), 
-                         [[":db/add", -1, "name", "Ivan"],
-                          [":db/add", -1, "aka", "X"],
-                          [":db/add", -1, "aka", "Y"],
-                          {":db/id": -2,
-                           "name": "Igor",
-                           "aka": ["F", "G"]}]);
-  var q = '[:find ?aka :in $ ?e :where [?e "aka" ?aka]]'; 
-  assert_eq_set([["X"], ["Y"]], d.q(q, db, 1));
-  assert_eq_set([["F"], ["G"]], d.q(q, db, 2));
-}
-
-function test_tuple() {
-  var schema = {"a+b+c": {":db/tupleAttrs": ["a", "b", "c"]}};
-  var db = d.db_with(d.empty_db(schema), 
-                         [[":db/add", 1, "a", "A"],
-                          [":db/add", 1, "b", "B"],
-                          [":db/add", 1, "c", "C"]]);
-  var q = '[:find ?e ?a+b+c :in $ :where [?e "a+b+c" ?a+b+c]]';
-  assert_eq_set([[1, ["A", "B", "C"]]], d.q(q, db));
-}
-
-function test_tx_report() {
-  var conn = d.create_conn();
-  var log = [];
-  var meta = [];
-  d.listen(conn, function(report) { log.push(report.tx_data); 
-                                    meta.push(report.tx_meta); });
-  var tx_report = d.transact(conn, [[":db/add", -1, "name", "Ivan"],
-                                    [":db/add", -1, "age", 17]], {"some-meta": 1});
-  assert_eq_datoms([[1, "name", "Ivan", tx0+1],
-                    [1, "age", 17, tx0+1]],
-                   tx_report.tx_data);
-  assert_eq({"-1": 1, ":db/current-tx": tx0+1}, tx_report.tempids);
-  assert_eq(1, d.resolve_tempid(tx_report.tempids, -1));
-  assert_eq(tx0+1, d.resolve_tempid(tx_report.tempids, ":db/current-tx"));
-  assert_eq_datoms([[1, "name", "Ivan", tx0+1],
-                    [1, "age", 17, tx0+1]],
-                    log[0]);
-  assert_eq(tx_report.tx_meta, {"some-meta": 1});
-  assert_eq(meta[0], {"some-meta": 1});
-}
-
-function test_conn() {
-  var datoms = [[1, "age",  17, tx0+1],
-                [1, "name", "Ivan", tx0+1]];
-  var conn = d.conn_from_datoms(datoms);
-  assert_eq_datoms(datoms, d.datoms(d.db(conn), ":eavt"));
-  
-  conn = d.conn_from_db(d.init_db(datoms));
-  assert_eq_datoms(datoms, d.datoms(d.db(conn), ":eavt"));
-  
-  var datoms2 = [[1, "age",  20, tx0+1],
-                 [1, "sex", "male", tx0+1]];
-  d.reset_conn(conn, d.init_db(datoms2));
-  assert_eq_datoms(datoms2, d.datoms(d.db(conn), ":eavt"));
-}
-
-function test_entity() {
-  var schema = {"aka": {":db/cardinality": ":db.cardinality/many"}};
-  var db = d.db_with(d.empty_db(schema), 
-                         [{":db/id": 1,
-                           "name": "Ivan",
-                           "aka": ["X", "Y"]},
-                          {":db/id": 2}]);
-  var e = d.entity(db, 1);
-  assert_eq("Ivan",     e.get("name"));
-  assert_eq(["X", "Y"], e.get("aka"));
-  assert_eq(1,          e.get(":db/id"));
-  
-  assert_ident(db, e.db);
-  
-  var e2 = d.entity(db, 2);
-  assert_eq(null, e2);
-
-  // js interop
-  assert_eq_set(["name", "aka"], e.key_set());
-  assert_eq_set(["Ivan", ["X", "Y"]], e.value_set());
-  assert_eq_set([["name", "Ivan"], ["aka", ["X", "Y"]]], e.entry_set());
-  
-  var foreach = [];
-  e.forEach(function(v, a) { foreach.push([a,v]); });
-  assert_eq_set([["name", "Ivan"], ["aka", ["X", "Y"]]], foreach);
-  
-  foreach = [];
-  e.forEach(function(v, a) { this.push([a,v]); }, foreach);
-  assert_eq_set([["name", "Ivan"], ["aka", ["X", "Y"]]], foreach);
-  
-  // js/map interfaces
-  assert_eq_iter_set(["name", "aka"], e.keys());
-  assert_eq_iter_set(["Ivan", ["X", "Y"]], e.values());
-  assert_eq_iter_set([["name", "Ivan"], ["aka", ["X", "Y"]]], e.entries());
-}
-
-function test_entity_refs() {
-  var schema = {"father":   {":db/valueType":   ":db.type/ref"},
-                "children": {":db/valueType":   ":db.type/ref",
-                             ":db/cardinality": ":db.cardinality/many"}};
-  var db = d.db_with(d.empty_db(schema), 
-                         [{":db/id": 1,   "children": [10]},
-                          {":db/id": 10,  "father":   1, "children": [100, 101]},
-                          {":db/id": 100, "father":   10},
-                          {":db/id": 101, "father":   10}]);
-  
-  var e = function(id) { return d.entity(db, id); };
-  assert_eq_refs([10], e(1).get("children"));
-  assert_eq_refs([101, 100], e(10).get("children"));
-  
-  // empty attribute
-  assert_eq(null, e(100).get("children"));
-  
-  // nested navigation
-  assert_eq_refs([100, 101], e(1).get("children")[0].get("children"));
-  assert_eq     (10,         e(10).get("children")[0].get("father").get(":db/id"));
-  assert_eq_refs([10],       e(10).get("father").get("children"));
-  
-  // backward navigation
-  assert_eq     (null,       e(1).get("_children"));
-  assert_eq_refs([10],       e(1).get("_father"));
-  assert_eq_refs([1],        e(10).get("_children"));
-  assert_eq_refs([100, 101], e(10).get("_father"));
-  assert_eq_refs([1],        e(100).get("_children")[0].get("_children"));
-}
-
-function test_entity_iterators() {
-  var schema = {"aka": {":db/cardinality": ":db.cardinality/many"}};
-  var db = d.db_with(d.empty_db(schema),
-                         [{":db/id": 1,
-                           "name": "Ivan",
-                           "aka": ["X", "Y"]},
-                          {":db/id": 2}]);
-  var e = d.entity(db, 1);
-  var keys = [...e.keys()];
-  assert_eq_set(["name", "aka"], keys);
-  var values = [...e.values()];
-  assert_eq_set(["Ivan", ["X", "Y"]], values);
-  var entries = [...e.entries()];
-  assert_eq_set([["name", "Ivan"], ["aka", ["X", "Y"]]], entries);
-  var entries2 = [...e];
-  assert_eq_set(entries, entries2);
-}
-
-function test_pull() {
-  var schema = {"father":   {":db/valueType":   ":db.type/ref"},
-                "children": {":db/valueType":   ":db.type/ref",
-                             ":db/cardinality": ":db.cardinality/many"}};
-  var db = d.db_with(d.empty_db(schema),
-                         [{":db/id": 1,   "name": "Ivan", "children": [10]},
-                          {":db/id": 10,  "father":   1, "children": [100, 101]},
-                          {":db/id": 100, "father":   10},
-                          {":db/id": 101, "father":   10}]);
-
-  var actual, expected;
-
-  actual   = d.pull(db, '["children"]', 1);
-  expected = {"children": [{":db/id": 10}]};
-  assert_eq(expected, actual);
-
-  actual   = d.pull(db, '["children", {"father" ["name" :db/id]}]', 10);
-  expected = {"children": [{":db/id": 100}, {":db/id": 101}],
-              "father": {"name": "Ivan", ":db/id": 1}};
-  assert_eq(expected, actual);
-}
-
-function test_lookup_refs() {
-  var schema = {"name": {":db/unique": ":db.unique/identity"}};
-  var db = d.db_with(d.empty_db(schema),
-                     [{":db/id": 1, "name": "Ivan", "age": 18},
-                      {":db/id": 2, "name": "Oleg", "age": 32}]);
-  // entity
-  assert_eq("Ivan", d.entity(db, ["name", "Ivan"]).get("name"));
-  // pull
-  assert_eq({"name": "Ivan"}, d.pull(db, '["name"]', ["name", "Ivan"]));
-  assert_eq_set(
-    [{"name": "Ivan"}, {"name": "Oleg"}],
-    d.pull_many(db, '["name"]', [["name", "Ivan"], ["name", "Oleg"]])
-  );
-  // index access
-  assert_eq_datoms([[1, "age", 18, tx0+1],
-                    [1, "name", "Ivan", tx0+1]],
-                   d.datoms(db, ":eavt", ["name", "Ivan"]));
-  // queries
-  assert_eq([[["name", "Ivan"], 18]], 
-            d.q('[:find ?e ?a\
-                  :in $ ?e \
-                  :where [?e "age" ?a]]', db, ["name", "Ivan"]));
-}
-
-function test_resolve_current_tx() {
-  var schema = {"created-at": {":db/valueType": ":db.type/ref"}};
-  var conn = d.create_conn(schema);
-  var tx_report = d.transact(conn, [{"name": "X", "created-at": ":db/current-tx"},
-                                    {":db/id": ":db/current-tx", "prop1": "val1"},
-                                    [":db/add", ":db/current-tx", "prop2", "val2"],
-                                    [":db/add", -1, "name", "Y"],
-                                    [":db/add", -1, "created-at", ":db/current-tx"]]);
-  var tx = tx_report.tempids[":db/current-tx"];
-  assert_eq(tx0+1, tx);
-  assert_eq_datoms(
-    [[1, "created-at", tx,     tx],
-     [1, "name",       "X",    tx],
-     [2, "created-at", tx,     tx],
-     [2, "name",       "Y",    tx],
-     [tx, "prop1",     "val1", tx],
-     [tx, "prop2",     "val2", tx]],
-    d.datoms(d.db(conn), ":eavt"));
-}
-
-
-var people_db = d.db_with(d.empty_db({"age": {":db/index": true}}),
-                 [{ ":db/id": 1, "name": "Ivan", "age": 15 },
-                  { ":db/id": 2, "name": "Petr", "age": 37 },
-                  { ":db/id": 3, "name": "Ivan", "age": 37 }]);
-
-function test_q_coll() {
-  assert_eq_set([[1, "Ivan"], [2, "Petr"], [3, "Ivan"]],
-                d.q('[:find ?e ?name \
-                      :in   $ [?name ...] \
-                      :where [?e "name" ?name]]',
-                    people_db,
-                    ["Ivan", "Petr"]));
-  
-  assert_eq_set([[1], [2]],
-                d.q('[:find ?x \
-                      :in   [?x ...] \
-                      :where [(pos? ?x)]]',
-                    [-2, -1, 0, 1, 2]));
-}
-
-function test_q_relation() {
-  var res = d.q('[:find ?e ?email \
-                  :in    $ $b \
-                  :where [?e "name" ?n] \
-                         [$b ?n ?email]]',
-                people_db,
-               [["Ivan", "ivan@mail.ru"],
-                ["Petr", "petr@gmail.com"]]);
-  assert_eq_set([[1, "ivan@mail.ru"], [2, "petr@gmail.com"], [3, "ivan@mail.ru"]], res);
-
-  res     = d.q('[:find ?e ?email \
-                  :in    $ [[?n ?email]] \
-                  :where [?e "name" ?n]]',
-                people_db,
-               [["Ivan", "ivan@mail.ru"],
-                ["Petr", "petr@gmail.com"]]);
-  assert_eq_set([[1, "ivan@mail.ru"], [2, "petr@gmail.com"], [3, "ivan@mail.ru"]], res);
-}
-
-function test_q_rules() {
-  var res = d.q('[:find ?e1 ?e2 \
-                  :in    $ % \
-                  :where (mate ?e1 ?e2) \
-                         [(< ?e1 ?e2)]]',
-                people_db,
-                '[[(mate ?e1 ?e2)   \
-                   [?e1 "name" ?n]  \
-                   [?e2 "name" ?n]] \
-                  [(mate ?e1 ?e2)   \
-                   [?e1 "age" ?a]   \
-                   [?e2 "age" ?a]]]');
-  assert_eq_set([[1, 3], [2, 3]], res);
-}
-
-function test_q_fns() {
-  var res = d.q('[:find ?e \
-                  :in    $ ?adult \
-                  :where [?e "age" ?a] \
-                         [(?adult ?a)]]',
-                people_db,
-                function(a) { return a > 18; });
-  assert_eq_set([[2], [3]], res);
-}
-
-function test_find_specs() {
-  var res = d.q('[:find [?name ...] \
-                  :where [_ "name" ?name]]',
-                people_db);
-  assert_eq(["Ivan", "Petr"], res);
-  
-  var res = d.q('[:find [?name ?age] \
-                  :where [1 "name" ?name] \
-                         [1 "age" ?age]]',
-                people_db);
-  assert_eq(["Ivan", 15], res);
-  
-  var res = d.q('[:find ?name . \
-                  :where [1 "name" ?name]]',
-                people_db);
-  assert_eq("Ivan", res);
-}
-
-function test_datoms() {
-  assert_eq_datoms([[1, "age", 15, tx0+1],
-                    [1, "name", "Ivan", tx0+1]],
-                   d.datoms(people_db, ":eavt", 1));
-  
-  assert_eq_datoms([[1, "age", 15, tx0+1]],
-                   d.datoms(people_db, ":eavt", 1, "age"));
-  
-  assert_eq_datoms([[2, "age", 37, tx0+1],
-                    [3, "age", 37, tx0+1]],
-                   d.seek_datoms(people_db, ":avet", "age", 20));
-}
-
-function test_filter() {
-  assert_eq_set([[1, "name", "Ivan"],
-                 [2, "name", "Petr"],
-                 [3, "name", "Ivan"]],
-                d.q("[:find ?e ?a ?v :where [?e ?a ?v]]",
-                    d.filter(people_db,
-                             function(db,datom) { return datom.a == "name"; })));
-  
-  assert_eq_set([[1, "name", "Ivan"],
-                 [1, "age", 15]],
-                d.q("[:find ?e ?a ?v :where [?e ?a ?v]]",
-                    d.filter(people_db,
-                             function(db,datom) { 
-                               var entity = d.entity(db, datom.e);
-                               return entity.get("age") <= 18;
-                             })));
-}
-
-function test_upsert() {
-  var schema = {
-    ":my/tid": {
-      ":db/unique": ":db.unique/identity"
-    }
-  };
-  var conn = d.create_conn(schema);
-  d.transact(conn, [{
-    ":my/tid": "5x",
-    ":my/name": "Terin"
-  }]);
-
-  d.transact(conn, [{
-    ":my/tid": "5x",
-    ":my/name": "Charlie"
-  }]);
-
-  var names = d.q('[:find ?name :where [?e ":my/tid" "5x"] [?e ":my/name" ?name]]', d.db(conn));
-  assert_eq_set([["Charlie"]], names);
-}
-
-function test_serialize() {
-  var schema = {
-    ":my/tid": {
-      ":db/unique": ":db.unique/identity"
-    }
-  };
-  var conn = d.create_conn(schema);
-  d.transact(conn, [{":my/email": "a", ":my/name": "A"}]);
-  d.transact(conn, [{":my/email": "b", ":my/name": "B"}]);
-  var db = d.db(conn);
-
-  assert_eq_set(
-    [[1, ":my/email", "a"], [1, ":my/name", "A"], [2, ":my/email", "b"], [2, ":my/name", "B"]],
-    d.q('[:find ?e ?a ?v :where [?e ?a ?v]]', db)
-  );
-
-  var json = JSON.stringify(d.serializable(db));
-  var db2 = d.from_serializable(JSON.parse(json));
-
-  assert_eq_set(
-    [[1, ":my/email", "a"], [1, ":my/name", "A"], [2, ":my/email", "b"], [2, ":my/name", "B"]],
-    d.q('[:find ?e ?a ?v :where [?e ?a ?v]]', db2)
-  );
-
-  assert_eq_set(
-    [[1, "A"], [2, "B"]],
-    d.q('[:find ?e ?v :where [?e ":my/name" ?v]]', db2)
-  );
-}
-
-
-function test_datascript_js() {
-  return test_fns([ test_db_with,
-                    test_nested_maps,
-                    test_init_db,
-                    test_dbfn_call,
-                    test_schema,
-                    test_tuple,
-                    test_tx_report,
-                    test_conn,
-                    test_entity,
-                    test_entity_refs,
-                    test_entity_iterators,
-                    test_pull,
-                    test_lookup_refs,
-                    test_resolve_current_tx,
-                    test_q_coll,
-                    test_q_relation,
-                    test_q_rules,
-                    test_q_fns,
-                    test_find_specs,
-                    test_datoms,
-                    test_filter,
-                    test_upsert,
-                    test_serialize,
-                  ]);
-}
-
-module.exports = { "test_all": test_datascript_js };
diff --git a/test/js/underscore-1.6.0.min.js b/test/js/underscore-1.6.0.min.js
deleted file mode 100644
index 3434d6c5..00000000
--- a/test/js/underscore-1.6.0.min.js
+++ /dev/null
@@ -1,6 +0,0 @@
-//     Underscore.js 1.6.0
-//     http://underscorejs.org
-//     (c) 2009-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
-//     Underscore may be freely distributed under the MIT license.
-(function(){var n=this,t=n._,r={},e=Array.prototype,u=Object.prototype,i=Function.prototype,a=e.push,o=e.slice,c=e.concat,l=u.toString,f=u.hasOwnProperty,s=e.forEach,p=e.map,h=e.reduce,v=e.reduceRight,g=e.filter,d=e.every,m=e.some,y=e.indexOf,b=e.lastIndexOf,x=Array.isArray,w=Object.keys,_=i.bind,j=function(n){return n instanceof j?n:this instanceof j?void(this._wrapped=n):new j(n)};"undefined"!=typeof exports?("undefined"!=typeof module&&module.exports&&(exports=module.exports=j),exports._=j):n._=j,j.VERSION="1.6.0";var A=j.each=j.forEach=function(n,t,e){if(null==n)return n;if(s&&n.forEach===s)n.forEach(t,e);else if(n.length===+n.length){for(var u=0,i=n.length;i>u;u++)if(t.call(e,n[u],u,n)===r)return}else for(var a=j.keys(n),u=0,i=a.length;i>u;u++)if(t.call(e,n[a[u]],a[u],n)===r)return;return n};j.map=j.collect=function(n,t,r){var e=[];return null==n?e:p&&n.map===p?n.map(t,r):(A(n,function(n,u,i){e.push(t.call(r,n,u,i))}),e)};var O="Reduce of empty array with no initial value";j.reduce=j.foldl=j.inject=function(n,t,r,e){var u=arguments.length>2;if(null==n&&(n=[]),h&&n.reduce===h)return e&&(t=j.bind(t,e)),u?n.reduce(t,r):n.reduce(t);if(A(n,function(n,i,a){u?r=t.call(e,r,n,i,a):(r=n,u=!0)}),!u)throw new TypeError(O);return r},j.reduceRight=j.foldr=function(n,t,r,e){var u=arguments.length>2;if(null==n&&(n=[]),v&&n.reduceRight===v)return e&&(t=j.bind(t,e)),u?n.reduceRight(t,r):n.reduceRight(t);var i=n.length;if(i!==+i){var a=j.keys(n);i=a.length}if(A(n,function(o,c,l){c=a?a[--i]:--i,u?r=t.call(e,r,n[c],c,l):(r=n[c],u=!0)}),!u)throw new TypeError(O);return r},j.find=j.detect=function(n,t,r){var e;return k(n,function(n,u,i){return t.call(r,n,u,i)?(e=n,!0):void 0}),e},j.filter=j.select=function(n,t,r){var e=[];return null==n?e:g&&n.filter===g?n.filter(t,r):(A(n,function(n,u,i){t.call(r,n,u,i)&&e.push(n)}),e)},j.reject=function(n,t,r){return j.filter(n,function(n,e,u){return!t.call(r,n,e,u)},r)},j.every=j.all=function(n,t,e){t||(t=j.identity);var u=!0;return null==n?u:d&&n.every===d?n.every(t,e):(A(n,function(n,i,a){return(u=u&&t.call(e,n,i,a))?void 0:r}),!!u)};var k=j.some=j.any=function(n,t,e){t||(t=j.identity);var u=!1;return null==n?u:m&&n.some===m?n.some(t,e):(A(n,function(n,i,a){return u||(u=t.call(e,n,i,a))?r:void 0}),!!u)};j.contains=j.include=function(n,t){return null==n?!1:y&&n.indexOf===y?n.indexOf(t)!=-1:k(n,function(n){return n===t})},j.invoke=function(n,t){var r=o.call(arguments,2),e=j.isFunction(t);return j.map(n,function(n){return(e?t:n[t]).apply(n,r)})},j.pluck=function(n,t){return j.map(n,j.property(t))},j.where=function(n,t){return j.filter(n,j.matches(t))},j.findWhere=function(n,t){return j.find(n,j.matches(t))},j.max=function(n,t,r){if(!t&&j.isArray(n)&&n[0]===+n[0]&&n.length<65535)return Math.max.apply(Math,n);var e=-1/0,u=-1/0;return A(n,function(n,i,a){var o=t?t.call(r,n,i,a):n;o>u&&(e=n,u=o)}),e},j.min=function(n,t,r){if(!t&&j.isArray(n)&&n[0]===+n[0]&&n.length<65535)return Math.min.apply(Math,n);var e=1/0,u=1/0;return A(n,function(n,i,a){var o=t?t.call(r,n,i,a):n;u>o&&(e=n,u=o)}),e},j.shuffle=function(n){var t,r=0,e=[];return A(n,function(n){t=j.random(r++),e[r-1]=e[t],e[t]=n}),e},j.sample=function(n,t,r){return null==t||r?(n.length!==+n.length&&(n=j.values(n)),n[j.random(n.length-1)]):j.shuffle(n).slice(0,Math.max(0,t))};var E=function(n){return null==n?j.identity:j.isFunction(n)?n:j.property(n)};j.sortBy=function(n,t,r){return t=E(t),j.pluck(j.map(n,function(n,e,u){return{value:n,index:e,criteria:t.call(r,n,e,u)}}).sort(function(n,t){var r=n.criteria,e=t.criteria;if(r!==e){if(r>e||r===void 0)return 1;if(e>r||e===void 0)return-1}return n.index-t.index}),"value")};var F=function(n){return function(t,r,e){var u={};return r=E(r),A(t,function(i,a){var o=r.call(e,i,a,t);n(u,o,i)}),u}};j.groupBy=F(function(n,t,r){j.has(n,t)?n[t].push(r):n[t]=[r]}),j.indexBy=F(function(n,t,r){n[t]=r}),j.countBy=F(function(n,t){j.has(n,t)?n[t]++:n[t]=1}),j.sortedIndex=function(n,t,r,e){r=E(r);for(var u=r.call(e,t),i=0,a=n.length;a>i;){var o=i+a>>>1;r.call(e,n[o])<u?i=o+1:a=o}return i},j.toArray=function(n){return n?j.isArray(n)?o.call(n):n.length===+n.length?j.map(n,j.identity):j.values(n):[]},j.size=function(n){return null==n?0:n.length===+n.length?n.length:j.keys(n).length},j.first=j.head=j.take=function(n,t,r){return null==n?void 0:null==t||r?n[0]:0>t?[]:o.call(n,0,t)},j.initial=function(n,t,r){return o.call(n,0,n.length-(null==t||r?1:t))},j.last=function(n,t,r){return null==n?void 0:null==t||r?n[n.length-1]:o.call(n,Math.max(n.length-t,0))},j.rest=j.tail=j.drop=function(n,t,r){return o.call(n,null==t||r?1:t)},j.compact=function(n){return j.filter(n,j.identity)};var M=function(n,t,r){return t&&j.every(n,j.isArray)?c.apply(r,n):(A(n,function(n){j.isArray(n)||j.isArguments(n)?t?a.apply(r,n):M(n,t,r):r.push(n)}),r)};j.flatten=function(n,t){return M(n,t,[])},j.without=function(n){return j.difference(n,o.call(arguments,1))},j.partition=function(n,t){var r=[],e=[];return A(n,function(n){(t(n)?r:e).push(n)}),[r,e]},j.uniq=j.unique=function(n,t,r,e){j.isFunction(t)&&(e=r,r=t,t=!1);var u=r?j.map(n,r,e):n,i=[],a=[];return A(u,function(r,e){(t?e&&a[a.length-1]===r:j.contains(a,r))||(a.push(r),i.push(n[e]))}),i},j.union=function(){return j.uniq(j.flatten(arguments,!0))},j.intersection=function(n){var t=o.call(arguments,1);return j.filter(j.uniq(n),function(n){return j.every(t,function(t){return j.contains(t,n)})})},j.difference=function(n){var t=c.apply(e,o.call(arguments,1));return j.filter(n,function(n){return!j.contains(t,n)})},j.zip=function(){for(var n=j.max(j.pluck(arguments,"length").concat(0)),t=new Array(n),r=0;n>r;r++)t[r]=j.pluck(arguments,""+r);return t},j.object=function(n,t){if(null==n)return{};for(var r={},e=0,u=n.length;u>e;e++)t?r[n[e]]=t[e]:r[n[e][0]]=n[e][1];return r},j.indexOf=function(n,t,r){if(null==n)return-1;var e=0,u=n.length;if(r){if("number"!=typeof r)return e=j.sortedIndex(n,t),n[e]===t?e:-1;e=0>r?Math.max(0,u+r):r}if(y&&n.indexOf===y)return n.indexOf(t,r);for(;u>e;e++)if(n[e]===t)return e;return-1},j.lastIndexOf=function(n,t,r){if(null==n)return-1;var e=null!=r;if(b&&n.lastIndexOf===b)return e?n.lastIndexOf(t,r):n.lastIndexOf(t);for(var u=e?r:n.length;u--;)if(n[u]===t)return u;return-1},j.range=function(n,t,r){arguments.length<=1&&(t=n||0,n=0),r=arguments[2]||1;for(var e=Math.max(Math.ceil((t-n)/r),0),u=0,i=new Array(e);e>u;)i[u++]=n,n+=r;return i};var R=function(){};j.bind=function(n,t){var r,e;if(_&&n.bind===_)return _.apply(n,o.call(arguments,1));if(!j.isFunction(n))throw new TypeError;return r=o.call(arguments,2),e=function(){if(!(this instanceof e))return n.apply(t,r.concat(o.call(arguments)));R.prototype=n.prototype;var u=new R;R.prototype=null;var i=n.apply(u,r.concat(o.call(arguments)));return Object(i)===i?i:u}},j.partial=function(n){var t=o.call(arguments,1);return function(){for(var r=0,e=t.slice(),u=0,i=e.length;i>u;u++)e[u]===j&&(e[u]=arguments[r++]);for(;r<arguments.length;)e.push(arguments[r++]);return n.apply(this,e)}},j.bindAll=function(n){var t=o.call(arguments,1);if(0===t.length)throw new Error("bindAll must be passed function names");return A(t,function(t){n[t]=j.bind(n[t],n)}),n},j.memoize=function(n,t){var r={};return t||(t=j.identity),function(){var e=t.apply(this,arguments);return j.has(r,e)?r[e]:r[e]=n.apply(this,arguments)}},j.delay=function(n,t){var r=o.call(arguments,2);return setTimeout(function(){return n.apply(null,r)},t)},j.defer=function(n){return j.delay.apply(j,[n,1].concat(o.call(arguments,1)))},j.throttle=function(n,t,r){var e,u,i,a=null,o=0;r||(r={});var c=function(){o=r.leading===!1?0:j.now(),a=null,i=n.apply(e,u),e=u=null};return function(){var l=j.now();o||r.leading!==!1||(o=l);var f=t-(l-o);return e=this,u=arguments,0>=f?(clearTimeout(a),a=null,o=l,i=n.apply(e,u),e=u=null):a||r.trailing===!1||(a=setTimeout(c,f)),i}},j.debounce=function(n,t,r){var e,u,i,a,o,c=function(){var l=j.now()-a;t>l?e=setTimeout(c,t-l):(e=null,r||(o=n.apply(i,u),i=u=null))};return function(){i=this,u=arguments,a=j.now();var l=r&&!e;return e||(e=setTimeout(c,t)),l&&(o=n.apply(i,u),i=u=null),o}},j.once=function(n){var t,r=!1;return function(){return r?t:(r=!0,t=n.apply(this,arguments),n=null,t)}},j.wrap=function(n,t){return j.partial(t,n)},j.compose=function(){var n=arguments;return function(){for(var t=arguments,r=n.length-1;r>=0;r--)t=[n[r].apply(this,t)];return t[0]}},j.after=function(n,t){return function(){return--n<1?t.apply(this,arguments):void 0}},j.keys=function(n){if(!j.isObject(n))return[];if(w)return w(n);var t=[];for(var r in n)j.has(n,r)&&t.push(r);return t},j.values=function(n){for(var t=j.keys(n),r=t.length,e=new Array(r),u=0;r>u;u++)e[u]=n[t[u]];return e},j.pairs=function(n){for(var t=j.keys(n),r=t.length,e=new Array(r),u=0;r>u;u++)e[u]=[t[u],n[t[u]]];return e},j.invert=function(n){for(var t={},r=j.keys(n),e=0,u=r.length;u>e;e++)t[n[r[e]]]=r[e];return t},j.functions=j.methods=function(n){var t=[];for(var r in n)j.isFunction(n[r])&&t.push(r);return t.sort()},j.extend=function(n){return A(o.call(arguments,1),function(t){if(t)for(var r in t)n[r]=t[r]}),n},j.pick=function(n){var t={},r=c.apply(e,o.call(arguments,1));return A(r,function(r){r in n&&(t[r]=n[r])}),t},j.omit=function(n){var t={},r=c.apply(e,o.call(arguments,1));for(var u in n)j.contains(r,u)||(t[u]=n[u]);return t},j.defaults=function(n){return A(o.call(arguments,1),function(t){if(t)for(var r in t)n[r]===void 0&&(n[r]=t[r])}),n},j.clone=function(n){return j.isObject(n)?j.isArray(n)?n.slice():j.extend({},n):n},j.tap=function(n,t){return t(n),n};var S=function(n,t,r,e){if(n===t)return 0!==n||1/n==1/t;if(null==n||null==t)return n===t;n instanceof j&&(n=n._wrapped),t instanceof j&&(t=t._wrapped);var u=l.call(n);if(u!=l.call(t))return!1;switch(u){case"[object String]":return n==String(t);case"[object Number]":return n!=+n?t!=+t:0==n?1/n==1/t:n==+t;case"[object Date]":case"[object Boolean]":return+n==+t;case"[object RegExp]":return n.source==t.source&&n.global==t.global&&n.multiline==t.multiline&&n.ignoreCase==t.ignoreCase}if("object"!=typeof n||"object"!=typeof t)return!1;for(var i=r.length;i--;)if(r[i]==n)return e[i]==t;var a=n.constructor,o=t.constructor;if(a!==o&&!(j.isFunction(a)&&a instanceof a&&j.isFunction(o)&&o instanceof o)&&"constructor"in n&&"constructor"in t)return!1;r.push(n),e.push(t);var c=0,f=!0;if("[object Array]"==u){if(c=n.length,f=c==t.length)for(;c--&&(f=S(n[c],t[c],r,e)););}else{for(var s in n)if(j.has(n,s)&&(c++,!(f=j.has(t,s)&&S(n[s],t[s],r,e))))break;if(f){for(s in t)if(j.has(t,s)&&!c--)break;f=!c}}return r.pop(),e.pop(),f};j.isEqual=function(n,t){return S(n,t,[],[])},j.isEmpty=function(n){if(null==n)return!0;if(j.isArray(n)||j.isString(n))return 0===n.length;for(var t in n)if(j.has(n,t))return!1;return!0},j.isElement=function(n){return!(!n||1!==n.nodeType)},j.isArray=x||function(n){return"[object Array]"==l.call(n)},j.isObject=function(n){return n===Object(n)},A(["Arguments","Function","String","Number","Date","RegExp"],function(n){j["is"+n]=function(t){return l.call(t)=="[object "+n+"]"}}),j.isArguments(arguments)||(j.isArguments=function(n){return!(!n||!j.has(n,"callee"))}),"function"!=typeof/./&&(j.isFunction=function(n){return"function"==typeof n}),j.isFinite=function(n){return isFinite(n)&&!isNaN(parseFloat(n))},j.isNaN=function(n){return j.isNumber(n)&&n!=+n},j.isBoolean=function(n){return n===!0||n===!1||"[object Boolean]"==l.call(n)},j.isNull=function(n){return null===n},j.isUndefined=function(n){return n===void 0},j.has=function(n,t){return f.call(n,t)},j.noConflict=function(){return n._=t,this},j.identity=function(n){return n},j.constant=function(n){return function(){return n}},j.property=function(n){return function(t){return t[n]}},j.matches=function(n){return function(t){if(t===n)return!0;for(var r in n)if(n[r]!==t[r])return!1;return!0}},j.times=function(n,t,r){for(var e=Array(Math.max(0,n)),u=0;n>u;u++)e[u]=t.call(r,u);return e},j.random=function(n,t){return null==t&&(t=n,n=0),n+Math.floor(Math.random()*(t-n+1))},j.now=Date.now||function(){return(new Date).getTime()};var T={escape:{"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#x27;"}};T.unescape=j.invert(T.escape);var I={escape:new RegExp("["+j.keys(T.escape).join("")+"]","g"),unescape:new RegExp("("+j.keys(T.unescape).join("|")+")","g")};j.each(["escape","unescape"],function(n){j[n]=function(t){return null==t?"":(""+t).replace(I[n],function(t){return T[n][t]})}}),j.result=function(n,t){if(null==n)return void 0;var r=n[t];return j.isFunction(r)?r.call(n):r},j.mixin=function(n){A(j.functions(n),function(t){var r=j[t]=n[t];j.prototype[t]=function(){var n=[this._wrapped];return a.apply(n,arguments),z.call(this,r.apply(j,n))}})};var N=0;j.uniqueId=function(n){var t=++N+"";return n?n+t:t},j.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g};var q=/(.)^/,B={"'":"'","\\":"\\","\r":"r","\n":"n","	":"t","\u2028":"u2028","\u2029":"u2029"},D=/\\|'|\r|\n|\t|\u2028|\u2029/g;j.template=function(n,t,r){var e;r=j.defaults({},r,j.templateSettings);var u=new RegExp([(r.escape||q).source,(r.interpolate||q).source,(r.evaluate||q).source].join("|")+"|$","g"),i=0,a="__p+='";n.replace(u,function(t,r,e,u,o){return a+=n.slice(i,o).replace(D,function(n){return"\\"+B[n]}),r&&(a+="'+\n((__t=("+r+"))==null?'':_.escape(__t))+\n'"),e&&(a+="'+\n((__t=("+e+"))==null?'':__t)+\n'"),u&&(a+="';\n"+u+"\n__p+='"),i=o+t.length,t}),a+="';\n",r.variable||(a="with(obj||{}){\n"+a+"}\n"),a="var __t,__p='',__j=Array.prototype.join,"+"print=function(){__p+=__j.call(arguments,'');};\n"+a+"return __p;\n";try{e=new Function(r.variable||"obj","_",a)}catch(o){throw o.source=a,o}if(t)return e(t,j);var c=function(n){return e.call(this,n,j)};return c.source="function("+(r.variable||"obj")+"){\n"+a+"}",c},j.chain=function(n){return j(n).chain()};var z=function(n){return this._chain?j(n).chain():n};j.mixin(j),A(["pop","push","reverse","shift","sort","splice","unshift"],function(n){var t=e[n];j.prototype[n]=function(){var r=this._wrapped;return t.apply(r,arguments),"shift"!=n&&"splice"!=n||0!==r.length||delete r[0],z.call(this,r)}}),A(["concat","join","slice"],function(n){var t=e[n];j.prototype[n]=function(){return z.call(this,t.apply(this._wrapped,arguments))}}),j.extend(j.prototype,{chain:function(){return this._chain=!0,this},value:function(){return this._wrapped}}),"function"==typeof define&&define.amd&&define("underscore",[],function(){return j})}).call(this);
-//# sourceMappingURL=underscore-min.map
\ No newline at end of file
diff --git a/test_datomic/datomic/extensions.edn b/test_datomic/datomic/extensions.edn
deleted file mode 100644
index fbb057a4..00000000
--- a/test_datomic/datomic/extensions.edn
+++ /dev/null
@@ -1 +0,0 @@
-{:xforms [clojure.core/first clojure.core/vector]}
\ No newline at end of file
diff --git a/test_datomic/test_datomic/pull_api.clj b/test_datomic/test_datomic/pull_api.clj
deleted file mode 100644
index 35f4ee97..00000000
--- a/test_datomic/test_datomic/pull_api.clj
+++ /dev/null
@@ -1,159 +0,0 @@
-(ns test-datomic.pull-api
-  "Mirrors dbval.test.pull-api with Datomic to check they behave the same"
-  (:require
-    [clojure.test :refer :all]
-    [datomic.api :as datomic]))
-
-(def ^:private test-schema
-  {:person/name   {:db/unique :db.unique/identity}
-   :person/aka    {:db/cardinality :db.cardinality/many}
-   :person/child  {:db/cardinality :db.cardinality/many
-                   :db/valueType   :db.type/ref}
-   :person/friend {:db/cardinality :db.cardinality/many
-                   :db/valueType   :db.type/ref}
-   :person/enemy  {:db/cardinality :db.cardinality/many
-                   :db/valueType   :db.type/ref}
-   :person/father {:db/valueType :db.type/ref}
-
-   :thing/name    {:db/unique :db.unique/identity}
-   :thing/part    {:db/valueType   :db.type/ref
-                   :db/isComponent true
-                   :db/cardinality :db.cardinality/many}
-   :thing/spec    {:db/valueType   :db.type/ref
-                   :db/isComponent true
-                   :db/cardinality :db.cardinality/one}})
-
-(defn- datomic-schema-attr [[name args]]
-  (merge
-    {:db/ident              name
-     :db/valueType          :db.type/string
-     :db/cardinality        :db.cardinality/one
-     :db.install/_attribute :db.part/db}
-    args))
-
-(def ^:private test-datomic-schema
-  (mapv datomic-schema-attr test-schema))
-
-(def tmpids (atom nil))
-
-(def test-data
-  [{:db/id        "petrid"
-    :person/name  "Petr"
-    :person/aka   ["Devil" "Tupen"]
-    :person/child [{:person/name "David"
-                    :person/father "petrid"}
-                   {:db/id       "thomasid"
-                    :person/name "Thomas"}]}
-   {:person/name "Lucy"}
-   {:person/name "Elizabeth"}
-   {:person/name "Mathew"
-    :person/father "thomasid"}
-   {:person/name "Eunan"}
-   {:person/name "Kerri"}
-   {:person/name "Rebecca"}
-   {:db/id "1" :person/name "1" :person/friend "2"}
-   {:db/id "2" :person/name "2" :person/enemy "3"}
-   {:db/id "3" :person/name "3" :person/friend "4"}
-   {:db/id "4" :person/name "4" :person/enemy "5"}
-   {:db/id "5" :person/name "5" :person/friend "6"}
-   {:db/id "6" :person/name "6" :person/enemy "7"}
-   {:db/id "7" :person/name "7" :person/friend "8"}
-   {:db/id "8" :person/name "8" :person/enemy "9"}
-   {:db/id "9" :person/name "9" :person/enemy "8"}
-   {:db/id "10" :person/name "10" :person/enemy "10"}
-   {:db/id "11" :person/name "11" :person/enemy ["11" "12"]}
-   {:db/id "12" :person/name "12" :person/enemy "13"}
-   {:db/id "13" :person/name "13" :person/enemy "14"}
-   {:db/id "14" :person/name "14" :person/enemy "15"}
-   {:db/id "15" :person/name "15"}
-
-   {:thing/name "Part A"
-    :thing/part [{:thing/name "Part A.A"
-                  :thing/part [{:thing/name "Part A.A.A"
-                                :thing/part [{:thing/name "Part A.A.A.A"}
-                                             {:thing/name "Part A.A.A.B"}]}
-                               {:thing/name "Part A.A.B"}]}
-                 {:thing/name "Part A.B"
-                  :thing/part [{:thing/name "Part A.B.A"
-                                :thing/part [{:thing/name "Part A.B.A.A"}
-                                             {:thing/name "Part A.B.A.B"}]}]}]}])
-
-(defn new-datomic-conn
-  ([] (new-datomic-conn "test"))
-  ([name]
-   (let [url (str "datomic:mem://" name)]
-     (datomic/delete-database url)
-     (datomic/create-database url)
-     (let [conn (datomic/connect url)]
-       @(datomic/transact conn (map datomic-schema-attr test-schema))
-       (reset! tmpids (:tempids @(datomic/transact conn test-data)))
-       conn))))
-
-(def ^:private test-datomic-db (datomic/db (new-datomic-conn)))
-
-(deftest test-pull-map
-  (is (= {:person/name "Petr"}
-        (datomic/pull test-datomic-db '[:person/name {:person/child [:not-an/attr]}] [:person/name "Petr"]))))
-
-(deftest test-pull-map-2
-  (testing "Map specs can override component expansion"
-    (let [parts {:thing/name "Part A"
-                 :thing/part [{:thing/name "Part A.A"}
-                              {:thing/name "Part A.B"}]}]
-      (is (= parts
-            (datomic/pull test-datomic-db
-              '[:thing/name {:thing/part [:thing/name]}]
-              [:thing/name "Part A"])))
-
-      (is (= parts
-            (datomic/pull test-datomic-db
-              '[:thing/name {:thing/part 1}]
-              [:thing/name "Part A"]))))))
-
-(deftest test-lookup-ref-pull
-  (is (= {:person/name "Petr" :person/aka ["Devil" "Tupen"]}
-        (datomic/pull test-datomic-db '[:person/name :person/aka] [:person/name "Petr"])))
-  (is (= nil
-        (datomic/pull test-datomic-db '[:person/name :person/aka] [:person/name "NotInDatabase"])))
-  (is (= [nil
-          {:person/aka ["Devil" "Tupen"]}
-          nil
-          nil
-          nil]
-        (datomic/pull-many test-datomic-db
-          '[:person/aka]
-          [[:person/name "Elizabeth"]
-           [:person/name "Petr"]
-           [:person/name "Eunan"]
-           [:person/name "Rebecca"]
-           [:person/name "Unknown"]]))))
-
-(deftest test-pull-recursion
-  (is (= {:person/name "1", :person/friend [{:person/name "2", :person/enemy [{:person/name "3", :person/friend [{:person/name "4", :person/enemy [{:person/name "5"}]}]}]}]}
-        (datomic/pull test-datomic-db '[:person/name {:person/friend 2 :person/enemy 2}] [:person/name "1"]))))
-
-(deftest test-seen
-  (is (= {:person/name "8", :person/enemy [{:person/name "9", :person/enemy [{:person/name "8", :person/enemy [{:person/name "9"}]}]}]}
-        (datomic/pull test-datomic-db '[:person/name {:person/enemy ...}] [:person/name "8"])))
-  (is (= {:person/name "10", :person/enemy [{:person/name "10", :person/enemy [{:person/name "10"}]}]}
-        (datomic/pull test-datomic-db '[:person/name {:person/enemy ...}] [:person/name "10"]))))
-
-(deftest test-xform
-  (is (= {:person/name ["Petr"]}
-        (datomic/pull test-datomic-db '[[:person/name :xform clojure.core/vector]] [:person/name "Petr"])))
-  (is (= {:person/aka [["Devil" "Tupen"]]}
-        (datomic/pull test-datomic-db '[[:person/aka :xform clojure.core/vector]] [:person/name "Petr"])))
-  (is (= {:person/child [[{:person/name "David"} {:person/name "Thomas"}]]}
-        (datomic/pull test-datomic-db '[{[:person/child :xform clojure.core/vector] [:person/name]}] [:person/name "Petr"])))
-  (is (= {:person/child {:person/name "David"}}
-        (datomic/pull test-datomic-db '[{[:person/child :xform clojure.core/first] [:person/name]}] [:person/name "Petr"])))
-  (is (= {:person/aka [nil]}
-        (datomic/pull test-datomic-db '[[:person/aka :xform clojure.core/vector]] [:person/name "Lucy"])))
-  (is (= {:person/child [nil]}
-        (datomic/pull test-datomic-db '[{[:person/child :xform clojure.core/vector] [:person/name]}] [:person/name "Lucy"]))))
-
-(defn -main [& args]
-  (let [{:keys [test pass fail error] :as res} (run-tests 'test-datomic.pull-api)]
-    (shutdown-agents)
-    (when (or (> (+ fail error) 0) (= test 0))
-      (System/exit 1))))