Struct PackGen 

pub struct PackGen { /* private fields */ }

The substrate’s GitPackGen implement: ADR-004’s pipeline over the object front’s real Find, the ADR-014 §5 ack predicate, and one of the two serving shapes (constructor-level posture — through the frozen trait signature runs no mode parameter; the wire layer is unchanged either way).

The object pool is global, not per-repo-namespaced (the wave-7 recorded interpretation): the &RepoRecord parameter is accepted and unused here — the Find front reads the git-object family directly, per-repo coverage is liveness-decided.

Implementations

impl PackGen

pub fn direct(front: ObjectFront) -> Self

The direct shape: the generated pack streams through the sink, no storage round-trip.

pub fn through_store(front: ObjectFront) -> Self

The through-store shape with the default request-digest cache (4 entries).

The fresh private cache is a deliberate per-piece probe surface (the documented-durable() posture, review 006 R-6’s second instance): the cache’s pins are reachable by no maintenance chain, so its release path is eviction alone and served packs go reclaim-only at sweep — an honest probe shape, not a production composition. The production through-store serving shape is the composition entry’s (crate::compose’s PackServing::ThroughStore, the cache shared with the chain’s housekeeping), and a hand-wired production embedder passes the chain-held handle explicitly (PackGen::through_store_with).

pub fn through_store_with(front: ObjectFront, cache: Arc<PackCache>) -> Self

The through-store shape with an explicit cache — shared (Arc): the same handle the composition’s maintenance chain holds, whose PackHousekeeping job runs PackCache::release_all.

Trait Implementations

impl GitPackGen for PackGen

fn generate<'life0, 'life1, 'async_trait>( &'life0 self, _repo: &'life1 RepoRecord, wants: Vec<ObjectId>, boundary_haves: Vec<ObjectId>, _limits: Limits, sink: Box<dyn Write + Send>, ) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

closure(wants) − closure(boundary_haves) → pack streamed into the sink (ADR-004). Missing objects abort with StorageError::ObjectMissing — never a broken pack on the sink.

fn common_haves<'life0, 'life1, 'async_trait>( &'life0 self, _repo: &'life1 RepoRecord, haves: Vec<ObjectId>, ) -> Pin<Box<dyn Future<Output = Result<Vec<ObjectId>, StorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

The negotiation ack seam’s real predicate (ADR-014 §5, the same predicate on the ack rounds and the done-round boundary alike): a have is recognized iff it exists in the object store and is a commit — the is-commit half over the loose header the odb layer owns (ObjectFront::kind, the bounded header peek — the predicate never reads a have’s body, so a hostile have set cannot walk the store’s object contents). A missing have is kind’s None (unrecognized — subtracts nothing); a non-sha1 have is StorageError::Invalid (OQ-05). One seam predicate, no wire-side refinement (ADR-010). The caller’s order is preserved verbatim.