Replace conflicts are resolved by keeping a candidate f7510b63cceb

        // A path the user writes settles its replace conflict, if any: they

        // chose that content (spec §9.3).

        let written: std::collections::HashSet<String> = edits

            .iter()

            .filter(|e| e.content.is_some())

            .map(|e| e.path.trim_matches('/').to_string())

            .collect();

        let built = self.build_from_entries_resolving(

            &base,

            &base_snapshot,

            HashMap::new(),

            &entries,

            &written,

        )?;

        self.build_from_entries_resolving(base, base_snapshot, reuse, fs_entries, &HashSet::new())

    }

    /// Like `build_from_entries`, settling the replace conflicts of the

    /// opaque files in `resolve` to their content (spec §9.3, §9.6): a

    /// caller that knows the user chose it, such as the hub's resolver. A

    /// snapshot never settles one on its own, since a checkout writes one

    /// candidate at the path.

    pub(crate) fn build_from_entries_resolving(

        &self,

        base: &State,

        base_snapshot: &Snapshot,

        reuse: HashMap<String, (NodeId, NodeKind)>,

        fs_entries: &BTreeMap<String, FsEntry>,

        resolve: &HashSet<String>,

    ) -> Result<BuiltChange> {

        b.resolve = resolve.clone();

    /// Opaque files whose replace conflict the content settles.

    resolve: HashSet<String>,

            resolve: HashSet::new(),

                }

                if blobs.len() > 1 && self.resolve.contains(path) && e.kind == expected.kind {

                    // Settle the replace conflict (spec §9.3): replace every

                    // live candidate with the chosen blob, depending on each

                    // change that made one live, so all are superseded.

                    let chosen = self.blob_of(repo, path, e, nocompress)?;

                    for b in blobs {

                        self.edits.push(Edit::Replace {

                            node,

                            old: Some(*b),

                            new: Some(chosen),

                        });

                    }

                    self.contributors

                        .extend(self.base.blob_contributors(&node, blobs));

                    self.resolves = true;

                    self.statuses.push(PathStatus {

                        path: path.to_string(),

                        status: ChangeStatus::Resolved,

                    });

                    return Ok(());

/// A replace conflict (spec §9.3) is settled by a change that writes one

/// candidate, or new bytes, at the path when the caller names it; a plain

/// snapshot of a checkout never settles it on its own.

#[test]

fn replace_conflicts_are_settled_when_asked() {

    hermetic();

    let dir = tempfile::tempdir().unwrap();

    let root = dir.path();

    let mut repo = Repo::init(root).unwrap().with_home(root.join("home"));

    let blob = |n: u8| {

        let mut v = vec![0u8; 64];

        v[1] = n;

        v

    };

    write(root, "img.bin", &blob(1));

    repo.commit("add img", &[]).unwrap();

    repo.bookmark_create("other", None).unwrap();

    write(root, "img.bin", &blob(2));

    repo.commit("img two", &[]).unwrap();

    repo.bookmark_switch("other", false).unwrap();

    write(root, "img.bin", &blob(3));

    repo.commit("img three", &[]).unwrap();

    repo.bookmark_switch("main", false).unwrap();

    repo.merge("other").unwrap();

    let heads = repo.bookmark_heads().unwrap();

    let merged = repo.load_state(&heads).unwrap().materialize();

    assert!(

        matches!(&merged.files["img.bin"].content, FileContent::Opaque { blobs } if blobs.len() == 2),

        "a replace conflict"

    );

    // A snapshot of the checkout records nothing.

    assert!(repo

        .snapshot("status")

        .unwrap()

        .statuses

        .iter()

        .all(|s| s.path != "img.bin"));

    // Keeping candidate 3 settles it.

    let author = repo.author();

    let edits = [FileEdit {

        path: "img.bin".into(),

        content: Some(blob(3)),

    }];

    let c = repo

        .build_change(&heads, &edits, "keep three", author)

        .unwrap();

    assert_eq!(c.kind, ChangeKind::Resolution);

    let mut st = repo.load_state(&heads).unwrap();

    for d in &c.deps {

        assert!(st.contains(d));

    }

    assert!(

        heads.iter().all(|h| c.deps.contains(h)),

        "depends on both contributors"

    );

    st.add(c).unwrap();

    let after = st.materialize();

    assert!(!after.is_conflicted());

    assert_eq!(

        after.files["img.bin"].content,

        FileContent::Opaque {

            blobs: vec![Repo::blob_ref(&blob(3))]

        }

    );

    // New bytes settle it too.

    let edits = [FileEdit {

        path: "img.bin".into(),

        content: Some(blob(9)),

    }];

    let c = repo.build_change(&heads, &edits, "new", author).unwrap();

    let mut st = repo.load_state(&heads).unwrap();

    st.add(c).unwrap();

    assert_eq!(

        st.materialize().files["img.bin"].content,

        FileContent::Opaque {

            blobs: vec![Repo::blob_ref(&blob(9))]

        }

    );

}

| **Status** | Draft 0.8m |

Which blobs are live: a replace record is superseded by a later replacement of its blob, a record whose `old` is its `new` and whose change depends on its change (§8.1 makes every replacement depend on the change that made its `old` current). Replacements that do not know each other both stay live, and a file reverted to an earlier blob keeps it. A replace conflict is **resolved** by a `kind = resolution` change with one `Replace` from each live blob to the chosen one, depending on every change that made a candidate live, so each is superseded and one blob remains. A working-copy snapshot never settles a replace conflict on its own (a checkout writes one candidate at the path); a tool that knows the user's choice, such as a forge's resolver, builds the resolution. A replacement recorded without that dependency (before Draft 0.8i) supersedes every record with its `new` that does not come after it, the rule until then.

*Changelog.* Draft 0.8m (2026-09-29): resolving replace conflicts (§9.3). Draft 0.8l (2026-09-28): deleting a reference on a remote; first serials from the clock (§16.4). Draft 0.8k (2026-09-28): the manifest records graph keys, so unchanged files are neither read nor rendered (§12.4). Draft 0.8j (2026-09-28): checkpoint payload version 2, file graphs by reference (§11).