Enum ClosureIssue 

pub enum ClosureIssue<R: Role> {
    MemberMissing {
        role: R,
    },
    MemberUnplanned {
        role: R,
    },
    MemberDuplicated {
        role: R,
        observed: u32,
    },
    OriginOrphan {
        role: R,
    },
    DigestMismatch {
        role: R,
    },
    SemanticKeyMismatch {
        role: R,
    },
    MaterializationMismatch {
        role: R,
    },
    MemberPlannedTwice {
        role: R,
        observed: u32,
    },
    MembershipDisagreement {
        role: R,
    },
    ReconstructionEmpty,
    ReconstructionUndeclarable {
        observed: u32,
    },
    JoinedTreeUnbounded {
        destination: Destination,
    },
    ArtifactAddressDoubled {
        role: R,
        address: OwnerIdentity,
    },
    ArtifactAddressAbsent {
        role: R,
    },
}

One way a rendering and the plan it claims to materialize disagree.

Every issue about a seat names it; the issues about the whole reconstruction name none, because there is no seat to name and electing one would be a stand-in nobody established.

Variants

MemberMissing

A seat the plan declared was not rendered at all.

Fields

role: R

The planned seat nothing materialized.

MemberUnplanned

A seat was rendered that the plan never declared — the output firewall’s own reversal.

Fields

role: R

The rendered seat nothing planned.

MemberDuplicated

One seat was rendered more than once.

Fields

role: R

The doubled seat.

observed: u32

How many units stood under it.

OriginOrphan

A rendered unit walks back to an origin the plan did not declare, which orphans it from the declaration it claims to project.

Fields

role: R

The seat whose origin disagreed.

DigestMismatch

The digest a rendered unit carries is not the digest of the bytes it actually carries, taken under the contract the plan stated.

Fields

role: R

The seat whose digest disagreed.

SemanticKeyMismatch

A unit stood under the planned seat and answered to a different semantic key: the right seat, filled by the wrong thing.

Fields

role: R

The seat whose semantic key disagreed.

MaterializationMismatch

A unit was rendered under a profile, or written to an address, the plan did not name.

The delivery cannot disagree and is not checked: a delivery is the seat’s own constant answer, so both sides read one value.

Fields

role: R

The seat whose materialization disagreed.

MemberPlannedTwice

The plan itself declared one seat twice, independent of what was rendered.

Two members under one seat make the seat-to-unit match elect one of them, and a proof that elected its own subject proves nothing.

Fields

role: R

The doubled seat.

observed: u32

How many members the plan declared under it.

MembershipDisagreement

The rebuilt membership and the planned one are not the same set under this seat.

The final theorem, checked as sets: a walk comparing one member per seat would agree about two memberships that differ in their second.

Fields

role: R

The seat the two sets disagree under.

ReconstructionEmpty

The rebuild produced no member at all.

ReconstructionUndeclarable

The rebuild produced members that will not declare as a complete output set.

Fields

observed: u32

How many members the rebuild produced.

JoinedTreeUnbounded

One delivery’s joined token tree outgrows the declared token magnitude.

It names the delivery it overran at: a caller told only that “the tree” is too wide does not know which build to cut.

Fields

destination: Destination

The delivery whose joined tree overran.

ArtifactAddressDoubled

Two rendered units are published to ONE address, so the artifact written second stands where the first stands.

The two stand under different seats and carry different material, so every check before this one passes them.

Fields

role: R

The seat whose artifact would stand at an address already taken.

address: OwnerIdentity

The address both units are written under.

ArtifactAddressAbsent

A unit was rendered into the publication delivery with no address to write it to.

A publication that elected an address for it would be minting the consumer’s own fact.

Fields

role: R

The seat whose artifact has nowhere to be written.

Implementations

impl<R: Role> ClosureIssue<R>

pub fn canonical_bytes(&self) -> Vec<u8>

This issue’s canonical bytes on their own, for the related identity a diagnostic derives over it.

pub fn encode_into(&self, into: &mut Vec<u8>)

Appends this issue’s canonical bytes: the row’s position in the declared roster, then the typed material that row carries, framed.

Exhaustive over the roster on purpose: an issue added to ClosureIssue stops compiling HERE until somebody says what of it a preimage commits to.

impl<R: Role> ClosureIssue<R>

pub const fn slot(&self) -> u8

This row’s position in the declared roster, written ahead of the issue’s own material.

Appended and never renumbered: the byte stands inside every identity derived over a refusal that carries it.

pub const fn role(&self) -> Option<R>

The seat this issue was established at, where it is about one.

pub const fn observed(&self) -> Observed

How what this issue observed differs from the contract that was expected.

pub const fn class(&self) -> RefusalClass

Which class of refusal a line opening with this issue is about.

Two rows are magnitudes rather than disagreements: what they report is a rendering that would have passed a declared bound, and the seats it filled are not in question.

Trait Implementations

impl<R: Clone + Role> Clone for ClosureIssue<R>

fn clone(&self) -> ClosureIssue<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R: Copy + Role> Copy for ClosureIssue<R>

impl<R: Debug + Role> Debug for ClosureIssue<R>

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

Formats the value using the given formatter.

impl<R: Role> Display for ClosureIssue<R>

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

Formats the value using the given formatter.

impl<R: Eq + Role> Eq for ClosureIssue<R>

impl<R: PartialEq + Role> PartialEq for ClosureIssue<R>

fn eq(&self, other: &ClosureIssue<R>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<R: PartialEq + Role> StructuralPartialEq for ClosureIssue<R>