                                     (conj acc result)))
                                 []
                                 frames)
+          log-atom (log/init)
           decoded (map (partial decode-bytes->child
                                 decode-src
-                                decode-sink)
+                                decode-sink
+                                log-atom)
                        binary-frames)]
       (try
         (dorun decoded)

          client-atom (atom nil)
          time-out 500
          client-parent-cb (fn [^bytes bs]
                             (let [log-state
                                   (log/info log-state
                                             ::client-parent-callback
                                             (str
                                              "Sending a" (count bs)
                                              "byte array to client's parent"))]
                               (reset! log-state log-state)
                               ;; TODO: Need lamport interactions everywhere the
                               ;; the streams cross.
                               ;; Calling out here is one place.
                               ;; But, honestly, so is the parameters into this callback.
                               ;; At the very least, I should pass in the caller's
                               ;; lamport clock so I could adjust an atom that
                               ;; tracks this test's clock.
                               ;; Alternatively, pass in the entire log-state.
                               ;; It's tempting to forward that along when we
                               ;; forward the message from client->server, but
                               ;; the current protocol does not allow that.
                               (let [sent (strm/try-put! client->server bs time-out ::timed-out)]
                                 (is (not= @sent ::timed-out)))))
          ;; Something that spans multiple packets would be better, but
          ;; that seems like a variation on this test.
          ;; Although this *does* take me back to the beginning, where

  ;; Then again, you *could* do something like
  ;; this, to experiment with the unencrypted
  ;; networking protocol.
  (swap! log-atom log/info log-ctx "Message over network")

  (let [prelog (utils/pre-log message-loop-name)
        consumption (dfrd/future
                      ;; 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
