fix(pack): infer trailer hash kind from checksum length, release 0.8.4

PackEncoder finalizes its running checksum on whichever async worker
thread runs the task, but ObjectHash::from_bytes re-read the thread-local
HashKind at finalize time. On threads where set_hash_kind was never
called (default SHA-1), finalizing a SHA-256 pack panicked with
"Invalid byte length: got 32, expected 20", surfacing as flaky SHA-256
pack failures (e.g. 'libra bundle create' on SHA-256 repositories).

Add ObjectHash::from_bytes_infer_kind, which derives the kind from the
checksum byte length (20 -> SHA-1, 32 -> SHA-256) instead of the
thread-local kind, and use it in both the delta (encode/mod.rs) and
non-delta parallel (encode/parallel.rs) trailer paths, replacing the
unwrap() with a propagated GitError. Includes a regression test that
drives a SHA-256 encoder on a fresh thread holding the default SHA-1
thread-local kind.

Also: bump version to 0.8.4, point repository metadata at
https://github.com/libra-tools/git-internal, add CHANGELOG.md, and
resolve pre-existing clippy -D warnings debt (delta::decode match -> ?,
internal::index iter() -> values()) with no behavior change.

Signed-off-by: Quanyi Ma <eli@patch.sh>

Author: genedna

CHANGELOG.md

@@ -0,0 +1,45 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.8.4] - 2026-07-25
+
+### Fixed
+
+- Pack encoding no longer panics with `Invalid byte length: got 32, expected 20`
+  when finalizing a SHA-256 pack trailer on a thread whose thread-local
+  `HashKind` was never set. `PackEncoder` finalizes its running checksum on
+  whichever async worker thread happens to run the task; the previous
+  `ObjectHash::from_bytes` call re-read the thread-local kind at finalize
+  time and could disagree with the hasher chosen at encoder construction,
+  which surfaced as flaky SHA-256 pack failures (affecting, for example,
+  `libra bundle create` on SHA-256 repositories). Both the delta path
+  (`encode/mod.rs`) and the non-delta parallel path (`encode/parallel.rs`)
+  now infer the hash kind from the checksum byte length via the new
+  `ObjectHash::from_bytes_infer_kind`, and propagate a `GitError` instead of
+  unwrapping.
+
+### Added
+
+- `ObjectHash::from_bytes_infer_kind` — constructs an `ObjectHash` from raw
+  bytes by inferring the hash kind from the byte length (20 → SHA-1,
+  32 → SHA-256) instead of consulting the thread-local `HashKind`.
+- Regression test
+  `internal::pack::encode::tests::test_parallel_encode_trailer_ignores_thread_local_kind`,
+  which drives a SHA-256 encoder on a fresh thread holding the default SHA-1
+  thread-local kind.
+
+### Changed
+
+- Package `repository` metadata now points to
+  <https://github.com/libra-tools/git-internal>.
+- Resolved pre-existing clippy `-D warnings` debt so the lint gate passes
+  again: `match` → `?` in `delta::decode`, and `iter()` → `values()` map
+  iteration in `internal::index` (no behavior change).
+
+## [0.8.3] - 2026-07-24
+
+- Previous release; changes predate this changelog.

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "git-internal"
-version = "0.8.3"
+version = "0.8.4"
 edition = "2024"
 authors = ["Eli Ma <genedna@gmail.com>"]
 description = "High-performance Rust library for Git internal objects, Pack files, and AI-assisted development objects (Intent, Plan, Task, Run, Evidence, Decision) with delta compression, streaming I/O, and smart protocol support."
@@ -9,7 +9,7 @@ categories = ["development-tools", "encoding", "parser-implementations"]
 documentation = "https://libra.tools/docs/internal"
 readme = "README.md"
 homepage = "https://libra.tools"
-repository = "https://github.com/web3infra-foundation/libra"
+repository = "https://github.com/libra-tools/git-internal"
 license = "MIT"
 exclude = ["tests", ".github", ".claude", ".devcontainer", "examples"]
 

Cargo.toml

@@ -71,10 +71,7 @@ pub fn delta_decode(
                 GitDeltaError::DeltaDecoderError("Invalid copy instruction".to_string())
             });
 
-            match base_data {
-                Ok(data) => buffer.extend_from_slice(data),
-                Err(e) => return Err(e),
-            }
+            buffer.extend_from_slice(base_data?);
         }
     }
     assert!(buffer.len() == result_size);

src/delta/decode/mod.rs

@@ -211,6 +211,33 @@ impl ObjectHash {
             }
         }
     }
+    /// Create `ObjectHash` from raw bytes, inferring the hash kind from the
+    /// byte length (20 → SHA-1, 32 → SHA-256).
+    ///
+    /// Unlike [`ObjectHash::from_bytes`], this does not consult the
+    /// thread-local [`HashKind`], so it is safe on threads where
+    /// [`set_hash_kind`] was never called. The pack encoder finalizes its
+    /// running checksum on whichever async worker thread happens to run the
+    /// task; the checksum bytes already carry the correct length, while the
+    /// worker's thread-local may still hold the default SHA-1 kind — the
+    /// mismatch used to panic with "Invalid byte length: got 32, expected 20".
+    pub fn from_bytes_infer_kind(bytes: &[u8]) -> Result<ObjectHash, String> {
+        match bytes.len() {
+            20 => {
+                let mut h = [0u8; 20];
+                h.copy_from_slice(bytes);
+                Ok(ObjectHash::Sha1(h))
+            }
+            32 => {
+                let mut h = [0u8; 32];
+                h.copy_from_slice(bytes);
+                Ok(ObjectHash::Sha256(h))
+            }
+            other => Err(format!(
+                "Invalid byte length: got {other}, expected 20 (SHA-1) or 32 (SHA-256)"
+            )),
+        }
+    }
     /// Read hash bytes from a stream according to current hash size.
     pub fn from_stream(data: &mut impl io::Read) -> io::Result<ObjectHash> {
         match get_hash_kind() {

src/hash.rs

@@ -383,7 +383,7 @@ impl Index {
         file.write_all(&header)?;
         hash.update(&header);
 
-        for (_, entry) in self.entries.iter() {
+        for entry in self.entries.values() {
             let mut entry_bytes = Vec::new();
             entry_bytes.write_u32::<BigEndian>(entry.ctime.seconds)?;
             entry_bytes.write_u32::<BigEndian>(entry.ctime.nanos)?;
@@ -607,7 +607,7 @@ mod tests {
 
         let index = Index::from_file(source).unwrap();
         assert_eq!(index.size(), 760);
-        for (_, entry) in index.entries.iter() {
+        for entry in index.entries.values() {
             println!("{entry}");
         }
     }
@@ -621,7 +621,7 @@ mod tests {
 
         let index = Index::from_file(source).unwrap();
         assert_eq!(index.size(), 9);
-        for (_, entry) in index.entries.iter() {
+        for entry in index.entries.values() {
             println!("{entry}");
         }
     }

src/internal/index.rs

@@ -404,8 +404,13 @@ impl PackEncoder {
         self.idx_entries = Some(idx_entries);
 
         // The checksum is both the pack trailer and the identifier used in pack-<hash>.pack.
+        // Infer the kind from the checksum length: this task may run on an async worker
+        // thread whose thread-local `HashKind` was never set, so `ObjectHash::from_bytes`
+        // could disagree with the hasher chosen at encoder construction.
         let hash_result = self.inner_hash.clone().finalize();
-        self.final_hash = Some(ObjectHash::from_bytes(&hash_result).unwrap());
+        self.final_hash = Some(
+            ObjectHash::from_bytes_infer_kind(&hash_result).map_err(GitError::PackEncodeError)?,
+        );
         self.send_data(hash_result).await;
 
         self.drop_sender();

src/internal/pack/encode/mod.rs

@@ -110,8 +110,13 @@ impl super::PackEncoder {
         }
 
         // Append the checksum trailer only after every encoded entry has updated the running hash.
+        // Infer the kind from the checksum length: this task may run on an async worker
+        // thread whose thread-local `HashKind` was never set, so `ObjectHash::from_bytes`
+        // could disagree with the hasher chosen at encoder construction.
         let hash_result = self.inner_hash.clone().finalize();
-        self.final_hash = Some(ObjectHash::from_bytes(&hash_result).unwrap());
+        self.final_hash = Some(
+            ObjectHash::from_bytes_infer_kind(&hash_result).map_err(GitError::PackEncodeError)?,
+        );
         self.send_data(hash_result).await;
         self.drop_sender();
 

src/internal/pack/encode/parallel.rs

@@ -1071,3 +1071,70 @@ fn test_multi_point_similar_no_match() {
 fn test_multi_point_similar_too_small() {
     assert!(!multi_point_similar(&[1u8, 2, 3], &[4u8, 5, 6]));
 }
+
+/// Regression: the pack trailer must be built from the checksum's own length,
+/// not from the thread-local `HashKind`. The encoder is constructed under
+/// SHA-256 and then driven on a fresh thread whose thread-local still holds
+/// the default SHA-1 kind — the previous `ObjectHash::from_bytes` call
+/// panicked there ("Invalid byte length: got 32, expected 20"), which
+/// surfaced as flaky SHA-256 pack failures in async runtimes that migrate
+/// tasks across worker threads.
+#[test]
+fn test_parallel_encode_trailer_ignores_thread_local_kind() {
+    use crate::hash::get_hash_kind;
+
+    let _guard = set_hash_kind_for_test(HashKind::Sha256);
+
+    let entries: Vec<Entry> = (0..8)
+        .map(|i| Entry::from(Blob::from_content(&format!("thread-local-kind-{i}"))))
+        .collect();
+    let (tx, mut rx) = mpsc::channel(16);
+    let (entry_tx, entry_rx) = mpsc::channel::<MetaAttached<Entry, EntryMeta>>(16);
+    let mut encoder = PackEncoder::new(entries.len(), 0, tx);
+
+    std::thread::spawn(move || {
+        // A fresh thread never saw `set_hash_kind`, so it holds the default
+        // SHA-1 kind — the exact condition that used to panic on finalize.
+        assert_eq!(get_hash_kind(), HashKind::Sha1);
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .expect("build current-thread runtime");
+        rt.block_on(async move {
+            for entry in entries {
+                entry_tx
+                    .send(MetaAttached {
+                        inner: entry,
+                        meta: EntryMeta::new(),
+                    })
+                    .await
+                    .expect("send entry");
+            }
+            drop(entry_tx);
+
+            encoder
+                .parallel_encode(entry_rx)
+                .await
+                .expect("parallel encode must succeed off the origin thread");
+
+            let mut pack = Vec::new();
+            while let Some(chunk) = rx.recv().await {
+                pack.extend(chunk);
+            }
+            let trailer = encoder
+                .get_hash()
+                .expect("final hash must be recorded after encode");
+            assert!(
+                matches!(trailer, ObjectHash::Sha256(_)),
+                "trailer must stay SHA-256 regardless of the worker thread's kind"
+            );
+            assert_eq!(
+                &pack[pack.len() - 32..],
+                trailer.to_data().as_slice(),
+                "pack trailer bytes must be the 32-byte SHA-256 checksum"
+            );
+        });
+    })
+    .join()
+    .expect("encoder thread must not panic");
+}