First commit: 12 s and 2.1 GB on the Linux tree (refs #41) 5b4c51307b14

 "memchr",

memchr = "2"

    /// An item already in its canonical encoding, written out as it is.

    /// Only built for encoding (never decoded): a large change's inline

    /// lines then cost their bytes, not a value per line.

    Encoded(Vec<u8>),

        Value::Encoded(b) => out.extend_from_slice(b),

    ends: Ends,

/// Line end offsets, four bytes each unless the buffer is over 4 GiB: a

/// first commit of the Linux tree holds 36 million of them at once. Which

/// form follows from the buffer's length alone, so equal lines compare

/// equal.

#[derive(PartialEq, Eq, Hash)]

enum Ends {

    Small(Vec<u32>),

    Large(Vec<u64>),

}

impl Default for Ends {

    fn default() -> Self {

        Ends::Small(Vec::new())

    }

}

impl Ends {

    fn from_u64(ends: Vec<u64>, buf_len: usize) -> Ends {

        if u32::try_from(buf_len).is_ok() {

            Ends::Small(ends.into_iter().map(|e| e as u32).collect())

        } else {

            Ends::Large(ends)

        }

    }

    fn len(&self) -> usize {

        match self {

            Ends::Small(v) => v.len(),

            Ends::Large(v) => v.len(),

        }

    }

    fn is_empty(&self) -> bool {

        self.len() == 0

    }

    fn get(&self, i: usize) -> Option<usize> {

        match self {

            Ends::Small(v) => v.get(i).map(|&e| e as usize),

            Ends::Large(v) => v.get(i).map(|&e| e as usize),

        }

    }

}

        // Counted first, so the offsets take exactly their room.

        let newlines = memchr::memchr_iter(b'\n', content).count();

        let unterminated = content.last().is_some_and(|&c| c != b'\n');

        let n = newlines + usize::from(unterminated);

        let ends_at = memchr::memchr_iter(b'\n', content)

            .map(|i| i + 1)

            .chain(unterminated.then_some(content.len()));

        let ends = if u32::try_from(content.len()).is_ok() {

            let mut v = Vec::with_capacity(n);

            v.extend(ends_at.map(|e| e as u32));

            Ends::Small(v)

        } else {

            let mut v = Vec::with_capacity(n);

            v.extend(ends_at.map(|e| e as u64));

            Ends::Large(v)

        };

        let end = self.0.ends.get(i)?;

        let start = if i == 0 { 0 } else { self.0.ends.get(i - 1)? };

        for i in 0..self.0.ends.len() {

            let end = self.0.ends.get(i).unwrap_or(start);

            let line = &buf[start..end];

            start = end;

        let ends = Ends::from_u64(ends, buf.len());

        let ends = Ends::from_u64(ends, buf.len());

    /// The edit's value; `compact` writes an inline insert's lines as

    /// their encoding rather than a value per line (same bytes encoded).

    fn to_value(&self, stored: Option<(ObjectRef, TextForm)>, compact: bool) -> Value {

                    if compact {

                        Value::Encoded(cbor::encode_byte_strings(lines))

                    } else {

                        Value::Array(lines.iter().map(|l| Value::Bytes(l.to_vec())).collect())

                    },

        self.value_with(&mut |_| true, false)

        // At most 256 texts or 32 MiB of them a batch: some directories

        // hold hundreds of generated files of megabytes each, and a batch

        // is copied and compressed at once.

        let mut batches: Vec<&[usize]> = Vec::new();

        let (mut start, mut bytes) = (0, 0usize);

        for (k, i) in stored.iter().enumerate() {

            if let Edit::Insert { lines, .. } = &self.edits[*i] {

                bytes += lines.bytes().len();

            }

            if k + 1 - start == 256 || bytes >= 32 << 20 {

                batches.push(&stored[start..=k]);

                (start, bytes) = (k + 1, 0);

            }

        }

        if start < stored.len() {

            batches.push(&stored[start..]);

        }

        for batch in batches {

    /// The change's value, its stored texts handed to `sink`; `compact`

    /// as [`Edit::to_value`] takes it, for a value that is only encoded.

    fn value_with(&self, sink: &mut TextSink, compact: bool) -> Value {

                        .map(|(e, stored)| e.to_value(stored, compact))

        cbor::encode(&self.value_with(&mut |_| true, true))

        let bytes = cbor::encode(&self.value_with(

            &mut |batch| {

                texts.extend(batch);

                true

            },

            true,

        ));

        let value = self.value_with(

            &mut |batch| match store(batch) {

                Ok(()) => true,

                Err(e) => {

                    failed = Some(e);

                    false

                }

            },

            true,

        );

    }

    #[test]

    fn compact_encoding_is_the_plain_one() {

        // Inline lines written as their encoding give the same bytes, so

        // the same hash, as a value per line.

        let c = sample_change();

        assert!(!c.has_stored_text(), "the sample's insert is inline");

        let plain = cbor::encode(&c.to_value());

        assert_eq!(c.encode(), plain);

        assert_eq!(c.encode_parts().0, plain);

        let streamed: Result<Vec<u8>, ()> = c.encode_streaming(|_| Ok(()));

        assert_eq!(streamed.unwrap(), plain);

        assert_eq!(Change::decode(&plain).unwrap(), c);

    /// The working-copy change's hash; for a commit's own snapshot, which

    /// does not encode it, the hash it had before.

        let storing = crate::timing::phase("store: the change");

        drop(storing);

            let _t = crate::timing::phase("store: sign it");

        // For a commit the change is neither encoded, stored nor recorded:

        // the commit stores its own, built from this one's operations, and

        // its texts with it. The hash it would have is not needed.

        let (new_hash, changed, encoded) = if for_commit {

            (old_hash, true, Vec::new())

        } else {

            let encoded = wc.encode_streaming(|batch| self.store.put_texts(&batch))?;

            let new_hash = crate::hash::hash_object(crate::hash::ObjectType::Change, &encoded);

            (new_hash, new_hash != old_hash, encoded)

        };

        let encoding = crate::timing::phase("store: encode the change and its texts");

        drop(encoding);

        let _t = crate::timing::phase("store: put the encoding");

    // The metadata only: a first commit's change holds the whole tree.

    let meta = repo.store().get_change_meta(&h)?;

        ui::id(meta.change_id.short(8)),