    {{: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)})))
+   ^bytes message]
+  {:pre [->child]}
+
+  (cancel-timer! 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

    :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)))
  (trigger-io
   state-agent
   (if (from-child/room-for-child-bytes? state)

       (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
