Struct Response 

pub struct Response {
    pub schema: ResponseTag,
    pub definition: DefinitionId,
    pub instance: InstanceId,
    pub revision: Revision,
    pub values: Vec<Submission>,
    pub idempotency_key: IdempotencyKey,
    pub responder_provenance: ResponderProvenance,
}

A submission bound to the exact offer it answers.

Binds type, definition, instance, digest, revision, control values, idempotency key, and responder provenance — the ADR’s own list. Nothing here authorizes on its own: the controller revalidates every field against the definition before it resolves anything.

Fields

schema: ResponseTag

Versioned type tag; see RESPONSE_SCHEMA_V1.

definition: DefinitionId

The definition answered — and, being a content id, its exact form digest. A definition that changed by one byte cannot be answered by a response minted against the old one.

instance: InstanceId

The instance answered.

revision: Revision

The revision the responder saw.

values: Vec<Submission>

The submitted values, each against the control it answers.

idempotency_key: IdempotencyKey

Makes a retry the same submission rather than a second one.

responder_provenance: ResponderProvenance

How the responder was authenticated, by reference — including which audience they answered from. Bound into the response’s identity, so a submission cannot be re-attributed after the fact.

There is deliberately no second responder: Audience field beside this one. Two bound fields carrying the same fact can disagree, and nothing in a plain record keeps them equal; the identity table would then be pinning a contradiction. The audience a responder was authenticated FROM is part of the assertion, so it lives with it.

Implementations

impl Response

pub fn response_id(&self) -> Result<ResponseId, ProtocolError>

This response’s identity.

Errors

Propagates a canonical-encoding failure.

pub fn schema_tag(&self) -> &'static str

The schema tag, as a string.

Reading it needs no check: the tag is a TYPE that deserializes from exactly one value, so a record of this type cannot carry any other one. What used to be a runtime ensure_known_schema is now a thing the wire cannot express — and the published schema says so with a const, so a foreign implementor validating against the wrong record’s schema fails instead of passing.

Trait Implementations

impl Clone for Response

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ContentAddressable for Response

fn canonical_form(&self) -> Result<Vec<u8>, ContentError>

Produce the deterministic byte representation of this value.

fn content_id(&self) -> Result<ContentId, ContentError>

Compute this value’s ContentId.

fn verify(&self, expected: &ContentId) -> Result<bool, ContentError>

Check whether this value’s content id matches an expected id.

fn ensure_content_id(&self, expected: &ContentId) -> Result<(), ContentError>

Verify, returning an error on mismatch instead of Ok(false).

fn from_canonical_form(bytes: &[u8]) -> Result<Self, ContentError>

where Self: Sized + DeserializeOwned,

Checked ingress: decode a value from its canonical form, proving the bytes reproduce it — a checked partial inverse of canonical_form.

impl Debug for Response

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Response

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Response

impl PartialEq for Response

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Response

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 Response