     (if (= ns (namespace (:dispatch-key ast)))
       (read-chan-values (p/join env))
       ::p/continue)))
-
-;; BUILT-IN READERS
 
 (defn map-reader [{:keys    [ast query]
                    ::p/keys [entity-key]

          (read-chan-values (p/join (assoc env entity-key v)))
          v))
      ::p/continue)))

#?(:cljs
   (defn js-obj-reader [{:keys    [query ast]
                         ::p/keys [js-key-transform js-value-transform entity-key]
                         :as      env
                         :or      {js-key-transform   name
                                   js-value-transform (fn [_ v] v)}}]
     "DEPRECATED: use async-plugin"
     (let [js-key (js-key-transform (:dispatch-key ast))
           entity (p/entity env)]
       (if (gobj/containsKey entity js-key)
         (let [v (gobj/get entity js-key)]
           (if (js/Array.isArray v)
             (read-chan-seq read-chan-values (p/join-seq env v))
             (if (and query (= (type v) js/Object))
               (read-chan-values (p/join (assoc env entity-key v)))
               (js-value-transform (:dispatch-key ast) v))))
         ::p/continue))))

;; PARSER READER


        :else
        v))))

(defn placeholder-node [ns]
  "DEPRECATED: use async-plugin
  Produces a reader that will respond to any keyword with the namespace ns. The join node logical level stays the same
