gc leaves a store that is already one full pack as it is a67914bced23

        let (mut refs, keys, trained): (Vec<ObjectRef>, Vec<String>, bool) = {

                packs.first().is_some_and(|p| p.dict.is_some()),

        // Nothing loose and one pack already made by a full repack (only

        // such a pack has a trained dictionary): rewriting it would give

        // the same pack. A hub's nightly gc rewrote andymccall/oxygen's

        // 48 000 objects (37 s under its write lock) every time.

        if loose.is_empty() && keys.len() <= 1 && (level == ZSTD_LEVEL || trained) {

        let packs = |dir: &Path| {

            let mut v: Vec<String> = fs::read_dir(dir)

                .unwrap()

                .flatten()

                .map(|e| e.file_name().to_string_lossy().into_owned())

                .filter(|n| n.starts_with("pack-"))

                .collect();

            v.sort();

            v

        };

        // With nothing new, a repack leaves that pack as it is: it would

        // only write the same again.

        let before = packs(dir.path());

        let (report, merged) = again.repack_all(REPACK_ZSTD_LEVEL).unwrap();

        assert_eq!((report.objects, merged), (0, 0));

        assert_eq!(packs(dir.path()), before);

        // One new object: a repack replaces the pack and its dictionary.

        let extra = again.put(ObjectType::Chunk, b"one more\n").unwrap();

        let files = packs(dir.path());

        assert_ne!(files, before);

        assert_eq!(again.get(&extra).unwrap().1, b"one more\n");

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. A store that is already one such pack (it has a dictionary) with nothing loose is left as it is: repacking it would write the same pack. 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.