1 files changed, 24 insertions, 17 deletions

diff --git a/src/swarm/peer/inbound.rs b/src/swarm/peer/inbound.rs
index b04aad9..2e89739 100644
--- a/src/swarm/peer/inbound.rs
+++ b/src/swarm/peer/inbound.rs
@@ -11,7 +11,7 @@ use super::epoch::observe_peer_epoch;
 use super::handshake::{
     discover_peers, ensure_handshake, establish_peer, peer_swarm, remember_peer, send_hello_reply,
 };
-use super::keepalive::{heal_if_diverged, local_keepalive, note_keepalive};
+use super::keepalive::{heal_if_diverged, local_status, note_alive, note_status, status_received};
 use super::lanes::SyncLanes;
 use crate::state::AppState;
 use crate::swarm::sync::SyncEvent;
@@ -30,6 +30,11 @@ pub(crate) async fn handle_message(
         debug!("Ignoring message from self");
         return Ok(());
     }
+    // PING and PONG only say the peer is alive (`keepalive::note_alive`).
+    if matches!(message, ParsedMessage::Ping(_) | ParsedMessage::Pong(_)) {
+        note_alive(state, &peer, &message).await;
+        return Ok(());
+    }
     // WHO and ME end at the identity layer (`transport::identity`).
     let Some((epoch, epoch_seq)) = message.epoch_stamp() else {
         return Ok(());
@@ -143,40 +148,42 @@ pub(crate) async fn handle_message(
         transport::ParsedMessage::Blob(blob) => {
             crate::swarm::blob::handle(state, &peer, blob).await;
         }
-        transport::ParsedMessage::Ping(remote) => {
-            let local = on_keepalive(state, &peer, &remote, reactivated).await;
+        transport::ParsedMessage::Status(remote) => {
+            status_received(state, &peer).await;
+            let local = on_status(state, &peer, &remote, reactivated).await;
             if let Err(error) = state
                 .transport
-                .send_message(&peer, &ParsedMessage::Pong(local))
+                .send_message(&peer, &ParsedMessage::StatusReply(local))
                 .await
             {
-                debug!(peer = %peer, error = %format!("{error:#}"), "PONG failed");
+                debug!(peer = %peer, error = %format!("{error:#}"), "STATUS_REPLY failed");
             }
         }
-        transport::ParsedMessage::Pong(remote) => {
-            // It answers our PING: a round-trip sample.
-            state.lock_rtt().pong_received(&peer, Instant::now());
-            on_keepalive(state, &peer, &remote, reactivated).await;
+        transport::ParsedMessage::StatusReply(remote) => {
+            on_status(state, &peer, &remote, reactivated).await;
         }
-        transport::ParsedMessage::Who(_) | transport::ParsedMessage::Me(_) => {}
+        transport::ParsedMessage::Who(_)
+        | transport::ParsedMessage::Me(_)
+        | transport::ParsedMessage::Ping(_)
+        | transport::ParsedMessage::Pong(_) => {}
     }
 
     Ok(())
 }
 
-/// What a PING and a PONG have in common: a handshake if needed, the peer's keepalive
-/// noted, and the heal if our documents differ. Returns our keepalive for the peer.
-async fn on_keepalive(
+/// What a STATUS and a STATUS_REPLY have in common: a handshake if needed, the peer's status
+/// noted, and the heal if our documents differ. Returns our status for the peer.
+async fn on_status(
     state: &AppState,
     peer: &str,
-    remote: &transport::Keepalive,
+    remote: &transport::Status,
     reactivated: bool,
-) -> transport::Keepalive {
+) -> transport::Status {
     if reactivated || peer_swarm(state, peer).await.is_none() {
         ensure_handshake(state, peer).await;
     }
-    note_keepalive(state, peer, remote).await;
-    let local = local_keepalive(state, peer).await;
+    note_status(state, peer, remote).await;
+    let local = local_status(state, peer).await;
     heal_if_diverged(state, peer, &local, remote).await;
     local
 }