gc repacks everything into one pack, compressed harder da652d6392d8

//! Garbage collection (spec §21): delete objects

    /// Packs folded into the one a full repack writes.

    /// Prune unreachable objects older than the grace period (`now`

    /// ignores it), then repack everything into one pack (spec §13.4).

        // Then everything left in one pack, compressed harder than a

        // commit's (spec §13.4), as `git gc` repacks.

        let (packed, merged_packs) = self.store.repack_all(crate::store::REPACK_ZSTD_LEVEL)?;

/// The level of a full repack (`oxy gc`): slower, once, for a smaller store.

pub const REPACK_ZSTD_LEVEL: i32 = 9;

            ZSTD_LEVEL,

    }

    /// Fold every pack and loose object into one pack compressed at

    /// `level` (spec §13.4): what an explicit `oxy gc` does, as `git gc`

    /// repacks. Returns the report and how many packs were folded in.

    pub fn repack_all(&self, level: i32) -> Result<(PackReport, usize)> {

        let loose = self.loose_objects()?;

        let (mut refs, paths): (Vec<ObjectRef>, Vec<PathBuf>) = {

            let packs = self.packs.borrow();

            (

                packs.iter().flat_map(|p| p.refs.iter().copied()).collect(),

                packs.iter().map(|p| p.path.clone()).collect(),

            )

        };

        if loose.is_empty() && paths.len() <= 1 && level == ZSTD_LEVEL {

            return Ok((PackReport::default(), 0));

        }

        refs.extend(loose.iter().map(|(r, _)| *r));

        let loose_paths: Vec<PathBuf> = loose.into_iter().map(|(_, p)| p).collect();

        let n = paths.len();

        let report = self.write_pack(&refs, &loose_paths, &paths, level)?;

        Ok((report, n))

        self.write_pack(&refs, &[], &paths, ZSTD_LEVEL)?;

            self.write_pack(&keep_refs, &[], &old_paths, ZSTD_LEVEL)?;

        level: i32,

            // Read a batch (the store is not shared between threads),

            // compress it on every core, write it in order.

            let mut batches = refs.chunks(1024);

            let mut compressed_batch = Vec::new();

            loop {

                if compressed_batch.is_empty() {

                    let Some(batch) = batches.next() else { break };

                    let mut read: Vec<(ObjectRef, ObjectType, Vec<u8>, bool)> =

                        Vec::with_capacity(batch.len());

                    for r in batch {

                        let (ty, body) = self.get(r)?;

                        read.push((*r, ty, body, self.is_nocompress(r)));

                    use rayon::prelude::*;

                    compressed_batch = read

                        .into_par_iter()

                        .map(|(r, ty, body, raw)| {

                            let packed = if raw {

                                None

                            } else {

                                zstd::bulk::compress(&body, level)

                                    .ok()

                                    .filter(|c| c.len() < body.len())

                            };

                            (r, ty, body, packed)

                        })

                        .collect::<Vec<_>>();

                    compressed_batch.reverse();

                }

                let Some((r, ty, body, packed)) = compressed_batch.pop() else {

                    continue;

                };

                let r = &r;

                let (flags, stored) = match packed {

                    Some(c) => (FLAG_ZSTD, c),

                    None => (0, body.clone()),

### Store size (2026-09-30, backlog P1)

The Linux tip's store was 448 MB, and 390 MB after `oxy gc`, against

311 MB for Git after `git gc`. The file contents cut into the store's

chunks compress, at zstd level 3, to 312 MB, level with Git; at level 9

to 284 MB (12.9 s on four cores), at level 19 to 270 MB (314 s). The

rest was two things:

- `oxy gc` left the first pack as written: packs merge only above 16.

- A text blob holds its lines as a CBOR array, so every line has a

  length header: 62 MB more raw, 35 MB more compressed for the tree's

  46 308 files of 4 KiB or more.

`oxy gc` now repacks everything into one pack at zstd level 9, compressed

on every core: 357 MB (349 MB pack) in 52 s. The text blob framing is the

next step (a change format version 3 with raw text blobs).

oxy gc              # prune unreachable objects past the grace period, repack into one pack

An automatic trigger when the loose object count exceeds 4096 writes loose objects into a new pack and merges packs when there are more than 16; `oxy gc` repacks every surviving object into one pack, compressed harder (zstd level 9, against level 3 for everyday writes) and on every core, as `git gc` repacks. Writers SHOULD batch: a snapshot, a fetched bundle, a Git import, or a checkpoint is one write batch, and a batch that grows beyond a small threshold (256 objects or 8 MiB) is written as a single pack with one `fsync` rather than as loose objects, each with its own; smaller batches stay loose so ordinary commits do not multiply packs. Objects of an open batch MUST be readable by the writer before the batch completes. Pack indexes MUST support lookup by ObjectRef prefix and MUST be memory-mappable. A repository with two million objects MUST be openable with under 64 MiB of resident index memory on the Full profile.

*Changelog.* Draft 0.8r (2026-09-29): `oxy gc` repacks into one pack at a higher compression level (§13.4); an import brings a deleted directory back rather than making a second node for its path, and retires a kept node's other placements (§23); graph keys at commit, lazy text in history-only loads, and a clean `status` from the manifest (§12.4); a parent checkout never moves a subrepo's bookmark backwards, and the pin is read from the nested working copy (§7.8); `bookmark create --upto/--only` (§10.1); the working-copy lock covers every command that writes the working copy; a workspace changed by two concurrent operations is an error (§12.1). Draft 0.8q (2026-09-29): change format version 2 stores large inserts as text blobs, so a change does not grow with the files it adds (§6.1, §7.4); no object may exceed 1 GiB (§13.2). Draft 0.8p (2026-09-29): Git import derives new NodeIds from the commit, making imports deterministic (§23). Draft 0.8o (2026-09-29): execution receipts, the `receipt` object and attestation (§14.6). Draft 0.8n (2026-09-29): line history, `oxy log -L` (§27). 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).

    /// Prune unreachable objects older than the grace period and repack everything into one pack

            "Packed {} into one pack: {} bytes -> {} bytes ({:.0}%).",

            plural(r.packed.objects, "object"),