Sparse checkout: filter.paths, clone --sparse (implies lazy blobs), oxy sparse, scope-aware snapshot/checkout/prompt (spec 0.6f) 7421309f5372

        // Write target files that differ (only inside the sparse filter).

            if !self.in_scope(path) {

                continue;

            }

    /// `filter.paths`: only these subtrees are materialized (spec §17); empty means everything.

    pub sparse_paths: Vec<String>,

            sparse_paths: Vec::new(),

            "filter.paths" => {

                self.sparse_paths = value

                    .split(',')

                    .map(|p| p.trim().trim_start_matches("./").trim_matches('/').to_string())

                    .filter(|p| !p.is_empty())

                    .collect();

            }

    /// Whether a repository path is inside the sparse filter (spec §17).

    pub fn in_scope(&self, path: &str) -> bool {

        self.config.sparse_paths.is_empty() || self.config.sparse_paths.iter().any(|p| path == p || path.starts_with(&format!("{p}/")))

    }

            if ft.is_dir() || !self.in_scope(&rel) {

            if !self.in_scope(&rel) {

                continue;

            }

            if fs_entries.contains_key(path) || !self.in_scope(path) {

            // A directory stays while anything under it exists or is out of scope.

            let still_needed = expected.kind == NodeKind::Dir

                && (fs_entries.keys().any(|p| p.starts_with(&format!("{path}/")))

                    || base_snapshot.files.keys().any(|p| p.starts_with(&format!("{path}/")) && !self.in_scope(p)));

        Self::clone_with(url, dest, None, &[])

    /// Clone, leaving blobs above `max_blob` bytes to be fetched on first

    /// read, and materializing only `sparse` paths (which implies lazy blobs

    /// unless a size is given, so out-of-scope binaries are never fetched).

    pub fn clone_with(url: &str, dest: &Path, max_blob: Option<u64>, sparse: &[String]) -> Result<Repo> {

        } else if !sparse.is_empty() {

            repo.config.set("filter.max-blob", "0")?;

        }

        if !sparse.is_empty() {

            repo.config.set("filter.paths", &sparse.join(","))?;

    let b = Repo::clone_with(&url, &root.join("b"), Some(1024), &[]).unwrap();

#[test]

fn sparse_checkout_materializes_only_chosen_paths() {

    hermetic();

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

    let root = dir.path();

    let origin_dir = root.join("origin");

    let origin = Repo::init(&origin_dir).unwrap().with_home(root.join("home"));

    write(&origin_dir, "src/main.rs", b"fn main() {}\n");

    write(&origin_dir, "src/lib.rs", b"pub fn a() {}\n");

    write(&origin_dir, "docs/guide.md", b"# guide\n");

    let logo: Vec<u8> = (0..50_000u32).map(|i| (i % 7) as u8).collect();

    write(&origin_dir, "docs/logo.png", &logo);

    write(&origin_dir, "README.md", b"# top\n");

    let h1 = origin.commit("tree", &[]).unwrap();

    let url = origin_dir.to_string_lossy().to_string();

    let a = Repo::clone_with(&url, &root.join("a"), None, &["src".into()]).unwrap().with_home(root.join("home"));

    assert_eq!(a.config.sparse_paths, vec!["src"]);

    assert_eq!(a.config.max_blob, Some(0), "sparse implies lazy blobs");

    assert!(root.join("a/src/main.rs").exists());

    assert!(!root.join("a/docs").exists() && !root.join("a/README.md").exists());

    assert!(!a.store().has(&Repo::blob_ref(&logo)), "out-of-scope blob never fetched");

    assert!(!a.snapshot("status").unwrap().changed, "out-of-scope files are not removals");

    assert_eq!(a.quick_status().unwrap().dirty, false);

    // Edits in scope commit normally and keep the rest of the tree intact.

    write(&root.join("a"), "src/lib.rs", b"pub fn a() {}\npub fn b() {}\n");

    let h2 = a.commit("edit lib", &[]).unwrap();

    let st = a.load_state(&[h2]).unwrap().materialize();

    assert!(st.files.contains_key("docs/guide.md"), "the state still has everything");

    assert!(a.push("origin", false).unwrap()[0].ok);

    // Files created outside the scope are ignored by status.

    write(&root.join("a"), "docs/new.md", b"ignored\n");

    assert!(a.snapshot("status").unwrap().statuses.is_empty());

    // Widening the filter checks out the rest; narrowing leaves stray files alone.

    let mut a = a;

    a.config.set("filter.paths", "src,docs").unwrap();

    a.save_config().unwrap();

    let r = a.checkout(&a.bookmark_heads().unwrap(), true, "widen").unwrap();

    assert!(r.written >= 2);

    assert_eq!(fs::read(root.join("a/docs/logo.png")).unwrap(), logo, "now fetched lazily");

    assert!(!root.join("a/README.md").exists());

    // Origin sees the change made under a sparse checkout with the full tree intact.

    origin.pull("origin").err();

    let full = origin.load_state(&origin.bookmark_heads().unwrap()).unwrap().materialize();

    assert!(matches!(&full.files["src/lib.rs"].content, FileContent::Text { bytes, .. } if bytes == b"pub fn a() {}\npub fn b() {}\n"));

    assert!(full.files.contains_key("README.md"));

    let _ = h1;

}

    let a = Repo::clone_with(&url, &root.join("a"), Some(1000), &[]).unwrap();

| **Status** | Draft 0.6f |

- **Sparse** repositories hold the full change graph but only materialize the listed paths: the working copy contains nothing else, files outside the filter are neither reported nor removed, and changes touching other paths are stored and applied to the graph. A sparse clone sets `max-blob` to zero unless a size is given, so blobs outside the filter are fetched only if the filter later widens (§13.5). `oxy sparse PATH..` changes the filter of a clean working copy and re-checks it out.

*Changelog.* Draft 0.6f (2026-09-27): sparse checkout semantics (§17).

Draft 0.6e (2026-09-27): lazy blobs: the `fetch` filter, the `objects` message, and the absent-blob record (§13.5, §16.3).

        /// Materialize only these paths (repeatable); implies lazy blobs

        #[arg(long = "sparse")]

        sparse: Vec<String>,

    /// Show or set the sparse filter (paths to materialize); re-checks out the bookmark

    Sparse { paths: Vec<String> },

    /// Set a configuration key (author.*, core.sign, core.op-retention, core.gc-grace, core.checkpoint-interval, filter.max-blob, filter.paths, workspace.bookmark, remote.<name>.url|token|ca)

        Cmd::Clone { url, dest, max_blob, sparse } => sync::clone(&url, dest, max_blob.as_deref(), &sparse),

        Cmd::Sparse { paths } => workspace::sparse(&paths),

pub fn clone(url: &str, dest: Option<PathBuf>, max_blob: Option<&str>, sparse: &[String]) -> Result<i32> {

    let repo = Repo::clone_with(url, &dest, max_blob, sparse)?;

pub fn sparse(paths: &[String]) -> Result<i32> {

    let mut repo = open()?;

    if paths.is_empty() {

        if repo.config.sparse_paths.is_empty() {

            println!("No sparse filter: the whole tree is materialized.");

        } else {

            println!("{}", ui::heading("Sparse filter"));

            for p in &repo.config.sparse_paths {

                println!("  {}", ui::path(p));

            }

        }

        return Ok(0);

    }

    let snap = repo.snapshot("oxy sparse")?;

    if !snap.wc.tree_ops.is_empty() || !snap.wc.edits.is_empty() {

        anyhow::bail!("the working copy has changes; commit them before changing the sparse filter");

    }

    repo.config.set("filter.paths", &paths.join(","))?;

    repo.save_config()?;

    let heads = repo.bookmark_heads()?;

    let sp = ui::spinner("Re-checking out with the new filter…");

    let r = repo.checkout(&heads, true, "oxy sparse (checkout)")?;

    sp.done(&format!("{} {}: {} written, {} removed", ui::ok("Sparse filter set to"), ui::path(paths.join(",")), plural(r.written, "file"), r.removed));

    Ok(0)

}