one walk since

1 files changed, 9 insertions, 11 deletions

diff --git a/src/swarm/sync.rs b/src/swarm/sync.rs
index a6467a7..c969678 100644
--- a/src/swarm/sync.rs
+++ b/src/swarm/sync.rs
@@ -610,9 +610,12 @@ pub(crate) async fn handle_sync(
             }
             stats.heads_seen(heads_after.len());
             let changed = heads_after != heads_before;
-            if changed {
+            // What it brought, walked once.
+            let since =
+                changed.then(|| crate::document::changes::since(&replica.doc, &heads_before));
+            if let Some(since) = &since {
                 // They came from it: none goes back (`SyncSession::came_from_peer`).
-                let new = peer_state.sync.came_from_peer(&replica.doc, &heads_before);
+                let new = peer_state.sync.these_came_from_peer(&since.hashes);
                 stats.new_changes(new);
             }
             if carried && !changed {
@@ -626,20 +629,15 @@ pub(crate) async fn handle_sync(
             }
             // Whose they are, to pass them on along their writers' trees, however they
             // came (along a tree, with an answer, pulled).
-            let authors = if changed {
-                crate::document::changes::authors_since(&replica.doc, &heads_before)
-            } else {
-                (Vec::new(), false)
+            let (authors, times) = match since {
+                Some(since) => ((since.authors, since.unauthored), since.times),
+                None => ((Vec::new(), false), Vec::new()),
             };
             if changed && measure_propagation {
                 // Now by the peers' clocks (their median): this node's own clock skew
                 // doesn't count; the writer's still does.
                 let now_ms = clock.now_millis().as_u64() as i64 - ahead_ms;
-                let delays: Vec<i64> =
-                    crate::document::changes::commit_times(&replica.doc, &heads_before)
-                        .into_iter()
-                        .map(|time| now_ms - time)
-                        .collect();
+                let delays: Vec<i64> = times.into_iter().map(|time| now_ms - time).collect();
                 if writer.is_none() {
                     stats.off_tree(&delays);
                 }