Struct PairReplayRecord 

pub struct PairReplayRecord {

    pub schema_version: u32,
    pub selection_hash: String,
    pub root_seed: u64,
    pub strategy: String,
    pub strategy_version: u32,
    pub singleton_policy: String,
    pub singleton_policy_version: u32,
    pub degenerate_policy_version: u32,
    pub budget: u64,
    pub default_was_clamped: bool,
    pub emitted_kinds: String,
    pub affected_singleton_classes: u64,
    pub deviation: [String; 3],
}

The ~200-byte record a pair stream regenerates from.

Pairs are replayed, not stored (D-09)

Forty benchmark cells times ten seeds times many epochs of pair bytes is gigabytes of derivable data. Only this record and the manifest hash are persisted; a serverless consumer carries the record instead of a file. An explicit DUMP path (dump_pairs) exists for audit and fixture generation, and it is the only thing that ever writes pair bytes.

Every field is present even when it holds its default, because an absent field is indistinguishable from a field that was never considered.

Fields

schema_version: u32

Record schema version.

selection_hash: String

Hex semantic_hash of the selection the pairs are drawn over.

root_seed: u64

The root seed every draw key derives from.

strategy: String

Wire name of the sampling strategy.

strategy_version: u32

Version tag of that strategy. A change here changes pair IDENTITIES.

singleton_policy: String

Wire name of the singleton policy.

singleton_policy_version: u32

Version tag of that policy.

degenerate_policy_version: u32

Version tag of the degenerate-layout policy.

budget: u64

The RESOLVED effective budget — post-clamp, exactly what the stream emitted.

The hard cap itself is deliberately NOT persisted: the resolved budget subsumes it for replay, and the record stays small (D-09).

default_was_clamped: bool

Whether the DEFAULT budget was clamped. A clamped run that looked unclamped in the artifact would defeat the point of recording it.

emitted_kinds: String

both, positives_only or negatives_only.

affected_singleton_classes: u64

How many classes held exactly one selected example (OBLIG-CPP-SINGLETON-EXPLICIT).

deviation: [String; 3]

The three declared deviation clauses, verbatim.

Implementations

impl PairReplayRecord

pub fn from_sampler(sampler: &PairSampler<'_>) -> Self

Describe a live sampler.

Why this takes ONLY the sampler

The plan’s interface sketch was from_sampler(sampler, selection, cfg). A sampler already BORROWS its selection and already retains its resolved configuration, so the extra parameters could only ever disagree with it — and a replay record that describes a different selection or a different budget than the stream it attests is precisely the artifact this record exists to make impossible. One argument, one source of truth.

pub fn to_canonical_bytes(&self) -> Result<Vec<u8>, ContrastiveDataError>

Deterministic canonical serialization — the bytes the manifest hash commits FIRST.

Errors

ContrastiveDataError::Serialization if the record cannot be serialized.

pub fn to_config(&self) -> Result<PairConfig, ContrastiveDataError>

Rebuild the configuration that produced the stream, refusing unknown versions.

Errors

ContrastiveDataError::UnsupportedSchemaVersion, ContrastiveDataError::UnsupportedAlgorithmVersion, ContrastiveDataError::UnsupportedPolicyVersion.

Trait Implementations

impl Clone for PairReplayRecord

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PairReplayRecord

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PairReplayRecord

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for PairReplayRecord

impl PartialEq for PairReplayRecord

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for PairReplayRecord

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for PairReplayRecord