                                                               (js/console.log "Listened TX: " tx-report)
                                                               (when (or (get-in tx-report [:tx-meta :tx/broadcast?])
                                                                         (get-in tx-report [:tx-meta :tx/persist?]))
-                                                                (js/console.log "Prep that shit!")
                                                                 (let [prepped (db/prep-broadcastable-tx-report tx-report)]
                                                                   (when @network-enabled?
-                                                                    (js/console.log "Send that tx-shit!")
                                                                     (dato-send! :ss/tx-requested prepped)))))))
-                                               (js/console.log "too: " (pr-str (type app-db)))
                                                (let [local-session-id (d/tempid :db.part/user)]
                                                  (d/transact! app-db (vals schema))
                                                  (d/transact! app-db [{:db/id                 (d/tempid :db.part/user)

                                                                      ;; TODO: This can likely be moved out to a user-land handler
                                                                      (assoc (:session data) :db/id local-session-id)
                                                                      {:local/current-session {:db/id local-session-id}}]))
                                               (js/console.log "app-db: " app-db)
                                               (reset! cast-bootstrapped? true))
                                             conn)]
                                    (js/console.log "Something")
                                    (put! dato-ch [:dato/bootstrap-succeeded session-id])
                                    (loop []
                                      (let [msg (<! ws-ch)]

        ws                 (ws/build dato-host dato-path {:on-open    (fn [event] (js/console.log ":on-open :" event))
                                                          :on-close   (fn [event] (js/console.log ":on-close :" event))
                                                          :on-message (fn [event]
                                                                        (let [fr (js/FileReader. (.-data event))]
                                                                          (aset fr "onloadend" (fn [e]
                                                                                                 (let [data (transit/read transit-reader (.. e -target -result))]
                                                                                                   (if-let [cb-id (:server/rpc-id data)]
                                                                                                     (let [cb-or-ch (get @pending-rpc cb-id)]
                                                                                                       (swap! pending-rpc dissoc cb-id)
                                                                                                       ;; Should we just pass the whole payload through, or just the data/resultts?
                                                                                                       (cond
