hecks 3.14.0 → 4.0.0

data/rust/codegen/src/commands.rs

@@ -10,16 +10,24 @@ use std::collections::HashMap;
 
 /// The aggregate's invariant set, generated once per aggregate file and passed to every dispatch.
 pub fn invariants_fn_name(aggregate: &Json) -> String {
-    format!("{}_invariants", naming::rust_ident_field(aggregate.get("name").and_then(Json::as_str).unwrap_or("")).to_lowercase())
+    format!(
+        "{}_invariants",
+        naming::rust_ident_field(aggregate.get("name").and_then(Json::as_str).unwrap_or(""))
+            .to_lowercase()
+    )
 }
 
 pub fn emit_invariants_fn(aggregate: &Json) -> String {
-    let aggregate_vec = invariant_specs_vec(aggregate.get("invariants").map(Json::each).unwrap_or(&[]), 8);
+    let aggregate_vec =
+        invariant_specs_vec(aggregate.get("invariants").map_or_default(Json::each), 8);
     let entities_vec = entity_invariants_vec(aggregate, 8);
     // `Expr` is imported only when an invariant literal was emitted; otherwise it is unused.
     let needs_expr = aggregate_vec.contains("Expr::") || entities_vec.contains("Expr::");
     [
-        Some(format!("fn {}() -> crate::kernel::InvariantSet {{", invariants_fn_name(aggregate))),
+        Some(format!(
+            "fn {}() -> crate::kernel::InvariantSet {{",
+            invariants_fn_name(aggregate)
+        )),
         needs_expr.then(|| "    use crate::kernel::Expr;".to_string()),
         Some("    crate::kernel::InvariantSet {".to_string()),
         Some(format!("        aggregate: {aggregate_vec},")),
@@ -33,6 +41,10 @@ pub fn emit_invariants_fn(aggregate: &Json) -> String {
     .join("\n")
 }
 
+#[allow(
+    clippy::panic,
+    reason = "a drifted exemplar or invalid IR aborts generation on purpose"
+)]
 fn invariant_specs_vec(rules: &[Json], indent: usize) -> String {
     if rules.is_empty() {
         return "vec![]".to_string();
@@ -42,7 +54,9 @@ fn invariant_specs_vec(rules: &[Json], indent: usize) -> String {
         .iter()
         .map(|rule| {
             let description = rule.get("description").and_then(Json::as_str).unwrap_or("");
-            let ast = rule.get("ast").unwrap_or_else(|| panic!("invariant row has no ast: {rule:?}"));
+            let ast = rule
+                .get("ast")
+                .unwrap_or_else(|| panic!("invariant row has no ast: {rule:?}"));
             format!(
                 "{pad}crate::kernel::InvariantSpec {{ description: {}, expr: {} }},",
                 naming::ruby_inspect_string(description),
@@ -54,18 +68,23 @@ fn invariant_specs_vec(rules: &[Json], indent: usize) -> String {
 }
 
 fn entity_invariants_vec(owner: &Json, indent: usize) -> String {
-    let entities = owner.get("entities").map(Json::each).unwrap_or(&[]);
-    let attributes = owner.get("attributes").map(Json::each).unwrap_or(&[]);
+    let entities = owner.get("entities").map_or_default(Json::each);
+    let attributes = owner.get("attributes").map_or_default(Json::each);
     let pieces: Vec<(&Json, String)> = entities
         .iter()
         .filter_map(|entity| {
-            if entity.get("invariants").map(Json::each).unwrap_or(&[]).is_empty() {
+            if entity
+                .get("invariants")
+                .map_or_default(Json::each)
+                .is_empty()
+            {
                 return None;
             }
             let name = entity.get("name").map(Json::to_s).unwrap_or_default();
-            let list = attributes
-                .iter()
-                .find(|a| a.get("list").map(Json::as_bool).unwrap_or(false) && a.get("type").map(Json::to_s).unwrap_or_default() == name)?;
+            let list = attributes.iter().find(|a| {
+                a.get("list").is_some_and(Json::as_bool)
+                    && a.get("type").map(Json::to_s).unwrap_or_default() == name
+            })?;
             Some((entity, list.get("name").map(Json::to_s).unwrap_or_default()))
         })
         .collect();
@@ -80,7 +99,7 @@ fn entity_invariants_vec(owner: &Json, indent: usize) -> String {
                 "{pad}crate::kernel::EntityInvariants {{ name: {}, list_field: {}, specs: {}, nested: {} }},",
                 naming::ruby_inspect_string(&entity.get("name").map(Json::to_s).unwrap_or_default()),
                 naming::ruby_inspect_string(list_field),
-                invariant_specs_vec(entity.get("invariants").map(Json::each).unwrap_or(&[]), indent + 4),
+                invariant_specs_vec(entity.get("invariants").map_or_default(Json::each), indent + 4),
                 entity_invariants_vec(entity, indent + 4)
             )
         })
@@ -89,14 +108,158 @@ fn entity_invariants_vec(owner: &Json, indent: usize) -> String {
 }
 
 /// Extra parameters of every generated `dispatch_*`/`dispatch_entity_*`, resolved by the router.
-fn deref_params() -> [&'static str; 2] {
-    ["owner_deref: Vec<(&'static str, crate::kernel::DerefNode)>", "command_deref: Vec<(&'static str, crate::kernel::DerefNode)>"]
+const fn deref_params() -> [&'static str; 2] {
+    [
+        "owner_deref: Vec<(&'static str, crate::kernel::DerefNode)>",
+        "command_deref: Vec<(&'static str, crate::kernel::DerefNode)>",
+    ]
 }
 
 /// Write-side tenant boundary result, threaded through aggregate commands only.
 /// The router always passes `Ok(())`: no domain generated from `ir.json` declares a boundary.
 const TENANT_BOUNDARY_PARAM: &str = "tenant_boundary_check: Result<(), crate::kernel::Refusal>";
 
+/// A node's `name`, or "" when it has none.
+fn name_of(node: &Json) -> &str {
+    node.get("name").and_then(Json::as_str).unwrap_or("")
+}
+
+/// The paths a node is identified by, joined the way a dispatch fn names them.
+fn identity_reading(node: &Json) -> String {
+    node.get("identified_by")
+        .map_or_default(Json::each)
+        .iter()
+        .map(Json::to_s)
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
+/// The first segment of each path a node is identified by.
+fn identity_heads(node: &Json) -> Vec<String> {
+    node.get("identified_by")
+        .map_or_default(Json::each)
+        .iter()
+        .map(|p| p.to_s().split('.').next().unwrap_or("").to_string())
+        .collect()
+}
+
+/// The Rust field of `owner` that holds `held` as a list.
+#[allow(
+    clippy::panic,
+    reason = "a drifted exemplar or invalid IR aborts generation on purpose"
+)]
+fn list_field_of(owner: &Json, held: &Json) -> String {
+    let held_name = name_of(held);
+    let list_attr = owner
+        .get("attributes")
+        .map_or_default(Json::each)
+        .iter()
+        .find(|a| crate::attr::list(a) && crate::attr::type_name(a) == held_name)
+        .unwrap_or_else(|| panic!("{held_name}: no list attribute on {} holds it — unsupported_attribute_types should have caught this", name_of(owner)));
+    naming::rust_ident_field(crate::attr::name(list_attr))
+}
+
+/// The `pub struct <struct_name> { .. }` text of a command's argument struct.
+fn args_struct_text(exemplar: &Exemplar, struct_name: &str, attrs: &[Json]) -> String {
+    let fields = attrs.iter().map(|attr| {
+        let mut ty = naming::rust_type(crate::attr::type_name(attr), crate::attr::list(attr));
+        if crate::attr::optional(attr) {
+            ty = format!("Option<{ty}>");
+        }
+        format!(
+            "    {}",
+            exemplar.render(
+                "struct_field",
+                &[
+                    ("TmplFieldType", ty),
+                    (
+                        "tmpl_field",
+                        naming::rust_ident_field(crate::attr::name(attr))
+                    ),
+                ]
+            )
+        )
+    });
+    std::iter::once(format!("pub struct {struct_name} {{"))
+        .chain(fields)
+        .chain(std::iter::once("}".to_string()))
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+/// One `GivenSpec` line per `given` of `command`, each prefixed with `indent`.
+#[allow(
+    clippy::panic,
+    reason = "a drifted exemplar or invalid IR aborts generation on purpose"
+)]
+fn given_spec_lines(command: &Json, indent: &str) -> Vec<String> {
+    command
+        .get("givens")
+        .map_or_default(Json::each)
+        .iter()
+        .map(|g| {
+            let description = g.get("description").and_then(Json::as_str).unwrap_or("");
+            let ast = g.get("ast").unwrap_or_else(|| panic!("given row has no ast: {g:?}"));
+            format!("{indent}crate::kernel::GivenSpec {{ description: {}, expr: {}, corrects_event: None }},", naming::ruby_inspect_string(description), crate::expr_emitter::emit_ast(ast))
+        })
+        .collect()
+}
+
+/// One `EnsuresSpec` line per `ensures` of `command`, each prefixed with `indent`.
+#[allow(
+    clippy::panic,
+    reason = "a drifted exemplar or invalid IR aborts generation on purpose"
+)]
+fn ensures_spec_lines(command: &Json, indent: &str) -> Vec<String> {
+    command
+        .get("ensures")
+        .map_or_default(Json::each)
+        .iter()
+        .map(|e| {
+            let description = e.get("description").and_then(Json::as_str).unwrap_or("");
+            let ast = e
+                .get("ast")
+                .unwrap_or_else(|| panic!("ensures row has no ast: {e:?}"));
+            format!(
+                "{indent}crate::kernel::EnsuresSpec {{ description: {}, expr: {} }},",
+                naming::ruby_inspect_string(description),
+                crate::expr_emitter::emit_ast(ast)
+            )
+        })
+        .collect()
+}
+
+/// The event names `command` emits, as a comma-separated list of Rust string literals.
+fn emits_expr_of(command: &Json) -> String {
+    command
+        .get("emits")
+        .map_or_default(Json::each)
+        .iter()
+        .map(|e| naming::ruby_inspect_string(&e.to_s()))
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
+/// Ends a command's mutation lines: the lifecycle transition's new state, or `let _ = record;`
+/// when there is nothing to write.
+fn close_mutation_lines(
+    mut lines: Vec<String>,
+    transition: Option<&mutations::Transition>,
+    indent: &str,
+) -> Vec<String> {
+    if let Some(t) = transition.filter(|t| !t.to_state.is_empty()) {
+        lines.push(format!(
+            "{indent}record.{} = {}.to_string();",
+            naming::rust_ident_field(&t.field),
+            naming::ruby_inspect_string(&t.to_state)
+        ));
+    }
+    if lines.is_empty() {
+        lines.push(format!("{indent}let _ = record;"));
+    }
+    lines
+}
+
 fn with_references_binding() -> String {
     "let with_references = crate::kernel::WithReferences { command_deref: &command_deref, args: &args, owner_deref: &owner_deref };".to_string()
 }
@@ -107,12 +270,19 @@ fn seed_projections_binding(aggregate: &Json) -> String {
     format!("let seed_projections = crate::kernel::seeded_projections(&with_references, {table}_PROJECTED_FIELDS);")
 }
 
-fn target_type_for<'a>(target: &str, aggregate: &'a Json, lifecycle_field: Option<&str>) -> Option<&'a str> {
+fn target_type_for<'a>(
+    target: &str,
+    aggregate: &'a Json,
+    lifecycle_field: Option<&str>,
+) -> Option<&'a str> {
     if lifecycle_field == Some(target) {
         return Some("String");
     }
-    let attrs = aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
-    attrs.iter().find(|a| crate::attr::name(a) == target).map(crate::attr::type_name)
+    let attrs = aggregate.get("attributes").map_or_default(Json::each);
+    attrs
+        .iter()
+        .find(|a| crate::attr::name(a) == target)
+        .map(crate::attr::type_name)
 }
 
 // The lifecycle field is never a list; `false` when the target is not found.
@@ -120,24 +290,49 @@ fn target_list_for(target: &str, aggregate: &Json, lifecycle_field: Option<&str>
     if lifecycle_field == Some(target) {
         return false;
     }
-    let attrs = aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
-    attrs.iter().find(|a| crate::attr::name(a) == target).map(crate::attr::list).unwrap_or(false)
+    let attrs = aggregate.get("attributes").map_or_default(Json::each);
+    attrs
+        .iter()
+        .find(|a| crate::attr::name(a) == target)
+        .is_some_and(crate::attr::list)
 }
 
-pub fn command_skip_reason(command: &Json, aggregate: &Json, value_objects_by_name: &HashMap<String, &Json>) -> Option<SkipReason> {
+pub fn command_skip_reason(
+    command: &Json,
+    aggregate: &Json,
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> Option<SkipReason> {
     command_skip_reason_with(command, aggregate, value_objects_by_name, true)
 }
 
 /// `creating_possible` is false for an entity command: its optional identity argument is not an
 /// identity source.
-fn command_skip_reason_with(command: &Json, aggregate: &Json, value_objects_by_name: &HashMap<String, &Json>, creating_possible: bool) -> Option<SkipReason> {
-    let mutations_list = command.get("mutations").map(Json::each).unwrap_or(&[]);
+fn command_skip_reason_with(
+    command: &Json,
+    aggregate: &Json,
+    value_objects_by_name: &HashMap<String, &Json>,
+    creating_possible: bool,
+) -> Option<SkipReason> {
+    let mutations_list = command.get("mutations").map_or_default(Json::each);
 
     let mut unsupported_ops: Vec<String> = Vec::new();
     for m in mutations_list {
         let op = m.get("op").map(Json::to_s).unwrap_or_default();
         // `remove` passes here; `mutations::remove_field_problems` narrows it to entity lists.
-        if !["append", "set", "increment", "decrement", "multiply", "clamp", "remove", "delegate", "corrects"].contains(&op.as_str()) && !unsupported_ops.contains(&op) {
+        if ![
+            "append",
+            "set",
+            "increment",
+            "decrement",
+            "multiply",
+            "clamp",
+            "remove",
+            "delegate",
+            "corrects",
+        ]
+        .contains(&op.as_str())
+            && !unsupported_ops.contains(&op)
+        {
             unsupported_ops.push(op);
         }
     }
@@ -148,7 +343,11 @@ fn command_skip_reason_with(command: &Json, aggregate: &Json, value_objects_by_n
     if let Some(corrects) = crate::bridging::corrects_of(command) {
         // The IR is already derived, so only a command carrying nothing but its `corrects` is
         // refused.
-        if crate::bridging::corrects_reverses(corrects) && mutations_list.iter().all(|m| m.get("op").map(Json::to_s).unwrap_or_default() == "corrects") {
+        if crate::bridging::corrects_reverses(corrects)
+            && mutations_list
+                .iter()
+                .all(|m| m.get("op").map(Json::to_s).unwrap_or_default() == "corrects")
+        {
             let event = corrects.get("target").map(Json::to_s).unwrap_or_default();
             return Some(skip("corrects_reverses", format!("corrects {event}, reverses: true — the derived append/remove-reversal shape is a real, separate gap Ruby's own authors haven't finished designing (AggregateBuilder#seal_correction_targets's own comment) — not generated yet")));
         }
@@ -158,27 +357,49 @@ fn command_skip_reason_with(command: &Json, aggregate: &Json, value_objects_by_n
         return Some(skip("delegate", problem));
     }
 
-    let append_problems = mutations::append_field_problems(command, aggregate, value_objects_by_name);
+    let append_problems =
+        mutations::append_field_problems(command, aggregate, value_objects_by_name);
     if !append_problems.is_empty() {
-        return Some(skip("append_field", format!("sets append field(s): {}", append_problems.join("; "))));
+        return Some(skip(
+            "append_field",
+            format!("sets append field(s): {}", append_problems.join("; ")),
+        ));
     }
 
-    let state_problems = mutations::state_source_problems(command, aggregate, value_objects_by_name);
+    let state_problems =
+        mutations::state_source_problems(command, aggregate, value_objects_by_name);
     if !state_problems.is_empty() {
-        return Some(skip("state_source", format!("sets state source(s): {}", state_problems.join("; "))));
+        return Some(skip(
+            "state_source",
+            format!("sets state source(s): {}", state_problems.join("; ")),
+        ));
     }
 
-    let expression_problems = mutations::expression_source_problems(command, aggregate, value_objects_by_name);
+    let expression_problems =
+        mutations::expression_source_problems(command, aggregate, value_objects_by_name);
     if !expression_problems.is_empty() {
-        return Some(skip("expression_source", format!("sets expression source(s): {}", expression_problems.join("; "))));
+        return Some(skip(
+            "expression_source",
+            format!(
+                "sets expression source(s): {}",
+                expression_problems.join("; ")
+            ),
+        ));
     }
 
-    let remove_problems = mutations::remove_field_problems(command, aggregate, value_objects_by_name);
+    let remove_problems =
+        mutations::remove_field_problems(command, aggregate, value_objects_by_name);
     if !remove_problems.is_empty() {
-        return Some(skip("remove_field", format!("sets remove field(s): {}", remove_problems.join("; "))));
+        return Some(skip(
+            "remove_field",
+            format!("sets remove field(s): {}", remove_problems.join("; ")),
+        ));
     }
 
-    let lifecycle_field = aggregate.get("lifecycle").and_then(|l| l.get("field")).map(Json::to_s);
+    let lifecycle_field = aggregate
+        .get("lifecycle")
+        .and_then(|l| l.get("field"))
+        .map(Json::to_s);
 
     let literal_set_targets: Vec<String> = mutations_list
         .iter()
@@ -186,14 +407,20 @@ fn command_skip_reason_with(command: &Json, aggregate: &Json, value_objects_by_n
             if m.get("op").map(Json::to_s).unwrap_or_default() != "set" {
                 return false;
             }
-            let Some(source) = m.get("source") else { return false };
+            let Some(source) = m.get("source") else {
+                return false;
+            };
             if source.get("kind").map(Json::to_s).unwrap_or_default() != "literal" {
                 return false;
             }
             let value = source.get("value").unwrap_or(&Json::Null);
             let target = m.get("target").map(Json::to_s).unwrap_or_default();
             let target_type = target_type_for(&target, aggregate, lifecycle_field.as_deref());
-            !crate::bridging::literal_set_bridgeable(&Literal::from_json(value), target_type, value_objects_by_name)
+            !crate::bridging::literal_set_bridgeable(
+                &Literal::from_json(value),
+                target_type,
+                value_objects_by_name,
+            )
         })
         .map(|m| m.get("target").map(Json::to_s).unwrap_or_default())
         .collect();
@@ -207,21 +434,26 @@ fn command_skip_reason_with(command: &Json, aggregate: &Json, value_objects_by_n
             if m.get("op").map(Json::to_s).unwrap_or_default() != "set" {
                 return false;
             }
-            let Some(source) = m.get("source") else { return false };
+            let Some(source) = m.get("source") else {
+                return false;
+            };
             if source.get("kind").map(Json::to_s).unwrap_or_default() != "argument" {
                 return false;
             }
             let target = m.get("target").map(Json::to_s).unwrap_or_default();
             let target_type = target_type_for(&target, aggregate, lifecycle_field.as_deref());
             let source_name = source.get("name").map(Json::to_s).unwrap_or_default();
-            let cmd_attrs = command.get("attributes").map(Json::each).unwrap_or(&[]);
-            let source_attr = cmd_attrs.iter().find(|a| crate::attr::name(a) == source_name);
+            let cmd_attrs = command.get("attributes").map_or_default(Json::each);
+            let source_attr = cmd_attrs
+                .iter()
+                .find(|a| crate::attr::name(a) == source_name);
             let source_type = source_attr.map(crate::attr::type_name);
             // List-ness must match too: element-type bridging alone would collapse a `Vec` to a
             // scalar.
             match (target_type, source_type, source_attr) {
                 (Some(t), Some(s), Some(source_attr)) => {
-                    target_list_for(&target, aggregate, lifecycle_field.as_deref()) != crate::attr::list(source_attr)
+                    target_list_for(&target, aggregate, lifecycle_field.as_deref())
+                        != crate::attr::list(source_attr)
                         || !crate::bridging::bridgeable_value_types(s, t, value_objects_by_name)
                 }
                 _ => false,
@@ -233,13 +465,37 @@ fn command_skip_reason_with(command: &Json, aggregate: &Json, value_objects_by_n
         return Some(skip("set_argument_bridge", format!("sets :{} sources an argument no single-field rewrap can bridge to the target's type — not generated yet", mismatched_sets.join(", "))));
     }
 
-    let arithmetic_targets: Vec<&Json> = mutations_list.iter().filter(|m| ["increment", "decrement", "multiply"].contains(&m.get("op").map(Json::to_s).unwrap_or_default().as_str())).collect();
+    let arithmetic_targets: Vec<&Json> = mutations_list
+        .iter()
+        .filter(|m| {
+            ["increment", "decrement", "multiply"]
+                .contains(&m.get("op").map(Json::to_s).unwrap_or_default().as_str())
+        })
+        .collect();
     let unsupported_arithmetic: Vec<String> = arithmetic_targets
         .iter()
         .filter(|m| {
-            let target = crate::bridging::arithmetic_target_field(m, aggregate, value_objects_by_name);
+            let target =
+                crate::bridging::arithmetic_target_field(m, aggregate, value_objects_by_name);
             match target {
-                Some((_, field)) => crate::bridging::arithmetic_amount_expr(m.get("source").unwrap_or(&Json::Null), command, value_objects_by_name, &field).is_none(),
+                Some((_, field, kind)) => {
+                    crate::bridging::arithmetic_amount_expr(
+                        m.get("source").unwrap_or(&Json::Null),
+                        command,
+                        value_objects_by_name,
+                        &field,
+                        kind,
+                    )
+                    .is_none()
+                        && crate::bridging::text_operand_expr(
+                            m,
+                            aggregate,
+                            command,
+                            value_objects_by_name,
+                            &field,
+                        )
+                        .is_none()
+                }
                 None => true,
             }
         })
@@ -250,104 +506,165 @@ fn command_skip_reason_with(command: &Json, aggregate: &Json, value_objects_by_n
     }
 
     // `:clamp`: target as for increment/decrement/multiply; bounds via `clamp_bounds_ints`.
-    let clamp_targets: Vec<&Json> = mutations_list.iter().filter(|m| m.get("op").map(Json::to_s).unwrap_or_default() == "clamp").collect();
+    let clamp_targets: Vec<&Json> = mutations_list
+        .iter()
+        .filter(|m| m.get("op").map(Json::to_s).unwrap_or_default() == "clamp")
+        .collect();
     let unsupported_clamp: Vec<String> = clamp_targets
         .iter()
         .filter(|m| {
-            let target = crate::bridging::arithmetic_target_field(m, aggregate, value_objects_by_name);
+            let target = crate::bridging::integer_target_field(m, aggregate, value_objects_by_name);
             let bounds = m.get("source").and_then(crate::bridging::clamp_bounds_ints);
             target.is_none() || bounds.is_none()
         })
         .map(|m| m.get("target").map(Json::to_s).unwrap_or_default())
         .collect();
     if !unsupported_clamp.is_empty() {
-        return Some(skip("clamp", format!("sets :{} clamp target field or bounds isn't bridgeable — not generated yet", unsupported_clamp.join(", "))));
+        return Some(skip(
+            "clamp",
+            format!(
+                "sets :{} clamp target field or bounds isn't bridgeable — not generated yet",
+                unsupported_clamp.join(", ")
+            ),
+        ));
     }
 
-    let optional_problems = optional_source_mismatches_with(command, aggregate, value_objects_by_name, creating_possible);
+    let optional_problems = optional_source_mismatches_with(
+        command,
+        aggregate,
+        value_objects_by_name,
+        creating_possible,
+    );
     if !optional_problems.is_empty() {
-        return Some(skip("optional_source", format!("optional argument feeds a non-optional target: {} — not generated yet", optional_problems.join("; "))));
+        return Some(skip(
+            "optional_source",
+            format!(
+                "optional argument feeds a non-optional target: {} — not generated yet",
+                optional_problems.join("; ")
+            ),
+        ));
     }
 
     None
 }
 
-pub fn optional_source_mismatches(command: &Json, aggregate: &Json, value_objects_by_name: &HashMap<String, &Json>) -> Vec<String> {
-    optional_source_mismatches_with(command, aggregate, value_objects_by_name, true)
-}
-
-fn optional_source_mismatches_with(command: &Json, aggregate: &Json, value_objects_by_name: &HashMap<String, &Json>, creating_possible: bool) -> Vec<String> {
-    let lifecycle_field = aggregate.get("lifecycle").and_then(|l| l.get("field")).map(Json::to_s);
+fn optional_source_mismatches_with(
+    command: &Json,
+    aggregate: &Json,
+    value_objects_by_name: &HashMap<String, &Json>,
+    creating_possible: bool,
+) -> Vec<String> {
+    let lifecycle_field = aggregate
+        .get("lifecycle")
+        .and_then(|l| l.get("field"))
+        .map(Json::to_s);
     let mut problems: Vec<String> = Vec::new();
-    let cmd_attrs = command.get("attributes").map(Json::each).unwrap_or(&[]);
+    let cmd_attrs = command.get("attributes").map_or_default(Json::each);
 
-    if creating_possible && crate::shared::creates_owner(aggregate, command, value_objects_by_name) {
-        let identified_by = aggregate.get("identified_by").map(Json::each).unwrap_or(&[]);
+    if creating_possible && crate::shared::creates_owner(aggregate, command) {
+        let identified_by = aggregate.get("identified_by").map_or_default(Json::each);
         for path in identified_by {
             let path = path.as_str().unwrap_or("");
             let head = path.split('.').next().unwrap_or("");
             if let Some(source_attr) = cmd_attrs.iter().find(|a| crate::attr::name(a) == head) {
                 if crate::attr::optional(source_attr) {
-                    problems.push(format!("identified_by :{path} sources optional argument {}", crate::attr::name(source_attr)));
+                    problems.push(format!(
+                        "identified_by :{path} sources optional argument {}",
+                        crate::attr::name(source_attr)
+                    ));
                 }
             }
         }
     }
 
-    let mutations_list = command.get("mutations").map(Json::each).unwrap_or(&[]);
+    let mutations_list = command.get("mutations").map_or_default(Json::each);
     for m in mutations_list {
         let op = m.get("op").map(Json::to_s).unwrap_or_default();
         let target = m.get("target").map(Json::to_s).unwrap_or_default();
         match op.as_str() {
             "set" => {
-                let Some(source) = m.get("source") else { continue };
+                let Some(source) = m.get("source") else {
+                    continue;
+                };
                 if source.get("kind").map(Json::to_s).unwrap_or_default() != "argument" {
                     continue;
                 }
                 let source_name = source.get("name").map(Json::to_s).unwrap_or_default();
-                let Some(source_attr) = cmd_attrs.iter().find(|a| crate::attr::name(a) == source_name) else { continue };
+                let Some(source_attr) = cmd_attrs
+                    .iter()
+                    .find(|a| crate::attr::name(a) == source_name)
+                else {
+                    continue;
+                };
                 if !crate::attr::optional(source_attr) {
                     continue;
                 }
 
                 if lifecycle_field.as_deref() == Some(target.as_str()) {
-                    problems.push(format!("sets :{target} sources optional argument {} into the lifecycle field", crate::attr::name(source_attr)));
+                    problems.push(format!(
+                        "sets :{target} sources optional argument {} into the lifecycle field",
+                        crate::attr::name(source_attr)
+                    ));
                     continue;
                 }
 
-                let attrs = aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
+                let attrs = aggregate.get("attributes").map_or_default(Json::each);
                 let target_attr = attrs.iter().find(|a| crate::attr::name(a) == target);
-                if target_attr.map(crate::attr::list).unwrap_or(false) {
+                if target_attr.is_some_and(crate::attr::list) {
                     continue;
                 }
                 // An aggregate command's record fields are all `Option<T>`.
                 if creating_possible {
                     continue;
                 }
-                if !target_attr.map(crate::attr::optional).unwrap_or(false) {
-                    problems.push(format!("sets :{target} sources optional argument {}", crate::attr::name(source_attr)));
+                if !target_attr.is_some_and(crate::attr::optional) {
+                    problems.push(format!(
+                        "sets :{target} sources optional argument {}",
+                        crate::attr::name(source_attr)
+                    ));
                 }
             }
             "append" => {
-                let attrs = aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
-                let Some(target_attr) = attrs.iter().find(|a| crate::attr::name(a) == target) else { continue };
-                let Some(element) = mutations::append_element(aggregate, crate::attr::type_name(target_attr), value_objects_by_name) else { continue };
+                let attrs = aggregate.get("attributes").map_or_default(Json::each);
+                let Some(target_attr) = attrs.iter().find(|a| crate::attr::name(a) == target)
+                else {
+                    continue;
+                };
+                let Some(element) = mutations::append_element(
+                    aggregate,
+                    crate::attr::type_name(target_attr),
+                    value_objects_by_name,
+                ) else {
+                    continue;
+                };
 
                 let fields = match m.get("fields") {
                     Some(Json::Object(pairs)) => pairs.clone(),
                     _ => Vec::new(),
                 };
-                let element_attrs = element.get("attributes").map(Json::each).unwrap_or(&[]);
+                let element_attrs = element.get("attributes").map_or_default(Json::each);
                 for (field_name, source) in &fields {
                     let parsed = mutations::append_field_source(&source.to_s());
-                    let Literal::Symbol(arg_name) = &parsed else { continue };
-                    let Some(source_attr) = cmd_attrs.iter().find(|a| crate::attr::name(a) == arg_name.as_str()) else { continue };
+                    let Literal::Symbol(arg_name) = &parsed else {
+                        continue;
+                    };
+                    let Some(source_attr) = cmd_attrs
+                        .iter()
+                        .find(|a| crate::attr::name(a) == arg_name.as_str())
+                    else {
+                        continue;
+                    };
                     if !crate::attr::optional(source_attr) {
                         continue;
                     }
-                    let field_attr = element_attrs.iter().find(|a| crate::attr::name(a) == field_name.as_str());
-                    if !field_attr.map(crate::attr::optional).unwrap_or(false) {
-                        problems.push(format!("sets append {target}.{field_name} sources optional argument {}", crate::attr::name(source_attr)));
+                    let field_attr = element_attrs
+                        .iter()
+                        .find(|a| crate::attr::name(a) == field_name.as_str());
+                    if !field_attr.is_some_and(crate::attr::optional) {
+                        problems.push(format!(
+                            "sets append {target}.{field_name} sources optional argument {}",
+                            crate::attr::name(source_attr)
+                        ));
                     }
                 }
             }
@@ -361,19 +678,31 @@ fn optional_source_mismatches_with(command: &Json, aggregate: &Json, value_objec
 /// One attribute's `admits:` check and value-object invariant check against `value_expr`.
 /// `pattern:` is not checked: Ruby never enforces it on a bare command attribute (ADR 0051).
 /// List attributes get no `admits:` check either, matching Ruby.
-pub fn argument_check_lines(exemplar: &Exemplar, attr: &Json, value_expr: &str, aggregates_by_name: &HashMap<String, &Json>, value_objects_by_name: &HashMap<String, &Json>) -> Vec<String> {
+pub fn argument_check_lines(
+    exemplar: &Exemplar,
+    attr: &Json,
+    value_expr: &str,
+    aggregates_by_name: &HashMap<String, &Json>,
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> Vec<String> {
     let mut lines: Vec<String> = Vec::new();
 
     if !crate::attr::list(attr) {
         // Raw field expression: `constraints.rs` handles optionals itself.
-        if let Some(c) = crate::constraints::emit_admits_check(exemplar, value_expr, attr, aggregates_by_name, value_objects_by_name) {
+        if let Some(c) = crate::constraints::emit_admits_check(
+            exemplar,
+            value_expr,
+            attr,
+            aggregates_by_name,
+            value_objects_by_name,
+        ) {
             lines.push(format!("        {c}"));
         }
     }
 
     let vo = value_objects_by_name.get(crate::attr::type_name(attr));
     if let Some(vo) = vo {
-        if !vo.get("closed_set").map(Json::as_bool).unwrap_or(false) {
+        if !vo.get("closed_set").is_some_and(Json::as_bool) {
             let line = if crate::attr::optional(attr) {
                 if crate::attr::list(attr) {
                     format!("        if let Some(items) = &{value_expr} {{ for item in items {{ item.check_invariants()?; }} }}")
@@ -393,65 +722,68 @@ pub fn argument_check_lines(exemplar: &Exemplar, attr: &Json, value_expr: &str,
 }
 
 /// Invariant checks against the built `args.{field}`, redundant with `emit_from_json_flat`'s copy.
-pub fn invariant_checks_for(exemplar: &Exemplar, command: &Json, aggregates_by_name: &HashMap<String, &Json>, value_objects_by_name: &HashMap<String, &Json>) -> Vec<String> {
-    let attrs = command.get("attributes").map(Json::each).unwrap_or(&[]);
+pub fn invariant_checks_for(
+    exemplar: &Exemplar,
+    command: &Json,
+    aggregates_by_name: &HashMap<String, &Json>,
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> Vec<String> {
+    let attrs = command.get("attributes").map_or_default(Json::each);
     let mut lines: Vec<String> = Vec::new();
 
     for attr in attrs {
         let field = naming::rust_ident_field(crate::attr::name(attr));
         let value_expr = format!("args.{field}");
-        lines.extend(argument_check_lines(exemplar, attr, &value_expr, aggregates_by_name, value_objects_by_name));
+        lines.extend(argument_check_lines(
+            exemplar,
+            attr,
+            &value_expr,
+            aggregates_by_name,
+            value_objects_by_name,
+        ));
     }
 
     lines
 }
 
 /// One emitter for every command shape `kernel::dispatch` can run.
-pub fn emit_command(exemplar: &Exemplar, command: &Json, aggregate: &Json, domain_name: &str, value_objects_by_name: &HashMap<String, &Json>, aggregates_by_name: &HashMap<String, &Json>) -> String {
-    let record = naming::rust_ident(aggregate.get("name").and_then(Json::as_str).unwrap_or(""));
-    let cmd = naming::rust_ident(command.get("name").and_then(Json::as_str).unwrap_or(""));
-    let creates = crate::shared::creates_owner(aggregate, command, value_objects_by_name);
+#[allow(
+    clippy::option_if_let_else,
+    clippy::panic,
+    reason = "a drifted exemplar or invalid IR aborts generation on purpose; a map_or_else closure would bury this long body"
+)]
+pub fn emit_command(
+    exemplar: &Exemplar,
+    command: &Json,
+    aggregate: &Json,
+    domain_name: &str,
+    value_objects_by_name: &HashMap<String, &Json>,
+    aggregates_by_name: &HashMap<String, &Json>,
+) -> String {
+    let record = naming::rust_ident(name_of(aggregate));
+    let cmd = naming::rust_ident(name_of(command));
+    let creates = crate::shared::creates_owner(aggregate, command);
     let identity = mutations::identity_components(aggregate, command);
-    let identity_extra_params: Vec<String> = identity.iter().filter_map(|c| c.param.clone()).collect();
+    let identity_extra_params: Vec<String> =
+        identity.iter().filter_map(|c| c.param.clone()).collect();
 
-    let aggregate_name = aggregate.get("name").and_then(Json::as_str).unwrap_or("").to_string();
-    let identity_reading = aggregate.get("identified_by").map(Json::each).unwrap_or(&[]).iter().map(Json::to_s).collect::<Vec<_>>().join(", ");
+    let aggregate_name = name_of(aggregate).to_string();
+    let identity_reading = identity_reading(aggregate);
 
-    let attrs = command.get("attributes").map(Json::each).unwrap_or(&[]);
-    let mut args_struct = vec![format!("pub struct {cmd}Args {{")];
-    for attr in attrs {
-        let mut ty = naming::rust_type(crate::attr::type_name(attr), crate::attr::list(attr));
-        if crate::attr::optional(attr) {
-            ty = format!("Option<{ty}>");
-        }
-        args_struct.push(format!("    {}", exemplar.render("struct_field", &[("TmplFieldType", ty), ("tmpl_field", naming::rust_ident_field(crate::attr::name(attr)))])));
-    }
-    args_struct.push("}".to_string());
+    let attrs = command.get("attributes").map_or_default(Json::each);
+    let args_struct = args_struct_text(exemplar, &format!("{cmd}Args"), attrs);
 
-    let invariant_checks = invariant_checks_for(exemplar, command, aggregates_by_name, value_objects_by_name);
+    let invariant_checks =
+        invariant_checks_for(exemplar, command, aggregates_by_name, value_objects_by_name);
 
-    let givens = command.get("givens").map(Json::each).unwrap_or(&[]);
     let mut given_specs: Vec<String> = crate::bridging::corrects_given_specs(command);
-    given_specs.extend(givens.iter().map(|g| {
-        let description = g.get("description").and_then(Json::as_str).unwrap_or("");
-        let ast = g.get("ast").unwrap_or_else(|| panic!("given row has no ast: {g:?}"));
-        format!("            crate::kernel::GivenSpec {{ description: {}, expr: {}, corrects_event: None }},", naming::ruby_inspect_string(description), crate::expr_emitter::emit_ast(ast))
-    }));
-
-    let ensures = command.get("ensures").map(Json::each).unwrap_or(&[]);
-    let ensures_specs: Vec<String> = ensures
-        .iter()
-        .map(|e| {
-            let description = e.get("description").and_then(Json::as_str).unwrap_or("");
-            let ast = e.get("ast").unwrap_or_else(|| panic!("ensures row has no ast: {e:?}"));
-            format!("            crate::kernel::EnsuresSpec {{ description: {}, expr: {} }},", naming::ruby_inspect_string(description), crate::expr_emitter::emit_ast(ast))
-        })
-        .collect();
+    given_specs.extend(given_spec_lines(command, "            "));
+    let ensures_specs = ensures_spec_lines(command, "            ");
 
     let transition = mutations::lifecycle_transition_for(command, aggregate);
     let transition_arg = mutations::transition_check_arg(transition.as_ref());
 
-    let mutations_list = command.get("mutations").map(Json::each).unwrap_or(&[]);
+    let mutations_list = command.get("mutations").map_or_default(Json::each);
     // A `delegate` mutation is rendered by `delegation_of`, which overwrites `mutation_lines`;
     // `mutations::emit_mutation_line` panics on the op, so it must be excluded here.
     let mut mutation_lines: Vec<String> = mutations_list
@@ -460,7 +792,16 @@ pub fn emit_command(exemplar: &Exemplar, command: &Json, aggregate: &Json, domai
             let op = m.get("op").map(Json::to_s).unwrap_or_default();
             op != "corrects" && op != "delegate"
         })
-        .map(|m| mutations::emit_mutation_line(exemplar, m, aggregate, command, value_objects_by_name, true))
+        .map(|m| {
+            mutations::emit_mutation_line(
+                exemplar,
+                m,
+                aggregate,
+                command,
+                value_objects_by_name,
+                true,
+            )
+        })
         .collect();
     if mutations::reads_pre_state(mutations_list) {
         mutation_lines.insert(0, mutations::pre_state_line());
@@ -468,7 +809,12 @@ pub fn emit_command(exemplar: &Exemplar, command: &Json, aggregate: &Json, domai
     // Stamp the fact forward for every command whose `emits` names an event a `corrects` targets.
     let correctable = crate::bridging::correctable_event_names(aggregate);
     let mut emitted_names: Vec<String> = Vec::new();
-    for name in command.get("emits").map(Json::each).unwrap_or(&[]).iter().map(Json::to_s) {
+    for name in command
+        .get("emits")
+        .map_or_default(Json::each)
+        .iter()
+        .map(Json::to_s)
+    {
         // `.uniq`: first-occurrence order, not sorted.
         if !emitted_names.contains(&name) {
             emitted_names.push(name);
@@ -476,30 +822,46 @@ pub fn emit_command(exemplar: &Exemplar, command: &Json, aggregate: &Json, domai
     }
     for name in &emitted_names {
         if correctable.contains(name) {
-            mutation_lines.push(format!("        record.{} = true;", crate::bridging::corrects_flag_field(name)));
-        }
-    }
-    if let Some(t) = &transition {
-        if !t.to_state.is_empty() {
-            mutation_lines.push(format!("        record.{} = {}.to_string();", naming::rust_ident_field(&t.field), naming::ruby_inspect_string(&t.to_state)));
+            mutation_lines.push(format!(
+                "        record.{} = true;",
+                crate::bridging::corrects_flag_field(name)
+            ));
         }
     }
-    if mutation_lines.is_empty() {
-        mutation_lines = vec!["        let _ = record;".to_string()];
-    }
-    let delegation = delegation_of(exemplar, command, aggregate, value_objects_by_name, domain_name);
+    let mut mutation_lines = close_mutation_lines(mutation_lines, transition.as_ref(), "        ");
+    let delegation = delegation_of(
+        exemplar,
+        command,
+        aggregate,
+        value_objects_by_name,
+        domain_name,
+    );
     if let Some(d) = &delegation {
-        assert!(!creates, "{cmd}: a creating command cannot delegate — nothing exists to delegate to");
+        assert!(
+            !creates,
+            "{cmd}: a creating command cannot delegate — nothing exists to delegate to"
+        );
         // `d.element` runs first, inside the closure `dispatch` calls after a successful hydrate.
         mutation_lines = vec![d.element.clone(), d.apply.clone()];
     }
-    let prelude = delegation.as_ref().map(|d| d.prelude.clone()).unwrap_or_default();
-    let payload = if delegation.is_some() { "delegate_facts.clone()," } else { "args.to_json()," }.to_string();
+    let prelude = delegation
+        .as_ref()
+        .map(|d| d.prelude.clone())
+        .unwrap_or_default();
+    let payload = if delegation.is_some() {
+        "delegate_facts.clone(),"
+    } else {
+        "args.to_json(),"
+    }
+    .to_string();
 
     let (hydrate, fn_signature);
     // A `projects` field is never a command argument; `seed_projections` populates it before save.
     // Owned because the pseudo-attributes are freshly built.
-    let mut record_agg_attrs_owned: Vec<Json> = aggregate.get("attributes").map(Json::each).unwrap_or(&[]).to_vec();
+    let mut record_agg_attrs_owned: Vec<Json> = aggregate
+        .get("attributes")
+        .map_or_default(Json::each)
+        .to_vec();
     record_agg_attrs_owned.extend(crate::types::projected_field_pseudo_attributes(aggregate));
     let record_agg_attrs = record_agg_attrs_owned.as_slice();
 
@@ -507,20 +869,37 @@ pub fn emit_command(exemplar: &Exemplar, command: &Json, aggregate: &Json, domai
         let record_fields: Vec<String> = record_agg_attrs
             .iter()
             .map(|attr| {
-                let matched = attrs.iter().find(|a| crate::attr::name(a) == crate::attr::name(attr));
+                let matched = attrs
+                    .iter()
+                    .find(|a| crate::attr::name(a) == crate::attr::name(attr));
                 let field = naming::rust_ident_field(crate::attr::name(attr));
                 if let Some(matched) = matched {
                     let matched_type = crate::attr::type_name(matched);
                     let attr_type = crate::attr::type_name(attr);
                     if crate::attr::optional(matched) {
-                        if crate::attr::list(attr) && !crate::shared::list_attr_creation_optional(aggregate, crate::attr::name(attr), value_objects_by_name) {
-                            format!("            {field}: args.{field}.clone().unwrap_or_default(),")
+                        if crate::attr::list(attr)
+                            && !crate::shared::list_attr_creation_optional(
+                                aggregate,
+                                crate::attr::name(attr),
+                            )
+                        {
+                            format!(
+                                "            {field}: args.{field}.clone().unwrap_or_default(),"
+                            )
                         } else if crate::attr::list(attr) || matched_type == attr_type {
                             format!("            {field}: args.{field}.clone(),")
                         } else {
                             // A cross-aggregate argument named like the owner's field but of
                             // another type needs a bridge.
-                            format!("            {field}: {},", mutations::optional_value_rhs(&format!("args.{field}"), matched_type, attr_type, value_objects_by_name))
+                            format!(
+                                "            {field}: {},",
+                                mutations::optional_value_rhs(
+                                    &format!("args.{field}"),
+                                    matched_type,
+                                    attr_type,
+                                    value_objects_by_name
+                                )
+                            )
                         }
                     } else if crate::attr::list(attr) || matched_type == attr_type {
                         if crate::attr::list(attr) {
@@ -529,15 +908,23 @@ pub fn emit_command(exemplar: &Exemplar, command: &Json, aggregate: &Json, domai
                             format!("            {field}: Some(args.{field}.clone()),")
                         }
                     } else {
-                        format!("            {field}: Some({}),", crate::bridging::value_rhs(&format!("args.{field}"), matched_type, attr_type, value_objects_by_name))
+                        format!(
+                            "            {field}: Some({}),",
+                            crate::bridging::value_rhs(
+                                &format!("args.{field}"),
+                                matched_type,
+                                attr_type,
+                                value_objects_by_name
+                            )
+                        )
                     }
                 } else if crate::attr::list(attr) {
                     format!("            {field}: vec![],")
                 } else {
-                    match crate::bridging::creation_default_rhs(attr, value_objects_by_name) {
-                        Some(rhs) => format!("            {field}: Some({rhs}),"),
-                        None => format!("            {field}: None,"),
-                    }
+                    crate::bridging::creation_default_rhs(attr, value_objects_by_name).map_or_else(
+                        || format!("            {field}: None,"),
+                        |rhs| format!("            {field}: Some({rhs}),"),
+                    )
                 }
             })
             .collect();
@@ -545,14 +932,25 @@ pub fn emit_command(exemplar: &Exemplar, command: &Json, aggregate: &Json, domai
         if let Some(lifecycle) = aggregate.get("lifecycle") {
             let field = lifecycle.get("field").and_then(Json::as_str).unwrap_or("");
             let default = lifecycle.get("default").map(Json::to_s).unwrap_or_default();
-            record_fields.push(format!("            {}: {}.to_string(),", naming::rust_ident_field(field), naming::ruby_inspect_string(&default)));
+            record_fields.push(format!(
+                "            {}: {}.to_string(),",
+                naming::rust_ident_field(field),
+                naming::ruby_inspect_string(&default)
+            ));
         }
         for ev in crate::bridging::correctable_event_names(aggregate) {
-            record_fields.push(format!("            {}: false,", crate::bridging::corrects_flag_field(&ev)));
+            record_fields.push(format!(
+                "            {}: false,",
+                crate::bridging::corrects_flag_field(&ev)
+            ));
         }
 
         // Mirrors `CommandInterpreter#step_hydrate`: `complete_state? && state_independent?`.
-        let state_independent = crate::dependency_planning::state_independent_creation(aggregate, command, value_objects_by_name);
+        let state_independent = crate::dependency_planning::state_independent_creation(
+            aggregate,
+            command,
+            value_objects_by_name,
+        );
         let create_block = format!(
             "crate::kernel::Hydrate::Create {{\n        id: __hydrate_id,\n        build: Box::new(|| {record} {{\n{}\n        }}),\n        state_independent: {state_independent},\n    }}",
             record_fields.join("\n")
@@ -560,7 +958,11 @@ pub fn emit_command(exemplar: &Exemplar, command: &Json, aggregate: &Json, domai
 
         // A route on a creating command is checked against its derived identity (`TypeMismatch`)
         // only when `complete_state_creation` holds; otherwise it forces find-or-`NotFound`.
-        let complete_state = crate::dependency_planning::complete_state_creation(aggregate, command, value_objects_by_name);
+        let complete_state = crate::dependency_planning::complete_state_creation(
+            aggregate,
+            command,
+            value_objects_by_name,
+        );
         let derived_id_expr = mutations::build_identity_expr(&identity);
         let route_mismatch_message = format!(
             "{} routes to {{:?}}, but its identity facts name {{:?}}",
@@ -584,7 +986,7 @@ pub fn emit_command(exemplar: &Exemplar, command: &Json, aggregate: &Json, domai
         sig_parts.extend(identity_extra_params.iter().cloned());
         sig_parts.push(format!("args: {cmd}Args"));
         sig_parts.push("mutations: &mut Vec<crate::kernel::MutationRecord>".to_string());
-        sig_parts.extend(deref_params().iter().map(|s| s.to_string()));
+        sig_parts.extend(deref_params().iter().map(std::string::ToString::to_string));
         sig_parts.push(TENANT_BOUNDARY_PARAM.to_string());
         fn_signature = sig_parts.join(", ");
     } else {
@@ -594,15 +996,20 @@ pub fn emit_command(exemplar: &Exemplar, command: &Json, aggregate: &Json, domai
             format!("args: {cmd}Args"),
             "mutations: &mut Vec<crate::kernel::MutationRecord>".to_string(),
         ];
-        sig_parts.extend(deref_params().iter().map(|s| s.to_string()));
+        sig_parts.extend(deref_params().iter().map(std::string::ToString::to_string));
         sig_parts.push(TENANT_BOUNDARY_PARAM.to_string());
         hydrate = "crate::kernel::Hydrate::Act { id: id.to_string() }".to_string();
         fn_signature = sig_parts.join(", ");
     }
 
     let emits_expr = match &delegation {
-        Some(d) => d.emits.iter().map(|e| naming::ruby_inspect_string(e)).collect::<Vec<_>>().join(", "),
-        None => command.get("emits").map(Json::each).unwrap_or(&[]).iter().map(|e| naming::ruby_inspect_string(&e.to_s())).collect::<Vec<_>>().join(", "),
+        Some(d) => d
+            .emits
+            .iter()
+            .map(|e| naming::ruby_inspect_string(e))
+            .collect::<Vec<_>>()
+            .join(", "),
+        None => emits_expr_of(command),
     };
 
     let dispatch_fn = exemplar.render(
@@ -635,85 +1042,145 @@ pub fn emit_command(exemplar: &Exemplar, command: &Json, aggregate: &Json, domai
         ],
     );
 
-    format!("{}\n\n#[derive(Debug, Clone)]\n{}\n\n{dispatch_fn}", crate::fielded::emit_fielded_flat(exemplar, &format!("{cmd}Args"), attrs, value_objects_by_name, &[]), args_struct.join("\n"))
+    format!(
+        "{}\n\n#[derive(Debug, Clone)]\n{}\n\n{dispatch_fn}",
+        crate::fielded::emit_fielded_flat(
+            exemplar,
+            &format!("{cmd}Args"),
+            attrs,
+            value_objects_by_name,
+            &[]
+        ),
+        args_struct
+    )
 }
 
 /// The `:delegate` mutation (`delegates_to`).
 fn delegate_of(command: &Json) -> Option<&Json> {
-    command.get("mutations").map(Json::each).unwrap_or(&[]).iter().find(|m| m.get("op").map(Json::to_s).unwrap_or_default() == "delegate")
+    command
+        .get("mutations")
+        .map_or_default(Json::each)
+        .iter()
+        .find(|m| m.get("op").map(Json::to_s).unwrap_or_default() == "delegate")
 }
 
 fn delegate_mapping(delegation: &Json) -> Vec<(String, String)> {
     match delegation.get("fields") {
-        Some(Json::Object(pairs)) => pairs.iter().map(|(k, v)| (k.clone(), v.to_s().trim_start_matches(':').to_string())).collect(),
+        Some(Json::Object(pairs)) => pairs
+            .iter()
+            .map(|(k, v)| (k.clone(), v.to_s().trim_start_matches(':').to_string()))
+            .collect(),
         _ => Vec::new(),
     }
 }
 
-fn delegate_target<'a>(delegation: &Json, aggregate: &'a Json) -> (Option<&'a Json>, Option<&'a Json>) {
+fn delegate_target<'a>(
+    delegation: &Json,
+    aggregate: &'a Json,
+) -> (Option<&'a Json>, Option<&'a Json>) {
     let target = delegation.get("target").map(Json::to_s).unwrap_or_default();
-    let (entity_name, command_name) = match target.rfind('.') {
-        Some(dot) => (&target[..dot], &target[dot + 1..]),
-        None => ("", target.as_str()),
-    };
-    let entity = aggregate.get("entities").map(Json::each).unwrap_or(&[]).iter().find(|e| e.get("name").map(Json::to_s).unwrap_or_default() == entity_name);
-    let command = entity.and_then(|e| e.get("commands").map(Json::each).unwrap_or(&[]).iter().find(|c| c.get("name").map(Json::to_s).unwrap_or_default() == command_name));
+    let (entity_name, command_name) = target.rfind('.').map_or(("", target.as_str()), |dot| {
+        (&target[..dot], &target[dot + 1..])
+    });
+    let entity = aggregate
+        .get("entities")
+        .map_or_default(Json::each)
+        .iter()
+        .find(|e| e.get("name").map(Json::to_s).unwrap_or_default() == entity_name);
+    let command = entity.and_then(|e| {
+        e.get("commands")
+            .map_or_default(Json::each)
+            .iter()
+            .find(|c| c.get("name").map(Json::to_s).unwrap_or_default() == command_name)
+    });
     (entity, command)
 }
 
-pub fn delegate_skip_reason(command: &Json, aggregate: &Json, value_objects_by_name: &HashMap<String, &Json>) -> Option<String> {
+pub fn delegate_skip_reason(
+    command: &Json,
+    aggregate: &Json,
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> Option<String> {
     let delegation = delegate_of(command)?;
-    let label = format!("delegates_to {}", delegation.get("target").map(Json::to_s).unwrap_or_default());
-    if command.get("mutations").map(Json::each).unwrap_or(&[]).len() > 1 {
+    let label = format!(
+        "delegates_to {}",
+        delegation.get("target").map(Json::to_s).unwrap_or_default()
+    );
+    if command.get("mutations").map_or_default(Json::each).len() > 1 {
         return Some(format!("{label} alongside other sets — not generated yet"));
     }
     let (entity, target) = delegate_target(delegation, aggregate);
     let Some(entity) = entity else {
-        return Some(format!("{label}: {} has no such entity", aggregate.get("name").map(Json::to_s).unwrap_or_default()));
+        return Some(format!(
+            "{label}: {} has no such entity",
+            aggregate.get("name").map(Json::to_s).unwrap_or_default()
+        ));
     };
     let entity_name = entity.get("name").map(Json::to_s).unwrap_or_default();
     let Some(target) = target else {
         return Some(format!("{label}: {entity_name} declares no such command"));
     };
     if !crate::json_codec::extract_id_supported(entity) {
-        return Some(format!("{label}: {entity_name} cannot be addressed by identity"));
+        return Some(format!(
+            "{label}: {entity_name} cannot be addressed by identity"
+        ));
     }
     if let Some(problem) = entity_command_skip_reason(target, entity, value_objects_by_name) {
         return Some(format!("{label}: {problem}"));
     }
     let mapping = delegate_mapping(delegation);
-    let source_name_for = |name: &str| mapping.iter().find(|(t, _)| t == name).map(|(_, s)| s.clone()).unwrap_or_else(|| name.to_string());
-    let argument_attrs = command.get("attributes").map(Json::each).unwrap_or(&[]);
-    for attr in target.get("attributes").map(Json::each).unwrap_or(&[]) {
+    let source_name_for = |name: &str| {
+        mapping
+            .iter()
+            .find(|(t, _)| t == name)
+            .map_or_else(|| name.to_string(), |(_, s)| s.clone())
+    };
+    let argument_attrs = command.get("attributes").map_or_default(Json::each);
+    for attr in target.get("attributes").map_or_default(Json::each) {
         let name = crate::attr::name(attr);
         let source_name = source_name_for(name);
-        let source = argument_attrs.iter().find(|a| crate::attr::name(a) == source_name);
+        let source = argument_attrs
+            .iter()
+            .find(|a| crate::attr::name(a) == source_name);
         let Some(source) = source else {
             if crate::attr::optional(attr) {
                 continue;
             }
-            return Some(format!("{label}: target argument {name} has no source on the entry point"));
+            return Some(format!(
+                "{label}: target argument {name} has no source on the entry point"
+            ));
         };
         if crate::attr::list(source) != crate::attr::list(attr) {
             return Some(format!("{label}: entry point argument {source_name} is a list, target wants a scalar (or vice versa) — not generated yet"));
         }
         // Bridgeable, not exact type-name equality: the alias-then-deserialize delegate never
         // compares declared type names (docs/decisions/0045).
-        if !crate::bridging::bridgeable_value_types(crate::attr::type_name(source), crate::attr::type_name(attr), value_objects_by_name) {
+        if !crate::bridging::bridgeable_value_types(
+            crate::attr::type_name(source),
+            crate::attr::type_name(attr),
+            value_objects_by_name,
+        ) {
             return Some(format!("{label}: entry point argument {source_name} is {}, target wants {} — not generated yet", crate::attr::type_name(source), crate::attr::type_name(attr)));
         }
         if crate::attr::optional(source) && !crate::attr::optional(attr) {
-            return Some(format!("{label}: optional entry point argument {source_name} feeds required {name}"));
+            return Some(format!(
+                "{label}: optional entry point argument {source_name} feeds required {name}"
+            ));
         }
     }
-    for path in entity.get("identified_by").map(Json::each).unwrap_or(&[]) {
+    for path in entity.get("identified_by").map_or_default(Json::each) {
         let path = path.to_s();
         let head = path.split('.').next().unwrap_or("").to_string();
         let source_name = source_name_for(&head);
-        if argument_attrs.iter().any(|a| crate::attr::name(a) == source_name && !crate::attr::optional(a)) {
+        if argument_attrs
+            .iter()
+            .any(|a| crate::attr::name(a) == source_name && !crate::attr::optional(a))
+        {
             continue;
         }
-        return Some(format!("{label}: the element's identity {head} has no source on the entry point"));
+        return Some(format!(
+            "{label}: the element's identity {head} has no source on the entry point"
+        ));
     }
     None
 }
@@ -727,30 +1194,59 @@ struct Delegation {
 }
 
 fn indent_block(text: &str, indent: &str) -> String {
-    text.lines().map(|l| format!("{indent}{l}")).collect::<Vec<_>>().join("\n").trim_end().to_string()
+    text.lines()
+        .map(|l| format!("{indent}{l}"))
+        .collect::<Vec<_>>()
+        .join("\n")
+        .trim_end()
+        .to_string()
 }
 
-fn delegation_of(exemplar: &Exemplar, command: &Json, aggregate: &Json, value_objects_by_name: &HashMap<String, &Json>, domain_name: &str) -> Option<Delegation> {
+#[allow(
+    clippy::expect_used,
+    clippy::panic,
+    reason = "a drifted exemplar or invalid IR aborts generation on purpose; the message names an invariant an earlier check in this generator established"
+)]
+fn delegation_of(
+    exemplar: &Exemplar,
+    command: &Json,
+    aggregate: &Json,
+    value_objects_by_name: &HashMap<String, &Json>,
+    domain_name: &str,
+) -> Option<Delegation> {
     let delegation = delegate_of(command)?;
     let (entity, target) = delegate_target(delegation, aggregate);
-    let (entity, target) = (entity.expect("delegate_skip_reason admitted the entity"), target.expect("delegate_skip_reason admitted the target"));
+    let (entity, target) = (
+        entity.expect("delegate_skip_reason admitted the entity"),
+        target.expect("delegate_skip_reason admitted the target"),
+    );
     let entity_name = entity.get("name").map(Json::to_s).unwrap_or_default();
     let aggregate_name = aggregate.get("name").map(Json::to_s).unwrap_or_default();
     let list_attr = aggregate
         .get("attributes")
-        .map(Json::each)
-        .unwrap_or(&[])
+        .map_or_default(Json::each)
         .iter()
         .find(|a| crate::attr::list(a) && crate::attr::type_name(a) == entity_name)
         .unwrap_or_else(|| panic!("{entity_name}: no list attribute on {aggregate_name} holds it"));
 
     let element_record = naming::rust_ident(&entity_name);
-    let target_args_name = format!("{element_record}{}EntityArgs", naming::rust_ident(&target.get("name").map(Json::to_s).unwrap_or_default()));
-    let aliases: Vec<String> = delegate_mapping(delegation).iter().map(|(t, s)| format!("({}, {})", naming::ruby_inspect_string(t), naming::ruby_inspect_string(s))).collect();
+    let target_args_name = format!(
+        "{element_record}{}EntityArgs",
+        naming::rust_ident(&target.get("name").map(Json::to_s).unwrap_or_default())
+    );
+    let aliases: Vec<String> = delegate_mapping(delegation)
+        .iter()
+        .map(|(t, s)| {
+            format!(
+                "({}, {})",
+                naming::ruby_inspect_string(t),
+                naming::ruby_inspect_string(s)
+            )
+        })
+        .collect();
     let given_specs: Vec<String> = target
         .get("givens")
-        .map(Json::each)
-        .unwrap_or(&[])
+        .map_or_default(Json::each)
         .iter()
         .map(|g| {
             let description = g.get("description").and_then(Json::as_str).unwrap_or("");
@@ -760,55 +1256,103 @@ fn delegation_of(exemplar: &Exemplar, command: &Json, aggregate: &Json, value_ob
         .collect();
     let ensures_specs: Vec<String> = target
         .get("ensures")
-        .map(Json::each)
-        .unwrap_or(&[])
+        .map_or_default(Json::each)
         .iter()
         .map(|e| {
             let description = e.get("description").and_then(Json::as_str).unwrap_or("");
-            let ast = e.get("ast").unwrap_or_else(|| panic!("ensures row has no ast: {e:?}"));
-            format!("            crate::kernel::EnsuresSpec {{ description: {}, expr: {} }},", naming::ruby_inspect_string(description), crate::expr_emitter::emit_ast(ast))
+            let ast = e
+                .get("ast")
+                .unwrap_or_else(|| panic!("ensures row has no ast: {e:?}"));
+            format!(
+                "            crate::kernel::EnsuresSpec {{ description: {}, expr: {} }},",
+                naming::ruby_inspect_string(description),
+                crate::expr_emitter::emit_ast(ast)
+            )
         })
         .collect();
     let transition = mutations::lifecycle_transition_for(target, entity);
     let transition_arg = mutations::transition_check_arg(transition.as_ref());
     let mut mutation_lines: Vec<String> = target
         .get("mutations")
-        .map(Json::each)
-        .unwrap_or(&[])
+        .map_or_default(Json::each)
         .iter()
-        .map(|m| mutations::emit_mutation_line(exemplar, m, entity, target, value_objects_by_name, false))
+        .map(|m| {
+            mutations::emit_mutation_line(exemplar, m, entity, target, value_objects_by_name, false)
+        })
         .collect();
-    if mutations::reads_pre_state(target.get("mutations").map(Json::each).unwrap_or(&[])) {
+    if mutations::reads_pre_state(target.get("mutations").map_or_default(Json::each)) {
         mutation_lines.insert(0, mutations::pre_state_line());
     }
     if let Some(t) = &transition {
         if !t.to_state.is_empty() {
-            mutation_lines.push(format!("        record.{} = {}.to_string();", naming::rust_ident_field(&t.field), naming::ruby_inspect_string(&t.to_state)));
+            mutation_lines.push(format!(
+                "        record.{} = {}.to_string();",
+                naming::rust_ident_field(&t.field),
+                naming::ruby_inspect_string(&t.to_state)
+            ));
         }
     }
     if mutation_lines.is_empty() {
         mutation_lines = vec!["        let _ = record;".to_string()];
     }
-    let identity_reading = entity.get("identified_by").map(Json::each).unwrap_or(&[]).iter().map(Json::to_s).collect::<Vec<_>>().join(", ");
+    let identity_reading = entity
+        .get("identified_by")
+        .map_or_default(Json::each)
+        .iter()
+        .map(Json::to_s)
+        .collect::<Vec<_>>()
+        .join(", ");
 
-    let prelude = exemplar.render("delegate_prelude", &[("tmpl_aliases_placeholder()", aliases.join(", ")), ("TmplTargetArgs", target_args_name)]);
-    let element = exemplar.render("delegate_element", &[("TmplElement", element_record.clone())]);
+    let prelude = exemplar.render(
+        "delegate_prelude",
+        &[
+            ("tmpl_aliases_placeholder()", aliases.join(", ")),
+            ("TmplTargetArgs", target_args_name),
+        ],
+    );
+    let element = exemplar.render(
+        "delegate_element",
+        &[("TmplElement", element_record.clone())],
+    );
     let apply = exemplar.render(
         "delegate_apply",
         &[
             ("TmplRecord", naming::rust_ident(&aggregate_name)),
-            ("tmpl_list_field", naming::rust_ident_field(crate::attr::name(list_attr))),
+            (
+                "tmpl_list_field",
+                naming::rust_ident_field(crate::attr::name(list_attr)),
+            ),
             ("TmplElement", element_record),
             // Bare, not entity-qualified: it feeds refusal-message text, as in Ruby.
-            ("\"TmplQualifiedCommandName\"", naming::ruby_inspect_string(&target.get("name").map(Json::to_s).unwrap_or_default())),
+            (
+                "\"TmplQualifiedCommandName\"",
+                naming::ruby_inspect_string(
+                    &target.get("name").map(Json::to_s).unwrap_or_default(),
+                ),
+            ),
             // Lets `apply_entity_command` (kernel/dispatch.rs) judge `corrects` admissibility.
-            ("\"TmplQualifiedName\"", naming::ruby_inspect_string(&format!("{domain_name}::{aggregate_name}"))),
-            ("\"TmplAggregateName\"", naming::ruby_inspect_string(&aggregate_name)),
-            ("\"TmplEntityName\"", naming::ruby_inspect_string(&entity_name)),
-            ("\"TmplEntityIdentityReading\"", naming::ruby_inspect_string(&identity_reading)),
+            (
+                "\"TmplQualifiedName\"",
+                naming::ruby_inspect_string(&format!("{domain_name}::{aggregate_name}")),
+            ),
+            (
+                "\"TmplAggregateName\"",
+                naming::ruby_inspect_string(&aggregate_name),
+            ),
+            (
+                "\"TmplEntityName\"",
+                naming::ruby_inspect_string(&entity_name),
+            ),
+            (
+                "\"TmplEntityIdentityReading\"",
+                naming::ruby_inspect_string(&identity_reading),
+            ),
             ("tmpl_given_spec_placeholder(),", given_specs.join("\n")),
             ("tmpl_transition_placeholder()", transition_arg),
-            ("tmpl_entity_mutation_lines_placeholder(record);", mutation_lines.join("\n")),
+            (
+                "tmpl_entity_mutation_lines_placeholder(record);",
+                mutation_lines.join("\n"),
+            ),
             ("tmpl_ensures_spec_placeholder(),", ensures_specs.join("\n")),
         ],
     );
@@ -816,16 +1360,30 @@ fn delegation_of(exemplar: &Exemplar, command: &Json, aggregate: &Json, value_ob
         prelude: indent_block(&prelude, "    "),
         element: indent_block(&element, "        "),
         apply: indent_block(&apply, "        "),
-        emits: target.get("emits").map(Json::each).unwrap_or(&[]).iter().map(Json::to_s).collect(),
+        emits: target
+            .get("emits")
+            .map_or_default(Json::each)
+            .iter()
+            .map(Json::to_s)
+            .collect(),
     })
 }
 
 /// `command_skip_reason` for an entity command; an entity has the same IR shape as an aggregate.
-pub fn entity_command_skip_reason(command: &Json, entity: &Json, value_objects_by_name: &HashMap<String, &Json>) -> Option<SkipReason> {
+pub fn entity_command_skip_reason(
+    command: &Json,
+    entity: &Json,
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> Option<SkipReason> {
     command_skip_reason_with(command, entity, value_objects_by_name, false)
 }
 
 /// Emits the dispatch function for an entity command.
+#[allow(clippy::too_many_arguments)] // established emitter signature
+#[allow(
+    clippy::panic,
+    reason = "a drifted exemplar or invalid IR aborts generation on purpose"
+)]
 pub fn emit_entity_command(
     exemplar: &Exemplar,
     command: &Json,
@@ -836,135 +1394,180 @@ pub fn emit_entity_command(
     aggregates_by_name: &HashMap<String, &Json>,
     process_managers: &[Json],
 ) -> String {
-    let parent_record = naming::rust_ident(parent_aggregate.get("name").and_then(Json::as_str).unwrap_or(""));
-    let element_record = naming::rust_ident(entity.get("name").and_then(Json::as_str).unwrap_or(""));
-    let cmd = naming::rust_ident(command.get("name").and_then(Json::as_str).unwrap_or(""));
+    let parent_record = naming::rust_ident(name_of(parent_aggregate));
+    let element_record = naming::rust_ident(name_of(entity));
+    let cmd = naming::rust_ident(name_of(command));
 
-    let aggregate_name = parent_aggregate.get("name").and_then(Json::as_str).unwrap_or("").to_string();
-    let parent_identity_reading = parent_aggregate.get("identified_by").map(Json::each).unwrap_or(&[]).iter().map(Json::to_s).collect::<Vec<_>>().join(", ");
-    let entity_name = entity.get("name").and_then(Json::as_str).unwrap_or("").to_string();
-    let entity_identity_reading = entity.get("identified_by").map(Json::each).unwrap_or(&[]).iter().map(Json::to_s).collect::<Vec<_>>().join(", ");
+    let aggregate_name = name_of(parent_aggregate).to_string();
+    let parent_identity_reading = identity_reading(parent_aggregate);
+    let entity_name = name_of(entity).to_string();
+    let entity_identity_reading = identity_reading(entity);
 
-    let parent_attrs = parent_aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
-    let list_attr = parent_attrs
-        .iter()
-        .find(|a| crate::attr::list(a) && crate::attr::type_name(a) == entity.get("name").and_then(Json::as_str).unwrap_or(""))
-        .unwrap_or_else(|| panic!("{entity_name}: no list attribute on {aggregate_name} holds it — unsupported_attribute_types should have caught this"));
-    let list_field = naming::rust_ident_field(crate::attr::name(list_attr));
+    let list_field = list_field_of(parent_aggregate, entity);
     let args_struct_name = format!("{element_record}{cmd}EntityArgs");
 
-    let attrs = command.get("attributes").map(Json::each).unwrap_or(&[]);
-    let mut args_struct = vec![format!("pub struct {args_struct_name} {{")];
-    for attr in attrs {
-        let mut ty = naming::rust_type(crate::attr::type_name(attr), crate::attr::list(attr));
-        if crate::attr::optional(attr) {
-            ty = format!("Option<{ty}>");
-        }
-        args_struct.push(format!("    {}", exemplar.render("struct_field", &[("TmplFieldType", ty), ("tmpl_field", naming::rust_ident_field(crate::attr::name(attr)))])));
-    }
-    args_struct.push("}".to_string());
+    let attrs = command.get("attributes").map_or_default(Json::each);
+    let args_struct = args_struct_text(exemplar, &args_struct_name, attrs);
 
-    let invariant_checks = invariant_checks_for(exemplar, command, aggregates_by_name, value_objects_by_name);
+    let invariant_checks =
+        invariant_checks_for(exemplar, command, aggregates_by_name, value_objects_by_name);
 
     // `corrects_given_specs` is prepended as in `emit_command`; `apply_entity_command` evaluates
     // it against the parent record, never the entity's element.
-    let givens = command.get("givens").map(Json::each).unwrap_or(&[]);
     let mut given_specs: Vec<String> = crate::bridging::corrects_given_specs(command);
-    given_specs.extend(givens.iter().map(|g| {
-        let description = g.get("description").and_then(Json::as_str).unwrap_or("");
-        let ast = g.get("ast").unwrap_or_else(|| panic!("given row has no ast: {g:?}"));
-        format!("            crate::kernel::GivenSpec {{ description: {}, expr: {}, corrects_event: None }},", naming::ruby_inspect_string(description), crate::expr_emitter::emit_ast(ast))
-    }));
-
-    let ensures = command.get("ensures").map(Json::each).unwrap_or(&[]);
-    let ensures_specs: Vec<String> = ensures
-        .iter()
-        .map(|e| {
-            let description = e.get("description").and_then(Json::as_str).unwrap_or("");
-            let ast = e.get("ast").unwrap_or_else(|| panic!("ensures row has no ast: {e:?}"));
-            format!("            crate::kernel::EnsuresSpec {{ description: {}, expr: {} }},", naming::ruby_inspect_string(description), crate::expr_emitter::emit_ast(ast))
-        })
-        .collect();
+    given_specs.extend(given_spec_lines(command, "            "));
+    let ensures_specs = ensures_spec_lines(command, "            ");
 
     let transition = mutations::lifecycle_transition_for(command, entity);
     let transition_arg = mutations::transition_check_arg(transition.as_ref());
 
-    let mutations_list = command.get("mutations").map(Json::each).unwrap_or(&[]);
-    let mut mutation_lines: Vec<String> = mutations_list.iter().map(|m| mutations::emit_mutation_line(exemplar, m, entity, command, value_objects_by_name, false)).collect();
+    let mutations_list = command.get("mutations").map_or_default(Json::each);
+    let mut mutation_lines: Vec<String> = mutations_list
+        .iter()
+        .map(|m| {
+            mutations::emit_mutation_line(
+                exemplar,
+                m,
+                entity,
+                command,
+                value_objects_by_name,
+                false,
+            )
+        })
+        .collect();
     if mutations::reads_pre_state(mutations_list) {
         mutation_lines.insert(0, mutations::pre_state_line());
     }
-    if let Some(t) = &transition {
-        if !t.to_state.is_empty() {
-            mutation_lines.push(format!("        record.{} = {}.to_string();", naming::rust_ident_field(&t.field), naming::ruby_inspect_string(&t.to_state)));
-        }
-    }
-    if mutation_lines.is_empty() {
-        mutation_lines = vec!["        let _ = record;".to_string()];
-    }
+    let mutation_lines = close_mutation_lines(mutation_lines, transition.as_ref(), "        ");
 
     // Bare, not entity-qualified, as in `delegate_apply`.
-    let qualified_command_name = command.get("name").and_then(Json::as_str).unwrap_or("").to_string();
-    let emits = command.get("emits").map(Json::each).unwrap_or(&[]);
-    let emits_expr = emits.iter().map(|e| naming::ruby_inspect_string(&e.to_s())).collect::<Vec<_>>().join(", ");
+    let qualified_command_name = name_of(command).to_string();
+    let emits_expr = emits_expr_of(command);
 
     let entity_dispatch_fn = exemplar.render(
         "entity_dispatch_fn",
         &[
-            ("dispatch_entity_tmpl", format!("dispatch_entity_{}_{}", entity.get("name").and_then(Json::as_str).unwrap_or("").to_lowercase(), naming::dispatch_fn_name(&cmd))),
+            (
+                "dispatch_entity_tmpl",
+                format!(
+                    "dispatch_entity_{}_{}",
+                    entity
+                        .get("name")
+                        .and_then(Json::as_str)
+                        .unwrap_or("")
+                        .to_lowercase(),
+                    naming::dispatch_fn_name(&cmd)
+                ),
+            ),
             ("TmplRecord", parent_record),
             ("TmplArgs", args_struct_name.clone()),
-            ("tmpl_deref_params_placeholder: ()", deref_params().join(", ")),
-            ("tmpl_invariant_check_placeholder()?;", invariant_checks.join("\n")),
-            ("let tmpl_eval_fielded = tmpl_with_references_placeholder();", with_references_binding()),
+            (
+                "tmpl_deref_params_placeholder: ()",
+                deref_params().join(", "),
+            ),
+            (
+                "tmpl_invariant_check_placeholder()?;",
+                invariant_checks.join("\n"),
+            ),
+            (
+                "let tmpl_eval_fielded = tmpl_with_references_placeholder();",
+                with_references_binding(),
+            ),
             ("&tmpl_eval_fielded,", "&with_references,".to_string()),
-            ("let tmpl_seed_projections = tmpl_seed_projections_placeholder();", seed_projections_binding(parent_aggregate)),
+            (
+                "let tmpl_seed_projections = tmpl_seed_projections_placeholder();",
+                seed_projections_binding(parent_aggregate),
+            ),
             ("tmpl_seed_projections,", "seed_projections,".to_string()),
             ("tmpl_list_field", list_field),
             ("TmplElement", element_record),
-            ("\"TmplQualifiedCommandName\"", naming::ruby_inspect_string(&qualified_command_name)),
-            ("\"TmplQualifiedName\"", naming::ruby_inspect_string(&format!("{domain_name}::{aggregate_name}"))),
-            ("\"TmplAggregateName\"", naming::ruby_inspect_string(&aggregate_name)),
-            ("\"TmplParentIdentityReading\"", naming::ruby_inspect_string(&parent_identity_reading)),
-            ("\"TmplEntityName\"", naming::ruby_inspect_string(&entity_name)),
-            ("\"TmplEntityIdentityReading\"", naming::ruby_inspect_string(&entity_identity_reading)),
+            (
+                "\"TmplQualifiedCommandName\"",
+                naming::ruby_inspect_string(&qualified_command_name),
+            ),
+            (
+                "\"TmplQualifiedName\"",
+                naming::ruby_inspect_string(&format!("{domain_name}::{aggregate_name}")),
+            ),
+            (
+                "\"TmplAggregateName\"",
+                naming::ruby_inspect_string(&aggregate_name),
+            ),
+            (
+                "\"TmplParentIdentityReading\"",
+                naming::ruby_inspect_string(&parent_identity_reading),
+            ),
+            (
+                "\"TmplEntityName\"",
+                naming::ruby_inspect_string(&entity_name),
+            ),
+            (
+                "\"TmplEntityIdentityReading\"",
+                naming::ruby_inspect_string(&entity_identity_reading),
+            ),
             ("tmpl_given_spec_placeholder(),", given_specs.join("\n")),
             ("tmpl_transition_placeholder()", transition_arg),
-            ("tmpl_entity_mutation_lines_placeholder(record);", mutation_lines.join("\n")),
+            (
+                "tmpl_entity_mutation_lines_placeholder(record);",
+                mutation_lines.join("\n"),
+            ),
             ("tmpl_ensures_spec_placeholder(),", ensures_specs.join("\n")),
-            ("tmpl_invariants_placeholder()", format!("{}()", invariants_fn_name(parent_aggregate))),
+            (
+                "tmpl_invariants_placeholder()",
+                format!("{}()", invariants_fn_name(parent_aggregate)),
+            ),
             ("tmpl_emit_placeholder()", emits_expr),
         ],
     );
 
     [
-        crate::fielded::emit_fielded_flat(exemplar, &args_struct_name, attrs, value_objects_by_name, &[]),
-        format!("#[derive(Debug, Clone)]\n{}", args_struct.join("\n")),
-        crate::json_codec::emit_to_json_flat_sparse(exemplar, &args_struct_name, attrs, value_objects_by_name),
+        crate::fielded::emit_fielded_flat(
+            exemplar,
+            &args_struct_name,
+            attrs,
+            value_objects_by_name,
+            &[],
+        ),
+        format!("#[derive(Debug, Clone)]\n{args_struct}"),
+        crate::json_codec::emit_to_json_flat_sparse(exemplar, &args_struct_name, attrs),
         {
             // `unknown_argument_allowlist:` as for an aggregate command, plus the entity's
             // identity head (`extra_identity_heads:` in Ruby's `ArgumentGate`).
-            let entity_identity_heads: Vec<String> = entity
-                .get("identified_by")
-                .map(Json::each)
-                .unwrap_or(&[])
-                .iter()
-                .map(|p| p.to_s().split('.').next().unwrap_or("").to_string())
-                .collect();
-            let allowlist = crate::json_codec::command_argument_allowlist(parent_aggregate, command, process_managers, &entity_identity_heads);
-            crate::json_codec::emit_from_json_flat(exemplar, &args_struct_name, attrs, value_objects_by_name, Some(&allowlist), Some(&qualified_command_name), true, true, Some(aggregates_by_name))
+            let entity_identity_heads = identity_heads(entity);
+            let allowlist = crate::json_codec::command_argument_allowlist(
+                parent_aggregate,
+                command,
+                process_managers,
+                &entity_identity_heads,
+            );
+            crate::json_codec::emit_from_json_flat(
+                exemplar,
+                &args_struct_name,
+                attrs,
+                value_objects_by_name,
+                Some(&allowlist),
+                Some(&qualified_command_name),
+                true,
+                true,
+                Some(aggregates_by_name),
+                None,
+            )
         },
         // Argument gates, run by `kernel::decode_entity_arguments` in `EntityStep::ORDER`.
         {
-            let entity_identity_heads: Vec<String> = entity
-                .get("identified_by")
-                .map(Json::each)
-                .unwrap_or(&[])
-                .iter()
-                .map(|p| p.to_s().split('.').next().unwrap_or("").to_string())
-                .collect();
-            let allowlist = crate::json_codec::command_argument_allowlist(parent_aggregate, command, process_managers, &entity_identity_heads);
-            crate::json_codec::emit_argument_gates(&args_struct_name, &qualified_command_name, attrs, Some(&allowlist))
+            let entity_identity_heads = identity_heads(entity);
+            let allowlist = crate::json_codec::command_argument_allowlist(
+                parent_aggregate,
+                command,
+                process_managers,
+                &entity_identity_heads,
+            );
+            crate::json_codec::emit_argument_gates(
+                &args_struct_name,
+                &qualified_command_name,
+                attrs,
+                Some(&allowlist),
+            )
         },
         entity_dispatch_fn,
     ]
@@ -973,6 +1576,11 @@ pub fn emit_entity_command(
 
 /// Emits the dispatch function for a command on an entity nested two levels deep.
 /// Takes plain `&str` ids per hop, so routed and flat-args callers can both use it.
+#[allow(clippy::too_many_arguments)] // established emitter signature
+#[allow(
+    clippy::panic,
+    reason = "a drifted exemplar or invalid IR aborts generation on purpose"
+)]
 pub fn emit_nested_entity_command(
     exemplar: &Exemplar,
     command: &Json,
@@ -984,96 +1592,66 @@ pub fn emit_nested_entity_command(
     aggregates_by_name: &HashMap<String, &Json>,
     process_managers: &[Json],
 ) -> String {
-    let parent_record = naming::rust_ident(parent_aggregate.get("name").and_then(Json::as_str).unwrap_or(""));
-    let entity_record = naming::rust_ident(entity.get("name").and_then(Json::as_str).unwrap_or(""));
-    let nested_record = naming::rust_ident(nested.get("name").and_then(Json::as_str).unwrap_or(""));
-    let cmd = naming::rust_ident(command.get("name").and_then(Json::as_str).unwrap_or(""));
-
-    let aggregate_name = parent_aggregate.get("name").and_then(Json::as_str).unwrap_or("").to_string();
-    let parent_identity_reading = parent_aggregate.get("identified_by").map(Json::each).unwrap_or(&[]).iter().map(Json::to_s).collect::<Vec<_>>().join(", ");
-    let entity_name = entity.get("name").and_then(Json::as_str).unwrap_or("").to_string();
-    let entity_identity_reading = entity.get("identified_by").map(Json::each).unwrap_or(&[]).iter().map(Json::to_s).collect::<Vec<_>>().join(", ");
-    let nested_name = nested.get("name").and_then(Json::as_str).unwrap_or("").to_string();
-    let nested_identity_reading = nested.get("identified_by").map(Json::each).unwrap_or(&[]).iter().map(Json::to_s).collect::<Vec<_>>().join(", ");
-
-    let parent_attrs = parent_aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
-    let list_attr1 = parent_attrs
-        .iter()
-        .find(|a| crate::attr::list(a) && crate::attr::type_name(a) == entity.get("name").and_then(Json::as_str).unwrap_or(""))
-        .unwrap_or_else(|| panic!("{entity_name}: no list attribute on {aggregate_name} holds it — unsupported_attribute_types should have caught this"));
-    let list_field1 = naming::rust_ident_field(crate::attr::name(list_attr1));
+    let parent_record = naming::rust_ident(name_of(parent_aggregate));
+    let entity_record = naming::rust_ident(name_of(entity));
+    let nested_record = naming::rust_ident(name_of(nested));
+    let cmd = naming::rust_ident(name_of(command));
 
-    let entity_attrs = entity.get("attributes").map(Json::each).unwrap_or(&[]);
-    let list_attr2 = entity_attrs
-        .iter()
-        .find(|a| crate::attr::list(a) && crate::attr::type_name(a) == nested.get("name").and_then(Json::as_str).unwrap_or(""))
-        .unwrap_or_else(|| panic!("{nested_name}: no list attribute on {entity_name} holds it — unsupported_attribute_types should have caught this"));
-    let list_field2 = naming::rust_ident_field(crate::attr::name(list_attr2));
+    let aggregate_name = name_of(parent_aggregate).to_string();
+    let parent_identity_reading = identity_reading(parent_aggregate);
+    let entity_name = name_of(entity).to_string();
+    let entity_identity_reading = identity_reading(entity);
+    let nested_name = name_of(nested).to_string();
+    let nested_identity_reading = identity_reading(nested);
 
-    let args_struct_name = format!("{nested_record}{cmd}NestedEntityArgs");
+    let list_field1 = list_field_of(parent_aggregate, entity);
+    let list_field2 = list_field_of(entity, nested);
 
-    let attrs = command.get("attributes").map(Json::each).unwrap_or(&[]);
-    let mut args_struct = vec![format!("pub struct {args_struct_name} {{")];
-    for attr in attrs {
-        let mut ty = naming::rust_type(crate::attr::type_name(attr), crate::attr::list(attr));
-        if crate::attr::optional(attr) {
-            ty = format!("Option<{ty}>");
-        }
-        args_struct.push(format!("    {}", exemplar.render("struct_field", &[("TmplFieldType", ty), ("tmpl_field", naming::rust_ident_field(crate::attr::name(attr)))])));
-    }
-    args_struct.push("}".to_string());
+    let args_struct_name = format!("{nested_record}{cmd}NestedEntityArgs");
 
-    let invariant_checks = invariant_checks_for(exemplar, command, aggregates_by_name, value_objects_by_name);
+    let attrs = command.get("attributes").map_or_default(Json::each);
+    let args_struct = args_struct_text(exemplar, &args_struct_name, attrs);
 
-    let givens = command.get("givens").map(Json::each).unwrap_or(&[]);
-    let given_specs: Vec<String> = givens
-        .iter()
-        .map(|g| {
-            let description = g.get("description").and_then(Json::as_str).unwrap_or("");
-            let ast = g.get("ast").unwrap_or_else(|| panic!("given row has no ast: {g:?}"));
-            format!("                    crate::kernel::GivenSpec {{ description: {}, expr: {}, corrects_event: None }},", naming::ruby_inspect_string(description), crate::expr_emitter::emit_ast(ast))
-        })
-        .collect();
+    let invariant_checks =
+        invariant_checks_for(exemplar, command, aggregates_by_name, value_objects_by_name);
 
-    let ensures = command.get("ensures").map(Json::each).unwrap_or(&[]);
-    let ensures_specs: Vec<String> = ensures
-        .iter()
-        .map(|e| {
-            let description = e.get("description").and_then(Json::as_str).unwrap_or("");
-            let ast = e.get("ast").unwrap_or_else(|| panic!("ensures row has no ast: {e:?}"));
-            format!("                    crate::kernel::EnsuresSpec {{ description: {}, expr: {} }},", naming::ruby_inspect_string(description), crate::expr_emitter::emit_ast(ast))
-        })
-        .collect();
+    let given_specs = given_spec_lines(command, "                    ");
+    let ensures_specs = ensures_spec_lines(command, "                    ");
 
     // The nested entity's lifecycle, as in `emit_entity_command`.
     let transition = mutations::lifecycle_transition_for(command, nested);
     let transition_arg = mutations::transition_check_arg(transition.as_ref());
 
-    let mutations_list = command.get("mutations").map(Json::each).unwrap_or(&[]);
-    let mut mutation_lines: Vec<String> = mutations_list.iter().map(|m| mutations::emit_mutation_line(exemplar, m, nested, command, value_objects_by_name, false)).collect();
+    let mutations_list = command.get("mutations").map_or_default(Json::each);
+    let mut mutation_lines: Vec<String> = mutations_list
+        .iter()
+        .map(|m| {
+            mutations::emit_mutation_line(
+                exemplar,
+                m,
+                nested,
+                command,
+                value_objects_by_name,
+                false,
+            )
+        })
+        .collect();
     if mutations::reads_pre_state(mutations_list) {
         mutation_lines.insert(0, mutations::pre_state_line());
     }
-    if let Some(t) = &transition {
-        if !t.to_state.is_empty() {
-            mutation_lines.push(format!("                record.{} = {}.to_string();", naming::rust_ident_field(&t.field), naming::ruby_inspect_string(&t.to_state)));
-        }
-    }
-    if mutation_lines.is_empty() {
-        mutation_lines = vec!["                let _ = record;".to_string()];
-    }
+    let mutation_lines =
+        close_mutation_lines(mutation_lines, transition.as_ref(), "                ");
 
     // Bare, as in `emit_entity_command`.
-    let qualified_command_name = command.get("name").and_then(Json::as_str).unwrap_or("").to_string();
+    let qualified_command_name = name_of(command).to_string();
     // The hop-2 `apply_entity_command` gets the root aggregate's qualified name only to satisfy
     // the signature: its `record` is the hop-1 entity, so `corrects` admissibility is not checked
     // there. Its trailing `parent_in_args` literal is `true`, byte for byte as Ruby emits.
-    let emits = command.get("emits").map(Json::each).unwrap_or(&[]);
-    let emits_expr = emits.iter().map(|e| naming::ruby_inspect_string(&e.to_s())).collect::<Vec<_>>().join(", ");
+    let emits_expr = emits_expr_of(command);
     let fn_name = format!(
         "dispatch_entity_{}_{}_{}",
-        entity.get("name").and_then(Json::as_str).unwrap_or("").to_lowercase(),
-        nested.get("name").and_then(Json::as_str).unwrap_or("").to_lowercase(),
+        name_of(entity).to_lowercase(),
+        name_of(nested).to_lowercase(),
         naming::dispatch_fn_name(&cmd)
     );
 
@@ -1154,48 +1732,76 @@ pub fn emit_nested_entity_command(
     );
 
     [
-        crate::fielded::emit_fielded_flat(exemplar, &args_struct_name, attrs, value_objects_by_name, &[]),
-        format!("#[derive(Debug, Clone)]\n{}", args_struct.join("\n")),
-        crate::json_codec::emit_to_json_flat_sparse(exemplar, &args_struct_name, attrs, value_objects_by_name),
+        crate::fielded::emit_fielded_flat(
+            exemplar,
+            &args_struct_name,
+            attrs,
+            value_objects_by_name,
+            &[],
+        ),
+        format!("#[derive(Debug, Clone)]\n{args_struct}"),
+        crate::json_codec::emit_to_json_flat_sparse(exemplar, &args_struct_name, attrs),
         {
             // Both hops' identity heads, as `ctx.chain.flat_map(&:identity_heads)` in Ruby.
             let mut identity_heads: Vec<String> = entity
                 .get("identified_by")
-                .map(Json::each)
-                .unwrap_or(&[])
+                .map_or_default(Json::each)
                 .iter()
                 .map(|p| p.to_s().split('.').next().unwrap_or("").to_string())
                 .collect();
             identity_heads.extend(
                 nested
                     .get("identified_by")
-                    .map(Json::each)
-                    .unwrap_or(&[])
+                    .map_or_default(Json::each)
                     .iter()
                     .map(|p| p.to_s().split('.').next().unwrap_or("").to_string()),
             );
-            let allowlist = crate::json_codec::command_argument_allowlist(parent_aggregate, command, process_managers, &identity_heads);
-            crate::json_codec::emit_from_json_flat(exemplar, &args_struct_name, attrs, value_objects_by_name, Some(&allowlist), Some(&qualified_command_name), true, true, Some(aggregates_by_name))
+            let allowlist = crate::json_codec::command_argument_allowlist(
+                parent_aggregate,
+                command,
+                process_managers,
+                &identity_heads,
+            );
+            crate::json_codec::emit_from_json_flat(
+                exemplar,
+                &args_struct_name,
+                attrs,
+                value_objects_by_name,
+                Some(&allowlist),
+                Some(&qualified_command_name),
+                true,
+                true,
+                Some(aggregates_by_name),
+                None,
+            )
         },
         // Argument gates, as in the one-hop entity command.
         {
             let mut identity_heads: Vec<String> = entity
                 .get("identified_by")
-                .map(Json::each)
-                .unwrap_or(&[])
+                .map_or_default(Json::each)
                 .iter()
                 .map(|p| p.to_s().split('.').next().unwrap_or("").to_string())
                 .collect();
             identity_heads.extend(
                 nested
                     .get("identified_by")
-                    .map(Json::each)
-                    .unwrap_or(&[])
+                    .map_or_default(Json::each)
                     .iter()
                     .map(|p| p.to_s().split('.').next().unwrap_or("").to_string()),
             );
-            let allowlist = crate::json_codec::command_argument_allowlist(parent_aggregate, command, process_managers, &identity_heads);
-            crate::json_codec::emit_argument_gates(&args_struct_name, &qualified_command_name, attrs, Some(&allowlist))
+            let allowlist = crate::json_codec::command_argument_allowlist(
+                parent_aggregate,
+                command,
+                process_managers,
+                &identity_heads,
+            );
+            crate::json_codec::emit_argument_gates(
+                &args_struct_name,
+                &qualified_command_name,
+                attrs,
+                Some(&allowlist),
+            )
         },
         nested_dispatch_fn,
     ]