GitoxideLabs/gitoxide · warning

a base object as root of any delta chain that we are here…

Error message

a base object as root of any delta chain that we are here to resolve

What it means

A `expect()` panic in `resolve_deltas` asserting that a base object kind is known when caching the resolved object. Any delta chain must terminate in a real object whose kind is tracked; if `object_kind` is `None` at cache-put time, the kind tracking through base resolution failed — an internal invariant of the decoder.

Solutions

1. Use stock `resolve_deltas`/decode paths; ensure custom resolve callbacks return well-formed entries
2. Update gix-pack
3. Report a reproducer upstream if triggered

let r = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| pack.decode_entry(id, &mut out, ...)));
if r.is_err() { eprintln!("delta base kind invariant violated"); }

When it happens

Trigger: `decode_entry` -> `resolve_deltas` completing a delta chain but having lost the base object's kind (defect in kind propagation from the first entry or resolved base).

Common situations: Library development, fuzzing corrupted packs, or custom base-resolution callbacks returning malformed entries.

Understand the failure class

Background: "This is a bug, please report it": internal invariant violations, unreachable panics, and SNH errors explained — this error's family across 47 libraries.

Related errors

• at least one delta chain item
• at least one decompressed delta object
• a non-delta entry
• object kind as set by cache
• consumed bytes as set by cache

AI-assisted analysis of GitoxideLabs/gitoxide@e73179060b (2026-09-08). Data as JSON: /api/errors/3e3fe093e0e90643. Report an issue: GitHub.

Appendix: source

Thrown at gix-pack/src/data/file/decode/entry.rs:452

        }

        let last_result_size = last_result_size.expect("at least one delta chain item");
        // uneven chains leave the target buffer after the source buffer
        // FIXME(Performance) If delta-chains are uneven, we know we will have to copy bytes over here
        //      Instead we could use a different start buffer, to naturally end up with the result in the
        //      right one.
        //      However, this is a bit more complicated than just that - you have to deal with the base
        //      object, which should also be placed in the second buffer right away. You don't have that
        //      control/knowledge for out-of-pack bases, so this is a special case to deal with, too.
        //      Maybe these invariants can be represented in the type system though.
        if chain_len % 2 == 1 {
            // this seems inverted, but remember: we swapped the buffers on the last iteration
            target_buf[..last_result_size].copy_from_slice(&source_buf[..last_result_size]);
        }
        debug_assert!(out.len() >= last_result_size);
        out.truncate(last_result_size);

        let object_kind = object_kind.expect("a base object as root of any delta chain that we are here to resolve");
        let consumed_input = consumed_input.expect("at least one decompressed delta object");
        cache.put(
            self.id,
            first_entry.data_offset,
            out.as_slice(),
            object_kind,
            consumed_input,
        );
        Ok(Outcome {
            kind: object_kind,
            // technically depending on the cache, the chain size is not correct as it might
            // have been cut short by a cache hit. The caller must deactivate the cache to get
            // actual results
            num_deltas: chain_len as u32,
            decompressed_size: first_entry.decompressed_size,
            compressed_size: consumed_input,
            object_size: last_result_size as u64,
        })

View on GitHub (pinned to e73179060b)