diff --git a/src/contrib/triple_store.cljc b/src/contrib/triple_store.cljc
index a790fdd87..8d99cf8d3 100644
--- a/src/contrib/triple_store.cljc
+++ b/src/contrib/triple_store.cljc
@@ -58,6 +58,7 @@
 ;;;;;;;;;;;;;;;
 
 (defn ->node [ts e] (get (:eav ts) e))
+(defn ? [ts e k] (get (->node ts e) k))
 (defn find [ts & kvs]
   (let [ret (reduce set/intersection (into [] (comp (partition-all 2) (map (fn [[k v]] (-> ts :ave (get k) (get v))))) kvs))]
     (when (seq ret) ret)))
diff --git a/src/hyperfiddle/electric/impl/lang3.clj b/src/hyperfiddle/electric/impl/lang3.clj
index a404acbbf..611f32de5 100644
--- a/src/hyperfiddle/electric/impl/lang3.clj
+++ b/src/hyperfiddle/electric/impl/lang3.clj
@@ -373,9 +373,11 @@
 (defn get-child-e [ts e] (ca/is (first (get-children-e ts e)) some? (str "no child for " e) {:e e, :nd (ts/->node ts e)}))
 (defn get-root-e [ts] (get-child-e ts '_))
 
-(defn ?add-source-map [{{::keys [->id]} :o :as ts} pe form]
+(defn ?add-source-map [{{::keys [->id]} :o :as ts} e form env]
   (let [mt (meta form)]
-    (cond-> ts (:line mt) (ts/add {:db/id (->id), ::source-map-of pe, ::line (:line mt), ::column (:column mt)}))))
+    (cond-> ts (:line mt) (ts/add {:db/id (->id), ::source-map-of e
+                                   ::line (:line mt), ::column (:column mt)
+                                   ::def (::def env), ::ns (get-ns env)}))))
 
 (defn untwin [s]
   (if (= "cljs.core" (namespace s))
@@ -496,33 +498,35 @@
   (-> ts (ts/add {:db/id e, ::parent pe, ::type ::pure})
     (ts/add {:db/id (->id), ::parent e, ::type ::literal, ::v v})))
 
-(defn add-ap-literal [f args pe e env {{::keys [->id ->uid]} :o :as ts}]
+(defn add-ap-literal [f args pe e env form {{::keys [->id ->uid]} :o :as ts}]
   (let [ce (->id)]
     (reduce (fn [ts form] (analyze form e env ts))
       (-> (ts/add ts {:db/id e, ::parent pe, ::type ::ap, ::uid (->uid)})
         #_(add-literal f ce e)
         (ts/add {:db/id ce, ::parent e, ::type ::pure})
-        (ts/add {:db/id (->id), ::parent ce, ::type ::literal, ::v f}))
+        (ts/add {:db/id (->id), ::parent ce, ::type ::literal, ::v f})
+        (?add-source-map e form env))
       args)))
 
 (defn ->class-method-call [clazz method method-args pe env form {{::keys [->id]} :o :as ts}]
   (if (seq method-args)
     (let [f (let [margs (repeatedly (count method-args) gensym), meth (symbol (str clazz) (str method))]
               `(fn [~@margs] (~meth ~@margs)))]
-      (add-ap-literal f method-args pe (->id) env ts))
+      (add-ap-literal f method-args pe (->id) env form ts))
     (let [e (->id)]                     ; (. java.time.Instant now)
       (-> ts (ts/add {:db/id e, ::parent pe, ::type ::pure})
-        (ts/add {:db/id (->id), ::parent e, ::type ::literal, ::v form})))))
+        (ts/add {:db/id (->id), ::parent e, ::type ::literal, ::v form})
+        (?add-source-map e form env)))))
 
 (defn meta-of-key [mp k] (-> mp keys set (get k) meta))
 (defn gensym-with-local-meta [env k]
   (let [g (gensym (if (instance? clojure.lang.Named k) (name k) "o")), mt (meta-of-key (:locals env) k)]
     (?untag (with-meta g (merge mt (meta k))) env)))
 
-(defn ->obj-method-call [o method method-args pe env {{::keys [->id]} :o :as ts}]
+(defn ->obj-method-call [o method method-args pe env form {{::keys [->id]} :o :as ts}]
   (let [f (let [[oo & margs] (mapv #(gensym-with-local-meta env %) (cons o method-args))]
             `(fn [~oo ~@margs] (. ~oo ~method ~@margs)))]
-    (add-ap-literal f (cons o method-args) pe (->id) env ts)))
+    (add-ap-literal f (cons o method-args) pe (->id) env form ts)))
 
 (defn def-sym-in-cljs-compiler! [sym ns]
   (swap! @(requiring-resolve 'cljs.env/*compiler*)
@@ -553,7 +557,7 @@
                    pe env ts))
         (::mklocal) (let [[_ k bform] form, e (->id), uid (->uid)
                           ts (-> ts (ts/add {:db/id e, ::parent pe, ::type ::mklocal, ::k k, ::uid uid})
-                               (?add-source-map e form))]
+                               (?add-source-map e form env))]
                       (recur bform e (update-in env [:locals k] assoc ::electric-let uid) ts))
         (::bindlocal) (let [[_ k v bform] form, e (->id)
                             ts (ts/add ts {:db/id e, ::parent pe, ::type ::bindlocal ::k k
@@ -576,7 +580,7 @@
                     [f & arg*] (wrap-foreign-for-electric (analyze-foreign form env))]
                 (if (or (nil? current) (= (->env-type env) current))
                   (if f
-                    (add-ap-literal f arg* pe (->id) env ts)
+                    (add-ap-literal f arg* pe (->id) env form ts)
                     (add-literal ts form (->id) pe))
                   (recur `[~@arg*] pe env ts)))
         (::cc-letfn) (let [current (get (::peers env) (::current env))
@@ -584,7 +588,7 @@
                            [f & arg*] (wrap-foreign-for-electric (analyze-foreign lfn* env))]
                        (if (or (nil? current) (= (->env-type env) current))
                          (if f
-                           (add-ap-literal f arg* pe e env (?add-source-map ts e form))
+                           (add-ap-literal f arg* pe e env form ts)
                            (add-literal ts lfn* e pe))
                          (recur `[~@arg*] pe env ts)))
         (new) (let [[_ f & args] form]
@@ -593,7 +597,7 @@
                             :clj (if (and (symbol? f) (jvm-type? f)) f 'Object)
                             :cljs (if (and (symbol? f) (js-type? f env)) f 'js/Object))
                         f (let [gs (repeatedly (count args) gensym)] `(fn [~@gs] (new ~f ~@gs)))]
-                    (add-ap-literal f args pe (->id) env ts))
+                    (add-ap-literal f args pe (->id) env form ts))
                   (recur `[~@args] pe env ts)))
         ;; (. java.time.Instant now)
         ;; (. java.time.Instant ofEpochMilli 1)
@@ -624,19 +628,19 @@
                 (seq? (nth form 2))     ; (. i1 (isAfter i2))
                 (let [[_ o [method & method-args]] form]
                   (if me?
-                    (->obj-method-call o method method-args pe env ts)
+                    (->obj-method-call o method method-args pe env form ts)
                     (recur `[~(second form) ~@(next (nth form 2))] pe env ts)))
 
                 :else
                 (let [[_ o x & xs] form]
                   (if (seq xs)          ; (. i1 isAfter i2)
                     (if me?
-                      (->obj-method-call o x xs pe env ts)
+                      (->obj-method-call o x xs pe env form ts)
                       (recur `[~o ~@xs] pe env ts))
                     (if me?             ; (. pt x)
                       (if (field-access? x)
-                        (add-ap-literal `(fn [oo#] (. oo# ~x)) [o] pe (->id) env ts)
-                        (->obj-method-call o x [] pe env ts))
+                        (add-ap-literal `(fn [oo#] (. oo# ~x)) [o] pe (->id) env form ts)
+                        (->obj-method-call o x [] pe env form ts))
                       (recur nil pe env ts))))))
         (binding clojure.core/binding) (let [[_ bs bform] form, gs (repeatedly (/ (count bs) 2) gensym)]
                                          (recur (if (seq bs)
@@ -651,32 +655,32 @@
                 (case (->env-type env)
                   :clj (recur `((fn* ([x#] (def ~sym x#))) ~v) pe env ts)
                   :cljs (do (def-sym-in-cljs-compiler! sym (get-ns env))
-                            (add-ap-literal `(fn [v#] (set! ~sym v#)) [v] pe (->id) env ts))))
+                            (add-ap-literal `(fn [v#] (set! ~sym v#)) [v] pe (->id) env form ts))))
         (set!) (let [[_ target v] form] (recur `((fn* ([v#] (set! ~target v#))) ~v) pe env ts))
         (::ctor) (let [e (->id), ce (->id)]
                    (recur (second form)
                      ce env (-> ts (ts/add {:db/id e, ::parent pe, ::type ::pure})
                               (ts/add {:db/id ce, ::parent e, ::type ::ctor, ::uid (->uid)})
-                              (?add-source-map e form))))
+                              (?add-source-map e form env))))
         (::call) (let [e (->id)] (recur (second form) e env
                                    (-> (ts/add ts {:db/id e, ::parent pe, ::type ::call, ::uid (->uid)})
-                                     (?add-source-map e form))))
+                                     (?add-source-map e form env))))
         (::tag) (let [e (->id)] (recur (second form) e env
                                   (-> (ts/add ts {:db/id e, ::parent pe, ::type ::call, ::uid (->uid), ::call-type ::tag})
-                                    (?add-source-map e form))))
+                                    (?add-source-map e form env))))
         (::pure) (let [pure (with-meta (gensym "pure") {::dont-inline true})]
                    (recur `(let* [~pure ~(second form)] (::pure-gen ~pure)) pe env ts))
         (::pure-gen) (let [e (->id)]
                        (recur (second form) e env (-> (ts/add ts {:db/id e, ::parent pe, ::type ::pure})
-                                                    (?add-source-map e form))))
+                                                    (?add-source-map e form env))))
         (::join) (let [e (->id)] (recur (second form) e env (-> (ts/add ts {:db/id e, ::parent pe, ::type ::join})
-                                                              (?add-source-map e form))))
+                                                              (?add-source-map e form env))))
         (::site) (let [[_ site bform] form, current (::current env), env2 (assoc env ::current site)]
                    (if (or (nil? site) (= site current) (= ::bindlocal (::type (ts/->node ts pe))))
                      (let [e (->id)]
                        (recur bform e env2
                          (-> (ts/add ts {:db/id e, ::parent pe, ::type ::site, ::site site})
-                           (?add-source-map e form))))
+                           (?add-source-map e form env))))
                      ;; Due to an early bad assumption only locals are considered for runtime nodes.
                      ;; Since any site change can result in a new node we wrap these sites in an implicit local.
                      ;; Electric aggressively inlines locals, so the generated code size will stay the same.
@@ -693,11 +697,11 @@
                        (let [js-call? (cljs-ana/js-call? @!a f (get-ns env))]
                          (when (::debug env) (prn :js-call? f '=> js-call?))
                          js-call?))
-                   (add-ap-literal (bound-js-fn f) args pe (->id) env ts)
+                   (add-ap-literal (bound-js-fn f) args pe (->id) env form ts)
                    (let [e (->id), uid (->uid)]
                      (reduce (fn [ts nx] (analyze nx e env ts))
                        (-> (ts/add ts {:db/id e, ::parent pe, ::type ::ap, ::uid uid})
-                         (?add-source-map uid form)) form)))))
+                         (?add-source-map e form env)) form)))))
 
       (instance? cljs.tagged_literals.JSValue form)
       (let [o (.-val ^cljs.tagged_literals.JSValue form)]
@@ -730,13 +734,13 @@
                                               (::lang ret) (assoc ::resolved-in (::lang ret)))))
               (::node) (ts/add ts {:db/id e, ::parent pe, ::type ::node, ::node (::node ret)})
               #_else (throw (ex-info (str "unknown symbol type " (::type ret)) (or ret {}))))
-          (?add-source-map e form)))
+          (?add-source-map e form env)))
 
       :else
       (let [e (->id)]
         (-> ts (ts/add {:db/id e, ::parent pe, ::type ::pure})
           (ts/add {:db/id (->id), ::parent e, ::type ::literal, ::v form})
-          (?add-source-map e form))))))
+          (?add-source-map e form env))))))
 
 (defn add-foreign-local [env sym] (update env :locals update sym assoc ::electric-let nil))
 
@@ -1080,12 +1084,18 @@
 
 (defn tag-call? [ts e] (= ::tag (::call-type (ts/->node ts e))))
 
+(defn ->code-meta [ts e]
+  (loop [e e]
+    (if-some [se (first (ts/find ts ::source-map-of e))]
+      (dissoc (ts/->node ts se) :db/id ::source-map-of)
+      (some-> (ts/? ts e ::parent) (recur)))))
+
 (defn emit [ts e ctor-e env nm]
   ((fn rec [e]
      (let [nd (get (:eav ts) e)]
        (case (::type nd)
          ::literal (::v nd)
-         ::ap (list* `r/ap {} (mapv rec (get-children-e ts e)))
+         ::ap (list* `r/ap (list 'quote (or (->code-meta ts e) {})) (mapv rec (get-children-e ts e)))
          ::var (let [in (::resolved-in nd)]
                  (list* `r/lookup 'frame (keyword (::qualified-var nd))
                    (when (or (nil? in) (= in (->env-type env))) [(list `r/pure (::qualified-var nd))])))
@@ -1420,7 +1430,7 @@
                                   ts (ts/find ts ::qualified-var `r/cannot-resolve)))
         ts (-> ts mark-used-calls2 index-calls reroute-local-aliases (optimize-locals (get-root-e ts))
              inline-locals order-nodes order-frees collapse-ap-with-only-pures expand-cannot-resolve)]
-    (when (::print-db env) (prn :db) (run! prn (ts->reducible ts)))
+    (when (::print-db env) (run! prn (ts->reducible ts)))
     ts))
 
 (defn compile* [nm env ts]
diff --git a/src/hyperfiddle/electric/impl/runtime3.cljc b/src/hyperfiddle/electric/impl/runtime3.cljc
index b5a529437..164c75b89 100644
--- a/src/hyperfiddle/electric/impl/runtime3.cljc
+++ b/src/hyperfiddle/electric/impl/runtime3.cljc
@@ -2,6 +2,7 @@
   (:refer-clojure :exclude [resolve])
   (:require [hyperfiddle.incseq :as i]
             [missionary.core :as m]
+            [hyperfiddle.electric.impl.lang3 :as-alias lang]
             [cognitect.transit :as t]
             [hyperfiddle.incseq.diff-impl :as d])
   (:import missionary.Cancelled
@@ -145,20 +146,27 @@ T T T -> (EXPR T)
 " [value]
   (->Pure value nil))
 
-(defn invoke
-  ([f] (f))
-  ([f a] (f a))
-  ([f a b] (f a b))
-  ([f a b c] (f a b c))
-  ([f a b c d] (f a b c d))
-  ([f a b c d & es] (apply f a b c d es)))
-
-;; TODO the runtime swallows exceptions somewhere
-;; maybe in latest-product, not sure.
-;; investigate and remove this afterwards
-(defn invoke-print-throws [& args]
-  (try (apply invoke args)
-       (catch #?(:clj Throwable :cljs :default) e (#?(:clj prn :cljs js/console.error) e))))
+(defn clean-ex [mt msg]
+  (let [msg (str "in " (::lang/ns mt) (let [d (::lang/def mt)] (when d (str "/" d)))
+              ", line " (::lang/line mt) ", column " (::lang/column mt) "\n\n" msg)]
+    #?(:clj (proxy [Exception] [msg nil false false])
+       :cljs (js/Error msg))))
+
+(defn ?swap-exception [f mt]
+  (try (f)
+       (catch #?(:clj Throwable :cljs :default) e
+         (let [clean-ex (clean-ex mt (ex-message e))]
+           ;; (println (ex-message clean-ex))
+           (throw clean-ex)))))
+
+(defn invoke-with [mt]
+  (fn
+    ([f] (?swap-exception #(f) mt))
+    ([f a] (?swap-exception #(f a) mt))
+    ([f a b] (?swap-exception #(f a b) mt))
+    ([f a b c] (?swap-exception #(f a b c) mt))
+    ([f a b c d] (?swap-exception #(f a b c d) mt))
+    ([f a b c d & es] (?swap-exception #(apply f a b c d es) mt))))
 
 (deftype Ap [mt inputs
              ^:unsynchronized-mutable ^:mutable hash-memo]
@@ -177,7 +185,7 @@ T T T -> (EXPR T)
   (deps [_ rf r site]
     (reduce (fn [r x] (deps x rf r site)) r inputs))
   (flow [_]
-    (apply i/latest-product invoke (map flow inputs))))
+    (apply i/latest-product (invoke-with mt) (map flow inputs))))
 
 (defn ap "
 (EXPR (-> T)) -> (EXPR T)
diff --git a/src/hyperfiddle/electric_dom3.cljc b/src/hyperfiddle/electric_dom3.cljc
index d29141438..37908b6f2 100644
--- a/src/hyperfiddle/electric_dom3.cljc
+++ b/src/hyperfiddle/electric_dom3.cljc
@@ -67,7 +67,7 @@
 
 #?(:cljs
    (defn attach! [parent-node tag e]
-     (assert (instance? js/Node parent-node))
+     (assert (instance? js/Node parent-node) "did you forget to bind `dom/node`?")
      (m/observe (fn [!]
                   (! nil)
                   (if-some [mount-point (get-mount-point parent-node)]
diff --git a/test/hyperfiddle/electric/impl/compiler_test.cljc b/test/hyperfiddle/electric/impl/compiler_test.cljc
index fb45cf863..67eda27d0 100644
--- a/test/hyperfiddle/electric/impl/compiler_test.cljc
+++ b/test/hyperfiddle/electric/impl/compiler_test.cljc
@@ -51,12 +51,12 @@
   (match (l/test-compile ::Main (prn "Hello world"))
     `[(r/cdef 0 [] [] nil
         (fn [~'frame]
-          (r/ap {} (r/lookup ~'frame :clojure.core/prn (r/pure prn)) (r/pure "Hello world"))))])
+          (r/ap '{} (r/lookup ~'frame :clojure.core/prn (r/pure prn)) (r/pure "Hello world"))))])
   (match (l/test-compile ::Main (prn (e/client 1)))
     `[(r/cdef 0 [:client] [] nil
         (fn [~'frame]
           (r/define-node ~'frame 0 (r/pure 1))
-          (r/ap {} (r/lookup ~'frame :clojure.core/prn (r/pure clojure.core/prn))
+          (r/ap '{} (r/lookup ~'frame :clojure.core/prn (r/pure clojure.core/prn))
             (r/node ~'frame 0))))]))
 
 (tests "test-join"
@@ -64,8 +64,8 @@
     `[(r/cdef 0 [] [] nil
         (fn [~'frame]
           (r/join
-            (r/ap {} (r/lookup ~'frame ::i/fixed (r/pure i/fixed))
-              (r/ap {} (r/lookup ~'frame ::m/watch (r/pure m/watch))
+            (r/ap '{} (r/lookup ~'frame ::i/fixed (r/pure i/fixed))
+              (r/ap '{} (r/lookup ~'frame ::m/watch (r/pure m/watch))
                 (r/pure ~'!x))))))]))
 
 (tests "test-siting"
@@ -77,17 +77,17 @@
   (match (l/test-compile ::Main (::lang/site :client (prn "Hello world")))
     `[(r/cdef 0 [] [] :client
         (fn [~'frame]
-          (r/ap {} (r/lookup ~'frame :clojure.core/prn) (r/pure "Hello world"))))])
+          (r/ap '{} (r/lookup ~'frame :clojure.core/prn) (r/pure "Hello world"))))])
 
   (match (l/test-compile ::Main (::lang/site :client (undefined?)))
     `[(r/cdef 0 [] [] :client
         (fn [~'frame]
-          (r/ap {} (r/lookup ~'frame :cljs.core/undefined?))))])
+          (r/ap '{} (r/lookup ~'frame :cljs.core/undefined?))))])
 
   (match (l/test-compile ::Main (lang/->cljs-env) (::lang/site :client (undefined?)))
     `[(r/cdef 0 [] [] :client
         (fn [~'frame]
-          (r/ap {} (r/lookup ~'frame :cljs.core/undefined? (r/pure cljs.core/undefined?)))))])
+          (r/ap '{} (r/lookup ~'frame :cljs.core/undefined? (r/pure cljs.core/undefined?)))))])
 
   (match (l/test-compile ::Main (e/server (let [x 1] (e/client x))))
     `[(r/cdef 0 [] [] :server
@@ -97,7 +97,7 @@
     `[(r/cdef 0 [:server] [] nil
         (fn [~'frame]
           (r/define-node ~'frame 0 (r/pure :foo))
-          (r/ap {} (r/lookup ~'frame :clojure.core/name (r/pure clojure.core/name))
+          (r/ap '{} (r/lookup ~'frame :clojure.core/name (r/pure clojure.core/name))
             (r/node ~'frame 0))))])
 
   (match (l/test-compile ::Main (prn (e/client (::lang/call (e/server (e/ctor nil))))))
@@ -106,7 +106,7 @@
           (r/define-node ~'frame 0 (r/pure (r/ctor ::Main 1)))
           (r/define-call ~'frame 0 (r/node ~'frame 0))
           (r/define-node ~'frame 1 (r/join (r/call ~'frame 0)))
-          (r/ap {} (r/lookup ~'frame :clojure.core/prn (r/pure prn)) (r/node ~'frame 1))))
+          (r/ap '{} (r/lookup ~'frame :clojure.core/prn (r/pure prn)) (r/node ~'frame 1))))
       (r/cdef 0 [] [] nil
         (fn [~'frame] (r/pure nil)))])
 
@@ -119,8 +119,8 @@
   (match (l/test-compile ::Main (let [x (e/server (identity 1))] (inc x)))
     `[(r/cdef 0 [:server] [] nil
         (fn [~'frame]
-          (r/define-node ~'frame 0 (r/ap {} (r/lookup ~'frame :clojure.core/identity (r/pure identity)) (r/pure 1)))
-          (r/ap {} (r/lookup ~'frame :clojure.core/inc (r/pure inc))
+          (r/define-node ~'frame 0 (r/ap '{} (r/lookup ~'frame :clojure.core/identity (r/pure identity)) (r/pure 1)))
+          (r/ap '{} (r/lookup ~'frame :clojure.core/inc (r/pure inc))
             (r/node ~'frame 0))))]))
 
 (tests "test-let"
@@ -128,23 +128,23 @@
     `[(r/cdef 0 [:client] [] :client
         (fn [~'frame]
           (r/define-node ~'frame 0 (r/pure :foo))
-          (r/ap {} (r/pure clojure.core/vector)
+          (r/ap '{} (r/pure clojure.core/vector)
             (r/node ~'frame 0) (r/node ~'frame 0))))])
 
   (match (l/test-compile ::Main (let [a :foo] [a a]))
     `[(r/cdef 0 [nil] [] nil
         (fn [~'frame]
           (r/define-node ~'frame 0 (r/pure :foo))
-          (r/ap {} (r/pure clojure.core/vector)
+          (r/ap '{} (r/pure clojure.core/vector)
             (r/node ~'frame 0) (r/node ~'frame 0))))])
 
   (match (l/test-compile ::Main (let [a (let [b :foo] [b b])] [a a]))
     `[(r/cdef 0 [nil nil] [] nil
         (fn [~'frame]
           (r/define-node ~'frame 0 (r/pure :foo))
-          (r/define-node ~'frame 1 (r/ap {} (r/pure clojure.core/vector)
+          (r/define-node ~'frame 1 (r/ap '{} (r/pure clojure.core/vector)
                                      (r/node ~'frame 0) (r/node ~'frame 0)))
-          (r/ap {} (r/pure clojure.core/vector)
+          (r/ap '{} (r/pure clojure.core/vector)
             (r/node ~'frame 1) (r/node ~'frame 1))))])
 
   (match (l/test-compile ::Main (let [a 1] a))
@@ -154,7 +154,7 @@
     `[(r/cdef 0 [:client] [] :server
         (fn [~'frame]
           (r/define-node ~'frame 0 (r/pure 1))
-          (r/ap {} (r/lookup ~'frame :clojure.core/prn (r/pure clojure.core/prn))
+          (r/ap '{} (r/lookup ~'frame :clojure.core/prn (r/pure clojure.core/prn))
             (r/node ~'frame 0))))])
 
   (match (l/test-compile ::Main (e/client (let [x "Hello", y "world"] [x y])))
@@ -165,7 +165,7 @@
   (match (l/test-compile ::Main (e/client (let [a (e/server :foo)] (e/server (prn a)))))
     `[(r/cdef 0 [] [] :server
         (fn [~'frame]
-          (r/ap {} (r/lookup ~'frame :clojure.core/prn (r/pure prn))
+          (r/ap '{} (r/lookup ~'frame :clojure.core/prn (r/pure prn))
             (r/pure :foo))))])
 
   (match (l/test-compile ::Main (concat (let [x 1] [x x]) (let [y 2] [y y])))
@@ -173,11 +173,11 @@
         (fn [~'frame]
           (r/define-node ~'frame 0 (r/pure 1))
           (r/define-node ~'frame 1 (r/pure 2))
-          (r/ap {} (r/lookup ~'frame :clojure.core/concat (r/pure clojure.core/concat))
-            (r/ap {} (r/pure clojure.core/vector)
+          (r/ap '{} (r/lookup ~'frame :clojure.core/concat (r/pure clojure.core/concat))
+            (r/ap '{} (r/pure clojure.core/vector)
               (r/node ~'frame 0)
               (r/node ~'frame 0))
-            (r/ap {} (r/pure clojure.core/vector)
+            (r/ap '{} (r/pure clojure.core/vector)
               (r/node ~'frame 1)
               (r/node ~'frame 1)))))]))
 
@@ -234,7 +234,7 @@
       (r/cdef 1 [nil] [] nil
         (fn [~'frame]
           (r/define-node ~'frame 0 (r/pure 2))
-          (r/ap {} (r/pure clojure.core/vector)
+          (r/ap '{} (r/pure clojure.core/vector)
             (r/free ~'frame 0)
             (r/pure (r/ctor ::Main 2 (r/node ~'frame 0))))))
       (r/cdef 1 [] [] nil
@@ -264,7 +264,7 @@
           (r/pure (r/ctor ::Main 1 (r/node ~'frame 0) (r/node ~'frame 1)))))
       (r/cdef 2 [] [] nil
         (fn [~'frame]
-          (r/ap {} (r/pure clojure.core/vector)
+          (r/ap '{} (r/pure clojure.core/vector)
             (r/free ~'frame 0)
             (r/pure (r/ctor ::Main 2 (r/free ~'frame 1))))))
       (r/cdef 1 [] [] nil
@@ -279,7 +279,7 @@
           (r/pure (r/ctor ::Main 1 (r/node ~'frame 1) (r/node ~'frame 0)))))
       (r/cdef 2 [] [] nil
         (fn [~'frame]
-          (r/ap {} (r/pure clojure.core/vector)
+          (r/ap '{} (r/pure clojure.core/vector)
             (r/free ~'frame 0)
             (r/pure (r/ctor ::Main 2 (r/free ~'frame 1))))))
       (r/cdef 1 [] [] nil
@@ -303,7 +303,7 @@
           (r/pure (r/ctor ::Main 1 (r/node ~'frame 0) (r/node ~'frame 1)))))
       (r/cdef 2 [] [] nil
         (fn [~'frame]
-          (r/ap {} (r/lookup ~'frame :clojure.core/str (r/pure clojure.core/str))
+          (r/ap '{} (r/lookup ~'frame :clojure.core/str (r/pure clojure.core/str))
             (r/free ~'frame 0)
             (r/free ~'frame 1))))]))
 
@@ -330,7 +330,7 @@
     `[(r/cdef 0 [] [nil] nil
         (fn [~'frame]
           (r/define-call ~'frame 0 (r/pure (r/ctor ::Main 1)))
-          (r/ap {} (r/lookup ~'frame :clojure.core/vector (r/pure clojure.core/vector))
+          (r/ap '{} (r/lookup ~'frame :clojure.core/vector (r/pure clojure.core/vector))
             (r/pure 1)
             (r/join (r/call ~'frame 0)))))
       (r/cdef 0 [] [] nil
@@ -342,7 +342,7 @@
           (r/define-node ~'frame 0 (r/pure (r/ctor ::Main 1)))
           (r/define-call ~'frame 0 (r/node ~'frame 0))
           (r/define-call ~'frame 1 (r/node ~'frame 0))
-          (r/ap {} (r/pure clojure.core/vector)
+          (r/ap '{} (r/pure clojure.core/vector)
             (r/join (r/call ~'frame 0))
             (r/join (r/call ~'frame 1)))))
       (r/cdef 0 [] [] nil
@@ -353,7 +353,7 @@
         (fn [~'frame]
           (r/define-call ~'frame 0 (r/pure (r/ctor ::Main 1)))
           (r/define-call ~'frame 1 (r/pure (r/ctor ::Main 2)))
-          (r/ap {} (r/pure clojure.core/vector)
+          (r/ap '{} (r/pure clojure.core/vector)
             (r/join (r/call ~'frame 0))
             (r/join (r/call ~'frame 1)))))
       (r/cdef 0 [] [] nil
@@ -382,7 +382,7 @@
     `[(r/cdef 0 [nil] [nil] nil
         (fn [~'frame]
           (r/define-node ~'frame 0 (r/pure (r/ctor ::Main 1)))
-          (r/define-call ~'frame 0 (r/ap {} (r/ap {} (r/pure hash-map) (r/pure 'nil) (r/node ~'frame 0))
+          (r/define-call ~'frame 0 (r/ap '{} (r/ap '{} (r/pure hash-map) (r/pure 'nil) (r/node ~'frame 0))
                                      (r/pure :x)
                                      (r/pure (r/ctor ::Main 2))))
           (r/join (r/call ~'frame 0))))
@@ -393,7 +393,7 @@
     `[(r/cdef 0 [nil] [nil] nil
         (fn [~'frame]
           (r/define-node ~'frame 0 (r/pure (r/ctor ::Main 1)))
-          (r/define-call ~'frame 0 (r/ap {} (r/ap {} (r/pure clojure.core/hash-map)
+          (r/define-call ~'frame 0 (r/ap '{} (r/ap '{} (r/pure clojure.core/hash-map)
                                               (r/pure '~'foo) (r/node ~'frame 0)
                                               (r/pure '~'bar) (r/node ~'frame 0))
                                      (r/pure '~'foo)
@@ -410,7 +410,7 @@
     `[(r/cdef 0 [nil] [nil] nil
         (fn [~'frame]
           (r/define-node ~'frame 0 (r/pure (r/ctor ::Main 1)))
-          (r/define-call ~'frame 0 (r/ap {} (r/ap {} (r/pure clojure.core/hash-map)
+          (r/define-call ~'frame 0 (r/ap '{} (r/ap '{} (r/pure clojure.core/hash-map)
                                               (r/pure 'nil) (r/node ~'frame 0)
                                               (r/pure 'false) (r/node ~'frame 0))
                                      (r/pure 1)
@@ -435,7 +435,7 @@
   (match (l/test-compile ::Main (should-work-in-cljs))
     `[(r/cdef 0 [] [] nil
         (fn [~'frame]
-          (r/ap {} (r/lookup ~'frame ::should-work-in-cljs
+          (r/ap '{} (r/lookup ~'frame ::should-work-in-cljs
                      (r/pure should-work-in-cljs)))))]))
 
 (tests "test-ctor-site-clearing"
@@ -446,7 +446,7 @@
       (r/cdef 0 [nil] [] nil
         (fn [~'frame]
           (r/define-node ~'frame 0 (r/pure 1))
-          (r/ap {} (r/pure clojure.core/vector)
+          (r/ap '{} (r/pure clojure.core/vector)
             (r/node ~'frame 0)
             (r/node ~'frame 0))))]))
 
@@ -459,15 +459,15 @@
           (r/define-node ~'frame 0 (r/lookup ~'frame :clojure.core/dec (r/pure clojure.core/dec)))
           (r/define-node ~'frame 1 (r/lookup ~'frame :clojure.core/inc (r/pure clojure.core/inc)))
           (r/define-call ~'frame 0
-            (r/ap {} (r/pure (fn* []
+            (r/ap '{} (r/pure (fn* []
                                (r/bind (r/ctor ::Main 1)
                                  :clojure.core/inc (r/node ~'frame 0)
                                  :clojure.core/dec (r/node ~'frame 1))))))
           (r/join (r/call ~'frame 0))))
       (r/cdef 0 [] [] nil
         (fn [~'frame]
-          (r/ap {} (r/lookup ~'frame :clojure.core/inc (r/pure clojure.core/inc))
-            (r/ap {} (r/lookup ~'frame :clojure.core/dec (r/pure clojure.core/dec))
+          (r/ap '{} (r/lookup ~'frame :clojure.core/inc (r/pure clojure.core/inc))
+            (r/ap '{} (r/lookup ~'frame :clojure.core/dec (r/pure clojure.core/dec))
               (r/pure 0)))))]))
 
 (tests "test-ap-collapse"
@@ -478,7 +478,7 @@
   (match (l/test-compile ::Main ((::lang/static-vars prn) 1))
     `[(r/cdef 0 [] [] nil
         (fn [~'frame]
-          (r/ap {} (r/pure (fn* [] (~'prn 1))))))]))
+          (r/ap '{} (r/pure (fn* [] (~'prn 1))))))]))
 
 (tests "ordering"
   (match (l/test-compile ::Main (::lang/call (::lang/call (::lang/ctor (::lang/ctor :foo)))))
@@ -498,7 +498,7 @@
         (fn [~'frame]
           (r/define-node ~'frame 0 (r/pure 1))
           (r/define-node ~'frame 1 (r/pure 2))
-          (r/ap {} (r/pure clojure.core/vector)
+          (r/ap '{} (r/pure clojure.core/vector)
             (r/node ~'frame 1) (r/node ~'frame 0) (r/node ~'frame 0) (r/node ~'frame 1))))])
   (match (l/test-compile ::Main (let [x 1] [(::lang/call (::lang/ctor 1)) x x (::lang/call (::lang/ctor 2))]))
     `[(r/cdef 0 [nil] [nil nil] nil
@@ -506,7 +506,7 @@
           (r/define-node ~'frame 0 (r/pure 1))
           (r/define-call ~'frame 0 (r/pure (r/ctor :hyperfiddle.electric.impl.compiler-test/Main 1)))
           (r/define-call ~'frame 1 (r/pure (r/ctor :hyperfiddle.electric.impl.compiler-test/Main 2)))
-          (r/ap {} (r/pure clojure.core/vector)
+          (r/ap '{} (r/pure clojure.core/vector)
             (r/join (r/call ~'frame 0))
             (r/node ~'frame 0)
             (r/node ~'frame 0)
@@ -522,12 +522,12 @@
     `[(r/cdef 0 [nil] [] :client
         (fn [~'frame]
           (r/define-node ~'frame 0 (r/pure 1))
-          (r/ap {} (r/pure vector) (r/node ~'frame 0))))])) ; shim, conveyed `x`
+          (r/ap '{} (r/pure vector) (r/node ~'frame 0))))])) ; shim, conveyed `x`
 
 (tests "js-vars-have-qualified-lookup"
   (match (l/test-compile ::Main (e/client (gm/clamp -1 0 5)))
     `[(r/cdef 0 [] [] :client
-        (fn [~'frame] (r/ap {} (r/lookup ~'frame :goog.math/clamp) (r/pure -1) (r/pure 0) (r/pure 5))))]))
+        (fn [~'frame] (r/ap '{} (r/lookup ~'frame :goog.math/clamp) (r/pure -1) (r/pure 0) (r/pure 5))))]))
 
 (tests "peers-dont-compile-foreign-code"
   (match (l/test-compile ::Main (merge e/web-config (lang/normalize-env {}) {:js-globals {}})
@@ -545,7 +545,7 @@
         (fn [~'frame]
           (r/define-call ~'frame 2 (r/pure (r/ctor ::Main 1)))
           (r/define-call ~'frame 4 (r/pure (r/ctor ::Main 2)))
-          (r/ap {} (r/pure vector)
+          (r/ap '{} (r/pure vector)
             (r/pure (r/tag ~'frame 0))
             (r/pure (r/tag ~'frame 1))
             (r/join (r/call ~'frame 2))
@@ -565,33 +565,33 @@
         (fn [~'frame]
           (r/define-node ~'frame 0 (r/pure 1))
           (r/define-call ~'frame 0
-            (r/ap {}
+            (r/ap '{}
               (r/pure (fn* []
                         (r/bind (r/ctor ::Main 2)
                           ::foo (r/node ~'frame 0))))))
           (r/define-node ~'frame 1 (r/join (r/call ~'frame 0)))
           (r/define-call ~'frame 1
             (r/join
-              (r/ap {} (r/lookup ~'frame ::i/fixed (r/pure i/fixed))
-                (r/ap {} (r/lookup ~'frame ::r/invariant (r/pure r/invariant))
+              (r/ap '{} (r/lookup ~'frame ::i/fixed (r/pure i/fixed))
+                (r/ap '{} (r/lookup ~'frame ::r/invariant (r/pure r/invariant))
                   (r/pure (r/ctor ::Main 1 (r/node ~'frame 1))))
-                (r/ap {} (r/lookup ~'frame ::r/invariant (r/pure r/invariant))
+                (r/ap '{} (r/lookup ~'frame ::r/invariant (r/pure r/invariant))
                   (r/pure (r/ctor ::Main 3 (r/node ~'frame 1)))))))
           (r/join (r/call ~'frame 1))))
       (r/cdef 1 [nil] [] nil
         (fn [~'frame]
           (r/define-node ~'frame 0
-            (r/ap {} (r/lookup ~'frame :clojure.core/prn (r/pure clojure.core/prn))
+            (r/ap '{} (r/lookup ~'frame :clojure.core/prn (r/pure clojure.core/prn))
               (r/free ~'frame 0)))
           (r/join
-            (r/ap {} (r/lookup ~'frame ::r/drain (r/pure r/drain))
+            (r/ap '{} (r/lookup ~'frame ::r/drain (r/pure r/drain))
               (r/pure (r/incseq ~'frame (r/node ~'frame 0)))))))
       (r/cdef 0 [] [] nil
         (fn [~'frame]
           (r/lookup ~'frame ::foo)))
       (r/cdef 1 [] [] nil
         (fn [~'frame]
-          (r/ap {} (r/lookup ~'frame :clojure.core/prn (r/pure clojure.core/prn))
+          (r/ap '{} (r/lookup ~'frame :clojure.core/prn (r/pure clojure.core/prn))
             (r/free ~'frame 0))))]))
 
 (def ^:dynamic *d* nil)
diff --git a/test/hyperfiddle/electric3_test.cljc b/test/hyperfiddle/electric3_test.cljc
index 0a86f4028..fdd5bbba2 100644
--- a/test/hyperfiddle/electric3_test.cljc
+++ b/test/hyperfiddle/electric3_test.cljc
@@ -2277,19 +2277,23 @@
 
 #?(:clj (defn clj-only [] :clj))
 #?(:cljs
-   (tests (with ((l/single {} (tap (clj-only))) tap tap)
-            (ex-message %) := "I cannot resolve [clj-only], maybe it's only defined on the other peer?")))
+   (tests (with ((l/single {} (clj-only)) tap tap)
+            (str/includes? (ex-message %)
+              "I cannot resolve [clj-only], maybe it's only defined on the other peer?") := true)))
 #?(:cljs
-   (tests (with ((l/single {} (tap (#(clj-only)))) tap tap)
-            (ex-message %) := "I cannot resolve [clj-only], maybe it's only defined on the other peer?")))
+   (tests (with ((l/single {} (#(clj-only))) tap tap)
+            (str/includes? (ex-message %)
+              "I cannot resolve [clj-only], maybe it's only defined on the other peer?") := true)))
 
 #?(:cljs (defn cljs-only [] :cljs))
 #?(:clj
    (tests (with ((l/single {} (cljs-only)) tap tap)
-            (ex-message %) := "I cannot resolve [cljs-only], maybe it's only defined on the other peer?")))
+            (str/includes? (ex-message %)
+              "I cannot resolve [cljs-only], maybe it's only defined on the other peer?") := true)))
 #?(:clj
    (tests (with ((l/single {} (#(cljs-only))) tap tap)
-            (ex-message %) := "I cannot resolve [cljs-only], maybe it's only defined on the other peer?")))
+            (str/includes? (ex-message %)
+              "I cannot resolve [cljs-only], maybe it's only defined on the other peer?") := true)))
 
 #?(:clj
    (tests (let [ex (try (lang/->source (merge (lang/normalize-env {}) e/web-config) `root '(e/fn [] (e/client (clj-only))))