Struct WorkloopContract 

pub struct WorkloopContract {
    pub cadence_seconds: Option<u64>,
    pub arms: Vec<String>,
    pub carries: Vec<CarryContract>,
    pub invariants: Vec<InvariantContract>,
    pub retention_seconds: u64,
    pub detached: Vec<DetachedContract>,
    pub reports: Vec<ReportContract>,
    pub has_retire_body: bool,
}

The workloop declaration surface, as compiled from a workloop document (workloop design brief R2/R8/R13): everything the engine needs to arm the loop, seed the first generation’s carries from the declared defaults, and evaluate tolerances without re-reading AWL source.

Carried on the COMPILE OUTPUT (aion_awl::CompiledWorkflow::workloop) and on the deployed archive’s PackageContract, where it is bound into package identity: the engine reads it at START time to arm the cadence, seed generation 1’s carries and evaluate tolerances, so it must survive a server restart and must not be rewritable in storage without changing the package’s version.

Fields

cadence_seconds: Option<u64>

The every cadence in seconds, when declared.

arms: Vec<String>

The on <signal> arming signal names, in declaration order.

carries: Vec<CarryContract>

The carries: name, value schema, and the declared default the engine seeds the FIRST generation with (later generations carry the values route start minted).

invariants: Vec<InvariantContract>

The invariants, with their declared tolerances and confirming routes.

retention_seconds: u64

The declared retention window in seconds (R8.1 — required, no default).

detached: Vec<DetachedContract>

The detached hatch-target contracts: name and start schema.

reports: Vec<ReportContract>

The report tiles: name and value schema.

has_retire_body: bool

Whether the document declares a retire block, and therefore whether the deployed module exports retire/1.

🔴 A DECLARATION, NOT A CALLER PREFERENCE. Retirement has two engine verbs — one that invokes the declared cleanup and one for a loop that declares none — and which applies is decided by the DOCUMENT. If an operator could choose, a declared cleanup could be skipped by passing an argument, which is how a lease is lost. If the engine guessed, it could not tell a module compiled before the entry existed from a loop that declared no cleanup, which is the same failure wearing a different hat. So the answer travels with the package, bound into its identity like every other executable authority here.

Trait Implementations

impl Clone for WorkloopContract

fn clone(&self) -> WorkloopContract

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WorkloopContract

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for WorkloopContract

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for WorkloopContract

impl PartialEq for WorkloopContract

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for WorkloopContract

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 WorkloopContract