     :keys [::specs/message-loop-name]
     :as state}
    array-o-bytes]
-  (log/debug (str message-loop-name
-                  ": trigger-from-child Received a "
-                  (class array-o-bytes)
-                  "\nSent stream address: "
-                  send-bytes))
-  (when-not send-bytes
-    (log/error (str message-loop-name
-                    ": Missing ::specs/send-bytes under"
-                    (keys outgoing)
-                    "inside"
-                    (keys state)
-                    "\na.k.a.\n"
-                    state)))
+  {:pre [array-o-bytes]}
+  (cancel-timer! state)
+  (log/info (str message-loop-name
+                 ": trigger-from-child\nSent stream address: "
+                 send-bytes))
   (trigger-io
    state-agent
    (if (from-child/room-for-child-bytes? state)

   {{:keys [::specs/->child]} ::specs/incoming
    :keys [::specs/message-loop-name]
    :as state}
   ^bytes buf]
  (when-not ->child
    (throw (ex-info "Missing ->child"
                    {::callbacks (::specs/callbacks state)})))
  (log/info (str message-loop-name ": Incoming from parent"))
  ;; This is basically an iteration of the top-level
  ;; event-loop handler from main().
  ;; I can skip the pieces that only relate to reading

       (let [result (from-child/consume-from-child state array-o-bytes)]
         result))
     ;; trigger-io does some state management, even
     ;; if we discard the incoming bytes because our
     ;; buffer is full
     ;; TODO: Need a way to signal the child to
     ;; try again shortly
     (do
       (log/error "Discarding incoming bytes, silently")
       state))))

(s/fdef trigger-from-parent
        :args (s/cat :state-agent ::specs/state-agent
                     :state ::specs/state
                     :array-o-bytes bytes?)
        :ret ::specs/state)
(defn trigger-from-parent
  "Message block arrived from parent. We have work to do."
  ;; TODO: Move as much of this as possible into from-parent
