Method compute_delta

atomic-remote/src/sync.rs:635–725

Compute the full `RemoteDelta` for a given view. This is the main entry point for sync operations. It: 1. Runs the dichotomy algorithm to find the divergence point 2. Downloads the remote's changelist from the divergence point 3. Compares "ours" (cached) vs "theirs" (actual) after divergence 4. Identifies changes to download, unrecords, and unknowns 5. Updates the local cache # Arguments `view

(
        &mut self,
        view: &str,
        local_hashes: &HashSet<String>,
    )

    /// * `local_hashes` - Set of change hashes present in the local repository.
    ///   Used to determine which remote changes need to be downloaded.
    pub async fn compute_delta(
        &mut self,
        view: &str,
        local_hashes: &HashSet<String>,
    ) -> RemoteResult<RemoteDelta> {
        // Order-invariant fast path (additive; dormant until the server
        // advertises a SetId). If the remote publishes the SetId of its
        // effective change set and it equals the SetId folded from our local
        // hashes, both sides hold the same SET of changes regardless of order
        // — we are in sync and can skip the O(log n) Merkle dichotomy and the
        // changelist download entirely. When the field is absent (older
        // server) or the local set cannot be folded, we fall through to the
        // existing dichotomy with no behavior change.
        let remote_state = self.remote.get_state(view).await?;
        if let (Some(remote_sid), Some(local_sid)) =
            (remote_state.set_id(), Self::local_set_id(local_hashes))
        {
            if remote_sid == local_sid {
                debug!("sync: SetId match ({}), views already in sync", remote_sid);
                return Ok(RemoteDelta::in_sync());
            }
        }

        // Handle from-scratch sync (no cache)
        if self.cache.is_empty() {
            return self.compute_delta_from_scratch(view, local_hashes).await;
        }

        // Find divergence point
        let divergence = self.dichotomy_changelist(view).await?;
        self.stats.divergence_point = divergence;

        // Collect our cached entries at or after divergence
        let ours_ge_dichotomy: Vec<(u64, Node)> = self
            .cache
            .entries_from(divergence)
            .into_iter()
            .map(|(seq, node)| (seq, node.clone()))
            .collect();

        let ours_ge_dichotomy_set: HashSet<Node> = ours_ge_dichotomy
            .iter()
            .map(|(_, node)| node.clone())
            .collect();

        // Download the remote's changelist from the divergence point
        let remote_entries = self.remote.get_changelist(view, divergence).await?;
        self.stats.changelist_entries_fetched = remote_entries.len();

        // Build "theirs" sets
        let mut theirs_ge_dichotomy = Vec::new();
        let mut theirs_ge_dichotomy_set = HashSet::new();
        let mut to_download = Vec::new();

        for entry in &remote_entries {
            let node = entry.to_node();
            theirs_ge_dichotomy_set.insert(node.clone());
            theirs_ge_dichotomy.push((entry.sequence, node.clone()));