Internal Dirac Error TypeError: Cannot read property '0' of null

[njj]

Recently updated to the newest version and I'm seeing this:

Internal Dirac Error TypeError: Cannot read property '0' of null
Dirac v0.7.1, Chrome/56.0.2888.0, Mac/10.11.6, Backend API/external (460 registrations), Backend CSS/external (406 definitions)

DevTools code has thrown an unhandled exception:
TypeError: Cannot read property '0' of null
    at vQ (chrome-extension://kbkdngfljkchidcjpnfcgcokkbhlkogi/devtools/front_end/inspector.js:4727:48)
    at hQ (chrome-extension://kbkdngfljkchidcjpnfcgcokkbhlkogi/devtools/front_end/inspector.js:4721:236)
    at qQ (chrome-extension://kbkdngfljkchidcjpnfcgcokkbhlkogi/devtools/front_end/inspector.js:4723:18)
    at hQ (chrome-extension://kbkdngfljkchidcjpnfcgcokkbhlkogi/devtools/front_end/inspector.js:4721:236)
    at qQ (chrome-extension://kbkdngfljkchidcjpnfcgcokkbhlkogi/devtools/front_end/inspector.js:4723:18)
    at hQ (chrome-extension://kbkdngfljkchidcjpnfcgcokkbhlkogi/devtools/front_end/inspector.js:4721:236)
    at qQ (chrome-extension://kbkdngfljkchidcjpnfcgcokkbhlkogi/devtools/front_end/inspector.js:4723:18)
    at hQ (chrome-extension://kbkdngfljkchidcjpnfcgcokkbhlkogi/devtools/front_end/inspector.js:4721:236)
    at qQ (chrome-extension://kbkdngfljkchidcjpnfcgcokkbhlkogi/devtools/front_end/inspector.js:4723:18)
    at iQ (chrome-extension://kbkdngfljkchidcjpnfcgcokkbhlkogi/devtools/front_end/inspector.js:4730:192)

---
Please report the issue here: https://github.com/binaryage/dirac/issues

[darwin]

This is still the same issue as #43.

It still looks like something is calling cljs.reader/read and that throws. I wonder why the callstack is not complete...

btw. Looks like I forgot to enable :pseudo-names for release build this time...

[darwin]

There are probably many places from where cljs.reader could be called.

I'm afraid you will have to help me identify the exact call site which is causing this.

1. open internal devtools of Dirac DevTools window
2. go to "Sources" panel
3. enable "Pause on exceptions" button with "Pause On Caught Exceptions" checked as well
4. reproduce the bug, Dirac window should stop in the debugger and hopefully the call-stack there will be complete.
5. find the spot where Dirac code is calling something which in turn calls cljs.reader, which in turn throws, also use the Watch/Scope panel to see the exact data passed there, so we know what exactly is malformed.

[Ninerian]

I have the same error. Here are more informations:

It's called in the on-message-handler function of the dirac.lib.ws-client namespace.

The given message is the following:

{:changed-namespaces {:cursive.repl.runtime {:aliases {:reflect "clojure.reflect",
                                                       :set "clojure.set"},
                                             :interns {:symbol-details {:arglists "([sym])"},
                                                       :field->map {:arglists "([field])"},
                                                       :class-exists? {:arglists "([fqn])"},
                                                       :constructor->map {:arglists "([constructor])"},
                                                       :parse-flags {},
                                                       :mapped-metadata {:arglists "([v])"},
                                                       :class-defs {:arglists "([fqns])"},
                                                       :method->map {:arglists "([method])"},
                                                       :ns-symbols-by-name {:arglists "([ns-name])"},
                                                       :mappings {},
                                                       :completions {:arglists "([ns])"}}},
                      :re-com.popover {:aliases {},
                                       :interns {}},
                      :tubax.core {:aliases {},
                                   :interns {}},
                      :cljs.tools.reader {:aliases {},
                                          :interns {}},
                      :re-com.box {:aliases {},
                                   :interns {}},
                      :reagent.core {:aliases {},
                                     :interns {}},
                      :re-com.text {:aliases {},
                                    :interns {}},
                      :vr-secondview.components.pano-menu {:aliases {},
                                                           :interns {}},
                      :devtools.formatters.state {:aliases {},
                                                  :interns {}},
                      :clojure.browser.repl {:aliases {},
                                             :interns {}},
                      :re-frame.undo {:aliases {},
                                      :interns {}},
                      :devtools.reporter {:aliases {},
                                          :interns {}},
                      :vr-secondview.components.history {:aliases {},
                                                         :interns {}},
                      :devtools.formatters {:aliases {},
                                            :interns {}},
                      :sundbry.autobahn {:aliases {},
                                         :interns {}},
                      :devtools.async {:aliases {},
                                       :interns {}},
                      :reagent.impl.template {:aliases {},
                                              :interns {}},
                      :reagent.impl.batching {:aliases {},
                                              :interns {}},
                      :cljs.core.async {:aliases {},
                                        :interns {}},
                      :cljs.core.async.impl.protocols {:aliases {},
                                                       :interns {}},
                      :figwheel.client.file-reloading {:aliases {},
                                                       :interns {}},
                      :dirac.runtime.repl {:aliases {},
                                           :interns {}},
                      :cljs.core.async.impl.buffers {:aliases {},
                                                     :interns {}},
                      :cljs-time.core {:aliases {},
                                       :interns {}},
                      :re-frame.router {:aliases {},
                                        :interns {}},
                      :clojure.core {:aliases {},
                                     :interns {:doseq {:arglists "([seq-exprs & body])",
                                                       :macro "true"},
                                               :unsigned-bit-shift-right {:arglists "([x n])"},
                                               :neg? {:arglists "([x])"},
                                               :expand-method-impl-cache {:arglists "([cache c f])"},
                                               :load-one {:arglists "([lib need-ns require])"},
                                               :load-data-readers {:arglists "([])"},
                                               :var-set {:arglists "([x val])"},
                                               :global-hierarchy {},
                                               :load {:arglists "([& paths])"},
                                               :if-not {:arglists "([test then] [test then else])",
                                                        :macro "true"},
                                               :sequential? {:arglists "([coll])"},
                                               :*verbose-defrecords* {},
                                               :*print-level* {},
                                               :shuffle {:arglists "([coll])"},
                                               :boolean-array {:arglists "([size-or-seq] [size init-val-or-seq])"},
                                               :find {:arglists "([map key])"},
                                               :ams {},
                                               :build-positional-factory {:arglists "([nom classname fields])"},
                                               :alength {:arglists "([array])"},
                                               :bit-xor {:arglists "([x y] [x y & more])"},
                                               :deliver {:arglists "([promise val])"},
                                               :when-let {:arglists "([bindings & body])",
                                                          :macro "true"},
                                               :int-array {:arglists "([size-or-seq] [size init-val-or-seq])"},
                                               :set? {:arglists "([x])"},
                                               :inc' {:arglists "([x])"},
                                               :process-annotation {:arglists "([av v])"},
                                               :cat {:arglists "([rf])"},
                                               :*suppress-read* {},
                                               :flush {:arglists "([])"},
                                               :take-while {:arglists "([pred] [pred coll])"},
                                               :unchecked-float {:arglists "([x])"},
                                               :pmap {:arglists "([f coll] [f coll & colls])"},
                                               :error-mode {:arglists "([a])"},
                                               :num {:arglists "([x])"},
                                               :reduced? {:arglists "([x])"},
                                               :disj! {:arglists "([set] [set key] [set key & ks])"},
                                               :float? {:arglists "([n])"},
                                               :aset-float {:arglists "([array idx val] [array idx idx2 & idxv])"},
                                               :bean {:arglists "([x])"},
                                               :deftype {:arglists "([name [& fields] & opts+specs])",
                                                         :macro "true"},
                                               :booleans {:arglists "([xs])"},
                                               :normalize-slurp-opts {:arglists "([opts])"},
                                               :ns-unalias {:arglists "([ns sym])"},
                                               :re-pattern {:arglists "([s])"},
                                               :min {:arglists "([x] [x y] [x y & more])"},
                                               :pop! {:arglists "([coll])"},
                                               :chunk-append {:arglists "([b x])"},
                                               :nary-inline {:arglists "([op] [op unchecked-op])"},
                                               :prn-str {:arglists "([& xs])"},
                                               :with-precision {:arglists "([precision & exprs])",
                                                                :macro "true"},
                                               :super-chain {:arglists "([c])"},
                                               :format {:arglists "([fmt & args])"},
                                               :reversible? {:arglists "([coll])"},
                                               :shutdown-agents {:arglists "([])"},
                                               :vary-meta {:arglists "([obj f & args])"},
                                               :<= {:arglists "([x] [x y] [x y & more])"},
                                               :alter {:arglists "([ref fun & args])"},
                                               :-' {:arglists "([x] [x y] [x y & more])"},
                                               :if-some {:arglists "([bindings then] [bindings then else & oldform])",
                                                         :macro "true"},
                                               :conj! {:arglists "([] [coll] [coll x])"},
                                               :repeatedly {:arglists "([f] [n f])"},
                                               :zipmap {:arglists "([keys vals])"},
                                               :alter-var-root {:arglists "([v f & args])"},
                                               :biginteger {:arglists "([x])"},
                                               :descriptor {:arglists "([c])"},
                                               :remove {:arglists "([pred] [pred coll])"},
                                               :* {:arglists "([] [x] [x y] [x y & more])"},
                                               :-> {:arglists "([x & forms])",
                                                    :macro "true"},
                                               :defstruct {:arglists "([name & keys])",
                                                           :macro "true"},
                                               :protocol? {:arglists "([maybe-p])"},
                                               :*err* {},
                                               :assert-same-protocol {:arglists "([protocol-var method-syms])"},
                                               :get {:arglists "([map key] [map key not-found])"},
                                               :doto {:arglists "([x & forms])",
                                                      :macro "true"},
                                               :identity {:arglists "([x])"},
                                               :into {:arglists "([to from] [to xform from])"},
                                               :areduce {:arglists "([a idx ret init expr])",
                                                         :macro "true"},
                                               :long {:arglists "([x])"},
                                               :double {:arglists "([x])"},
                                               :volatile? {:arglists "([x])"},
                                               :conj {:arglists "([coll x] [coll x & xs])"},
                                               :transduce {:arglists "([xform f coll] [xform f init coll])"},
                                               :bound? {:arglists "([& vars])"},
                                               :lazy-seq {:arglists "([& body])",
                                                          :macro "true"},
                                               :*print-length* {},
                                               :*file* {},
                                               :compare-and-set! {:arglists "([atom oldval newval])"},
                                               :*use-context-classloader* {},
                                               :await1 {:arglists "([a])"},
                                               :let {:arglists "([bindings & body])",
                                                     :macro "true"},
                                               :parse-opts+specs {:arglists "([opts+specs])"},
                                               :ref-set {:arglists "([ref val])"},
                                               :pop-thread-bindings {:arglists "([])"},
                                               :interleave {:arglists "([] [c1] [c1 c2] [c1 c2 & colls])"},
                                               :print-map {:arglists "([m print-one w])"},
                                               :printf {:arglists "([fmt & args])"},
                                               :map? {:arglists "([x])"},
                                               :cycle {:arglists "([coll])"},
                                               :fn {:arglists "([& sigs])",
                                                    :macro "true"},
                                               :seque {:arglists "([s] [n-or-q s])"},
                                               :empty? {:arglists "([coll])"},
                                               :short {:arglists "([x])"},
                                               :definterface {:arglists "([name & sigs])",
                                                              :macro "true"},
                                               :pref {:arglists "([] [a] [a b])"},
                                               :filterv {:arglists "([pred coll])"},
                                               :hash {:arglists "([x])"},
                                               :definline {:arglists "([name & decl])",
                                                           :macro "true"},
                                               :nfirst {:arglists "([x])"},
                                               :meta {:arglists "([obj])"},
                                               :find-protocol-impl {:arglists "([protocol x])"},
                                               :emit-extend-protocol {:arglists "([p specs])"},
                                               :bit-and-not {:arglists "([x y] [x y & more])"},
                                               :*default-data-reader-fn* {},
                                               :var? {:arglists "([v])"},
                                               :method-sig {:arglists "([meth])"},
                                               :unchecked-add-int {:arglists "([x y])"},
                                               :unquote-splicing {},
                                               :emit-method-builder {:arglists "([on-interface method on-method arglists])"},
                                               :hash-ordered-coll {:arglists "([coll])"},
                                               :deref-as-map {:arglists "([o])"},
                                               :future {:arglists "([& body])",
                                                        :macro "true"},
                                               :reset-meta! {:arglists "([iref metadata-map])"},
                                               :shift-mask {:arglists "([shift mask x])"},
                                               :chunk-rest {:arglists "([s])"},
                                               :pcalls {:arglists "([& fns])"},
                                               :*allow-unresolved-vars* {},
                                               :ns-resolve {:arglists "([ns sym] [ns env sym])"},
                                               :remove-all-methods {:arglists "([multifn])"},
                                               :most-specific {:arglists "([rtypes])"},
                                               :as-> {:arglists "([expr name & forms])",
                                                      :macro "true"},
                                               :aset-boolean {:arglists "([array idx val] [array idx idx2 & idxv])"},
                                               :trampoline {:arglists "([f] [f & args])"},
                                               :fits-table? {:arglists "([ints])"},
                                               :when-not {:arglists "([test & body])",
                                                          :macro "true"},
                                               :*1 {},
                                               :vec {:arglists "([coll])"},
                                               :*print-meta* {},
                                               :quot {:arglists "([num div])"},
                                               :ns-aliases {:arglists "([ns])"},
                                               :read {:arglists "([] [stream] [stream eof-error? eof-value] [stream eof-error? eof-value recursive?] [opts stream])"},
                                               :unchecked-double {:arglists "([x])"},
                                               :key {:arglists "([e])"},
                                               :longs {:arglists "([xs])"},
                                               :not= {:arglists "([x] [x y] [x y & more])"},
                                               :string? {:arglists "([x])"},
                                               :emit-defrecord {:arglists "([tagname cname fields interfaces methods opts])"},
                                               :aset-double {:arglists "([array idx val] [array idx idx2 & idxv])"},
                                               :overload-name {:arglists "([mname pclasses])"},
                                               :unchecked-multiply-int {:arglists "([x y])"},
                                               :unchecked-int {:arglists "([x])"},
                                               :set-error-handler! {:arglists "([a handler-fn])"},
                                               :keyword? {:arglists "([x])"},
                                               :force {:arglists "([x])"},
                                               :bound-fn* {:arglists "([f])"},
                                               :namespace-munge {:arglists "([ns])"},
                                               :group-by {:arglists "([f coll])"},
                                               :prn {:arglists "([& more])"},
                                               :extend {:arglists "([atype & proto+mmaps])"},
                                               :when {:arglists "([test & body])",
                                                      :macro "true"},
                                               :int {:arglists "([x])"},
                                               :print-meta {:arglists "([o w])"},
                                               :map-entry? {:arglists "([x])"},
                                               :ns-refers {:arglists "([ns])"},
                                               :rand {:arglists "([] [n])"},
                                               :second {:arglists "([x])"},
                                               :vector-of {:arglists "([t] [t & elements])"},
                                               :hash-combine {:arglists "([x y])"},
                                               :> {:arglists "([x] [x y] [x y & more])"},
                                               :replace {:arglists "([smap] [smap coll])"},
                                               :associative? {:arglists "([coll])"},
                                               :defn {:arglists "([name doc-string? attr-map? [params*] prepost-map? body] [name doc-string? attr-map? ([params*] prepost-map? body) + attr-map?])",
                                                      :macro "true"},
                                               :ref {:arglists "([x] [x & options])"},
                                               :bigint {:arglists "([x])"},
                                               :spread {:arglists "([arglist])"},
                                               :extends? {:arglists "([protocol atype])"},
                                               :promise {:arglists "([])"},
                                               :aset-char {:arglists "([array idx val] [array idx idx2 & idxv])"},
                                               :rseq {:arglists "([rev])"},
                                               :load-all {:arglists "([lib need-ns require])"},
                                               :construct-proxy {:arglists "([c & ctor-args])"},
                                               :agent-errors {:arglists "([a])",
                                                              :deprecated "\"1.2\""},
                                               :*compile-files* {},
                                               :>0? {:arglists "([n])"},
                                               :unchecked-multiply {:arglists "([x y])"},
                                               :print-tagged-object {:arglists "([o rep w])"},
                                               :default-data-readers {},
                                               :some->> {:arglists "([expr & forms])",
                                                         :macro "true"},
                                               :->VecSeq {:arglists "([am vec anode i offset])"},
                                               :even? {:arglists "([n])"},
                                               :unchecked-dec {:arglists "([x])"},
                                               :tagged-literal? {:arglists "([value])"},
                                               :double-array {:arglists "([size-or-seq] [size init-val-or-seq])"},
                                               :in-ns {:arglists "([name])"},
                                               :create-ns {:arglists "([sym])"},
                                               :re-matcher {:arglists "([re s])"},
                                               :*loading-verbosely* {},
                                               :amap {:arglists "([a idx ret expr])",
                                                      :macro "true"},
                                               :pop {:arglists "([coll])"},
                                               :use {:arglists "([& args])"},
                                               :print-object {:arglists "([o w])"},
                                               :unquote {},
                                               :declare {:arglists "([& names])",
                                                         :macro "true"},
                                               :*math-context* {},
                                               :float {:arglists "([x])"},
                                               :pr-str {:arglists "([& xs])"},
                                               :concat {:arglists "([] [x] [x y] [x y & zs])"},
                                               :aset-short {:arglists "([array idx val] [array idx idx2 & idxv])"},
                                               :set-agent-send-off-executor! {:arglists "([executor])"},
                                               :ns {:arglists "([name docstring? attr-map? references*])",
                                                    :macro "true"},
                                               :mk-am {:arglists "([t])",
                                                       :macro "true"},
                                               :symbol {:arglists "([name] [ns name])"},
                                               :to-array-2d {:arglists "([coll])"},
                                               :valid-java-method-name {:arglists "([s])"},
                                               :mod {:arglists "([num div])"},
                                               :reset! {:arglists "([atom newval])"},
                                               :name {:arglists "([x])"},
                                               :ffirst {:arglists "([x])"},
                                               :emit-protocol {:arglists "([name opts+sigs])"},
                                               :sorted-set {:arglists "([& keys])"},
                                               :emit-hinted-impl {:arglists "([c [p fs]])"},
                                               :counted? {:arglists "([coll])"},
                                               :byte-array {:arglists "([size-or-seq] [size init-val-or-seq])"},
                                               :dissoc! {:arglists "([map key] [map key & ks])"},
                                               :reductions {:arglists "([f coll] [f init coll])"},
                                               :aset-byte {:arglists "([array idx val] [array idx idx2 & idxv])"},
                                               :ref-history-count {:arglists "([ref])"},
                                               :- {:arglists "([x] [x y] [x y & more])"},
                                               :assoc! {:arglists "([coll key val] [coll key val & kvs])"},
                                               :hash-set {:arglists "([] [& keys])"},
                                               :reduce-kv {:arglists "([f init coll])"},
                                               :or {:arglists "([] [x] [x & next])",
                                                    :macro "true"},
                                               :cast {:arglists "([c x])"},
                                               :EMPTY-NODE {},
                                               :time {:arglists "([expr])",
                                                      :macro "true"},
                                               :memoize {:arglists "([f])"},
                                               :alter-meta! {:arglists "([iref f & args])"},
                                               :future? {:arglists "([x])"},
                                               :zero? {:arglists "([x])"},
                                               :add-annotations {:arglists "([visitor m] [visitor m i])"},
                                               :tagged-literal {:arglists "([tag form])"},
                                               :println {:arglists "([& more])"},
                                               :assert-args {:arglists "([& pairs])",
                                                             :macro "true"},
                                               :extend-type {:arglists "([t & specs])",
                                                             :macro "true"},
                                               :macroexpand-1 {:arglists "([form])"},
                                               :assoc-in {:arglists "([m [k & ks] v])"},
                                               :char-name-string {},
                                               :bit-test {:arglists "([x n])"},
                                               :defmethod {:arglists "([multifn dispatch-val & fn-tail])",
                                                           :macro "true"},
                                               :memfn {:arglists "([name & args])",
                                                       :macro "true"},
                                               :struct-map {:arglists "([s & inits])"},
                                               :drop {:arglists "([n] [n coll])"},
                                               :parse-impls {:arglists "([specs])"},
                                               :*data-readers* {},
                                               :load-libs {:arglists "([& args])"},
                                               :nth {:arglists "([coll index] [coll index not-found])"},
                                               :nil? {:arglists "([x])"},
                                               :sorted? {:arglists "([coll])"},
                                               :extend-protocol {:arglists "([p & specs])",
                                                                 :macro "true"},
                                               :split-at {:arglists "([n coll])"},
                                               :*e {},
                                               :validate-generate-class-options {:arglists "([{:keys [methods]}])"},
                                               :load-reader {:arglists "([rdr])"},
                                               :require {:arglists "([& args])"},
                                               :unchecked-dec-int {:arglists "([x])"},
                                               :persistent! {:arglists "([coll])"},
                                               :nnext {:arglists "([x])"},
                                               :not-every? {:arglists "([pred coll])"},
                                               :class? {:arglists "([x])"},
                                               :add-watch {:arglists "([reference key fn])"},
                                               :rem {:arglists "([num div])"},
                                               :agent-error {:arglists "([a])"},
                                               :some {:arglists "([pred coll])"},
                                               :future-cancelled? {:arglists "([f])"},
                                               :instance? {:arglists "([c x])"},
                                               :with-open {:arglists "([bindings & body])",
                                                           :macro "true"},
                                               :mix-collection-hash {:arglists "([hash-basis count])"},
                                               :re-find {:arglists "([m] [re s])"},
                                               :run! {:arglists "([proc coll])"},
                                               :val {:arglists "([e])"},
                                               :defonce {:arglists "([name expr])",
                                                         :macro "true"},
                                               :unchecked-add {:arglists "([x y])"},
                                               :print-sequential {:arglists "([begin print-one sep end sequence w])"},
                                               :loaded-libs {:arglists "([])"},
                                               :->Vec {:arglists "([am cnt shift root tail _meta])"},
                                               :filter-methods {:arglists "([c invalid-method?])"},
                                               :not {:arglists "([x])"},
                                               :with-meta {:arglists "([obj m])"},
                                               :unreduced {:arglists "([x])"},
                                               :the-ns {:arglists "([x])"},
                                               :record? {:arglists "([x])"},
                                               :type {:arglists "([x])"},
                                               :identical? {:arglists "([x y])"},
                                               :random-sample {:arglists "([prob] [prob coll])"},
                                               :cond-> {:arglists "([expr & clauses])",
                                                        :macro "true"},
                                               :dotimes {:arglists "([bindings & body])",
                                                         :macro "true"},
                                               :select-keys {:arglists "([map keyseq])"},
                                               :bit-and {:arglists "([x y] [x y & more])"},
                                               :update {:arglists "([m k f] [m k f x] [m k f x y] [m k f x y z] [m k f x y z & more])"},
                                               :group-by-sig {:arglists "([coll])"},
                                               :list* {:arglists "([args] [a args] [a b args] [a b c args] [a b c d & more])"},
                                               :reify {:arglists "([& opts+specs])",
                                                       :macro "true"},
                                               :update-in {:arglists "([m [k & ks] f & args])"},
                                               :prefer-method {:arglists "([multifn dispatch-val-x dispatch-val-y])"},
                                               :aset-int {:arglists "([array idx val] [array idx idx2 & idxv])"},
                                               :*clojure-version* {},
                                               :ensure-reduced {:arglists "([x])"},
                                               :*' {:arglists "([] [x] [x y] [x y & more])"},
                                               :set-validator! {:arglists "([iref validator-fn])"},
                                               :maybe-destructured {:arglists "([params body])"},
                                               :maybe-min-hash {:arglists "([hashes])"},
                                               :max-switch-table-size {},
                                               :defprotocol {:arglists "([name & opts+sigs])",
                                                             :macro "true"},
                                               :the-class {:arglists "([x])"},
                                               :swap! {:arglists "([atom f] [atom f x] [atom f x y] [atom f x y & args])"},
                                               :vals {:arglists "([map])"},
                                               :unchecked-divide-int {:arglists "([x y])"},
                                               :ns-name {:arglists "([ns])"},
                                               :is-annotation? {:arglists "([c])"},
                                               :max-key {:arglists "([k x] [k x y] [k x y & more])"},
                                               :*unchecked-math* {},
                                               :defn- {:arglists "([name & decls])",
                                                       :macro "true"},
                                               :*out* {},
                                               :file-seq {:arglists "([dir])"},
                                               :agent {:arglists "([state & options])"},
                                               :ns-map {:arglists "([ns])"},
                                               :remove-method {:arglists "([multifn dispatch-val])"},
                                               :*in* {},
                                               :load-lib {:arglists "([prefix lib & options])"},
                                               :print-ctor {:arglists "([o print-args w])"},
                                               :letfn {:arglists "([fnspecs & body])",
                                                       :macro "true"},
                                               :volatile! {:arglists "([val])"},
                                               :/ {:arglists "([x] [x y] [x y & more])"},
                                               :read-line {:arglists "([])"},
                                               :binding-conveyor-fn {:arglists "([f])"},
                                               :reader-conditional? {:arglists "([value])"},
                                               :bit-or {:arglists "([x y] [x y & more])"},
                                               :clear-agent-errors {:arglists "([a])",
                                                                    :deprecated "\"1.2\""},
                                               :vector {:arglists "([] [a] [a b] [a b c] [a b c d] [a b c d e] [a b c d e f] [a b c d e f & args])"},
                                               :unchecked-subtract {:arglists "([x y])"},
                                               :*warn-on-reflection* {},
                                               :sorted-set-by {:arglists "([comparator & keys])"},
                                               :sync {:arglists "([flags-ignored-for-now & body])",
                                                      :macro "true"},
                                               :assert {:arglists "([x] [x message])",
                                                        :macro "true"},
                                               :*compile-path* {},
                                               :true? {:arglists "([x])"},
                                               :array {:arglists "([& items])"},
                                               :release-pending-sends {:arglists "([])"},
                                               :print {:arglists "([& more])"},
                                               :empty {:arglists "([coll])"},
                                               :add-classpath {:arglists "([url])",
                                                               :deprecated "\"1.1\""},
                                               :bit-flip {:arglists "([x n])"},
                                               :long-array {:arglists "([size-or-seq] [size init-val-or-seq])"},
                                               :filter-key {:arglists "([keyfn pred amap])"},
                                               :descendants {:arglists "([tag] [h tag])"},
                                               :find-field {:arglists "([c f])"},
                                               :merge {:arglists "([& maps])"},
                                               :accessor {:arglists "([s key])"},
                                               :proxy-super {:arglists "([meth & args])",
                                                             :macro "true"},
                                               :>= {:arglists "([x] [x y] [x y & more])"},
                                               :drop-last {:arglists "([s] [n s])"},
                                               :not-empty {:arglists "([coll])"},
                                               :root-directory {:arglists "([lib])"},
                                               :distinct {:arglists "([] [coll])"},
                                               :partition {:arglists "([n coll] [n step coll] [n step pad coll])"},
                                               :data-reader-urls {:arglists "([])"},
                                               :loop {:arglists "([bindings & body])",
                                                      :macro "true"},
                                               :special-symbol? {:arglists "([s])"},
                                               :prep-hashes {:arglists "([expr-sym default tests thens])"},
                                               :subseq {:arglists "([sc test key] [sc start-test start-key end-test end-key])"},
                                               :error-handler {:arglists "([a])"},
                                               :ancestors {:arglists "([tag] [h tag])"},
                                               :gensym {:arglists "([] [prefix-string])"},
                                               :cond {:arglists "([& clauses])",
                                                      :macro "true"},
                                               :check-valid-options {:arglists "([options & valid-keys])"},
                                               :ratio? {:arglists "([n])"},
                                               :delay? {:arglists "([x])"},
                                               :intern {:arglists "([ns name] [ns name val])"},
                                               :print-simple {:arglists "([o w])"},
                                               :flatten {:arglists "([x])"},
                                               :doubles {:arglists "([xs])"},
                                               :integer? {:arglists "([n])"},
                                               :mapv {:arglists "([f coll] [f c1 c2] [f c1 c2 c3] [f c1 c2 c3 & colls])"},
                                               :partition-all {:arglists "([n] [n coll] [n step coll])"},
                                               :partition-by {:arglists "([f] [f coll])"},
                                               :numerator {:arglists "([r])"},
                                               :object-array {:arglists "([size-or-seq])"},
                                               :with-out-str {:arglists "([& body])",
                                                              :macro "true"},
                                               :condp {:arglists "([pred expr & clauses])",
                                                       :macro "true"},
                                               :derive {:arglists "([tag parent] [h tag parent])"},
                                               :load-string {:arglists "([s])"},
                                               :chunked-seq? {:arglists "([s])"},
                                               :find-keyword {:arglists "([name] [ns name])"},
                                               :replicate {:arglists "([n x])",
                                                           :deprecated "\"1.3\""},
                                               :min-key {:arglists "([k x] [k x y] [k x y & more])"},
                                               :reduced {:arglists "([x])"},
                                               :char-escape-string {},
                                               :re-matches {:arglists "([re s])"},
                                               :array-map {:arglists "([] [& keyvals])"},
                                               :unchecked-byte {:arglists "([x])"},
                                               :reduce1 {:arglists "([f coll] [f val coll])"},
                                               :with-local-vars {:arglists "([name-vals-vec & body])",
                                                                 :macro "true"},
                                               :ns-imports {:arglists "([ns])"},
                                               :send-off {:arglists "([a f & args])"},
                                               :defmacro {:arglists "([name doc-string? attr-map? [params*] body] [name doc-string? attr-map? ([params*] body) + attr-map?])",
                                                          :macro "true"},
                                               :with-in-str {:arglists "([s & body])",
                                                             :macro "true"},
                                               :remove-watch {:arglists "([reference key])"},
                                               :ex-info {:arglists "([msg map] [msg map cause])"},
                                               :ifn? {:arglists "([x])"},
                                               :some-> {:arglists "([expr & forms])",
                                                        :macro "true"},
                                               :asm-type {:arglists "([c])"},
                                               :proxy-name {:arglists "([super interfaces])"},
                                               :ns-interns {:arglists "([ns])"},
                                               :all-ns {:arglists "([])"},
                                               :find-protocol-method {:arglists "([protocol methodk x])"},
                                               :subvec {:arglists "([v start] [v start end])"},
                                               :for {:arglists "([seq-exprs body-expr])",
                                                     :macro "true"},
                                               :binding {:arglists "([bindings & body])",
                                                         :macro "true"},
                                               :partial {:arglists "([f] [f arg1] [f arg1 arg2] [f arg1 arg2 arg3] [f arg1 arg2 arg3 & more])"},
                                               :print-throwable {:arglists "([o w])"},
                                               :*3 {},
                                               :validate-fields {:arglists "([fields name])"},
                                               :alias {:arglists "([alias namespace-sym])"},
                                               :frequencies {:arglists "([coll])"},
                                               :read-string {:arglists "([s] [opts s])"},
                                               :proxy {:arglists "([class-and-interfaces args & fs])",
                                                       :macro "true"},
                                               :rsubseq {:arglists "([sc test key] [sc start-test start-key end-test end-key])"},
                                               :inc {:arglists "([x])"},
                                               :get-method {:arglists "([multifn dispatch-val])"},
                                               :with-redefs {:arglists "([bindings & body])",
                                                             :macro "true"},
                                               :bit-clear {:arglists "([x n])"},
                                               :filter {:arglists "([pred] [pred coll])"},
                                               :every-pred {:arglists "([p] [p1 p2] [p1 p2 p3] [p1 p2 p3 & ps])"},
                                               :keys {:arglists "([map])"},
                                               :rationalize {:arglists "([num])"},
                                               :load-file {:arglists "([name])"},
                                               :distinct? {:arglists "([x] [x y] [x y & more])"},
                                               :max-mask-bits {},
                                               :libspec? {:arglists "([x])"},
                                               :prep-ints {:arglists "([tests thens])"},
                                               :extenders {:arglists "([protocol])"},
                                               :unchecked-short {:arglists "([x])"},
                                               :methods {:arglists "([multifn])"},
                                               :odd? {:arglists "([n])"},
                                               :->ArrayChunk {:arglists "([am arr off end])"},
                                               :float-array {:arglists "([size-or-seq] [size init-val-or-seq])"},
                                               :ctor-sigs {:arglists "([super])"},
                                               :chars {:arglists "([xs])"},
                                               :str {:arglists "([] [x] [x & ys])"},
                                               :next {:arglists "([coll])"},
                                               :hash-map {:arglists "([] [& keyvals])"},
                                               :if-let {:arglists "([bindings then] [bindings then else & oldform])",
                                                        :macro "true"},
                                               :underive {:arglists "([tag parent] [h tag parent])"},
                                               :ref-max-history {:arglists "([ref] [ref n])"},
                                               :locking {:arglists "([x & body])",
                                                         :macro "true"},
                                               :list {:arglists "([& items])"},
                                               :+ {:arglists "([] [x] [x y] [x y & more])"},
                                               :def-aset {:arglists "([name method coerce])",
                                                          :macro "true"},
                                               :split-with {:arglists "([pred coll])"},
                                               :aset {:arglists "([array idx val] [array idx idx2 & idxv])"},
                                               :->VecNode {:arglists "([edit arr])"},
                                               :keyword {:arglists "([name] [ns name])"},
                                               :*ns* {},
                                               :destructure {:arglists "([bindings])"},
                                               :*assert* {},
                                               :defmulti {:arglists "([name docstring? attr-map? dispatch-fn & options])",
                                                          :macro "true"},
                                               :non-private-methods {:arglists "([c])"},
                                               :bit-not {:arglists "([x])"},
                                               :io! {:arglists "([& body])",
                                                     :macro "true"},
                                               :generate-interface {:arglists "([{:keys [name extends methods]}])"},
                                               :xml-seq {:arglists "([root])"},
                                               :case-map {:arglists "([case-f test-f tests thens])"},
                                               :byte {:arglists "([x])"},
                                               :max {:arglists "([x] [x y] [x y & more])"},
                                               :== {:arglists "([x] [x y] [x y & more])"},
                                               :Throwable->map {:arglists "([o])"},
                                               :false? {:arglists "([x])"},
                                               :*print-readably* {},
                                               :ints {:arglists "([xs])"},
                                               :case {:arglists "([e & clauses])",
                                                      :macro "true"},
                                               :class {:arglists "([x])"},
                                               :some-fn {:arglists "([p] [p1 p2] [p1 p2 p3] [p1 p2 p3 & ps])"},
                                               :*flush-on-newline* {},
                                               :to-array {:arglists "([coll])"},
                                               :bigdec {:arglists "([x])"},
                                               :list? {:arglists "([x])"},
                                               :add-doc-and-meta {:arglists "([name docstring meta])",
                                                                  :macro "true"},
                                               :interpose {:arglists "([sep] [sep coll])"},
                                               :deref {:arglists "([ref] [ref timeout-ms timeout-val])"},
                                               :emit-impl {:arglists "([[p fs]])"},
                                               :*pending-paths* {},
                                               :assoc {:arglists "([map key val] [map key val & kvs])"},
                                               :*agent* {},
                                               :lazy-cat {:arglists "([& colls])",
                                                          :macro "true"},
                                               :comment {:arglists "([& body])",
                                                         :macro "true"},
                                               :parents {:arglists "([tag] [h tag])"},
                                               :count {:arglists "([coll])"},
                                               :root-resource {:arglists "([lib])"},
                                               :*loaded-libs* {},
                                               :supers {:arglists "([class])"},
                                               :generate-proxy {:arglists "([super interfaces])"},
                                               :*fn-loader* {},
                                               :sorted-map-by {:arglists "([comparator & keyvals])"},
                                               :apply {:arglists "([f args] [f x args] [f x y args] [f x y z args] [f a b c d & args])"},
                                               :complement {:arglists "([f])"},
                                               :*compiler-options* {},
                                               :*print-dup* {},
                                               :defrecord {:arglists "([name [& fields] & opts+specs])",
                                                           :macro "true"},
                                               :with-redefs-fn {:arglists "([binding-map func])"},
                                               :sequence {:arglists "([coll] [xform coll] [xform coll & colls])"},
                                               :constantly {:arglists "([x])"},
                                               :get-proxy-class {:arglists "([& bases])"},
                                               :system-newline {},
                                               :rational? {:arglists "([n])"},
                                               :transient {:arglists "([coll])"},
                                               :clojure-version {:arglists "([])"},
                                               :merge-hash-collisions {:arglists "([expr-sym default tests thens])"},
                                               :chunk-cons {:arglists "([chunk rest])"},
                                               :comparator {:arglists "([pred])"},
                                               :sorted-map {:arglists "([& keyvals])"},
                                               :send {:arglists "([a f & args])"},
                                               :drop-while {:arglists "([pred] [pred coll])"},
                                               :proxy-call-with-super {:arglists "([call this meth])"},
                                               :realized? {:arglists "([x])"},
                                               :char-array {:arglists "([size-or-seq] [size init-val-or-seq])"},
                                               :resolve {:arglists "([sym] [env sym])"},
                                               :compare {:arglists "([x y])"},
                                               :nthnext {:arglists "([coll n])"},
                                               :and {:arglists "([] [x] [x & next])",
                                                     :macro "true"},
                                               :create-struct {:arglists "([& keys])"},
                                               :preserving-reduced {:arglists "([rf])"},
                                               :get-validator {:arglists "([iref])"},
                                               :number? {:arglists "([x])"},
                                               :await-for {:arglists "([timeout-ms & agents])"},
                                               :chunk-next {:arglists "([s])"},
                                               :print-str {:arglists "([& xs])"},
                                               :not-any? {:arglists "([pred coll])"},
                                               :into-array {:arglists "([aseq] [type aseq])"},
                                               :make-array {:arglists "([type len] [type dim & more-dims])"},
                                               :shorts {:arglists "([xs])"},
                                               :completing {:arglists "([f] [f cf])"},
                                               :update-proxy {:arglists "([proxy mappings])"},
                                               :unchecked-negate-int {:arglists "([x])"},
                                               :hash-unordered-coll {:arglists "([coll])"},
                                               :repeat {:arglists "([x] [n x])"},
                                               :unchecked-inc {:arglists "([x])"},
                                               :coll? {:arglists "([x])"},
                                               :get-in {:arglists "([m ks] [m ks not-found])"},
                                               :fnext {:arglists "([x])"},
                                               :denominator {:arglists "([r])"},
                                               :bytes {:arglists "([xs])"},
                                               :refer-clojure {:arglists "([& filters])",
                                                               :macro "true"},
                                               :escape-class-name {:arglists "([c])"},
                                               :init-proxy {:arglists "([proxy mappings])"},
                                               :chunk-buffer {:arglists "([capacity])"},
                                               :symbol? {:arglists "([x])"},
                                               :when-some {:arglists "([bindings & body])",
                                                           :macro "true"},
                                               :unchecked-char {:arglists "([x])"},
                                               :>1? {:arglists "([n])"},
                                               :->> {:arglists "([x & forms])",
                                                     :macro "true"},
                                               :future-cancel {:arglists "([f])"},
                                               :var-get {:arglists "([x])"},
                                               :commute {:arglists "([ref fun & args])"},
                                               :when-first {:arglists "([bindings & body])",
                                                            :macro "true"},
                                               :find-ns {:arglists "([sym])"},
                                               :get-thread-bindings {:arglists "([])"},
                                               :into1 {:arglists "([to from])"},
                                               :contains? {:arglists "([coll key])"},
                                               :every? {:arglists "([pred coll])"},
                                               :proxy-mappings {:arglists "([proxy])"},
                                               :keep-indexed {:arglists "([f] [f coll])"},
                                               :cond->> {:arglists "([expr & clauses])",
                                                         :macro "true"},
                                               :subs {:arglists "([s start] [s start end])"},
                                               :ref-min-history {:arglists "([ref] [ref n])"},
                                               :primitives-classnames {},
                                               :+' {:arglists "([] [x] [x y] [x y & more])"},
                                               :decimal? {:arglists "([n])"},
                                               :prependss {:arglists "([x coll])"},
                                               :restart-agent {:arglists "([a new-state & options])"},
                                               :sort-by {:arglists "([keyfn coll] [keyfn comp coll])"},
                                               :is-runtime-annotation? {:arglists "([c])"},
                                               :macroexpand {:arglists "([form])"},
                                               :ensure {:arglists "([ref])"},
                                               :imap-cons {:arglists "([this o])"},
                                               :chunk-first {:arglists "([s])"},
                                               :add-annotation {:arglists "([av name v])"},
                                               :load-data-reader-file {:arglists "([mappings url])"},
                                               :eduction {:arglists "([xform* coll])"},
                                               :tree-seq {:arglists "([branch? children root])"},
                                               :unchecked-remainder-int {:arglists "([x y])"},
                                               :seq {:arglists "([coll])"},
                                               :reduce {:arglists "([f coll] [f val coll])"},
                                               :line-seq {:arglists "([rdr])"},
                                               :unchecked-subtract-int {:arglists "([x y])"},
                                               :take-nth {:arglists "([n] [n coll])"},
                                               :first {:arglists "([coll])"},
                                               :re-groups {:arglists "([m])"},
                                               :seq? {:arglists "([x])"},
                                               :dec' {:arglists "([x])"},
                                               :ns-unmap {:arglists "([ns sym])"},
                                               :println-str {:arglists "([& xs])"},
                                               :with-bindings* {:arglists "([binding-map f & args])"},
                                               :iterator-seq {:arglists "([iter])"},
                                               :sigs {},
                                               :set {:arglists "([coll])"},
                                               :take-last {:arglists "([n coll])"},
                                               :bit-set {:arglists "([x n])"},
                                               :reader-conditional {:arglists "([form splicing?])"},
                                               :gen-class {:arglists "([& options])",
                                                           :macro "true"},
                                               :while {:arglists "([test & body])",
                                                       :macro "true"},
                                               :->Eduction {:arglists "([xform coll])"},
                                               :throw-if {:arglists "([pred fmt & args])"},
                                               :butlast {:arglists "([coll])"},
                                               :satisfies? {:arglists "([protocol x])"},
                                               :pr-on {:arglists "([x w])"},
                                               :dissoc {:arglists "([map] [map key] [map key & ks])"},
                                               :atom {:arglists "([x] [x & options])"},
                                               :import {:arglists "([& import-symbols-or-lists])",
                                                        :macro "true"},
                                               :bit-shift-right {:arglists "([x n])"},
                                               :print-method {},
                                               :peek {:arglists "([coll])"},
                                               :aget {:arglists "([array idx] [array idx & idxs])"},
                                               :pvalues {:arglists "([& exprs])",
                                                         :macro "true"},
                                               :bound-fn {:arglists "([& fntail])",
                                                          :macro "true"},
                                               :check-cyclic-dependency {:arglists "([path])"},
                                               :iterate {:arglists "([f x])"},
                                               :slurp {:arglists "([f & opts])"},
                                               :newline {:arglists "([])"},
                                               :short-array {:arglists "([size-or-seq] [size init-val-or-seq])"},
                                               :deref-future {:arglists "([fut] [fut timeout-ms timeout-val])"},
                                               :fn? {:arglists "([x])"},
                                               :doall {:arglists "([coll] [n coll])"},
                                               :prefers {:arglists "([multifn])"},
                                               :enumeration-seq {:arglists "([e])"},
                                               :dedupe {:arglists "([] [coll])"},
                                               :bit-shift-left {:arglists "([x n])"},
                                               :find-var {:arglists "([sym])"},
                                               :rand-int {:arglists "([n])"},
                                               :aclone {:arglists "([array])"},
                                               :vreset! {:arglists "([vol newval])"},
                                               :chunk {:arglists "([b])"},
                                               :dec {:arglists "([x])"},
                                               :future-call {:arglists "([f])"},
                                               :resultset-seq {:arglists "([rs])"},
                                               :struct {:arglists "([s & vals])"},
                                               :mk-bound-fn {:arglists "([sc test key])"},
                                               :vswap! {:arglists "([vol f & args])",
                                                        :macro "true"},
                                               :last {:arglists "([coll])"},
                                               :pr {:arglists "([] [x] [x & more])"},
                                               :namespace {:arglists "([x])"},
                                               :push-thread-bindings {:arglists "([bindings])"},
                                               :bases {:arglists "([c])"},
                                               := {:arglists "([x] [x y] [x y & more])"},
                                               :dosync {:arglists "([& exprs])",
                                                        :macro "true"},
                                               :take {:arglists "([n] [n coll])"},
                                               :remove-ns {:arglists "([sym])"},
                                               :vector? {:arglists "([x])"},
                                               :thread-bound? {:arglists "([& vars])"},
                                               :send-via {:arglists "([executor a f & args])"},
                                               :boolean {:arglists "([x])"},
                                               :compile {:arglists "([lib])"},
                                               :isa? {:arglists "([child parent] [h child parent])"},
                                               :.. {:arglists "([x form] [x form & more])",
                                                    :macro "true"},
                                               :munge {:arglists "([s])"},
                                               :delay {:arglists "([& body])",
                                                       :macro "true"},
                                               :protected-final-methods {:arglists "([c])"},
                                               :set-error-mode! {:arglists "([a mode-keyword])"},
                                               :re-seq {:arglists "([re s])"},
                                               :char? {:arglists "([x])"},
                                               :make-hierarchy {:arglists "([])"},
                                               :data-reader-var {:arglists "([sym])"},
                                               :map {:arglists "([f] [f coll] [f c1 c2] [f c1 c2 c3] [f c1 c2 c3 & colls])"},
                                               :juxt {:arglists "([f] [f g] [f g h] [f g h & fs])"},
                                               :print-initialized {},
                                               :setup-reference {:arglists "([r options])"},
                                               :ns-publics {:arglists "([ns])"},
                                               :< {:arglists "([x] [x y] [x y & more])"},
                                               :*source-path* {},
                                               :with-loading-context {:arglists "([& body])",
                                                                      :macro "true"},
                                               :test {:arglists "([v])"},
                                               :rest {:arglists "([coll])"},
                                               :ex-data {:arglists "([ex])"},
                                               :emit-deftype* {:arglists "([tagname cname fields interfaces methods opts])"},
                                               :sort {:arglists "([coll] [comp coll])"},
                                               :generate-class {:arglists "([options-map])"},
                                               :-cache-protocol-fn {:arglists "([pf x c interf])"},
                                               :unchecked-inc-int {:arglists "([x])"},
                                               :map-indexed {:arglists "([f] [f coll])"},
                                               :with-bindings {:arglists "([binding-map & body])",
                                                               :macro "true"},
                                               :rand-nth {:arglists "([coll])"},
                                               :comp {:arglists "([] [f] [f g] [f g & fs])"},
                                               :await {:arglists "([& agents])"},
                                               :spit {:arglists "([f content & options])"},
                                               :future-done? {:arglists "([f])"},
                                               :set-agent-send-executor! {:arglists "([executor])"},
                                               :keep {:arglists "([f] [f coll])"},
                                               :char {:arglists "([x])"},
                                               :mapcat {:arglists "([f] [f & colls])"},
                                               :unchecked-long {:arglists "([x])"},
                                               :emit-extend-type {:arglists "([c specs])"},
                                               :aset-long {:arglists "([array idx val] [array idx idx2 & idxv])"},
                                               :some? {:arglists "([x])"},
                                               :unchecked-negate {:arglists "([x])"},
                                               :get-super-and-interfaces {:arglists "([bases])"},
                                               :parse-opts {:arglists "([s])"},
                                               :gen-interface {:arglists "([& options])",
                                                               :macro "true"},
                                               :reverse {:arglists "([coll])"},
                                               :*command-line-args* {},
                                               :prim->class {},
                                               :range {:arglists "([] [end] [start end] [start end step])"},
                                               :cons {:arglists "([x seq])"},
                                               :refer {:arglists "([ns-sym & filters])"},
                                               :print-dup {},
                                               :-reset-methods {:arglists "([protocol])"},
                                               :floats {:arglists "([xs])"},
                                               :pos? {:arglists "([x])"},
                                               :fnil {:arglists "([f x] [f x y] [f x y z])"},
                                               :merge-with {:arglists "([f & maps])"},
                                               :nthrest {:arglists "([coll n])"},
                                               :*read-eval* {},
                                               :dorun {:arglists "([coll] [n coll])"},
                                               :implements? {:arglists "([protocol atype])"},
                                               :assert-valid-fdecl {:arglists "([fdecl])"},
                                               :disj {:arglists "([set] [set key] [set key & ks])"},
                                               :*2 {},
                                               :eval {:arglists "([form])"}}},
                      :vr-secondview.utils.path-gen {:aliases {},
                                                     :interns {}},
                      :tubax.helpers {:aliases {},
                                      :interns {}},
                      :dirac.runtime.deps {:aliases {},
                                           :interns {}},
                      :re-frame.utils {:aliases {},
                                       :interns {}},
                      :clojure.set {:aliases {},
                                    :interns {:intersection {:arglists "([s1] [s1 s2] [s1 s2 & sets])"},
                                              :superset? {:arglists "([set1 set2])"},
                                              :index {:arglists "([xrel ks])"},
                                              :bubble-max-key {:arglists "([k coll])"},
                                              :subset? {:arglists "([set1 set2])"},
                                              :rename {:arglists "([xrel kmap])"},
                                              :rename-keys {:arglists "([map kmap])"},
                                              :project {:arglists "([xrel ks])"},
                                              :difference {:arglists "([s1] [s1 s2] [s1 s2 & sets])"},
                                              :union {:arglists "([] [s1] [s1 s2] [s1 s2 & sets])"},
                                              :map-invert {:arglists "([m])"},
                                              :join {:arglists "([xrel yrel] [xrel yrel km])"},
                                              :select {:arglists "([pred xset])"}}},
                      :vr-secondview.autobahn {:aliases {},
                                               :interns {}},
                      :devtools.protocols {:aliases {},
                                           :interns {}},
                      :reagent.impl.component {:aliases {},
                                               :interns {}},
                      :re-com.tabs {:aliases {},
                                    :interns {}},
                      :vr-secondview.utils.helpers {:aliases {},
                                                    :interns {}},
                      :dirac.runtime.bootstrap {:aliases {},
                                                :interns {}},
                      :devtools.hints {:aliases {},
                                       :interns {}},
                      :vr-secondview.handlers {:aliases {},
                                               :interns {}},
                      :com.stuartsierra.component {:aliases {:dep "com.stuartsierra.dependency",
                                                             :platform "com.stuartsierra.component.platform"},
                                                   :interns {:get-component {:arglists "([system key])"},
                                                             :update-system {:arglists "([system component-keys f & args])"},
                                                             :nil-component {:arglists "([system key])"},
                                                             :ex-without-components {:arglists "([error])"},
                                                             :get-dependency {:arglists "([system system-key component dependency-key])"},
                                                             :system-using {:arglists "([system dependency-map])"},
                                                             :assoc-dependencies {:arglists "([component system])"},
                                                             :start {:arglists "([component])"},
                                                             :dependency-graph {:arglists "([system component-keys])"},
                                                             :stop-system {:arglists "([system] [system component-keys])"},
                                                             :update-system-reverse {:arglists "([system component-keys f & args])"},
                                                             :map->SystemMap {:arglists "([m__6522__auto__])"},
                                                             :stop {:arglists "([component])"},
                                                             :assoc-dependency {:arglists "([system component dependency-key system-key])"},
                                                             :try-action {:arglists "([component system key f args])"},
                                                             :ex-component? {:arglists "([error])"},
                                                             :->SystemMap {:arglists "([])"},
                                                             :system-map {:arglists "([& keyvals])"},
                                                             :start-system {:arglists "([system] [system component-keys])"},
                                                             :Lifecycle {},
                                                             :using {:arglists "([component dependencies])"},
                                                             :dependencies {:arglists "([component])"}}},
                      :vr-secondview.utils.file-loader {:aliases {},
                                                        :interns {}},
                      :cljs.tools.reader.impl.utils {:aliases {},
                                                     :interns {}},
                      :cljs-time.internal.core {:aliases {},
                                                :interns {}},
                      :re-frame.handlers {:aliases {},
                                          :interns {}},
                      :vr-secondview.components.tour-viewer {:aliases {},
                                                             :interns {}},
                      :dirac.runtime {:aliases {},
                                      :interns {}},
                      :re-com.alert {:aliases {},
                                     :interns {}},
                      :re-com.datepicker {:aliases {},
                                          :interns {}},
                      :dirac.runtime.output {:aliases {},
                                             :interns {}},
                      :re-com.input-time {:aliases {},
                                          :interns {}},
                      :clojure.browser.net {:aliases {},
                                            :interns {}},
                      :re-frame.subs {:aliases {},
                                      :interns {}},
                      :devtools.formatters.budgeting {:aliases {},
                                                      :interns {}},
                      :re-frame.middleware {:aliases {},
                                            :interns {}},
                      :vr-secondview.db {:aliases {},
                                         :interns {}},
                      :re-com.buttons {:aliases {},
                                       :interns {}},
                      :devtools.format {:aliases {},
                                        :interns {}},
                      :dirac.runtime.util {:aliases {},
                                           :interns {}},
                      :cljs.core.async.impl.ioc-helpers {:aliases {},
                                                         :interns {}},
                      :cljs-time.format {:aliases {},
                                         :interns {}},
                      :re-com.tour {:aliases {},
                                    :interns {}},
                      :vr-secondview.devtools {:aliases {},
                                               :interns {}},
                      :figwheel.client.socket {:aliases {},
                                               :interns {}},
                      :devtools.core {:aliases {},
                                      :interns {}},
                      :re-com.selection-list {:aliases {},
                                              :interns {}},
                      :figwheel.client.heads-up {:aliases {},
                                                 :interns {}},
                      :cljs.reader {:aliases {},
                                    :interns {}},
                      :re-com.dropdown {:aliases {},
                                        :interns {}},
                      :vr-secondview.components.tour-selector {:aliases {},
                                                               :interns {}},
                      :vr-secondview.config {:aliases {},
                                             :interns {}},
                      :re-com.misc {:aliases {},
                                    :interns {}},
                      :re-com.splits {:aliases {},
                                      :interns {}},
                      :re-frame.db {:aliases {},
                                    :interns {}},
                      :re-frame.core {:aliases {},
                                      :interns {}},
                      :cljs.core.async.impl.timers {:aliases {},
                                                    :interns {}},
                      :cljs-time.predicates {:aliases {},
                                             :interns {}},
                      :cljs.user {:aliases {},
                                  :interns {}},
                      :re-com.modal-panel {:aliases {},
                                           :interns {}},
                      :clojure.browser.event {:aliases {},
                                              :interns {}},
                      :vr-secondview.components.client-list {:aliases {},
                                                             :interns {}},
                      :reagent.impl.util {:aliases {},
                                          :interns {}},
                      :devtools.formatters.core {:aliases {},
                                                 :interns {}},
                      :devtools.formatters.helpers {:aliases {},
                                                    :interns {}},
                      :vr-secondview.core {:aliases {},
                                           :interns {}},
                      :cljs.core.async.impl.channels {:aliases {},
                                                      :interns {}},
                      :vr-secondview.routes {:aliases {},
                                             :interns {}},
                      :cljs.core.async.impl.dispatch {:aliases {},
                                                      :interns {}},
                      :re-com.util {:aliases {},
                                    :interns {}},
                      :cljs.tools.reader.impl.commons {:aliases {},
                                                       :interns {}},
                      :vr-secondview.views {:aliases {},
                                            :interns {}},
                      :re-frame-tracer.core {:aliases {},
                                             :interns {}},
                      :clojure.reflect {:aliases {:set "clojure.set",
                                                  :str "clojure.string"},
                                        :interns {:map->Method {:arglists "([m__6522__auto__])"},
                                                  :field->map {:arglists "([field])"},
                                                  :internal-name->class-symbol {:arglists "([d])"},
                                                  :typename {:arglists "([o])"},
                                                  :->JavaReflector {:arglists "([classloader])"},
                                                  :->AsmReflector {:arglists "([class-resolver])"},
                                                  :resolve-class {:arglists "([this name])"},
                                                  :constructor->map {:arglists "([constructor])"},
                                                  :flag-descriptors {},
                                                  :parse-flags {:arglists "([flags context])"},
                                                  :do-reflect {:arglists "([reflector typeref])"},
                                                  :resource-name {:arglists "([typeref])"},
                                                  :ClassResolver {},
                                                  :parse-method-descriptor {:arglists "([md])"},
                                                  :Reflector {},
                                                  :field-descriptor->class-symbol {:arglists "([d])"},
                                                  :declared-fields {:arglists "([cls])"},
                                                  :typesym {:arglists "([t])"},
                                                  :declared-methods {:arglists "([cls])"},
                                                  :map->Constructor {:arglists "([m__6522__auto__])"},
                                                  :->Constructor {:arglists "([name declaring-class parameter-types exception-types flags])"},
                                                  :type-reflect {:arglists "([typeref & options])"},
                                                  :method->map {:arglists "([method])"},
                                                  :->Field {:arglists "([name type declaring-class flags])"},
                                                  :default-reflector {},
                                                  :access-flag {:arglists "([[name flag & contexts]])"},
                                                  :declared-constructors {:arglists "([cls])"},
                                                  :->Method {:arglists "([name return-type declaring-class parameter-types exception-types flags])"},
                                                  :TypeReference {},
                                                  :reflect {:arglists "([obj & options])"},
                                                  :map->Field {:arglists "([m__6522__auto__])"}}},
                      :devtools.toolbox {:aliases {},
                                         :interns {}},
                      :vr-secondview.subs {:aliases {},
                                           :interns {}},
                      :user {:aliases {:component "com.stuartsierra.component"},
                             :interns {:javadoc {:arglists "([class-or-object])"},
                                       :find-doc {:arglists "([re-string-or-pattern])"},
                                       :system {},
                                       :deep-merge {:arglists "([& vals])"},
                                       :cljs-repl {:arglists "([] [id])"},
                                       :dir {:arglists "([nsname])",
                                             :macro "true"},
                                       :figwheel-config {},
                                       :pst {:arglists "([] [e-or-depth] [e depth])"},
                                       :pp {:arglists "([])",
                                            :macro "true"},
                                       :start {:arglists "([])"},
                                       :source {:arglists "([n])",
                                                :macro "true"},
                                       :stop {:arglists "([])"},
                                       :sass-config {},
                                       :->Figwheel {:arglists "([])"},
                                       :->SassWatcher {:arglists "([executable-path input-dir output-dir])"},
                                       :repl {:arglists "([])"},
                                       :map->SassWatcher {:arglists "([m__6522__auto__])"},
                                       :reload {:arglists "([])"},
                                       :apropos {:arglists "([str-or-pattern])"},
                                       :map->Figwheel {:arglists "([m__6522__auto__])"},
                                       :start-figwheel! {},
                                       :doc {:arglists "([name])",
                                             :macro "true"},
                                       :pprint {:arglists "([object] [object writer])"},
                                       :stop-figwheel! {:arglists "([])"}}},
                      :figwheel.connect.dev {:aliases {},
                                             :interns {}},
                      :cljs.tools.reader.edn {:aliases {},
                                              :interns {}},
                      :devtools.formatters.printing {:aliases {},
                                                     :interns {}},
                      :devtools.formatters.templating {:aliases {},
                                                       :interns {}}},
 :id "f170bf75-0c52-4801-84a2-4dc3129bf993",
 :repl-type "clj",
 :session "4b167080-2237-44ef-ad51-85815ab2f023",
 :status ["state"]}

[darwin]

@Ninerian Hmm, that nREPL message looks like Cursive trying to communicate something to nREPL server and the message gets processed by Dirac middleware. Can you describe your workflow? This should not happen under normal circumstances. Also the problem is that this Cursive message contains some Clojure-isms, so pr-str in Clojure does not encode edn which would be consumable by read-string in ClojureScript. That is why my web-socket unserialization breaks.

At least I wrote more robust handling of this case in ws-client.

[Ninerian]

Actually I start a figwheel dev environment, using a combination of dirac and the workflow, documented in the figwheel wiki.

I start a Repl with the dev profile. After it's loaded, I load the repl.clj to start figwheel. Formerly I loaded the repl.js directly from the REPL profile, as in the wiki. But with dirac, I have to load the profile, which is not possible, when loading the repl through the JVM process.

In the core namespace I initialize dirac with (dirac.runtime/install!).

You may notice the commented part in the project.clj. This is my attempt to load figwheel and dirac directly. I had asked you about on the slack channel on Nov. 18.

My project.clj:

(defproject vr-secondview "0.4.0"
  :dependencies [[org.clojure/clojure "1.8.0"]
                 [org.clojure/clojurescript "1.9.76"]
                 [org.clojure/data.xml "0.1.0-beta1"]
                 [org.clojure/data.zip "0.1.2"]
                 [into-edn "1.0.2"]
								 [com.taoensso/tufte "1.1.0"]
								 [com.taoensso/timbre "4.7.4"]
                 [org.clojure/core.async "0.2.385"]
                 [reagent "0.5.1"]
                 [re-frame "0.7.0"]
                 [re-com "0.8.3"]
                 [secretary "1.2.3"]
                 [garden "1.3.2"]
                 [funcool/tubax "0.2.0"]
                 [sundbry/autobahn.cljs "0.1.2-SNAPSHOT"]
                 [org.clojars.stumitchell/clairvoyant "0.2.0"]
                 [day8/re-frame-tracer "0.1.1-SNAPSHOT"]
                 ;; For Dirac DevTools
                 [environ "1.1.0"]]

  :source-paths ["src/clj" "src/cljs"]

  :plugins [[lein-cljsbuild "1.1.3"]
            [lein-garden "0.2.6"]
            [lein-ancient "0.6.8"]
            [lein-sassc "0.10.4"]
						[lein-environ "1.1.0"]
						[lein-figwheel "0.5.8"]]

  :clean-targets ^{:protect false} ["resources/public/js/compiled" "target" "resources/production"
                                    "test/js"
                                    "resources/public/css/compiled"]

  :figwheel {;:server-port    7111
						 :css-dirs ["resources/public/css"]
             :repl        false}

  :garden {:builds [{:id           "screen"
                     :source-paths ["src/clj"]
                     :stylesheet   vr-secondview.css/screen
                     :compiler     {:output-to     "resources/public/css/compiled/screen.css"
                                    :pretty-print? true}}]}

  :profiles {:dev           {:dependencies [[lein-figwheel "0.5.8"]
																						[figwheel-sidecar "0.5.8"]
																						[binaryage/devtools "0.8.3"]
																						[binaryage/dirac "0.8.4"]
																						]

														 :env          {:devtools       "true"}

														 :repl-options {:port             8230
																						:nrepl-middleware [dirac.nrepl/middleware]
																						:init             (do
																																(require 'dirac.agent)
																																(dirac.agent/boot!))
																						}

														 :cljsbuild    {:builds {:dev {:source-paths ["dev-resources"]}}}
														 }

						 ;:repl {:repl-options {:port             8230
							;													:nrepl-middleware [dirac.nrepl/middleware]
							;													:init             (do
							;																							(require 'dirac.agent)
							;																							(dirac.agent/boot!))
							;			}}

						 ;:figwheel-nrepl
							;							[:figwheel-config
							;							 ; following https://github.com/bhauman/lein-figwheel/wiki/Using-the-Figwheel-REPL-within-NRepl
							;							 { :figwheel     {:on-jsload "vr-secondview.core/mount-root"
							;																;:websockewt-url "wss://daniel.dev/figwheel-ws"
							;																}
							;								:dependencies [[figwheel-sidecar "0.5.8"]]
							;								:repl-options {:init ^:replace (do
							;																								 (require 'dirac.agent)
							;																								 (use 'figwheel-sidecar.repl-api)
							;																								 (start-figwheel!
							;																									 {:figwheel-options {:server-port 7111}                                      ;; <-- figwheel server config goes here
							;																										:build-ids        ["dirac"]                                                 ;; <-- a vector of build ids to start autobuilding
							;																										:all-builds                                                                ;; <-- supply your build configs here
							;																																			[{:id           "dirac"
							;																																				:figwheel     true
							;																																				:source-paths ["src/cljs"]
							;																																				:compiler     {:closure-defines {"clairvoyant.core.devmode" true}
							;																																											 :output-to            "resources/public/js/compiled/app.js"
							;																																											 :output-dir           "resources/public/js/compiled/out"
							;																																											 :asset-path           "js/compiled/out"
							;																																											 :optimizations :none
							;																																											 :source-map true
							;																																											 :source-map-timestamp true
							;																																											 :preloads      ['devtools.preload 'dirac.runtime.preload]
							;																																											 :main          'vr-secondview.core
							;																																											 }}]})
							;																								 (dirac.agent/boot!)
							;																								 #_(cljs-repl))
						 ;
							;															 }
							;								}]


						 }

  :sassc [{:output-to    "resources/production/css/main.css"      ;; default "target/sassc/main.css"
           :style        "compressed"          ;; "nested" or "compressed", default "nested"
           :import-path  "src/scss"}]           ;; default "src/scss"


  :cljsbuild {:builds {:dev  {:source-paths ["src/cljs"]

                              :figwheel     {:on-jsload "vr-secondview.core/mount-root"
                                             ;:websocket-url "wss://daniel.dev/figwheel-ws"
																						 }

                              :compiler     {
																						 :main   vr-secondview.core
																						 :preloads      [devtools.preload dirac.runtime.preload]
																						 :external-config {:dirac.runtime/config {:agent-host "daniel.dev"}}
                                             :closure-defines {"clairvoyant.core.devmode" true}
                                             :output-to            "resources/public/js/compiled/app.js"
                                             :output-dir           "resources/public/js/compiled/out"
                                             :asset-path           "js/compiled/out"
																						 :optimizations :none
																						 :source-map true
                                             :source-map-timestamp true}}

                       :test {:source-paths   ["src/cljs" "test/cljs"]
                              :notify-command ["phantomjs" "test/unit-test.js" "test/unit-test.html"]
                              :compiler       {:optimizations :whitespace
                                               :pretty-print  true
                                               :output-to     "test/js/app_test.js"
                                               ;:warnings      {:single-segment-namespace false}
																							 }
															}

                       :min  {:source-paths ["src/cljs"]
                              :compiler     {:main            vr-secondview.core
                                             :output-to       "resources/production/js/app.min.js"
                                             :output-dir      "resources/production/js"
                                             :source-map      "resources/production/js/app.js.map"
                                             :optimizations   :advanced
                                             :externs         ["resources/public/vendor/js/tour.ext.js"]
                                             :closure-defines {goog.DEBUG false}
                                             :pretty-print    false
                                             :parallel-build  true}}}}

  :aliases {
            "develop" ["with-profile" "+dev" "figwheel"]
            ;"figwheel-repl" ["with-profile" "+figwheel-nrepl" "repl"]
            "production" ["do" "clean" ["cljsbuild" "once" "min"] ["sassc" "once"]]})

And the repl.clj

(require
  '[dirac.agent]
  '[figwheel-sidecar.repl-api :refer [start-figwheel! cljs-repl stop-figwheel!]]
  '[com.stuartsierra.component :as component])

(import 'java.lang.Runtime)

(defn deep-merge
  "Recursively merges maps. If keys are not maps, the last value wins."
  [& vals]
  (cond
    (every? map? vals) (apply merge-with deep-merge vals)
    (every? vector? vals) (into [] (reduce concat vals))
    :else (-> vals
              concat)))


(def figwheel-config
  (let [p (figwheel-sidecar.config/get-project-config)
        cljsbuild (get-in p [:cljsbuild :builds :dev])
        profile (get-in p [:profiles :dev])
        cljs-devbuild (get-in profile [:cljsbuild :builds :dev])
        build (deep-merge {:id "dev"} cljsbuild cljs-devbuild)
        figwheel (:figwheel p)]



    {:figwheel-options figwheel
     :build-ids ["dev"]
     :all-builds
                       [build]}))



;(start-figwheel! {:all-builds (figwheel-sidecar.config/prep-builds [config])})


(def sass-config
  {:executable-path "/usr/local/var/rbenv/shims/sass" ; e.g. /usr/local/bin/sass
   :input-dir "src/scss" ; location of the sass/scss files
   :output-dir "resources/public/css"})

(defrecord Figwheel []
  component/Lifecycle
  (start [config]
		(start-figwheel! config)
    config)
  (stop [config]
    (stop-figwheel!)
    config))

(defrecord SassWatcher [executable-path input-dir output-dir]
  component/Lifecycle
  (start [config]
    (if (not (:sass-watcher-process config))
      (do
        (println "Figwheel: Starting SASS watch process")
        (assoc config :sass-watcher-process
                      (.exec (Runtime/getRuntime)
                             (str executable-path " --watch " input-dir ":" output-dir))))
      config))
  (stop [config]
    (when-let [process (:sass-watcher-process config)]
      (println "Figwheel: Stopping SASS watch process")
      (.destroy process))
    config))

(def system
  (atom
    (component/system-map
      :figwheel (map->Figwheel figwheel-config)
      :sass (map->SassWatcher sass-config))))

(defn start []
  (swap! system component/start))

(defn stop []
  (swap! system component/stop))

(defn reload []
  (stop)
  (start))

(defn repl []
  (cljs-repl))

;; Start the components and the repl
(start)

[darwin]

@Ninerian I'm not able to parse and validate your project.clj in my head. It would be more helpful if you could create a sample project and give me a link to a git repo. Then I could go fork it and possibly fix it after testing the real thing on my machine.

[darwin]

Original issue as reported by @njj fixed by 546f63b in v0.8.5.

@Ninerian if you still have problems please open a separate bug report. Also this document might help: https://github.com/binaryage/dirac/blob/master/docs/about-repls.md#dirac--figwheel