hecks 3.14.0 → 5.0.0

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

@@ -55,221 +55,221 @@ pub enum RefusalSite {
 
 impl RefusalSite {
     /// Every row, in declared order.
-    pub const ALL: &'static [RefusalSite] = &[
-        RefusalSite::NotFoundCreatingNoIdentity,
-        RefusalSite::AlreadyExistsCreatingDuplicate,
-        RefusalSite::AlreadyExistsEntityDuplicate,
-        RefusalSite::NotFoundActingNoIdentity,
-        RefusalSite::NotFoundRecordMissing,
-        RefusalSite::NotFoundEntityParentNoIdentity,
-        RefusalSite::UnknownVerbEntityUnknown,
-        RefusalSite::NotFoundEntityElementNoIdentity,
-        RefusalSite::NotFoundEntityElementMissing,
-        RefusalSite::NotFoundReferenceTargetMissing,
-        RefusalSite::NotFoundReadModelReferenceMissing,
-        RefusalSite::TypeMismatchReadModelObjectReference,
-        RefusalSite::UnknownVerbNoQuery,
-        RefusalSite::UnknownVerbEntityQueryMissing,
-        RefusalSite::UnknownVerbEntityHoldsNoList,
-        RefusalSite::UnknownVerbEntityNoCommand,
-        RefusalSite::UnknownVerbAggregateNoCommand,
-        RefusalSite::UnknownVerbPortNoOperation,
-        RefusalSite::UnknownVerbNoDomain,
-        RefusalSite::UnknownVerbNoReadModel,
-        RefusalSite::UnknownVerbNotFullyQualified,
-        RefusalSite::UnknownVerbNoAggregate,
-        RefusalSite::LifecycleRefusedTransitionBlocked,
-        RefusalSite::TypeMismatchValueObjectShape,
-        RefusalSite::TypeMismatchReferenceWrongShape,
-        RefusalSite::TypeMismatchMultiFieldScalar,
-        RefusalSite::TypeMismatchCompositeIdentity,
-        RefusalSite::TypeMismatchNumericField,
-        RefusalSite::TypeMismatchNonFiniteField,
-        RefusalSite::TypeMismatchIntegerRange,
-        RefusalSite::TypeMismatchPatternMismatch,
-        RefusalSite::TypeMismatchArithmeticAmount,
-        RefusalSite::TypeMismatchArithmeticCurrent,
-        RefusalSite::TypeMismatchArithmeticSharedField,
-        RefusalSite::UnknownArgumentUnknownArgs,
-        RefusalSite::AbsentArgumentAbsentArgs,
-        RefusalSite::InvariantViolationClosedSetMember,
-        RefusalSite::InvariantViolationValueObjectInvariant,
-        RefusalSite::InvariantViolationAdmitsDeclaredSet,
-        RefusalSite::InvariantViolationUndeclaredSet,
-        RefusalSite::InvariantViolationGroupByCollision,
-        RefusalSite::UnauthorizedTenantRequired,
-        RefusalSite::UnauthorizedRoleMismatch,
-        RefusalSite::UnauthorizedCrossTenantReference,
-        RefusalSite::AttributeAbsentAbsentRead,
-        RefusalSite::ProjectionAbsentAbsentRead,
+    pub const ALL: &'static [Self] = &[
+        Self::NotFoundCreatingNoIdentity,
+        Self::AlreadyExistsCreatingDuplicate,
+        Self::AlreadyExistsEntityDuplicate,
+        Self::NotFoundActingNoIdentity,
+        Self::NotFoundRecordMissing,
+        Self::NotFoundEntityParentNoIdentity,
+        Self::UnknownVerbEntityUnknown,
+        Self::NotFoundEntityElementNoIdentity,
+        Self::NotFoundEntityElementMissing,
+        Self::NotFoundReferenceTargetMissing,
+        Self::NotFoundReadModelReferenceMissing,
+        Self::TypeMismatchReadModelObjectReference,
+        Self::UnknownVerbNoQuery,
+        Self::UnknownVerbEntityQueryMissing,
+        Self::UnknownVerbEntityHoldsNoList,
+        Self::UnknownVerbEntityNoCommand,
+        Self::UnknownVerbAggregateNoCommand,
+        Self::UnknownVerbPortNoOperation,
+        Self::UnknownVerbNoDomain,
+        Self::UnknownVerbNoReadModel,
+        Self::UnknownVerbNotFullyQualified,
+        Self::UnknownVerbNoAggregate,
+        Self::LifecycleRefusedTransitionBlocked,
+        Self::TypeMismatchValueObjectShape,
+        Self::TypeMismatchReferenceWrongShape,
+        Self::TypeMismatchMultiFieldScalar,
+        Self::TypeMismatchCompositeIdentity,
+        Self::TypeMismatchNumericField,
+        Self::TypeMismatchNonFiniteField,
+        Self::TypeMismatchIntegerRange,
+        Self::TypeMismatchPatternMismatch,
+        Self::TypeMismatchArithmeticAmount,
+        Self::TypeMismatchArithmeticCurrent,
+        Self::TypeMismatchArithmeticSharedField,
+        Self::UnknownArgumentUnknownArgs,
+        Self::AbsentArgumentAbsentArgs,
+        Self::InvariantViolationClosedSetMember,
+        Self::InvariantViolationValueObjectInvariant,
+        Self::InvariantViolationAdmitsDeclaredSet,
+        Self::InvariantViolationUndeclaredSet,
+        Self::InvariantViolationGroupByCollision,
+        Self::UnauthorizedTenantRequired,
+        Self::UnauthorizedRoleMismatch,
+        Self::UnauthorizedCrossTenantReference,
+        Self::AttributeAbsentAbsentRead,
+        Self::ProjectionAbsentAbsentRead,
     ];
 
     /// The row's declared `refusal`.
-    pub fn refusal_class(&self) -> &'static str {
+    pub const fn refusal_class(&self) -> &'static str {
         match self {
-            RefusalSite::NotFoundCreatingNoIdentity => "NotFound",
-            RefusalSite::AlreadyExistsCreatingDuplicate => "AlreadyExists",
-            RefusalSite::AlreadyExistsEntityDuplicate => "AlreadyExists",
-            RefusalSite::NotFoundActingNoIdentity => "NotFound",
-            RefusalSite::NotFoundRecordMissing => "NotFound",
-            RefusalSite::NotFoundEntityParentNoIdentity => "NotFound",
-            RefusalSite::UnknownVerbEntityUnknown => "UnknownVerb",
-            RefusalSite::NotFoundEntityElementNoIdentity => "NotFound",
-            RefusalSite::NotFoundEntityElementMissing => "NotFound",
-            RefusalSite::NotFoundReferenceTargetMissing => "NotFound",
-            RefusalSite::NotFoundReadModelReferenceMissing => "NotFound",
-            RefusalSite::TypeMismatchReadModelObjectReference => "TypeMismatch",
-            RefusalSite::UnknownVerbNoQuery => "UnknownVerb",
-            RefusalSite::UnknownVerbEntityQueryMissing => "UnknownVerb",
-            RefusalSite::UnknownVerbEntityHoldsNoList => "UnknownVerb",
-            RefusalSite::UnknownVerbEntityNoCommand => "UnknownVerb",
-            RefusalSite::UnknownVerbAggregateNoCommand => "UnknownVerb",
-            RefusalSite::UnknownVerbPortNoOperation => "UnknownVerb",
-            RefusalSite::UnknownVerbNoDomain => "UnknownVerb",
-            RefusalSite::UnknownVerbNoReadModel => "UnknownVerb",
-            RefusalSite::UnknownVerbNotFullyQualified => "UnknownVerb",
-            RefusalSite::UnknownVerbNoAggregate => "UnknownVerb",
-            RefusalSite::LifecycleRefusedTransitionBlocked => "LifecycleRefused",
-            RefusalSite::TypeMismatchValueObjectShape => "TypeMismatch",
-            RefusalSite::TypeMismatchReferenceWrongShape => "TypeMismatch",
-            RefusalSite::TypeMismatchMultiFieldScalar => "TypeMismatch",
-            RefusalSite::TypeMismatchCompositeIdentity => "TypeMismatch",
-            RefusalSite::TypeMismatchNumericField => "TypeMismatch",
-            RefusalSite::TypeMismatchNonFiniteField => "TypeMismatch",
-            RefusalSite::TypeMismatchIntegerRange => "TypeMismatch",
-            RefusalSite::TypeMismatchPatternMismatch => "TypeMismatch",
-            RefusalSite::TypeMismatchArithmeticAmount => "TypeMismatch",
-            RefusalSite::TypeMismatchArithmeticCurrent => "TypeMismatch",
-            RefusalSite::TypeMismatchArithmeticSharedField => "TypeMismatch",
-            RefusalSite::UnknownArgumentUnknownArgs => "UnknownArgument",
-            RefusalSite::AbsentArgumentAbsentArgs => "AbsentArgument",
-            RefusalSite::InvariantViolationClosedSetMember => "InvariantViolation",
-            RefusalSite::InvariantViolationValueObjectInvariant => "InvariantViolation",
-            RefusalSite::InvariantViolationAdmitsDeclaredSet => "InvariantViolation",
-            RefusalSite::InvariantViolationUndeclaredSet => "InvariantViolation",
-            RefusalSite::InvariantViolationGroupByCollision => "InvariantViolation",
-            RefusalSite::UnauthorizedTenantRequired => "Unauthorized",
-            RefusalSite::UnauthorizedRoleMismatch => "Unauthorized",
-            RefusalSite::UnauthorizedCrossTenantReference => "Unauthorized",
-            RefusalSite::AttributeAbsentAbsentRead => "AttributeAbsent",
-            RefusalSite::ProjectionAbsentAbsentRead => "ProjectionAbsent",
+            Self::NotFoundCreatingNoIdentity => "NotFound",
+            Self::AlreadyExistsCreatingDuplicate => "AlreadyExists",
+            Self::AlreadyExistsEntityDuplicate => "AlreadyExists",
+            Self::NotFoundActingNoIdentity => "NotFound",
+            Self::NotFoundRecordMissing => "NotFound",
+            Self::NotFoundEntityParentNoIdentity => "NotFound",
+            Self::UnknownVerbEntityUnknown => "UnknownVerb",
+            Self::NotFoundEntityElementNoIdentity => "NotFound",
+            Self::NotFoundEntityElementMissing => "NotFound",
+            Self::NotFoundReferenceTargetMissing => "NotFound",
+            Self::NotFoundReadModelReferenceMissing => "NotFound",
+            Self::TypeMismatchReadModelObjectReference => "TypeMismatch",
+            Self::UnknownVerbNoQuery => "UnknownVerb",
+            Self::UnknownVerbEntityQueryMissing => "UnknownVerb",
+            Self::UnknownVerbEntityHoldsNoList => "UnknownVerb",
+            Self::UnknownVerbEntityNoCommand => "UnknownVerb",
+            Self::UnknownVerbAggregateNoCommand => "UnknownVerb",
+            Self::UnknownVerbPortNoOperation => "UnknownVerb",
+            Self::UnknownVerbNoDomain => "UnknownVerb",
+            Self::UnknownVerbNoReadModel => "UnknownVerb",
+            Self::UnknownVerbNotFullyQualified => "UnknownVerb",
+            Self::UnknownVerbNoAggregate => "UnknownVerb",
+            Self::LifecycleRefusedTransitionBlocked => "LifecycleRefused",
+            Self::TypeMismatchValueObjectShape => "TypeMismatch",
+            Self::TypeMismatchReferenceWrongShape => "TypeMismatch",
+            Self::TypeMismatchMultiFieldScalar => "TypeMismatch",
+            Self::TypeMismatchCompositeIdentity => "TypeMismatch",
+            Self::TypeMismatchNumericField => "TypeMismatch",
+            Self::TypeMismatchNonFiniteField => "TypeMismatch",
+            Self::TypeMismatchIntegerRange => "TypeMismatch",
+            Self::TypeMismatchPatternMismatch => "TypeMismatch",
+            Self::TypeMismatchArithmeticAmount => "TypeMismatch",
+            Self::TypeMismatchArithmeticCurrent => "TypeMismatch",
+            Self::TypeMismatchArithmeticSharedField => "TypeMismatch",
+            Self::UnknownArgumentUnknownArgs => "UnknownArgument",
+            Self::AbsentArgumentAbsentArgs => "AbsentArgument",
+            Self::InvariantViolationClosedSetMember => "InvariantViolation",
+            Self::InvariantViolationValueObjectInvariant => "InvariantViolation",
+            Self::InvariantViolationAdmitsDeclaredSet => "InvariantViolation",
+            Self::InvariantViolationUndeclaredSet => "InvariantViolation",
+            Self::InvariantViolationGroupByCollision => "InvariantViolation",
+            Self::UnauthorizedTenantRequired => "Unauthorized",
+            Self::UnauthorizedRoleMismatch => "Unauthorized",
+            Self::UnauthorizedCrossTenantReference => "Unauthorized",
+            Self::AttributeAbsentAbsentRead => "AttributeAbsent",
+            Self::ProjectionAbsentAbsentRead => "ProjectionAbsent",
         }
     }
 
     /// The row's declared `site`.
-    pub fn site(&self) -> &'static str {
+    pub const fn site(&self) -> &'static str {
         match self {
-            RefusalSite::NotFoundCreatingNoIdentity => "creating_no_identity",
-            RefusalSite::AlreadyExistsCreatingDuplicate => "creating_duplicate",
-            RefusalSite::AlreadyExistsEntityDuplicate => "entity_duplicate",
-            RefusalSite::NotFoundActingNoIdentity => "acting_no_identity",
-            RefusalSite::NotFoundRecordMissing => "record_missing",
-            RefusalSite::NotFoundEntityParentNoIdentity => "entity_parent_no_identity",
-            RefusalSite::UnknownVerbEntityUnknown => "entity_unknown",
-            RefusalSite::NotFoundEntityElementNoIdentity => "entity_element_no_identity",
-            RefusalSite::NotFoundEntityElementMissing => "entity_element_missing",
-            RefusalSite::NotFoundReferenceTargetMissing => "reference_target_missing",
-            RefusalSite::NotFoundReadModelReferenceMissing => "read_model_reference_missing",
-            RefusalSite::TypeMismatchReadModelObjectReference => "read_model_object_reference",
-            RefusalSite::UnknownVerbNoQuery => "no_query",
-            RefusalSite::UnknownVerbEntityQueryMissing => "entity_query_missing",
-            RefusalSite::UnknownVerbEntityHoldsNoList => "entity_holds_no_list",
-            RefusalSite::UnknownVerbEntityNoCommand => "entity_no_command",
-            RefusalSite::UnknownVerbAggregateNoCommand => "aggregate_no_command",
-            RefusalSite::UnknownVerbPortNoOperation => "port_no_operation",
-            RefusalSite::UnknownVerbNoDomain => "no_domain",
-            RefusalSite::UnknownVerbNoReadModel => "no_read_model",
-            RefusalSite::UnknownVerbNotFullyQualified => "not_fully_qualified",
-            RefusalSite::UnknownVerbNoAggregate => "no_aggregate",
-            RefusalSite::LifecycleRefusedTransitionBlocked => "transition_blocked",
-            RefusalSite::TypeMismatchValueObjectShape => "value_object_shape",
-            RefusalSite::TypeMismatchReferenceWrongShape => "reference_wrong_shape",
-            RefusalSite::TypeMismatchMultiFieldScalar => "multi_field_scalar",
-            RefusalSite::TypeMismatchCompositeIdentity => "composite_identity",
-            RefusalSite::TypeMismatchNumericField => "numeric_field",
-            RefusalSite::TypeMismatchNonFiniteField => "non_finite_field",
-            RefusalSite::TypeMismatchIntegerRange => "integer_range",
-            RefusalSite::TypeMismatchPatternMismatch => "pattern_mismatch",
-            RefusalSite::TypeMismatchArithmeticAmount => "arithmetic_amount",
-            RefusalSite::TypeMismatchArithmeticCurrent => "arithmetic_current",
-            RefusalSite::TypeMismatchArithmeticSharedField => "arithmetic_shared_field",
-            RefusalSite::UnknownArgumentUnknownArgs => "unknown_args",
-            RefusalSite::AbsentArgumentAbsentArgs => "absent_args",
-            RefusalSite::InvariantViolationClosedSetMember => "closed_set_member",
-            RefusalSite::InvariantViolationValueObjectInvariant => "value_object_invariant",
-            RefusalSite::InvariantViolationAdmitsDeclaredSet => "admits_declared_set",
-            RefusalSite::InvariantViolationUndeclaredSet => "undeclared_set",
-            RefusalSite::InvariantViolationGroupByCollision => "group_by_collision",
-            RefusalSite::UnauthorizedTenantRequired => "tenant_required",
-            RefusalSite::UnauthorizedRoleMismatch => "role_mismatch",
-            RefusalSite::UnauthorizedCrossTenantReference => "cross_tenant_reference",
-            RefusalSite::AttributeAbsentAbsentRead => "absent_read",
-            RefusalSite::ProjectionAbsentAbsentRead => "absent_read",
+            Self::NotFoundCreatingNoIdentity => "creating_no_identity",
+            Self::AlreadyExistsCreatingDuplicate => "creating_duplicate",
+            Self::AlreadyExistsEntityDuplicate => "entity_duplicate",
+            Self::NotFoundActingNoIdentity => "acting_no_identity",
+            Self::NotFoundRecordMissing => "record_missing",
+            Self::NotFoundEntityParentNoIdentity => "entity_parent_no_identity",
+            Self::UnknownVerbEntityUnknown => "entity_unknown",
+            Self::NotFoundEntityElementNoIdentity => "entity_element_no_identity",
+            Self::NotFoundEntityElementMissing => "entity_element_missing",
+            Self::NotFoundReferenceTargetMissing => "reference_target_missing",
+            Self::NotFoundReadModelReferenceMissing => "read_model_reference_missing",
+            Self::TypeMismatchReadModelObjectReference => "read_model_object_reference",
+            Self::UnknownVerbNoQuery => "no_query",
+            Self::UnknownVerbEntityQueryMissing => "entity_query_missing",
+            Self::UnknownVerbEntityHoldsNoList => "entity_holds_no_list",
+            Self::UnknownVerbEntityNoCommand => "entity_no_command",
+            Self::UnknownVerbAggregateNoCommand => "aggregate_no_command",
+            Self::UnknownVerbPortNoOperation => "port_no_operation",
+            Self::UnknownVerbNoDomain => "no_domain",
+            Self::UnknownVerbNoReadModel => "no_read_model",
+            Self::UnknownVerbNotFullyQualified => "not_fully_qualified",
+            Self::UnknownVerbNoAggregate => "no_aggregate",
+            Self::LifecycleRefusedTransitionBlocked => "transition_blocked",
+            Self::TypeMismatchValueObjectShape => "value_object_shape",
+            Self::TypeMismatchReferenceWrongShape => "reference_wrong_shape",
+            Self::TypeMismatchMultiFieldScalar => "multi_field_scalar",
+            Self::TypeMismatchCompositeIdentity => "composite_identity",
+            Self::TypeMismatchNumericField => "numeric_field",
+            Self::TypeMismatchNonFiniteField => "non_finite_field",
+            Self::TypeMismatchIntegerRange => "integer_range",
+            Self::TypeMismatchPatternMismatch => "pattern_mismatch",
+            Self::TypeMismatchArithmeticAmount => "arithmetic_amount",
+            Self::TypeMismatchArithmeticCurrent => "arithmetic_current",
+            Self::TypeMismatchArithmeticSharedField => "arithmetic_shared_field",
+            Self::UnknownArgumentUnknownArgs => "unknown_args",
+            Self::AbsentArgumentAbsentArgs => "absent_args",
+            Self::InvariantViolationClosedSetMember => "closed_set_member",
+            Self::InvariantViolationValueObjectInvariant => "value_object_invariant",
+            Self::InvariantViolationAdmitsDeclaredSet => "admits_declared_set",
+            Self::InvariantViolationUndeclaredSet => "undeclared_set",
+            Self::InvariantViolationGroupByCollision => "group_by_collision",
+            Self::UnauthorizedTenantRequired => "tenant_required",
+            Self::UnauthorizedRoleMismatch => "role_mismatch",
+            Self::UnauthorizedCrossTenantReference => "cross_tenant_reference",
+            Self::AttributeAbsentAbsentRead => "absent_read",
+            Self::ProjectionAbsentAbsentRead => "absent_read",
         }
     }
 
     /// The row's declared `template`.
-    pub fn template(&self) -> &'static str {
+    pub const fn template(&self) -> &'static str {
         match self {
-            RefusalSite::NotFoundCreatingNoIdentity => "{command} creates a {aggregate} — pass {identity}:",
-            RefusalSite::AlreadyExistsCreatingDuplicate => "{command} creates a {aggregate} that already exists — {identity} {offered}",
-            RefusalSite::AlreadyExistsEntityDuplicate => "a {entity} already exists on {aggregate} — {identity} {offered}",
-            RefusalSite::NotFoundActingNoIdentity => "{command} acts on an existing {aggregate} — pass {identity}:",
-            RefusalSite::NotFoundRecordMissing => "no {aggregate} with {identity} {offered}",
-            RefusalSite::NotFoundEntityParentNoIdentity => "{command} acts on a {aggregate}'s {entity} — pass {identity}:",
-            RefusalSite::UnknownVerbEntityUnknown => "{aggregate} has no entity {entity}",
-            RefusalSite::NotFoundEntityElementNoIdentity => "{command} acts on one {entity} — pass {identity}:",
-            RefusalSite::NotFoundEntityElementMissing => "no {entity} with {identity} {wants} on {aggregate} {parent_id}",
-            RefusalSite::NotFoundReferenceTargetMissing => "no {target} with {heads} {key}",
-            RefusalSite::NotFoundReadModelReferenceMissing => "no {aggregate} with reference {offered}",
-            RefusalSite::TypeMismatchReadModelObjectReference => "{query} refused — a reference is an id, and {field} arrived as an object",
-            RefusalSite::UnknownVerbNoQuery => "{aggregate} has no query {query}",
-            RefusalSite::UnknownVerbEntityQueryMissing => "{entity} has no query {query}",
-            RefusalSite::UnknownVerbEntityHoldsNoList => "{aggregate} holds no list of {entity}",
-            RefusalSite::UnknownVerbEntityNoCommand => "{entity} has no command {command}",
-            RefusalSite::UnknownVerbAggregateNoCommand => "{aggregate} has no command {command}",
-            RefusalSite::UnknownVerbPortNoOperation => "{port} has no operation {operation}",
-            RefusalSite::UnknownVerbNoDomain => "no domain {domain} loaded (verb {verb})",
-            RefusalSite::UnknownVerbNoReadModel => "{domain} has no read model {query}",
-            RefusalSite::UnknownVerbNotFullyQualified => "{verb} is not a fully-qualified verb (Domain::Aggregate.Command)",
-            RefusalSite::UnknownVerbNoAggregate => "{domain} has no aggregate {aggregate}",
-            RefusalSite::LifecycleRefusedTransitionBlocked => "{command} refused — {field} is {current}, and {command} moves it only from {allowed}",
-            RefusalSite::TypeMismatchValueObjectShape => "{name} is a {type} — pass its fields as an object, not {offered}",
-            RefusalSite::TypeMismatchReferenceWrongShape => "{command} refused — a reference is an id, and {attribute} arrived as {offered}{known_by}",
-            RefusalSite::TypeMismatchMultiFieldScalar => "{type} has multiple fields and cannot stand in for a scalar",
-            RefusalSite::TypeMismatchCompositeIdentity => "{type} is a composite identity — an identity must have exactly one field",
-            RefusalSite::TypeMismatchNumericField => "{type}.{field} expects {expected}, got {offered}",
-            RefusalSite::TypeMismatchNonFiniteField => "{type}.{field} must be a finite number, got {offered}",
-            RefusalSite::TypeMismatchIntegerRange => "{type}.{field} must fit in a 64-bit integer, got {offered}",
-            RefusalSite::TypeMismatchPatternMismatch => "{type}.{field} must match {pattern}, got {offered}",
-            RefusalSite::TypeMismatchArithmeticAmount => "{op} of {target} needs an Integer, got {offered}",
-            RefusalSite::TypeMismatchArithmeticCurrent => "{op} of {target} needs an Integer {target}, got {offered}",
-            RefusalSite::TypeMismatchArithmeticSharedField => "{op} of {target} needs a value object with one shared Integer field",
-            RefusalSite::UnknownArgumentUnknownArgs => "{command} does not declare {unknown} — it takes {declared}",
-            RefusalSite::AbsentArgumentAbsentArgs => "{command} was not given {absent} — it takes {declared}",
-            RefusalSite::InvariantViolationClosedSetMember => "{type} admits {admitted} — got {offered}",
-            RefusalSite::InvariantViolationValueObjectInvariant => "{name} invariant violated — {description} (given {offered})",
-            RefusalSite::InvariantViolationAdmitsDeclaredSet => "{name} admits {admits} — {admitted} — got {offered}",
-            RefusalSite::InvariantViolationUndeclaredSet => "{name} admits {admits}, which this chapter does not declare — a closed set is named Aggregate::SetName, and it must be one the bluebook actually holds",
-            RefusalSite::InvariantViolationGroupByCollision => "{read_model} groups by {fields}, but rows {ids} share {key} — a group_by leaf holds one row; add a field that tells them apart",
-            RefusalSite::UnauthorizedTenantRequired => "{query} declares authorize with tenant: {field} — pass {field}: to name which {field} this ask is scoped to",
-            RefusalSite::UnauthorizedRoleMismatch => "{command} refused — role: {role}, and the caller stated {caller_role}",
-            RefusalSite::UnauthorizedCrossTenantReference => "{aggregate} {field} is {tenant}, but {attribute} names a {target} whose own {target_field} is {other} — a cross-tenant reference",
-            RefusalSite::AttributeAbsentAbsentRead => "{aggregate} {field} is absent on this record — declared, not optional, and added since it was written. Backfill it in a translation (backfill :{field}, default: ...), or declare it optional: true",
-            RefusalSite::ProjectionAbsentAbsentRead => "{aggregate} {field} is not yet projected on this record — declared via projects :{field}, but no rebuild sweep has populated it. Run the sweep, or read {reference}.{remote_field} directly if this rule cannot wait",
+            Self::NotFoundCreatingNoIdentity => "{command} creates a {aggregate} — pass {identity}:",
+            Self::AlreadyExistsCreatingDuplicate => "{command} creates a {aggregate} that already exists — {identity} {offered}",
+            Self::AlreadyExistsEntityDuplicate => "a {entity} already exists on {aggregate} — {identity} {offered}",
+            Self::NotFoundActingNoIdentity => "{command} acts on an existing {aggregate} — pass {identity}:",
+            Self::NotFoundRecordMissing => "no {aggregate} with {identity} {offered}",
+            Self::NotFoundEntityParentNoIdentity => "{command} acts on a {aggregate}'s {entity} — pass {identity}:",
+            Self::UnknownVerbEntityUnknown => "{aggregate} has no entity {entity}",
+            Self::NotFoundEntityElementNoIdentity => "{command} acts on one {entity} — pass {identity}:",
+            Self::NotFoundEntityElementMissing => "no {entity} with {identity} {wants} on {aggregate} {parent_id}",
+            Self::NotFoundReferenceTargetMissing => "no {target} with {heads} {key}",
+            Self::NotFoundReadModelReferenceMissing => "no {aggregate} with reference {offered}",
+            Self::TypeMismatchReadModelObjectReference => "{query} refused — a reference is an id, and {field} arrived as an object",
+            Self::UnknownVerbNoQuery => "{aggregate} has no query {query}",
+            Self::UnknownVerbEntityQueryMissing => "{entity} has no query {query}",
+            Self::UnknownVerbEntityHoldsNoList => "{aggregate} holds no list of {entity}",
+            Self::UnknownVerbEntityNoCommand => "{entity} has no command {command}",
+            Self::UnknownVerbAggregateNoCommand => "{aggregate} has no command {command}",
+            Self::UnknownVerbPortNoOperation => "{port} has no operation {operation}",
+            Self::UnknownVerbNoDomain => "no domain {domain} loaded (verb {verb})",
+            Self::UnknownVerbNoReadModel => "{domain} has no read model {query}",
+            Self::UnknownVerbNotFullyQualified => "{verb} is not a fully-qualified verb (Domain::Aggregate.Command)",
+            Self::UnknownVerbNoAggregate => "{domain} has no aggregate {aggregate}",
+            Self::LifecycleRefusedTransitionBlocked => "{command} refused — {field} is {current}, and {command} moves it only from {allowed}",
+            Self::TypeMismatchValueObjectShape => "{name} is a {type} — pass its fields as an object, not {offered}",
+            Self::TypeMismatchReferenceWrongShape => "{command} refused — a reference is an id, and {attribute} arrived as {offered}{known_by}",
+            Self::TypeMismatchMultiFieldScalar => "{type} has multiple fields and cannot stand in for a scalar",
+            Self::TypeMismatchCompositeIdentity => "{type} is a composite identity — an identity must have exactly one field",
+            Self::TypeMismatchNumericField => "{type}.{field} expects {expected}, got {offered}",
+            Self::TypeMismatchNonFiniteField => "{type}.{field} must be a finite number, got {offered}",
+            Self::TypeMismatchIntegerRange => "{type}.{field} must fit in a 64-bit integer, got {offered}",
+            Self::TypeMismatchPatternMismatch => "{type}.{field} must match {pattern}, got {offered}",
+            Self::TypeMismatchArithmeticAmount => "{op} of {target} needs an Integer, got {offered}",
+            Self::TypeMismatchArithmeticCurrent => "{op} of {target} needs an Integer {target}, got {offered}",
+            Self::TypeMismatchArithmeticSharedField => "{op} of {target} needs a value object with one shared Integer field",
+            Self::UnknownArgumentUnknownArgs => "{command} does not declare {unknown} — it takes {declared}",
+            Self::AbsentArgumentAbsentArgs => "{command} was not given {absent} — it takes {declared}",
+            Self::InvariantViolationClosedSetMember => "{type} admits {admitted} — got {offered}",
+            Self::InvariantViolationValueObjectInvariant => "{name} invariant violated — {description} (given {offered})",
+            Self::InvariantViolationAdmitsDeclaredSet => "{name} admits {admits} — {admitted} — got {offered}",
+            Self::InvariantViolationUndeclaredSet => "{name} admits {admits}, which this chapter does not declare — a closed set is named Aggregate::SetName, and it must be one the bluebook actually holds",
+            Self::InvariantViolationGroupByCollision => "{read_model} groups by {fields}, but rows {ids} share {key} — a group_by leaf holds one row; add a field that tells them apart",
+            Self::UnauthorizedTenantRequired => "{query} declares authorize with tenant: {field} — pass {field}: to name which {field} this ask is scoped to",
+            Self::UnauthorizedRoleMismatch => "{command} refused — role: {role}, and the caller stated {caller_role}",
+            Self::UnauthorizedCrossTenantReference => "{aggregate} {field} is {tenant}, but {attribute} names a {target} whose own {target_field} is {other} — a cross-tenant reference",
+            Self::AttributeAbsentAbsentRead => "{aggregate} {field} is absent on this record — declared, not optional, and added since it was written. Backfill it in a translation (backfill :{field}, default: ...), or declare it optional: true",
+            Self::ProjectionAbsentAbsentRead => "{aggregate} {field} is not yet projected on this record — declared via projects :{field}, but no rebuild sweep has populated it. Run the sweep, or read {reference}.{remote_field} directly if this rule cannot wait",
         }
     }
 
     /// The row whose `site` is `name`, if any.
-    pub fn from_name(name: &str) -> Option<RefusalSite> {
-        RefusalSite::ALL.iter().copied().find(|row| row.site() == name)
+    pub fn from_name(name: &str) -> Option<Self> {
+        Self::ALL.iter().copied().find(|row| row.site() == name)
     }
 
     /// `RefusalWording.substitute`: replace every `{key}` marker, in the
     /// order given. A template is read, never evaluated. Private: call
     /// sites go through a site's typed `<Variant>Args::render_args`,
     /// which formats and supplies every declared argument.
-    fn render(&self, values: &[(&str, &str)]) -> String {
+    fn render(self, values: &[(&str, &str)]) -> String {
         let mut text = self.template().to_string();
         for (key, value) in values {
             text = text.replace(&format!("{{{key}}}"), value);
@@ -296,7 +296,13 @@ fn list(items: &[&str], sorted: bool, inspect: bool, separator: &str, when_empty
     if items.is_empty() {
         return when_empty.to_string();
     }
-    let write = |item: &&str| if inspect { quoted(item) } else { item.to_string() };
+    let write = |item: &&str| {
+        if inspect {
+            quoted(item)
+        } else {
+            item.to_string()
+        }
+    };
     items.iter().map(write).collect::<Vec<_>>().join(separator)
 }
 
@@ -547,10 +553,8 @@ pub struct NotFoundReadModelReferenceMissingArgs<'a> {
 impl NotFoundReadModelReferenceMissingArgs<'_> {
     /// The site's wording, every argument formatted by its declared row.
     pub fn render_args(&self) -> String {
-        RefusalSite::NotFoundReadModelReferenceMissing.render(&[
-            ("aggregate", self.aggregate),
-            ("offered", self.offered),
-        ])
+        RefusalSite::NotFoundReadModelReferenceMissing
+            .render(&[("aggregate", self.aggregate), ("offered", self.offered)])
     }
 }
 
@@ -566,10 +570,8 @@ pub struct TypeMismatchReadModelObjectReferenceArgs<'a> {
 impl TypeMismatchReadModelObjectReferenceArgs<'_> {
     /// The site's wording, every argument formatted by its declared row.
     pub fn render_args(&self) -> String {
-        RefusalSite::TypeMismatchReadModelObjectReference.render(&[
-            ("query", self.query),
-            ("field", self.field),
-        ])
+        RefusalSite::TypeMismatchReadModelObjectReference
+            .render(&[("query", self.query), ("field", self.field)])
     }
 }
 
@@ -606,10 +608,8 @@ impl UnknownVerbEntityQueryMissingArgs<'_> {
     /// The site's wording, every argument formatted by its declared row.
     pub fn render_args(&self) -> String {
         let query_text = quoted(self.query);
-        RefusalSite::UnknownVerbEntityQueryMissing.render(&[
-            ("entity", self.entity),
-            ("query", query_text.as_str()),
-        ])
+        RefusalSite::UnknownVerbEntityQueryMissing
+            .render(&[("entity", self.entity), ("query", query_text.as_str())])
     }
 }
 
@@ -625,10 +625,8 @@ pub struct UnknownVerbEntityHoldsNoListArgs<'a> {
 impl UnknownVerbEntityHoldsNoListArgs<'_> {
     /// The site's wording, every argument formatted by its declared row.
     pub fn render_args(&self) -> String {
-        RefusalSite::UnknownVerbEntityHoldsNoList.render(&[
-            ("aggregate", self.aggregate),
-            ("entity", self.entity),
-        ])
+        RefusalSite::UnknownVerbEntityHoldsNoList
+            .render(&[("aggregate", self.aggregate), ("entity", self.entity)])
     }
 }
 
@@ -645,10 +643,8 @@ impl UnknownVerbEntityNoCommandArgs<'_> {
     /// The site's wording, every argument formatted by its declared row.
     pub fn render_args(&self) -> String {
         let command_text = quoted(self.command);
-        RefusalSite::UnknownVerbEntityNoCommand.render(&[
-            ("entity", self.entity),
-            ("command", command_text.as_str()),
-        ])
+        RefusalSite::UnknownVerbEntityNoCommand
+            .render(&[("entity", self.entity), ("command", command_text.as_str())])
     }
 }
 
@@ -685,10 +681,8 @@ impl UnknownVerbPortNoOperationArgs<'_> {
     /// The site's wording, every argument formatted by its declared row.
     pub fn render_args(&self) -> String {
         let operation_text = quoted(self.operation);
-        RefusalSite::UnknownVerbPortNoOperation.render(&[
-            ("port", self.port),
-            ("operation", operation_text.as_str()),
-        ])
+        RefusalSite::UnknownVerbPortNoOperation
+            .render(&[("port", self.port), ("operation", operation_text.as_str())])
     }
 }
 
@@ -705,10 +699,8 @@ impl UnknownVerbNoDomainArgs<'_> {
     /// The site's wording, every argument formatted by its declared row.
     pub fn render_args(&self) -> String {
         let domain_text = quoted(self.domain);
-        RefusalSite::UnknownVerbNoDomain.render(&[
-            ("domain", domain_text.as_str()),
-            ("verb", self.verb),
-        ])
+        RefusalSite::UnknownVerbNoDomain
+            .render(&[("domain", domain_text.as_str()), ("verb", self.verb)])
     }
 }
 
@@ -725,10 +717,8 @@ impl UnknownVerbNoReadModelArgs<'_> {
     /// The site's wording, every argument formatted by its declared row.
     pub fn render_args(&self) -> String {
         let query_text = quoted(self.query);
-        RefusalSite::UnknownVerbNoReadModel.render(&[
-            ("domain", self.domain),
-            ("query", query_text.as_str()),
-        ])
+        RefusalSite::UnknownVerbNoReadModel
+            .render(&[("domain", self.domain), ("query", query_text.as_str())])
     }
 }
 
@@ -743,9 +733,7 @@ impl UnknownVerbNotFullyQualifiedArgs<'_> {
     /// The site's wording, every argument formatted by its declared row.
     pub fn render_args(&self) -> String {
         let verb_text = quoted(self.verb);
-        RefusalSite::UnknownVerbNotFullyQualified.render(&[
-            ("verb", verb_text.as_str()),
-        ])
+        RefusalSite::UnknownVerbNotFullyQualified.render(&[("verb", verb_text.as_str())])
     }
 }
 
@@ -852,9 +840,7 @@ pub struct TypeMismatchMultiFieldScalarArgs<'a> {
 impl TypeMismatchMultiFieldScalarArgs<'_> {
     /// The site's wording, every argument formatted by its declared row.
     pub fn render_args(&self) -> String {
-        RefusalSite::TypeMismatchMultiFieldScalar.render(&[
-            ("type", self.r#type),
-        ])
+        RefusalSite::TypeMismatchMultiFieldScalar.render(&[("type", self.r#type)])
     }
 }
 
@@ -868,9 +854,7 @@ pub struct TypeMismatchCompositeIdentityArgs<'a> {
 impl TypeMismatchCompositeIdentityArgs<'_> {
     /// The site's wording, every argument formatted by its declared row.
     pub fn render_args(&self) -> String {
-        RefusalSite::TypeMismatchCompositeIdentity.render(&[
-            ("type", self.r#type),
-        ])
+        RefusalSite::TypeMismatchCompositeIdentity.render(&[("type", self.r#type)])
     }
 }
 
@@ -1024,10 +1008,8 @@ pub struct TypeMismatchArithmeticSharedFieldArgs<'a> {
 impl TypeMismatchArithmeticSharedFieldArgs<'_> {
     /// The site's wording, every argument formatted by its declared row.
     pub fn render_args(&self) -> String {
-        RefusalSite::TypeMismatchArithmeticSharedField.render(&[
-            ("op", self.op),
-            ("target", self.target),
-        ])
+        RefusalSite::TypeMismatchArithmeticSharedField
+            .render(&[("op", self.op), ("target", self.target)])
     }
 }
 
@@ -1162,10 +1144,8 @@ pub struct InvariantViolationUndeclaredSetArgs<'a> {
 impl InvariantViolationUndeclaredSetArgs<'_> {
     /// The site's wording, every argument formatted by its declared row.
     pub fn render_args(&self) -> String {
-        RefusalSite::InvariantViolationUndeclaredSet.render(&[
-            ("name", self.name),
-            ("admits", self.admits),
-        ])
+        RefusalSite::InvariantViolationUndeclaredSet
+            .render(&[("name", self.name), ("admits", self.admits)])
     }
 }
 
@@ -1208,10 +1188,8 @@ pub struct UnauthorizedTenantRequiredArgs<'a> {
 impl UnauthorizedTenantRequiredArgs<'_> {
     /// The site's wording, every argument formatted by its declared row.
     pub fn render_args(&self) -> String {
-        RefusalSite::UnauthorizedTenantRequired.render(&[
-            ("query", self.query),
-            ("field", self.field),
-        ])
+        RefusalSite::UnauthorizedTenantRequired
+            .render(&[("query", self.query), ("field", self.field)])
     }
 }
 
@@ -1283,10 +1261,8 @@ pub struct AttributeAbsentAbsentReadArgs<'a> {
 impl AttributeAbsentAbsentReadArgs<'_> {
     /// The site's wording, every argument formatted by its declared row.
     pub fn render_args(&self) -> String {
-        RefusalSite::AttributeAbsentAbsentRead.render(&[
-            ("aggregate", self.aggregate),
-            ("field", self.field),
-        ])
+        RefusalSite::AttributeAbsentAbsentRead
+            .render(&[("aggregate", self.aggregate), ("field", self.field)])
     }
 }
 
@@ -1336,8 +1312,12 @@ mod tests {
                     (_, None) => {}
                 }
             }
-            let dummies: Vec<(String, String)> = keys.iter().map(|k| (k.clone(), format!("<{k}>"))).collect();
-            let pairs: Vec<(&str, &str)> = dummies.iter().map(|(k, v)| (k.as_str(), v.as_str())).collect();
+            let dummies: Vec<(String, String)> =
+                keys.iter().map(|k| (k.clone(), format!("<{k}>"))).collect();
+            let pairs: Vec<(&str, &str)> = dummies
+                .iter()
+                .map(|(k, v)| (k.as_str(), v.as_str()))
+                .collect();
             let rendered = site.render(&pairs);
             assert!(
                 !rendered.contains('{') && !rendered.contains('}'),
@@ -1349,7 +1329,12 @@ mod tests {
     #[test]
     fn render_args_matches_ruby_render_site() {
         assert_eq!(
-            NotFoundCreatingNoIdentityArgs { command: "command \"x\"", aggregate: "aggregate \"x\"", identity: "identity \"x\"" }.render_args(),
+            NotFoundCreatingNoIdentityArgs {
+                command: "command \"x\"",
+                aggregate: "aggregate \"x\"",
+                identity: "identity \"x\""
+            }
+            .render_args(),
             "command \"x\" creates a aggregate \"x\" — pass identity \"x\":"
         );
         assert_eq!(
@@ -1357,83 +1342,178 @@ mod tests {
             "command \"x\" creates a aggregate \"x\" that already exists — identity \"x\" offered \"x\""
         );
         assert_eq!(
-            AlreadyExistsEntityDuplicateArgs { entity: "entity \"x\"", aggregate: "aggregate \"x\"", identity: "identity \"x\"", offered: &[] }.render_args(),
+            AlreadyExistsEntityDuplicateArgs {
+                entity: "entity \"x\"",
+                aggregate: "aggregate \"x\"",
+                identity: "identity \"x\"",
+                offered: &[]
+            }
+            .render_args(),
             "a entity \"x\" already exists on aggregate \"x\" — identity \"x\" "
         );
         assert_eq!(
-            AlreadyExistsEntityDuplicateArgs { entity: "entity \"x\"", aggregate: "aggregate \"x\"", identity: "identity \"x\"", offered: &["only \"one\""] }.render_args(),
+            AlreadyExistsEntityDuplicateArgs {
+                entity: "entity \"x\"",
+                aggregate: "aggregate \"x\"",
+                identity: "identity \"x\"",
+                offered: &["only \"one\""]
+            }
+            .render_args(),
             "a entity \"x\" already exists on aggregate \"x\" — identity \"x\" only \"one\""
         );
         assert_eq!(
-            AlreadyExistsEntityDuplicateArgs { entity: "entity \"x\"", aggregate: "aggregate \"x\"", identity: "identity \"x\"", offered: &["zeta", "alpha", "mid"] }.render_args(),
+            AlreadyExistsEntityDuplicateArgs {
+                entity: "entity \"x\"",
+                aggregate: "aggregate \"x\"",
+                identity: "identity \"x\"",
+                offered: &["zeta", "alpha", "mid"]
+            }
+            .render_args(),
             "a entity \"x\" already exists on aggregate \"x\" — identity \"x\" zeta, alpha, mid"
         );
         assert_eq!(
-            NotFoundActingNoIdentityArgs { command: "command \"x\"", aggregate: "aggregate \"x\"", identity: "identity \"x\"" }.render_args(),
+            NotFoundActingNoIdentityArgs {
+                command: "command \"x\"",
+                aggregate: "aggregate \"x\"",
+                identity: "identity \"x\""
+            }
+            .render_args(),
             "command \"x\" acts on an existing aggregate \"x\" — pass identity \"x\":"
         );
         assert_eq!(
-            NotFoundRecordMissingArgs { aggregate: "aggregate \"x\"", identity: "identity \"x\"", offered: "offered \"x\"" }.render_args(),
+            NotFoundRecordMissingArgs {
+                aggregate: "aggregate \"x\"",
+                identity: "identity \"x\"",
+                offered: "offered \"x\""
+            }
+            .render_args(),
             "no aggregate \"x\" with identity \"x\" offered \"x\""
         );
         assert_eq!(
-            NotFoundEntityParentNoIdentityArgs { command: "command \"x\"", aggregate: "aggregate \"x\"", entity: "entity \"x\"", identity: "identity \"x\"" }.render_args(),
+            NotFoundEntityParentNoIdentityArgs {
+                command: "command \"x\"",
+                aggregate: "aggregate \"x\"",
+                entity: "entity \"x\"",
+                identity: "identity \"x\""
+            }
+            .render_args(),
             "command \"x\" acts on a aggregate \"x\"'s entity \"x\" — pass identity \"x\":"
         );
         assert_eq!(
-            UnknownVerbEntityUnknownArgs { aggregate: "aggregate \"x\"", entity: "entity \"x\"" }.render_args(),
+            UnknownVerbEntityUnknownArgs {
+                aggregate: "aggregate \"x\"",
+                entity: "entity \"x\""
+            }
+            .render_args(),
             "aggregate \"x\" has no entity \"entity \\\"x\\\"\""
         );
         assert_eq!(
-            NotFoundEntityElementNoIdentityArgs { command: "command \"x\"", entity: "entity \"x\"", identity: "identity \"x\"" }.render_args(),
+            NotFoundEntityElementNoIdentityArgs {
+                command: "command \"x\"",
+                entity: "entity \"x\"",
+                identity: "identity \"x\""
+            }
+            .render_args(),
             "command \"x\" acts on one entity \"x\" — pass identity \"x\":"
         );
         assert_eq!(
-            NotFoundEntityElementMissingArgs { entity: "entity \"x\"", identity: "identity \"x\"", wants: "wants \"x\"", aggregate: "aggregate \"x\"", parent_id: "parent_id \"x\"" }.render_args(),
+            NotFoundEntityElementMissingArgs {
+                entity: "entity \"x\"",
+                identity: "identity \"x\"",
+                wants: "wants \"x\"",
+                aggregate: "aggregate \"x\"",
+                parent_id: "parent_id \"x\""
+            }
+            .render_args(),
             "no entity \"x\" with identity \"x\" wants \"x\" on aggregate \"x\" parent_id \"x\""
         );
         assert_eq!(
-            NotFoundReferenceTargetMissingArgs { target: "target \"x\"", heads: "heads \"x\"", key: "key \"x\"" }.render_args(),
+            NotFoundReferenceTargetMissingArgs {
+                target: "target \"x\"",
+                heads: "heads \"x\"",
+                key: "key \"x\""
+            }
+            .render_args(),
             "no target \"x\" with heads \"x\" \"key \\\"x\\\"\""
         );
         assert_eq!(
-            NotFoundReadModelReferenceMissingArgs { aggregate: "aggregate \"x\"", offered: "offered \"x\"" }.render_args(),
+            NotFoundReadModelReferenceMissingArgs {
+                aggregate: "aggregate \"x\"",
+                offered: "offered \"x\""
+            }
+            .render_args(),
             "no aggregate \"x\" with reference offered \"x\""
         );
         assert_eq!(
-            TypeMismatchReadModelObjectReferenceArgs { query: "query \"x\"", field: "field \"x\"" }.render_args(),
+            TypeMismatchReadModelObjectReferenceArgs {
+                query: "query \"x\"",
+                field: "field \"x\""
+            }
+            .render_args(),
             "query \"x\" refused — a reference is an id, and field \"x\" arrived as an object"
         );
         assert_eq!(
-            UnknownVerbNoQueryArgs { aggregate: "aggregate \"x\"", query: "query \"x\"" }.render_args(),
+            UnknownVerbNoQueryArgs {
+                aggregate: "aggregate \"x\"",
+                query: "query \"x\""
+            }
+            .render_args(),
             "aggregate \"x\" has no query \"query \\\"x\\\"\""
         );
         assert_eq!(
-            UnknownVerbEntityQueryMissingArgs { entity: "entity \"x\"", query: "query \"x\"" }.render_args(),
+            UnknownVerbEntityQueryMissingArgs {
+                entity: "entity \"x\"",
+                query: "query \"x\""
+            }
+            .render_args(),
             "entity \"x\" has no query \"query \\\"x\\\"\""
         );
         assert_eq!(
-            UnknownVerbEntityHoldsNoListArgs { aggregate: "aggregate \"x\"", entity: "entity \"x\"" }.render_args(),
+            UnknownVerbEntityHoldsNoListArgs {
+                aggregate: "aggregate \"x\"",
+                entity: "entity \"x\""
+            }
+            .render_args(),
             "aggregate \"x\" holds no list of entity \"x\""
         );
         assert_eq!(
-            UnknownVerbEntityNoCommandArgs { entity: "entity \"x\"", command: "command \"x\"" }.render_args(),
+            UnknownVerbEntityNoCommandArgs {
+                entity: "entity \"x\"",
+                command: "command \"x\""
+            }
+            .render_args(),
             "entity \"x\" has no command \"command \\\"x\\\"\""
         );
         assert_eq!(
-            UnknownVerbAggregateNoCommandArgs { aggregate: "aggregate \"x\"", command: "command \"x\"" }.render_args(),
+            UnknownVerbAggregateNoCommandArgs {
+                aggregate: "aggregate \"x\"",
+                command: "command \"x\""
+            }
+            .render_args(),
             "aggregate \"x\" has no command \"command \\\"x\\\"\""
         );
         assert_eq!(
-            UnknownVerbPortNoOperationArgs { port: "port \"x\"", operation: "operation \"x\"" }.render_args(),
+            UnknownVerbPortNoOperationArgs {
+                port: "port \"x\"",
+                operation: "operation \"x\""
+            }
+            .render_args(),
             "port \"x\" has no operation \"operation \\\"x\\\"\""
         );
         assert_eq!(
-            UnknownVerbNoDomainArgs { domain: "domain \"x\"", verb: "verb \"x\"" }.render_args(),
+            UnknownVerbNoDomainArgs {
+                domain: "domain \"x\"",
+                verb: "verb \"x\""
+            }
+            .render_args(),
             "no domain \"domain \\\"x\\\"\" loaded (verb verb \"x\")"
         );
         assert_eq!(
-            UnknownVerbNoReadModelArgs { domain: "domain \"x\"", query: "query \"x\"" }.render_args(),
+            UnknownVerbNoReadModelArgs {
+                domain: "domain \"x\"",
+                query: "query \"x\""
+            }
+            .render_args(),
             "domain \"x\" has no read model \"query \\\"x\\\"\""
         );
         assert_eq!(
@@ -1441,7 +1521,11 @@ mod tests {
             "\"verb \\\"x\\\"\" is not a fully-qualified verb (Domain::Aggregate.Command)"
         );
         assert_eq!(
-            UnknownVerbNoAggregateArgs { domain: "domain \"x\"", aggregate: "aggregate \"x\"" }.render_args(),
+            UnknownVerbNoAggregateArgs {
+                domain: "domain \"x\"",
+                aggregate: "aggregate \"x\""
+            }
+            .render_args(),
             "domain \"x\" has no aggregate \"aggregate \\\"x\\\"\""
         );
         assert_eq!(
@@ -1457,7 +1541,12 @@ mod tests {
             "command \"x\" refused — field \"x\" is current \"x\", and command \"x\" moves it only from \"zeta\" or \"alpha\" or \"mid\""
         );
         assert_eq!(
-            TypeMismatchValueObjectShapeArgs { name: "name \"x\"", r#type: "type \"x\"", offered: "offered \"x\"" }.render_args(),
+            TypeMismatchValueObjectShapeArgs {
+                name: "name \"x\"",
+                r#type: "type \"x\"",
+                offered: "offered \"x\""
+            }
+            .render_args(),
             "name \"x\" is a type \"x\" — pass its fields as an object, not offered \"x\""
         );
         assert_eq!(
@@ -1465,91 +1554,201 @@ mod tests {
             "command \"x\" refused — a reference is an id, and attribute \"x\" arrived as offered \"x\"known_by \"x\""
         );
         assert_eq!(
-            TypeMismatchMultiFieldScalarArgs { r#type: "type \"x\"" }.render_args(),
+            TypeMismatchMultiFieldScalarArgs {
+                r#type: "type \"x\""
+            }
+            .render_args(),
             "type \"x\" has multiple fields and cannot stand in for a scalar"
         );
         assert_eq!(
-            TypeMismatchCompositeIdentityArgs { r#type: "type \"x\"" }.render_args(),
+            TypeMismatchCompositeIdentityArgs {
+                r#type: "type \"x\""
+            }
+            .render_args(),
             "type \"x\" is a composite identity — an identity must have exactly one field"
         );
         assert_eq!(
-            TypeMismatchNumericFieldArgs { r#type: "type \"x\"", field: "field \"x\"", expected: "expected \"x\"", offered: "offered \"x\"" }.render_args(),
+            TypeMismatchNumericFieldArgs {
+                r#type: "type \"x\"",
+                field: "field \"x\"",
+                expected: "expected \"x\"",
+                offered: "offered \"x\""
+            }
+            .render_args(),
             "type \"x\".field \"x\" expects expected \"x\", got offered \"x\""
         );
         assert_eq!(
-            TypeMismatchNonFiniteFieldArgs { r#type: "type \"x\"", field: "field \"x\"", offered: "offered \"x\"" }.render_args(),
+            TypeMismatchNonFiniteFieldArgs {
+                r#type: "type \"x\"",
+                field: "field \"x\"",
+                offered: "offered \"x\""
+            }
+            .render_args(),
             "type \"x\".field \"x\" must be a finite number, got offered \"x\""
         );
         assert_eq!(
-            TypeMismatchIntegerRangeArgs { r#type: "type \"x\"", field: "field \"x\"", offered: "offered \"x\"" }.render_args(),
+            TypeMismatchIntegerRangeArgs {
+                r#type: "type \"x\"",
+                field: "field \"x\"",
+                offered: "offered \"x\""
+            }
+            .render_args(),
             "type \"x\".field \"x\" must fit in a 64-bit integer, got offered \"x\""
         );
         assert_eq!(
-            TypeMismatchPatternMismatchArgs { r#type: "type \"x\"", field: "field \"x\"", pattern: "pattern \"x\"", offered: "offered \"x\"" }.render_args(),
+            TypeMismatchPatternMismatchArgs {
+                r#type: "type \"x\"",
+                field: "field \"x\"",
+                pattern: "pattern \"x\"",
+                offered: "offered \"x\""
+            }
+            .render_args(),
             "type \"x\".field \"x\" must match pattern \"x\", got offered \"x\""
         );
         assert_eq!(
-            TypeMismatchArithmeticAmountArgs { op: "op \"x\"", target: "target \"x\"", offered: "offered \"x\"" }.render_args(),
+            TypeMismatchArithmeticAmountArgs {
+                op: "op \"x\"",
+                target: "target \"x\"",
+                offered: "offered \"x\""
+            }
+            .render_args(),
             "op \"x\" of target \"x\" needs an Integer, got offered \"x\""
         );
         assert_eq!(
-            TypeMismatchArithmeticCurrentArgs { op: "op \"x\"", target: "target \"x\"", offered: "offered \"x\"" }.render_args(),
+            TypeMismatchArithmeticCurrentArgs {
+                op: "op \"x\"",
+                target: "target \"x\"",
+                offered: "offered \"x\""
+            }
+            .render_args(),
             "op \"x\" of target \"x\" needs an Integer target \"x\", got offered \"x\""
         );
         assert_eq!(
-            TypeMismatchArithmeticSharedFieldArgs { op: "op \"x\"", target: "target \"x\"" }.render_args(),
+            TypeMismatchArithmeticSharedFieldArgs {
+                op: "op \"x\"",
+                target: "target \"x\""
+            }
+            .render_args(),
             "op \"x\" of target \"x\" needs a value object with one shared Integer field"
         );
         assert_eq!(
-            UnknownArgumentUnknownArgsArgs { command: "command \"x\"", unknown: &[], declared: &[] }.render_args(),
+            UnknownArgumentUnknownArgsArgs {
+                command: "command \"x\"",
+                unknown: &[],
+                declared: &[]
+            }
+            .render_args(),
             "command \"x\" does not declare  — it takes none"
         );
         assert_eq!(
-            UnknownArgumentUnknownArgsArgs { command: "command \"x\"", unknown: &["only \"one\""], declared: &["only \"one\""] }.render_args(),
+            UnknownArgumentUnknownArgsArgs {
+                command: "command \"x\"",
+                unknown: &["only \"one\""],
+                declared: &["only \"one\""]
+            }
+            .render_args(),
             "command \"x\" does not declare only \"one\" — it takes only \"one\""
         );
         assert_eq!(
-            UnknownArgumentUnknownArgsArgs { command: "command \"x\"", unknown: &["zeta", "alpha", "mid"], declared: &["zeta", "alpha", "mid"] }.render_args(),
+            UnknownArgumentUnknownArgsArgs {
+                command: "command \"x\"",
+                unknown: &["zeta", "alpha", "mid"],
+                declared: &["zeta", "alpha", "mid"]
+            }
+            .render_args(),
             "command \"x\" does not declare alpha, mid, zeta — it takes zeta, alpha, mid"
         );
         assert_eq!(
-            AbsentArgumentAbsentArgsArgs { command: "command \"x\"", absent: &[], declared: &[] }.render_args(),
+            AbsentArgumentAbsentArgsArgs {
+                command: "command \"x\"",
+                absent: &[],
+                declared: &[]
+            }
+            .render_args(),
             "command \"x\" was not given  — it takes none"
         );
         assert_eq!(
-            AbsentArgumentAbsentArgsArgs { command: "command \"x\"", absent: &["only \"one\""], declared: &["only \"one\""] }.render_args(),
+            AbsentArgumentAbsentArgsArgs {
+                command: "command \"x\"",
+                absent: &["only \"one\""],
+                declared: &["only \"one\""]
+            }
+            .render_args(),
             "command \"x\" was not given only \"one\" — it takes only \"one\""
         );
         assert_eq!(
-            AbsentArgumentAbsentArgsArgs { command: "command \"x\"", absent: &["zeta", "alpha", "mid"], declared: &["zeta", "alpha", "mid"] }.render_args(),
+            AbsentArgumentAbsentArgsArgs {
+                command: "command \"x\"",
+                absent: &["zeta", "alpha", "mid"],
+                declared: &["zeta", "alpha", "mid"]
+            }
+            .render_args(),
             "command \"x\" was not given alpha, mid, zeta — it takes zeta, alpha, mid"
         );
         assert_eq!(
-            InvariantViolationClosedSetMemberArgs { r#type: "type \"x\"", admitted: &[], offered: "offered \"x\"" }.render_args(),
+            InvariantViolationClosedSetMemberArgs {
+                r#type: "type \"x\"",
+                admitted: &[],
+                offered: "offered \"x\""
+            }
+            .render_args(),
             "type \"x\" admits  — got offered \"x\""
         );
         assert_eq!(
-            InvariantViolationClosedSetMemberArgs { r#type: "type \"x\"", admitted: &["only \"one\""], offered: "offered \"x\"" }.render_args(),
+            InvariantViolationClosedSetMemberArgs {
+                r#type: "type \"x\"",
+                admitted: &["only \"one\""],
+                offered: "offered \"x\""
+            }
+            .render_args(),
             "type \"x\" admits \"only \\\"one\\\"\" — got offered \"x\""
         );
         assert_eq!(
-            InvariantViolationClosedSetMemberArgs { r#type: "type \"x\"", admitted: &["zeta", "alpha", "mid"], offered: "offered \"x\"" }.render_args(),
+            InvariantViolationClosedSetMemberArgs {
+                r#type: "type \"x\"",
+                admitted: &["zeta", "alpha", "mid"],
+                offered: "offered \"x\""
+            }
+            .render_args(),
             "type \"x\" admits \"zeta\", \"alpha\", \"mid\" — got offered \"x\""
         );
         assert_eq!(
-            InvariantViolationValueObjectInvariantArgs { name: "name \"x\"", description: "description \"x\"", offered: "offered \"x\"" }.render_args(),
+            InvariantViolationValueObjectInvariantArgs {
+                name: "name \"x\"",
+                description: "description \"x\"",
+                offered: "offered \"x\""
+            }
+            .render_args(),
             "name \"x\" invariant violated — description \"x\" (given offered \"x\")"
         );
         assert_eq!(
-            InvariantViolationAdmitsDeclaredSetArgs { name: "name \"x\"", admits: "admits \"x\"", admitted: &[], offered: "offered \"x\"" }.render_args(),
+            InvariantViolationAdmitsDeclaredSetArgs {
+                name: "name \"x\"",
+                admits: "admits \"x\"",
+                admitted: &[],
+                offered: "offered \"x\""
+            }
+            .render_args(),
             "name \"x\" admits admits \"x\" —  — got offered \"x\""
         );
         assert_eq!(
-            InvariantViolationAdmitsDeclaredSetArgs { name: "name \"x\"", admits: "admits \"x\"", admitted: &["only \"one\""], offered: "offered \"x\"" }.render_args(),
+            InvariantViolationAdmitsDeclaredSetArgs {
+                name: "name \"x\"",
+                admits: "admits \"x\"",
+                admitted: &["only \"one\""],
+                offered: "offered \"x\""
+            }
+            .render_args(),
             "name \"x\" admits admits \"x\" — \"only \\\"one\\\"\" — got offered \"x\""
         );
         assert_eq!(
-            InvariantViolationAdmitsDeclaredSetArgs { name: "name \"x\"", admits: "admits \"x\"", admitted: &["zeta", "alpha", "mid"], offered: "offered \"x\"" }.render_args(),
+            InvariantViolationAdmitsDeclaredSetArgs {
+                name: "name \"x\"",
+                admits: "admits \"x\"",
+                admitted: &["zeta", "alpha", "mid"],
+                offered: "offered \"x\""
+            }
+            .render_args(),
             "name \"x\" admits admits \"x\" — \"zeta\", \"alpha\", \"mid\" — got offered \"x\""
         );
         assert_eq!(
@@ -1573,7 +1772,12 @@ mod tests {
             "query \"x\" declares authorize with tenant: field \"x\" — pass field \"x\": to name which field \"x\" this ask is scoped to"
         );
         assert_eq!(
-            UnauthorizedRoleMismatchArgs { command: "command \"x\"", role: "role \"x\"", caller_role: "caller_role \"x\"" }.render_args(),
+            UnauthorizedRoleMismatchArgs {
+                command: "command \"x\"",
+                role: "role \"x\"",
+                caller_role: "caller_role \"x\""
+            }
+            .render_args(),
             "command \"x\" refused — role: role \"x\", and the caller stated caller_role \"x\""
         );
         assert_eq!(