   ;; back to the Server.
   (if-not (or (= vouch ::drained)
               (= vouch ::timeout))
-    (strm/try-put! (:chan ->server)
-                   {:message vouch
-                    :host "tester-client"
-                    :port 65536}
-                   500
-                   ::timeout)
+    (let [copy (.directBuffer mem-pool (.readableBytes vouch))]
+      (.readBytes vouch copy)
+      (.release vouch)
+      (strm/try-put! (:chan ->server)
+                     {:message copy
+                      :host "tester-client"
+                      :port 65536}
+                     500
+                     ::timeout))
     (throw (ex-info "Retrieving Vouch from client failed"
                     {:failure vouch}))))
 


(defn wrote-cookie
  [clnt-> success]
  (is (and success
           (not (keyword? success))))
  (if (not= success ::timeout)
    (do
      (println "Server Cookie sent to client. Waiting for Initiate packet in response")
      (strm/try-take! clnt-> ::drained 500 ::timeout))))

(defn vouch->server
  [->server vouch]
  ;; I don't have any real failure indication available
  ;; if something goes wrong with/on the server trying
  ;; to cope with this incoming vouch.
  ;; I almost need an error stream for dealing with exceptions.
  (println "Got Initiate packet from client: "
           vouch
           " for forwarding along to "
           ->server)
  (is (not (keyword? vouch)))
  ;; There's something inside out going on.
  ;; We just forwarded the from the server to the

                ;; Q: Is there anything interesting about the deferred that it
                ;; currently returns?
                (let [eventually-started (clnt/start! client)
                      clnt->srvr (::clnt/chan->server @client)
                      ;; Start with one that prefers direct buffers, even though it doesn't
                      ;; make a lot of sense for this test.
                      ;; I'm as certain as I can be (without actual metrics) that's the most
                      ;; realistic picture I'll get of the way it needs to really work
                      mem-pool (io.netty.buffer.PooledByteBufAllocator. true)]
                  (assert (= chan->server clnt->srvr)
                          (str "Client channels don't match.\n"
                               "Expected:" chan->server
                               "\nHave:" clnt->srvr))
                  (assert chan->server)
                  (let [write-hello (partial retrieve-hello mem-pool chan<-client)
                        build-cookie (partial wrote-hello chan->client)
                        write-cookie (partial forward-cookie chan<-server)
                        ;; This pulls the Initiate packet from the client
                        get-cookie (partial wrote-cookie chan->server)
                        write-vouch (partial vouch->server mem-pool chan<-client)
                        get-server-response (partial wrote-vouch chan->client)
                        write-server-response (partial finalize chan<-server)
                        _ (println "interaction-test: Starting the stream "
