   [server-atom state-atom chzbrgr-length bs]
   (let [prelog (utils/pre-log "Server's child callback")
         _ (log/debug prelog "Message arrived at server's child")
-        {:keys [::state]
-         incoming ::next-object} (extract-next-object-from-stream @state-atom bs)]
-    (reset! state-atom state)
+        ;; Hopefully, sticking encode-to-stream in the middle of
+        ;; the mock networking layer will allow this to just
+        ;; go back to working magically again
+        incoming (if-not (keyword? bs)
+                   (io/decode protocol bs)
+                   bs)]
     (when incoming
       (log/debug prelog
                  (str "Matching '" incoming

            [frereth-cp.message.specs :as specs]
            [frereth-cp.shared.bit-twiddling :as b-t]
            [frereth-cp.util :as utils]
            [manifold.deferred :as dfrd]
            [manifold.stream :as strm])
  (:import io.netty.buffer.Unpooled))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Helper functions

;;;; TODO: Consolidate these next 2 to eliminate duplication
(defn srvr->client-consumer
  [client-io time-out succeeded? bs]
  (let [prelog (utils/pre-log "server->client consumer")]
    (log/info prelog "Message from server to client")
    (let [client-state (message/get-state client-io time-out ::timed-out)]
      (if (or (= ::timed-out client-state)
              (instance? Throwable client-state)
              (nil? client-state))
        (let [problem (if (instance? Throwable client-state)
                        client-state
                        (ex-info "Non-exception in server->client consumer"
                                 {::problem client-state}))]
          (log/error problem prelog "Client failed!")
          (dfrd/error! succeeded? problem))
        (message/parent->! client-io bs)))))

(defn client->srvr-consumer
  [server-io time-out succeeded? bs]
  ;; Note that, at this point, we're blocking the
  ;; server's I/O loop.
  ;; Whatever happens here must return control
  ;; quickly.
  (let [prelog (utils/pre-log "client->server")]
    (log/info prelog "Incoming")
    ;; Checking for the server state is wasteful here.
    ;; And very dubious...depending on implementation details,
    ;; it wouldn't take much to shift this over to triggering
    ;; a deadlock (since we're really running on the event loop
    ;; thread).
    ;; Actually, I'm a little surprised that this works at all.
    ;; And it definitely *has* had issues.
    ;; Q: But is it worth it for the test's sake?
    (let [srvr-state (message/get-state server-io time-out ::timed-out)]
      (if (or (= ::timed-out srvr-state)
              (instance? Throwable srvr-state)
              (nil? srvr-state))
        (let [problem (if (instance? Throwable srvr-state)
                        srvr-state
                        (ex-info "Non-exception in client->server consumer"
                                 {::problem srvr-state}))]
          (do
            (log/error problem prelog "Server failed!")
            (dfrd/error! succeeded? problem)))
        (message/parent->! server-io bs)))))

(defn buffer-response!
  [io-handle


        (try
          (strm/consume (partial client->srvr-consumer server-io time-out succeeded?)
                        (strm/map #(io/encode protocol %) client->server))
          (strm/consume (partial srvr->client-consumer client-io time-out succeeded?)
                        (strm/map #(io/encode protocol %) server->client))

          (let [initial-message (Unpooled/buffer K/k-1)
                helo (.getBytes (pr-str ::ohai!))]
