   (def test-data
     {:cljsbuild {:assert true
                  :builds [{ :id "example-admin"
-                           :source-paths ["src" "dev" "tests" "../support/src"]
+                           :source-paths ["src" "dev" "tests" "../support/src"
+                                          "src" "dev" "tests" "../support/src"
+                                          { :websocket-host "localhost"
+                            :compiler { :main 'example.core
+                                       :asset-path "js/out"
+                                       :libsers ["libs_src" "libs_sscr/tweaky.js"]
+                                      :output-to "resources/public/js/example.js"
+                                      :output-dir "resources/public/js/out"
+                                      :libs ["libs_src" "libs_sscr/tweaky.js"]
+                                      ;; :externs ["foreign/wowza-externs.js"]
+                                      :foreign-libs [{:file "foreign/wowza.js"
+                                                      :provides ["wowzacore"]}]
+                                      ;; :recompile-dependents true
+                                      :optimizations :none}
+                            :on-jsload      'example.core/fig-reload
+                            :on-message     'example.core/on-message
+                            :open-urls ["http://localhost:3449/index.html"
+                                        "http://localhost:3449/index.html"
+                                        "http://localhost:3449/index.html"
+                                        "http://localhost:3449/index.html"
+                                        "http://localhost:3449/index.html"]
+                            :debug true
+                            } "dev" "tests" "../support/src"
+                                          "src" "dev" "tests" "../support/src"
+                                          "src" "dev" "tests" "../support/src"]
                            :source-paths-list '("src" "dev" "tests" "../support/src")
                            :source-paths-set #{"src" "dev" "tests" "../support/src"}
                            :notify-command ["notify"]

    (pp/with-pprint-dispatch error-path-dispatch
      (pp/pprint
       (annotate-path-only test-data
                           [:cljsbuild :builds 0 :source-paths-set]
                           {:abbrev true
                            :comments {"src" {
                                              :key-colors     [:green]
                                              :value-colors   [:bright]
                                              :comment-colors [:magenta]
                                              :comment " is screwwed"
                                              }
                                       "tests" {
                                                :key-colors [:green]
                                                :value-colors [:bright]
                                                :comment-colors [:magenta]

      [aseq (seq avec)
       c    0]
      (when aseq
        (let [v (first aseq)
              v (if (and abbrev (coll? v))
                  (vary-meta v assoc :abbrev :tight)
                  v)]
          (if-let [{:keys [comment value-colors comment-colors]
                    :as current-comment} (get comments (comment-key-fn v c))]
            (do
              (print-colored value-colors v)
              (pp/pprint-newline :mandatory)
              (print-colored comment-colors (CommentPointer. comment))
              #_(pp/pprint-newline :mandatory))
            (pp/write-out v))
          (when (next aseq)
            (.write ^java.io.Writer *out* " ")
            (pp/pprint-newline :linear)
            (recur (next aseq) (inc c)))))))))

(defn abbrev-seq-with-pointer [pre suf a-seq comment-key-fn]
  (if-let [abr-level (-> a-seq meta :abbrev)]
    (let [maxk   (or
                  (when-let [comments (not-empty (-> a-seq meta :comments))]
                    (and (every? integer? (keys comments))
                         (reduce max (keys comments))))
                  0)
          length (if (= :tight abr-level) (+ maxk 2) (+ maxk 4))
          level  (if (= :tight abr-level) 2 3)]
      (binding [*print-level* (+ level
                                 (or @(resolve 'clojure.pprint/*current-level*) 0))
                *print-length* length]
        (pprint-seq-with-pointer pre suf a-seq comment-key-fn)))
    (pprint-seq-with-pointer pre suf a-seq comment-key-fn)))

(defn pprint-vector-with-pointer [avec]
  (if (-> avec meta :comments)
    (abbrev-seq-with-pointer "[" "]" avec (fn [_ c] c))
    (orig-pprint-vector avec)))

(defn pprint-set-with-pointer [a-set]
  (if (-> a-set meta :comments)
    (abbrev-seq-with-pointer "#{" "}" a-set (fn [_ c] c))
    (orig-pprint-set a-set)))

(defn pprint-simple-list-with-pointer [alis]
  (abbrev-seq-with-pointer "(" ")" alis (fn [_ c] c)))

(defn pprint-list-with-pointer [aseq]
  (if (-> aseq meta :comments)
