hecks 3.14.0 → 4.0.0

data/rust/src/kernel/routing.rs

@@ -102,6 +102,16 @@ impl RoutingEnvelope {
     }
 }
 
+/// Step-envelope keys (`verb`, `role`, ...) are not facts, so `with:` may sit beside them.
+const STEP_ENVELOPE_KEYS: [&str; 6] = [
+    "verb",
+    "role",
+    "actor_id",
+    "occurred_at",
+    "dry_run",
+    "query",
+];
+
 #[derive(Debug, Clone, PartialEq)]
 pub struct CommandInvocation {
     route: Option<RoutingEnvelope>,
@@ -121,15 +131,14 @@ impl CommandInvocation {
     /// The facts source depends on `with:` alone, never on `to:`.
     pub fn from_json(value: &Json) -> Result<Self, Refusal> {
         let target = non_null(value.get("to"));
-        let explicit_facts = non_null(value.get("with"));
-        if explicit_facts.is_none() {
+        let Some(explicit_facts) = non_null(value.get("with")) else {
             let route = target.map(RoutingEnvelope::from_json).transpose()?;
             return Ok(Self {
                 route,
                 facts: strip_routing_keys(value),
                 explicit: false,
             });
-        }
+        };
 
         if value.get("args").is_some() {
             return Err(routing_refusal("cannot combine to/with with legacy args"));
@@ -137,42 +146,40 @@ impl CommandInvocation {
 
         // `with:` beside a loose fact is refused, as Ruby's `Routing.payload` refuses it.
         // Step-envelope keys (`verb`, `role`, ...) are not facts and are exempt.
-        const STEP_ENVELOPE_KEYS: [&str; 6] =
-            ["verb", "role", "actor_id", "occurred_at", "dry_run", "query"];
-        if explicit_facts.is_some() {
-            if let Json::Object(fields) = value {
-                let extra = fields
-                    .iter()
-                    .any(|(key, _)| key != "to" && key != "with" && !STEP_ENVELOPE_KEYS.contains(&key.as_str()));
-                if extra {
-                    return Err(routing_refusal(
-                        "with: takes command facts, not both with: and loose keyword arguments",
-                    ));
-                }
+        if let Json::Object(fields) = value {
+            let extra = fields.iter().any(|(key, _)| {
+                key != "to" && key != "with" && !STEP_ENVELOPE_KEYS.contains(&key.as_str())
+            });
+            if extra {
+                return Err(routing_refusal(
+                    "with: takes command facts, not both with: and loose keyword arguments",
+                ));
             }
         }
 
         let route = target.map(RoutingEnvelope::from_json).transpose()?;
-        let facts = explicit_facts
-            .cloned()
-            .expect("explicit_facts checked Some above");
+        let facts = explicit_facts.clone();
         if !matches!(facts, Json::Object(_)) {
             return Err(routing_refusal("with must be an object of command facts"));
         }
 
-        Ok(Self { route, facts, explicit: true })
+        Ok(Self {
+            route,
+            facts,
+            explicit: true,
+        })
     }
 
-    pub fn route(&self) -> Option<&RoutingEnvelope> {
+    pub const fn route(&self) -> Option<&RoutingEnvelope> {
         self.route.as_ref()
     }
 
-    pub fn facts(&self) -> &Json {
+    pub const fn facts(&self) -> &Json {
         &self.facts
     }
 
     /// True when this call used the explicit `with:` shape, false for flat facts.
-    pub fn explicit_with(&self) -> bool {
+    pub const fn explicit_with(&self) -> bool {
         self.explicit
     }
 
@@ -358,21 +365,24 @@ mod tests {
         assert_eq!(invocation.route(), None);
         assert_eq!(
             invocation.facts(),
-            &Json::obj(vec![("name", Json::obj(vec![("value", Json::str("golf"))]))])
+            &Json::obj(vec![(
+                "name",
+                Json::obj(vec![("value", Json::str("golf"))])
+            )])
         );
     }
 
     // Same for a null `with`: read as the no-`to:` shape; the null key is dropped from the facts.
     #[test]
     fn null_with_and_no_to_key_is_read_as_legacy_shape_not_explicit_facts() {
-        let input = Json::obj(vec![
-            ("with", Json::Null),
-            ("amount", Json::int(20)),
-        ]);
+        let input = Json::obj(vec![("with", Json::Null), ("amount", Json::int(20))]);
 
         let invocation = CommandInvocation::from_json(&input).unwrap();
         assert_eq!(invocation.route(), None);
-        assert_eq!(invocation.facts(), &Json::obj(vec![("amount", Json::int(20))]));
+        assert_eq!(
+            invocation.facts(),
+            &Json::obj(vec![("amount", Json::int(20))])
+        );
     }
 
     // A non-null `to` is always parsed as a route, even when a domain fact is named `to`.
@@ -381,7 +391,9 @@ mod tests {
         let input = Json::obj(vec![("to", Json::obj(vec![("value", Json::int(282))]))]);
 
         let err = CommandInvocation::from_json(&input).unwrap_err();
-        assert!(err.to_string().contains("entity route requires a scalar aggregate identity"));
+        assert!(err
+            .to_string()
+            .contains("entity route requires a scalar aggregate identity"));
     }
 
     // A real `to:` with flat facts and no `with:` must keep the facts; only `with:` selects them.
@@ -396,7 +408,10 @@ mod tests {
         let route = invocation.route().unwrap();
         route.require_depth(0).unwrap();
         assert_eq!(route.aggregate(), "ORDER-7");
-        assert_eq!(invocation.facts(), &Json::obj(vec![("quantity", Json::int(3))]));
+        assert_eq!(
+            invocation.facts(),
+            &Json::obj(vec![("quantity", Json::int(3))])
+        );
     }
 
     // Same, with an entity route as `to:`.
@@ -427,14 +442,14 @@ mod tests {
     // Same, with `to: null` beside real facts.
     #[test]
     fn null_to_alongside_real_facts_keeps_the_flat_facts() {
-        let input = Json::obj(vec![
-            ("to", Json::Null),
-            ("quantity", Json::int(3)),
-        ]);
+        let input = Json::obj(vec![("to", Json::Null), ("quantity", Json::int(3))]);
 
         let invocation = CommandInvocation::from_json(&input).unwrap();
         assert_eq!(invocation.route(), None);
-        assert_eq!(invocation.facts(), &Json::obj(vec![("quantity", Json::int(3))]));
+        assert_eq!(
+            invocation.facts(),
+            &Json::obj(vec![("quantity", Json::int(3))])
+        );
     }
 
     // `explicit_with()` is true only when the explicit `with:` branch was taken.
@@ -461,11 +476,8 @@ mod tests {
         .unwrap();
         assert!(!legacy_with_to.explicit_with());
 
-        let legacy_no_to = CommandInvocation::from_json(&Json::obj(vec![(
-            "amount",
-            Json::int(20),
-        )]))
-        .unwrap();
+        let legacy_no_to =
+            CommandInvocation::from_json(&Json::obj(vec![("amount", Json::int(20))])).unwrap();
         assert!(!legacy_no_to.explicit_with());
 
         let legacy_null_with = CommandInvocation::from_json(&Json::obj(vec![
@@ -499,7 +511,9 @@ mod tests {
             ),
         ]))
         .unwrap();
-        let (receiver, facts) = explicit.split_aggregate_receiver(Some("order"), None).unwrap();
+        let (receiver, facts) = explicit
+            .split_aggregate_receiver(Some("order"), None)
+            .unwrap();
         assert_eq!(receiver, "ORDER-7");
         assert_eq!(facts, Json::obj(vec![("amount", Json::int(20))]));
 
@@ -508,7 +522,9 @@ mod tests {
             ("amount", Json::int(30)),
         ]))
         .unwrap();
-        let (receiver, facts) = legacy.split_aggregate_receiver(Some("order"), None).unwrap();
+        let (receiver, facts) = legacy
+            .split_aggregate_receiver(Some("order"), None)
+            .unwrap();
         assert_eq!(receiver, "ORDER-8");
         assert_eq!(facts, Json::obj(vec![("amount", Json::int(30))]));
 

data/rust/src/kernel/ruby_float.rs

@@ -0,0 +1,139 @@
+//! Ruby-style `Float#to_s` and the finite-result check shared by float arithmetic.
+//!
+//! Fault wording quotes operands the way Ruby prints them (`1.0e+308`, not Rust's 309-digit
+//! expansion), so a Fault from either runtime reads the same.
+
+use crate::kernel::Refusal;
+
+// Ruby switches to scientific notation when the decimal point sits left of 1e-4 or right of 1e16.
+const FIXED_MIN_EXPONENT: i32 = -4;
+const FIXED_MAX_EXPONENT: i32 = 15;
+
+/// `Float#to_s`: shortest round-trip digits, fixed notation for `1e-4 <= |n| < 1e16`, else `d.ddde+XX`.
+pub fn to_s(n: f64) -> String {
+    if n.is_nan() {
+        return "NaN".to_string();
+    }
+    if n.is_infinite() {
+        return if n < 0.0 { "-Infinity" } else { "Infinity" }.to_string();
+    }
+    let sign = if n.is_sign_negative() { "-" } else { "" };
+    if n == 0.0 {
+        return format!("{sign}0.0");
+    }
+    // `{:e}` yields the shortest round-trip digits as `d.ddde<exp>`.
+    let scientific = format!("{:e}", n.abs());
+    let (mantissa, exponent) = scientific.split_once('e').unwrap_or((&scientific, "0"));
+    let exponent: i32 = exponent.parse().unwrap_or(0);
+    let digits: String = mantissa.chars().filter(char::is_ascii_digit).collect();
+    if (FIXED_MIN_EXPONENT..=FIXED_MAX_EXPONENT).contains(&exponent) {
+        return format!("{sign}{}", fixed(&digits, exponent));
+    }
+    let (head, tail) = digits.split_at(1);
+    let tail = if tail.is_empty() { "0" } else { tail };
+    let exponent_sign = if exponent < 0 { '-' } else { '+' };
+    format!("{sign}{head}.{tail}e{exponent_sign}{:02}", exponent.abs())
+}
+
+// Places the decimal point `exponent` digits after the first digit, padding zeros as needed.
+fn fixed(digits: &str, exponent: i32) -> String {
+    if exponent < 0 {
+        let zeros = "0".repeat(exponent.unsigned_abs() as usize - 1);
+        return format!("0.{zeros}{digits}");
+    }
+    let whole_len = exponent as usize + 1;
+    if digits.len() <= whole_len {
+        let zeros = "0".repeat(whole_len - digits.len());
+        return format!("{digits}{zeros}.0");
+    }
+    let (whole, fraction) = digits.split_at(whole_len);
+    format!("{whole}.{fraction}")
+}
+
+/// Passes a float arithmetic `result` through only if finite; else the C3.4 Fault.
+///
+/// Ruby quotes the right operand by absolute value, so a decrement still reads `a - |b|`.
+pub fn finite_or_fault(
+    op: &str,
+    symbol: &str,
+    lhs: f64,
+    rhs: f64,
+    result: f64,
+) -> Result<f64, Refusal> {
+    if result.is_finite() {
+        return Ok(result);
+    }
+    Err(Refusal::Fault(format!(
+        "{op} overflowed: {} {symbol} {} is not a finite number",
+        to_s(lhs),
+        to_s(rhs.abs())
+    )))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn whole_numbers_keep_a_decimal_point() {
+        assert_eq!(to_s(1.0), "1.0");
+        assert_eq!(to_s(-250.0), "-250.0");
+        assert_eq!(to_s(0.0), "0.0");
+    }
+
+    #[test]
+    fn fractions_print_shortest_round_trip_digits() {
+        assert_eq!(to_s(0.1), "0.1");
+        assert_eq!(to_s(1.5), "1.5");
+        assert_eq!(to_s(0.0001), "0.0001");
+        assert_eq!(to_s(123_456.789), "123456.789");
+    }
+
+    #[test]
+    fn large_magnitudes_switch_to_scientific_at_1e16() {
+        assert_eq!(to_s(1.0e15), "1000000000000000.0");
+        assert_eq!(to_s(1.0e16), "1.0e+16");
+        assert_eq!(to_s(1.0e308), "1.0e+308");
+        assert_eq!(to_s(1.5e20), "1.5e+20");
+    }
+
+    #[test]
+    fn small_magnitudes_switch_to_scientific_below_1e_4() {
+        assert_eq!(to_s(0.00001), "1.0e-05");
+        assert_eq!(to_s(1.25e-7), "1.25e-07");
+    }
+
+    #[test]
+    fn non_finite_values_use_rubys_names() {
+        assert_eq!(to_s(f64::INFINITY), "Infinity");
+        assert_eq!(to_s(f64::NEG_INFINITY), "-Infinity");
+        assert_eq!(to_s(f64::NAN), "NaN");
+    }
+
+    #[test]
+    fn an_infinite_result_faults_with_rubys_wording() {
+        let fault = finite_or_fault("increment", "+", 1.0e308, 1.0e308, f64::INFINITY);
+        assert_eq!(
+            fault,
+            Err(Refusal::Fault(
+                "increment overflowed: 1.0e+308 + 1.0e+308 is not a finite number".to_string()
+            ))
+        );
+    }
+
+    #[test]
+    fn a_decrement_quotes_the_amount_by_absolute_value() {
+        let fault = finite_or_fault("decrement", "-", -1.0e308, -1.0e308, f64::NEG_INFINITY);
+        assert_eq!(
+            fault,
+            Err(Refusal::Fault(
+                "decrement overflowed: -1.0e+308 - 1.0e+308 is not a finite number".to_string()
+            ))
+        );
+    }
+
+    #[test]
+    fn a_finite_result_passes_through() {
+        assert_eq!(finite_or_fault("multiply", "*", 2.0, 3.0, 6.0), Ok(6.0));
+    }
+}

data/rust/src/kernel/vocab/aggregate_dispatch_order.rs

@@ -26,74 +26,74 @@ pub enum AggregateStep {
 
 impl AggregateStep {
     /// The declared step order, first to last.
-    pub const ORDER: [AggregateStep; 17] = [
-        AggregateStep::DecodeArguments,
-        AggregateStep::RefuseUnknownArguments,
-        AggregateStep::RefuseAbsentArguments,
-        AggregateStep::NormalizeArgs,
-        AggregateStep::RefuseRoleMismatch,
-        AggregateStep::ResolveReferences,
-        AggregateStep::Hydrate,
-        AggregateStep::EnforceGivens,
-        AggregateStep::AdmissibleTransition,
-        AggregateStep::AssignCreationAttributes,
-        AggregateStep::ApplyMutations,
-        AggregateStep::AdvanceLifecycle,
-        AggregateStep::DelegateToEntity,
-        AggregateStep::EnforceEnsures,
-        AggregateStep::EnforceInvariants,
-        AggregateStep::Save,
-        AggregateStep::Emit,
+    pub const ORDER: [Self; 17] = [
+        Self::DecodeArguments,
+        Self::RefuseUnknownArguments,
+        Self::RefuseAbsentArguments,
+        Self::NormalizeArgs,
+        Self::RefuseRoleMismatch,
+        Self::ResolveReferences,
+        Self::Hydrate,
+        Self::EnforceGivens,
+        Self::AdmissibleTransition,
+        Self::AssignCreationAttributes,
+        Self::ApplyMutations,
+        Self::AdvanceLifecycle,
+        Self::DelegateToEntity,
+        Self::EnforceEnsures,
+        Self::EnforceInvariants,
+        Self::Save,
+        Self::Emit,
     ];
 
     /// The row's declared `step`.
-    pub fn step(&self) -> &'static str {
+    pub const fn step(&self) -> &'static str {
         match self {
-            AggregateStep::DecodeArguments => "decode_arguments",
-            AggregateStep::RefuseUnknownArguments => "refuse_unknown_arguments",
-            AggregateStep::RefuseAbsentArguments => "refuse_absent_arguments",
-            AggregateStep::NormalizeArgs => "normalize_args",
-            AggregateStep::RefuseRoleMismatch => "refuse_role_mismatch",
-            AggregateStep::ResolveReferences => "resolve_references",
-            AggregateStep::Hydrate => "hydrate",
-            AggregateStep::EnforceGivens => "enforce_givens",
-            AggregateStep::AdmissibleTransition => "admissible_transition",
-            AggregateStep::AssignCreationAttributes => "assign_creation_attributes",
-            AggregateStep::ApplyMutations => "apply_mutations",
-            AggregateStep::AdvanceLifecycle => "advance_lifecycle",
-            AggregateStep::DelegateToEntity => "delegate_to_entity",
-            AggregateStep::EnforceEnsures => "enforce_ensures",
-            AggregateStep::EnforceInvariants => "enforce_invariants",
-            AggregateStep::Save => "save",
-            AggregateStep::Emit => "emit",
+            Self::DecodeArguments => "decode_arguments",
+            Self::RefuseUnknownArguments => "refuse_unknown_arguments",
+            Self::RefuseAbsentArguments => "refuse_absent_arguments",
+            Self::NormalizeArgs => "normalize_args",
+            Self::RefuseRoleMismatch => "refuse_role_mismatch",
+            Self::ResolveReferences => "resolve_references",
+            Self::Hydrate => "hydrate",
+            Self::EnforceGivens => "enforce_givens",
+            Self::AdmissibleTransition => "admissible_transition",
+            Self::AssignCreationAttributes => "assign_creation_attributes",
+            Self::ApplyMutations => "apply_mutations",
+            Self::AdvanceLifecycle => "advance_lifecycle",
+            Self::DelegateToEntity => "delegate_to_entity",
+            Self::EnforceEnsures => "enforce_ensures",
+            Self::EnforceInvariants => "enforce_invariants",
+            Self::Save => "save",
+            Self::Emit => "emit",
         }
     }
 
     /// The row whose `step` is `name`, if any.
-    pub fn from_name(name: &str) -> Option<AggregateStep> {
-        AggregateStep::ORDER.iter().copied().find(|row| row.step() == name)
+    pub fn from_name(name: &str) -> Option<Self> {
+        Self::ORDER.iter().copied().find(|row| row.step() == name)
     }
 
     /// This step's index in `ORDER`.
-    pub fn position(&self) -> usize {
+    pub const fn position(&self) -> usize {
         match self {
-            AggregateStep::DecodeArguments => 0,
-            AggregateStep::RefuseUnknownArguments => 1,
-            AggregateStep::RefuseAbsentArguments => 2,
-            AggregateStep::NormalizeArgs => 3,
-            AggregateStep::RefuseRoleMismatch => 4,
-            AggregateStep::ResolveReferences => 5,
-            AggregateStep::Hydrate => 6,
-            AggregateStep::EnforceGivens => 7,
-            AggregateStep::AdmissibleTransition => 8,
-            AggregateStep::AssignCreationAttributes => 9,
-            AggregateStep::ApplyMutations => 10,
-            AggregateStep::AdvanceLifecycle => 11,
-            AggregateStep::DelegateToEntity => 12,
-            AggregateStep::EnforceEnsures => 13,
-            AggregateStep::EnforceInvariants => 14,
-            AggregateStep::Save => 15,
-            AggregateStep::Emit => 16,
+            Self::DecodeArguments => 0,
+            Self::RefuseUnknownArguments => 1,
+            Self::RefuseAbsentArguments => 2,
+            Self::NormalizeArgs => 3,
+            Self::RefuseRoleMismatch => 4,
+            Self::ResolveReferences => 5,
+            Self::Hydrate => 6,
+            Self::EnforceGivens => 7,
+            Self::AdmissibleTransition => 8,
+            Self::AssignCreationAttributes => 9,
+            Self::ApplyMutations => 10,
+            Self::AdvanceLifecycle => 11,
+            Self::DelegateToEntity => 12,
+            Self::EnforceEnsures => 13,
+            Self::EnforceInvariants => 14,
+            Self::Save => 15,
+            Self::Emit => 16,
         }
     }
 }
@@ -104,7 +104,7 @@ mod tests {
 
     #[test]
     fn every_row_is_found_by_its_own_name() {
-        for row in AggregateStep::ORDER.iter() {
+        for row in &AggregateStep::ORDER {
             assert_eq!(AggregateStep::from_name(row.step()), Some(*row));
         }
     }

data/rust/src/kernel/vocab/entity_dispatch_order.rs

@@ -25,71 +25,71 @@ pub enum EntityStep {
 
 impl EntityStep {
     /// The declared step order, first to last.
-    pub const ORDER: [EntityStep; 16] = [
-        EntityStep::DecodeArguments,
-        EntityStep::RefuseUnknownArguments,
-        EntityStep::RefuseAbsentArguments,
-        EntityStep::NormalizeArgs,
-        EntityStep::RefuseRoleMismatch,
-        EntityStep::ResolveReferences,
-        EntityStep::HydrateParent,
-        EntityStep::LocateElement,
-        EntityStep::EnforceGivens,
-        EntityStep::AdmissibleTransition,
-        EntityStep::ApplyMutations,
-        EntityStep::AdvanceLifecycle,
-        EntityStep::EnforceEnsures,
-        EntityStep::EnforceInvariants,
-        EntityStep::Save,
-        EntityStep::Emit,
+    pub const ORDER: [Self; 16] = [
+        Self::DecodeArguments,
+        Self::RefuseUnknownArguments,
+        Self::RefuseAbsentArguments,
+        Self::NormalizeArgs,
+        Self::RefuseRoleMismatch,
+        Self::ResolveReferences,
+        Self::HydrateParent,
+        Self::LocateElement,
+        Self::EnforceGivens,
+        Self::AdmissibleTransition,
+        Self::ApplyMutations,
+        Self::AdvanceLifecycle,
+        Self::EnforceEnsures,
+        Self::EnforceInvariants,
+        Self::Save,
+        Self::Emit,
     ];
 
     /// The row's declared `step`.
-    pub fn step(&self) -> &'static str {
+    pub const fn step(&self) -> &'static str {
         match self {
-            EntityStep::DecodeArguments => "decode_arguments",
-            EntityStep::RefuseUnknownArguments => "refuse_unknown_arguments",
-            EntityStep::RefuseAbsentArguments => "refuse_absent_arguments",
-            EntityStep::NormalizeArgs => "normalize_args",
-            EntityStep::RefuseRoleMismatch => "refuse_role_mismatch",
-            EntityStep::ResolveReferences => "resolve_references",
-            EntityStep::HydrateParent => "hydrate_parent",
-            EntityStep::LocateElement => "locate_element",
-            EntityStep::EnforceGivens => "enforce_givens",
-            EntityStep::AdmissibleTransition => "admissible_transition",
-            EntityStep::ApplyMutations => "apply_mutations",
-            EntityStep::AdvanceLifecycle => "advance_lifecycle",
-            EntityStep::EnforceEnsures => "enforce_ensures",
-            EntityStep::EnforceInvariants => "enforce_invariants",
-            EntityStep::Save => "save",
-            EntityStep::Emit => "emit",
+            Self::DecodeArguments => "decode_arguments",
+            Self::RefuseUnknownArguments => "refuse_unknown_arguments",
+            Self::RefuseAbsentArguments => "refuse_absent_arguments",
+            Self::NormalizeArgs => "normalize_args",
+            Self::RefuseRoleMismatch => "refuse_role_mismatch",
+            Self::ResolveReferences => "resolve_references",
+            Self::HydrateParent => "hydrate_parent",
+            Self::LocateElement => "locate_element",
+            Self::EnforceGivens => "enforce_givens",
+            Self::AdmissibleTransition => "admissible_transition",
+            Self::ApplyMutations => "apply_mutations",
+            Self::AdvanceLifecycle => "advance_lifecycle",
+            Self::EnforceEnsures => "enforce_ensures",
+            Self::EnforceInvariants => "enforce_invariants",
+            Self::Save => "save",
+            Self::Emit => "emit",
         }
     }
 
     /// The row whose `step` is `name`, if any.
-    pub fn from_name(name: &str) -> Option<EntityStep> {
-        EntityStep::ORDER.iter().copied().find(|row| row.step() == name)
+    pub fn from_name(name: &str) -> Option<Self> {
+        Self::ORDER.iter().copied().find(|row| row.step() == name)
     }
 
     /// This step's index in `ORDER`.
-    pub fn position(&self) -> usize {
+    pub const fn position(&self) -> usize {
         match self {
-            EntityStep::DecodeArguments => 0,
-            EntityStep::RefuseUnknownArguments => 1,
-            EntityStep::RefuseAbsentArguments => 2,
-            EntityStep::NormalizeArgs => 3,
-            EntityStep::RefuseRoleMismatch => 4,
-            EntityStep::ResolveReferences => 5,
-            EntityStep::HydrateParent => 6,
-            EntityStep::LocateElement => 7,
-            EntityStep::EnforceGivens => 8,
-            EntityStep::AdmissibleTransition => 9,
-            EntityStep::ApplyMutations => 10,
-            EntityStep::AdvanceLifecycle => 11,
-            EntityStep::EnforceEnsures => 12,
-            EntityStep::EnforceInvariants => 13,
-            EntityStep::Save => 14,
-            EntityStep::Emit => 15,
+            Self::DecodeArguments => 0,
+            Self::RefuseUnknownArguments => 1,
+            Self::RefuseAbsentArguments => 2,
+            Self::NormalizeArgs => 3,
+            Self::RefuseRoleMismatch => 4,
+            Self::ResolveReferences => 5,
+            Self::HydrateParent => 6,
+            Self::LocateElement => 7,
+            Self::EnforceGivens => 8,
+            Self::AdmissibleTransition => 9,
+            Self::ApplyMutations => 10,
+            Self::AdvanceLifecycle => 11,
+            Self::EnforceEnsures => 12,
+            Self::EnforceInvariants => 13,
+            Self::Save => 14,
+            Self::Emit => 15,
         }
     }
 }
@@ -100,7 +100,7 @@ mod tests {
 
     #[test]
     fn every_row_is_found_by_its_own_name() {
-        for row in EntityStep::ORDER.iter() {
+        for row in &EntityStep::ORDER {
             assert_eq!(EntityStep::from_name(row.step()), Some(*row));
         }
     }