Method try_merge

atomic-core/src/merge/engine.rs:89–250

Attempt to merge a conflict group using token-level semantics. # Algorithm 1. Extract the two competing vertices (only 2-way supported). 2. Retrieve content bytes for both from the [`ChangeStore`]. 3. Find the common ancestor vertex — the dead vertex that both competing changes deleted. 4. Retrieve content bytes for the ancestor. 5. Tokenize all three byte sequences. 6. Run a three-way diff at t

(&self, group: &ConflictGroup)

    ///
    /// Returns [`PristineError`] on database access failure.
    pub fn try_merge(&self, group: &ConflictGroup) -> Result<MergeOutcome, PristineError> {
        // ── Step 1: Read content for every vertex in the group ────────
        //
        // If any vertex's content is unreadable we give up immediately.
        let mut vertex_contents: Vec<(GraphNode<NodeId>, Vec<u8>)> = Vec::new();
        for v in &group.vertices {
            match self.get_vertex_content(v) {
                Ok(c) => vertex_contents.push((*v, c)),
                Err(e) => {
                    log::debug!("try_merge: cannot read vertex {}: {}", v, e);
                    return Ok(MergeOutcome::NoCrdtData);
                }
            }
        }
        if vertex_contents.is_empty() {
            return Ok(MergeOutcome::NoCrdtData);
        }

        // ── Step 2: Deduplicate identical-content vertices ────────────
        //
        // Collapse vertices that share byte-identical content into a
        // single representative.  This handles the common N-way fork
        // where multiple concurrent changes insert the same whitespace
        // or the same boilerplate line.  Indices of surviving (unique)
        // vertices are collected in `unique`; everything else lands in
        // `skipped` so the caller can mark them.
        let mut unique: Vec<usize> = vec![0];
        let mut skipped: Vec<usize> = Vec::new();
        for i in 1..vertex_contents.len() {
            if unique
                .iter()
                .any(|&j| vertex_contents[j].1 == vertex_contents[i].1)
            {
                skipped.push(i);
            } else {
                unique.push(i);
            }
        }

        // All vertices identical — no conflict at all.
        if unique.len() == 1 && !skipped.is_empty() {
            log::info!(
                "try_merge: all {} vertices identical ({} bytes), deduplicating",
                vertex_contents.len(),
                vertex_contents[0].1.len(),
            );
            return Ok(MergeOutcome::AutoMerged {
                content: vertex_contents[0].1.clone(),
                sources: vec![MergeSource::new(vertex_contents[0].0.change, 0)],
            });
        }

        // Partial dedup: log, but continue with the unique subset.
        if !skipped.is_empty() {
            log::info!(
                "try_merge: dedup reduced {}-way fork to {}-way",
                vertex_contents.len(),
                unique.len(),