#[non_exhaustive]pub enum StepFact {
Show 23 variants
CeremonyStarted {
name: String,
template: Sha256Digest,
},
RoleDeclared {
role: RoleId,
name: String,
},
RoleAssigned {
role: RoleId,
person: String,
},
ParameterBound {
name: ParamId,
value: Value,
},
MaterialLoaded {
name: MaterialId,
identifier: Option<String>,
},
MaterialDigest {
name: MaterialId,
digest: Sha256Digest,
},
BackendBound {
name: String,
provider: String,
identity: String,
},
MachineInfoRecorded {
step: StepId,
info: Value,
},
ActStarted {
id: ActId,
label: String,
},
StepStarted {
id: StepId,
label: String,
role: RoleId,
},
PromptAnswered {
step: Option<StepId>,
prompt: Prompt,
response: ResponseRecord,
},
BackendOperation {
step: StepId,
kind: String,
backend: Option<String>,
inputs: Value,
outputs: Value,
fingerprint: Option<String>,
},
WrapRecipientRecorded {
step: StepId,
source: String,
fingerprint: String,
declared: bool,
},
AttestationRecorded {
step: StepId,
role: RoleId,
statement: String,
},
ArtifactWritten {
step: StepId,
name: String,
file: String,
digest: Option<Sha256Digest>,
},
DeviationRecorded {
step: Option<StepId>,
text: String,
},
StepAttemptFailed {
step: StepId,
attempt: u32,
error: ErrorRecord,
},
StepCompleted {
id: StepId,
outcome: StepOutcome,
},
CeremonyCompleted {},
CeremonyFailed {
error: ErrorRecord,
},
EntropySeeded {
m: String,
source: String,
derivation: String,
},
EntropyContributed {
step: StepId,
epoch: u32,
contribution: String,
},
EntropyDrawn {
step: StepId,
path: String,
value: String,
},
}Expand description
Durable, transcript-worthy fact.
Every variant is recorded by the runtime’s transcript sink synchronously
before being forwarded to the UI. Action handlers emit
BackendOperation and AttestationRecorded; all other variants are
emitted by the executor at the corresponding lifecycle boundary.
Variants (Non-exhaustive)§
This enum is marked as non-exhaustive
CeremonyStarted
Ceremony has started running.
Fields
template: Sha256DigestDigest of the ceremony YAML the run was resolved from. The inputs supplied for this run are recorded as their own facts, one each, so this digest covers the template only.
RoleDeclared
A role the ceremony defines, with its display name.
Recorded once per role at ceremony start, whether or not anyone is assigned to it. Later facts name the role by id only.
Fields
RoleAssigned
A person was assigned to a role for this run.
One fact per assignment, so each can be withheld on its own.
Fields
ParameterBound
A parameter took its value for this run, supplied or defaulted.
MaterialLoaded
A material was loaded at ceremony start.
The digest of a digital material is a separate fact,
MaterialDigest, so the two can be
disclosed to different audiences.
Fields
name: MaterialIdMaterial identifier.
MaterialDigest
The digest of a digital material’s bytes.
BackendBound
A backend was first acquired in this run.
Recorded once per backend, before the first operation on it. Backend operations name the backend and do not repeat its identity, which can carry device serials.
Fields
MachineInfoRecorded
A snapshot of the machine the ceremony ran on.
Fields
ActStarted
Beginning of an act (named subdivision of a ceremony).
StepStarted
Beginning of a step.
Fields
role: RoleIdRole responsible for this step. Its name is on the role’s
RoleDeclared fact.
PromptAnswered
A prompt has been answered and validated.
Fields
step: Option<StepId>Step that issued the prompt, if any. None for ceremony-level
prompts emitted before the first step (e.g. the ceremony-start
confirmation) or after the last step.
response: ResponseRecordRedacted response record.
BackendOperation
A backend operation completed and produced structured evidence.
Fields
backend: Option<String>The backend the step ran with, by the name the ceremony gives it;
its identity is on that backend’s StepFact::BackendBound.
Absent for an operation done in software.
WrapRecipientRecorded
A key held outside the ceremony was used as the recipient of a wrap.
Its own fact rather than a field on the wrap operation: the method of a wrap is publishable and the identity of a custodian may not be, and a fact carries one confidentiality level.
The fingerprint records the bytes that were present. Nothing in the ceremony corroborates that they belong to the intended recipient, and nothing shows the recipient can open the result. The fact states an assumption the ceremony rests on, not something Rite proved.
Fields
AttestationRecorded
A human attestation was recorded.
Fields
ArtifactWritten
An artifact was written to the run’s artifacts/ directory.
Fields
digest: Option<Sha256Digest>Digest of the file’s bytes. Absent when the artifact is content a step opened: a digest of a secret can be tested against guesses, so none is recorded.
DeviationRecorded
A deviation was logged by the operator.
Fields
StepAttemptFailed
A step attempt failed. Recorded per attempt, so a retried step shows
StepAttemptFailed{attempt: 1} followed by the operator’s retry
decision and, on success, StepCompleted. The final attempt of a step
that the run gives up on is followed by the terminal CeremonyFailed.
Fields
error: ErrorRecordStructured error record for the failed attempt.
StepCompleted
Step finished executing.
CeremonyCompleted
Ceremony finished successfully.
The transcript’s fingerprint is the chain value of this line, which
any reader recomputes, so the fact itself carries no fingerprint
field. The runtime forwards the value to frontends through an
out-of-band channel event.
CeremonyFailed
Ceremony failed or was aborted.
Fields
error: ErrorRecordStructured error record.
EntropySeeded
The ceremony entropy source was seeded with machine randomness.
Emitted once by the runner at ceremony start (run-metadata). Records
the machine contribution m and the frozen derivation scheme so any
value the ceremony later draws is re-derivable from the transcript
alone. Part of the entropy source family.
Like every fact, it is timed by the at on its chain envelope.
Fields
EntropyContributed
A human folded additional entropy into the seed, advancing the ratchet.
Emitted by the authored gather_entropy step. The verbatim operator
contribution is recorded so the epoch chain re-folds identically; it is
public, witnessed entropy, not a secret. Timed by its enclosing step
boundaries (and by the PromptAnswered that captured the input).
Fields
EntropyDrawn
A value was drawn from the entropy source (a nonce, certificate serial, or challenge).
Emitted whenever an action draws bytes from the entropy source. The
derivation path plus the recorded seed let rite verify re-derive
the value and confirm the right value reached the right consumer. Like
other action-emitted evidence, it is timed by its enclosing step.
Implementations§
Source§impl StepFact
impl StepFact
Sourcepub fn default_level(&self) -> Level
pub fn default_level(&self) -> Level
The level a fact of this type is recorded at.
Method facts (what was done, in what order, with what result) are public, and so are attestations, whose statement is authored in the ceremony. Free text, answers typed at prompts, the error message of a failed attempt, and identities of devices and inputs are restricted. Persons, material digests and the host snapshot are confidential.
A failed ceremony stays public despite its error message: a public disclosure needs its terminal fact.
Sourcepub fn is_side_effect(&self) -> bool
pub fn is_side_effect(&self) -> bool
Whether this fact evidences work performed on the world: a backend operation, a written artifact, a captured attestation, or consumed entropy. Interaction records (an answered prompt, an operator deviation note) and lifecycle markers are not side effects: repeating the interaction is safe and simply produces a fresh record.
The runtime’s retry gate refuses to re-execute a step attempt that already emitted a side-effect fact.