hecks 3.9.1 → 3.11.0

data/rust/codegen/src/asks.rs

@@ -0,0 +1,103 @@
+//! Resolution of a policy's `ask :name` to the port operation the hecksagon declared for it,
+//! mirroring `Hecks::Bluebook::AskResolution`: by the event's aggregate and the ask's name, with
+//! `chosen` (`ask_via`) breaking a tie between ports.
+
+use crate::json::Json;
+use crate::naming;
+
+/// Policies whose `ask` is replaced by the `Aggregate::Port.Operation` trigger it resolves to,
+/// so every table below reads the verb as it reads a port-naming `trigger`.
+///
+/// Panics when an ask resolves to nothing or to several operations: the Ruby boot refuses both
+/// before the IR is ever exported.
+pub fn resolve_asks(policies: &[Json], aggregates: &[Json]) -> Vec<Json> {
+    policies
+        .iter()
+        .map(|policy| match policy.get("ask").map(Json::to_s) {
+            Some(ask) if !ask.is_empty() => with_trigger(policy, resolve(policy, &ask, aggregates)),
+            _ => policy.clone(),
+        })
+        .collect()
+}
+
+fn with_trigger(policy: &Json, verb: String) -> Json {
+    let mut resolved = policy.clone();
+    resolved.set("trigger_command", Json::String(verb));
+    resolved
+}
+
+fn resolve(policy: &Json, ask: &str, aggregates: &[Json]) -> String {
+    let name = policy.get("name").map(Json::to_s).unwrap_or_default();
+    let on_event = policy.get("on_event").map(Json::to_s).unwrap_or_default();
+    let aggregate = event_aggregate(&on_event, aggregates)
+        .unwrap_or_else(|| panic!("policy {name}: ask :{ask} reacts to {on_event:?}, whose aggregate is not declared"));
+    let agg_name = aggregate.get("name").map(Json::to_s).unwrap_or_default();
+    let mut found = candidates(aggregate, ask);
+    if found.len() > 1 && found.iter().any(|(_, op)| op.get("chosen").is_some_and(Json::as_bool)) {
+        found.retain(|(_, op)| op.get("chosen").is_some_and(Json::as_bool));
+    }
+    match found.as_slice() {
+        [(port, op)] => format!("{agg_name}::{port}.{}", op.get("name").map(Json::to_s).unwrap_or_default()),
+        [] => panic!("policy {name}: ask :{ask} matches no `asks` declared on {agg_name}"),
+        _ => panic!("policy {name}: ask :{ask} is asked on several ports of {agg_name}; pick one with ask_via"),
+    }
+}
+
+// The aggregate the event is qualified with, or else the one whose commands emit the bare event.
+fn event_aggregate<'a>(on_event: &str, aggregates: &'a [Json]) -> Option<&'a Json> {
+    let named = |wanted: &str| aggregates.iter().find(|a| a.get("name").map(Json::to_s).unwrap_or_default() == wanted);
+    match on_event.split_once('.') {
+        Some((qualifier, _)) => named(qualifier.rsplit("::").next().unwrap_or(qualifier)),
+        None => aggregates.iter().find(|a| {
+            a.get("commands")
+                .map(Json::each)
+                .unwrap_or(&[])
+                .iter()
+                .any(|c| c.get("emits").map(Json::to_s).unwrap_or_default() == on_event)
+        }),
+    }
+}
+
+// Every outbound operation of the aggregate's ports whose snake-cased name is the ask.
+fn candidates<'a>(aggregate: &'a Json, ask: &str) -> Vec<(String, &'a Json)> {
+    let mut found = Vec::new();
+    for port in aggregate.get("ports").map(Json::each).unwrap_or(&[]) {
+        let port_name = port.get("name").map(Json::to_s).unwrap_or_default();
+        for op in port.get("operations").map(Json::each).unwrap_or(&[]) {
+            let outbound = op.get("direction").map(Json::to_s).as_deref() == Some("outbound");
+            let spelled = naming::snake(&op.get("name").map(Json::to_s).unwrap_or_default());
+            if outbound && spelled == ask {
+                found.push((port_name.clone(), op));
+            }
+        }
+    }
+    found
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+
+    // The neutral corpus fixture `spec/corpus/asks/errand.json`: the Ruby spec holds the same
+    // `targets` against the Ruby runtime's reaction log, so the two cannot drift.
+    fn corpus(name: &str) -> Json {
+        let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../spec/corpus/asks").join(name);
+        Json::parse(&std::fs::read_to_string(path).expect("corpus file")).expect("corpus json")
+    }
+
+    #[test]
+    fn every_ask_resolves_to_the_target_the_corpus_freezes() {
+        let ir = corpus("errand.ir.json");
+        let expect = corpus("errand.json");
+        let domain = ir.get("name").map(Json::to_s).unwrap_or_default();
+        let resolved = resolve_asks(ir.get("policies").unwrap().each(), ir.get("aggregates").unwrap().each());
+
+        for policy in &resolved {
+            let name = policy.get("name").map(Json::to_s).unwrap_or_default();
+            let target = format!("{domain}::{}", policy.get("trigger_command").map(Json::to_s).unwrap_or_default());
+            let frozen = expect.get("targets").and_then(|t| t.get(&name)).map(Json::to_s);
+            assert_eq!(frozen, Some(target), "{name}");
+        }
+    }
+}

data/rust/codegen/src/bridging.rs

@@ -29,7 +29,7 @@ pub fn cross_aggregate_vo_imports(aggregate: &Json, domain_value_object_owner: &
 
     let mut pairs: Vec<(String, String)> = foreign_types.into_iter().filter_map(|type_name| domain_value_object_owner.get(&type_name).map(|owner| (type_name, owner.clone()))).collect();
     pairs.sort_by(|(a_type, a_owner), (b_type, b_owner)| (a_owner, a_type).cmp(&(b_owner, b_type)));
-    pairs.into_iter().map(|(type_name, owner)| format!("use crate::generated::{mod_name}::{}::{};", owner.to_lowercase(), naming::rust_ident(&type_name))).collect()
+    pairs.into_iter().map(|(type_name, owner)| format!("use crate::generated::{mod_name}::{}::{};", naming::aggregate_module(&owner), naming::rust_ident(&type_name))).collect()
 }
 
 /// True when a value object rebuilds into a differently-named one by matching field names.

data/rust/codegen/src/commands.rs

@@ -168,6 +168,11 @@ fn command_skip_reason_with(command: &Json, aggregate: &Json, value_objects_by_n
         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);
+    if !expression_problems.is_empty() {
+        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);
     if !remove_problems.is_empty() {
         return Some(skip("remove_field", format!("sets remove field(s): {}", remove_problems.join("; "))));
@@ -678,37 +683,37 @@ pub fn delegate_skip_reason(command: &Json, aggregate: &Json, value_objects_by_n
     }
     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 door_attrs = command.get("attributes").map(Json::each).unwrap_or(&[]);
+    let argument_attrs = command.get("attributes").map(Json::each).unwrap_or(&[]);
     for attr in target.get("attributes").map(Json::each).unwrap_or(&[]) {
         let name = crate::attr::name(attr);
         let source_name = source_name_for(name);
-        let source = door_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 door"));
+            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}: door argument {source_name} is a list, target wants a scalar (or vice versa) — not generated yet"));
+            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) {
-            return Some(format!("{label}: door argument {source_name} is {}, target wants {} — not generated yet", crate::attr::type_name(source), crate::attr::type_name(attr)));
+            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 door 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(&[]) {
         let path = path.to_s();
         let head = path.split('.').next().unwrap_or("").to_string();
         let source_name = source_name_for(&head);
-        if door_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 door"));
+        return Some(format!("{label}: the element's identity {head} has no source on the entry point"));
     }
     None
 }

data/rust/codegen/src/constraints.rs

@@ -107,3 +107,28 @@ pub fn emit_pattern_check(exemplar: &Exemplar, value_expr: &str, attr: &Json, ow
     );
     Some(wrap_if_optional(check, optional_source))
 }
+
+/// A `pattern:` on a list of Strings, checked once per member: Ruby's `check_patterns` walks
+/// `offered_items`, so every element of the list must match, and an optional list left unset has
+/// none to check. Lists of anything but plain Strings get no check.
+pub fn emit_list_pattern_check(exemplar: &Exemplar, value_expr: &str, attr: &Json, owner_type_name: &str) -> Option<String> {
+    let pattern = crate::attr::pattern(attr)?;
+    if !crate::attr::list(attr) || naming::effective_scalar_type(crate::attr::type_name(attr)) != Some("String") {
+        return None;
+    }
+
+    let check = exemplar.render(
+        "pattern_check",
+        &[
+            ("\"tmpl_pattern_text\"", naming::ruby_inspect_string(pattern)),
+            ("tmpl_scalar", "item".to_string()),
+            ("\"tmpl_pattern_owner\"", naming::ruby_inspect_string(owner_type_name)),
+            ("\"tmpl_pattern_field\"", naming::ruby_inspect_string(crate::attr::name(attr))),
+        ],
+    );
+    Some(if crate::attr::optional(attr) {
+        format!("if let Some(items) = &{value_expr} {{ for item in items {{ {check} }} }}")
+    } else {
+        format!("for item in &{value_expr} {{ {check} }}")
+    })
+}

data/rust/codegen/src/domain_generator.rs

@@ -85,8 +85,8 @@ fn reference_checks(
                 target_mod: target
                     .get("name")
                     .and_then(Json::as_str)
-                    .unwrap_or("")
-                    .to_lowercase(),
+                    .map(crate::naming::aggregate_module)
+                    .unwrap_or_default(),
                 target_name: target
                     .get("name")
                     .and_then(Json::as_str)
@@ -161,8 +161,8 @@ fn state_reference_checks(
                 target_mod: target
                     .get("name")
                     .and_then(Json::as_str)
-                    .unwrap_or("")
-                    .to_lowercase(),
+                    .map(crate::naming::aggregate_module)
+                    .unwrap_or_default(),
                 target_name: target
                     .get("name")
                     .and_then(Json::as_str)
@@ -225,7 +225,7 @@ fn tenant_boundary_checks(
 
             Some(TenantBoundaryCheck {
                 reference_field: crate::attr::name(attr).to_string(),
-                target_mod: target_decl_name.to_lowercase(),
+                target_mod: crate::naming::aggregate_module(&target_decl_name),
                 target_name: target_decl_name,
                 aggregate_name: aggregate_name.clone(),
                 own_tenant_field: own_tenant_field.clone(),
@@ -289,6 +289,8 @@ pub fn generate(
     source_label: &str,
     mod_name: &str,
 ) -> GeneratedDomain {
+    let resolved_ir = types::with_resolved_projection_types(ir);
+    let ir = &resolved_ir;
     let domain_name = ir.get("name").and_then(Json::as_str).unwrap_or("");
     let all_aggregates = ir.get("aggregates").map(Json::each).unwrap_or(&[]);
     let aggregates_by_name: HashMap<String, &Json> = all_aggregates
@@ -1036,13 +1038,13 @@ pub fn generate(
         }
 
         aggregate_files.push(GeneratedFile {
-            name: format!("{}.rs", agg_name.to_lowercase()),
+            name: format!("{}.rs", crate::naming::aggregate_module(agg_name)),
             content: out,
         });
 
         registry_aggregates.push(AggregateEntry {
             name: agg_name.to_string(),
-            module_name: agg_name.to_lowercase(),
+            module_name: crate::naming::aggregate_module(agg_name),
             record: record_name,
             commands: registry_commands,
             entity_commands,
@@ -1092,7 +1094,7 @@ pub fn generate(
             query_defs.push(queries::QueryDef {
                 verb: format!("{domain_name}::{agg_name}.{query_name}"),
                 aggregate: format!("{domain_name}::{agg_name}"),
-                arg_checks: queries::query_arg_checks(query, &format!("crate::generated::{mod_name}::{}", agg_name.to_lowercase()), &value_objects_by_name),
+                arg_checks: queries::query_arg_checks(query, &format!("crate::generated::{mod_name}::{}", crate::naming::aggregate_module(agg_name)), &value_objects_by_name),
                 conditions,
                 reference_hop_conditions,
                 order_by: query.get("order_by").map(|ob| queries::emit_query_order_by(ob, query.get("null_semantics"))),
@@ -1273,7 +1275,7 @@ pub fn generate(
     puts_str(&mut mod_rs, "pub mod metadata;");
     puts_str(&mut mod_rs, "pub mod registry;");
     for a in &registry_aggregates {
-        puts_str(&mut mod_rs, &format!("pub mod {};", a.name.to_lowercase()));
+        puts_str(&mut mod_rs, &format!("pub mod {};", a.module_name));
     }
 
     GeneratedDomain {

data/rust/codegen/src/expr_emitter.rs

@@ -23,6 +23,9 @@ pub fn emit_ast(node: &Json) -> String {
         "nil" => "Expr::Nil".to_string(),
         "lookup" => format!("Expr::Lookup({})", ruby_inspect_string(&path_of(node, op).join("."))),
         "add" => format!("Expr::Add({}, {})", boxed("left"), boxed("right")),
+        "sub" => format!("Expr::Sub({}, {})", boxed("left"), boxed("right")),
+        "mul" => format!("Expr::Mul({}, {})", boxed("left"), boxed("right")),
+        "div" => format!("Expr::Div({}, {})", boxed("left"), boxed("right")),
         "sign_test" => format!("Expr::SignTest {{ op: {}, receiver: {} }}", emit_comparison(field(node, op, "cmp")), boxed("receiver")),
         "empty" => format!("Expr::Empty({})", boxed("receiver")),
         "to_s" => format!("Expr::ToS({})", boxed("receiver")),
@@ -50,6 +53,7 @@ pub fn emit_ast(node: &Json) -> String {
         "presence" => format!("Expr::Presence {{ receiver: {}, negated: {} }}", boxed("receiver"), field(node, op, "negated").to_s()),
         "assignment" => format!("Expr::Assignment {{ receiver: {}, negated: {} }}", boxed("receiver"), field(node, op, "negated").to_s()),
         "split" => format!("Expr::Split {{ receiver: {}, separator: {}.to_string() }}", boxed("receiver"), text("separator")),
+        "strip" => format!("Expr::Strip {{ receiver: {}, side: crate::kernel::StripSide::{} }}", boxed("receiver"), strip_side(node, op)),
         "starts_with" => format!("Expr::StartsWith {{ receiver: {}, substring: {}.to_string() }}", boxed("receiver"), text("substring")),
         "ends_with" => format!("Expr::EndsWith {{ receiver: {}, substring: {}.to_string() }}", boxed("receiver"), text("substring")),
         "first" => format!("Expr::First({})", boxed("receiver")),
@@ -77,6 +81,15 @@ fn path_of(node: &Json, op: &str) -> Vec<String> {
         .collect()
 }
 
+fn strip_side(node: &Json, op: &str) -> &'static str {
+    match field(node, op, "side").as_str() {
+        Some("both") => "Both",
+        Some("left") => "Left",
+        Some("right") => "Right",
+        other => panic!("strip's side {other:?} is none of both/left/right: {node:?}"),
+    }
+}
+
 fn block_mode(node: &Json, op: &str) -> &'static str {
     match field(node, op, "mode").as_str() {
         Some("all") => "All",

data/rust/codegen/src/json_codec.rs

@@ -17,20 +17,22 @@ pub fn list_shape_error(struct_name: &str, key: &str, element_type: &str, value_
     format!("crate::kernel::Refusal::TypeMismatch(format!({}, {value_var}.inspect()))", naming::ruby_inspect_string(&template))
 }
 
-// A String field refuses only composite-shaped (or null) values, as Ruby's
-// `Value::Coercion#check_scalar_shapes` does; the offered shape is only known at runtime.
+// A String field refuses any value that is not a String, and an Integer or Float field any that
+// is not a number, as Ruby's `Value::Coercion#check_scalar_shapes` and `check_numeric_item!`
+// do; the offered shape is only known at runtime, so the message renders it. A whole number
+// beyond signed 64 bits words as Ruby's `integer_range` site.
 pub fn scalar_type_error(struct_name: &str, key: &str, scalar_type: &str, value_var: &str) -> String {
     if scalar_type != "Integer" && scalar_type != "Float" && scalar_type != "String" {
         return json_type_error(struct_name, key, scalar_type);
     }
     let template = format!("{struct_name}.{key} expects {scalar_type}, got {{}}");
     let proper = format!("crate::kernel::Refusal::TypeMismatch(format!({}, {value_var}.inspect()))", naming::ruby_inspect_string(&template));
-    if scalar_type != "String" {
+    if scalar_type != "Integer" {
         return proper;
     }
-    let generic = json_type_error(struct_name, key, scalar_type);
-    // `Json::Null` words like a composite: Ruby's `check_required_fields` says "got nil".
-    format!("if matches!({value_var}, crate::kernel::Json::Array(_) | crate::kernel::Json::Object(_) | crate::kernel::Json::Null) {{ {proper} }} else {{ {generic} }}")
+    let range_template = format!("{struct_name}.{key} must fit in a 64-bit integer, got {{}}");
+    let range = format!("crate::kernel::Refusal::TypeMismatch(format!({}, {value_var}.inspect()))", naming::ruby_inspect_string(&range_template));
+    format!("if matches!({value_var}, crate::kernel::Json::Num(n, _) if n.is_finite() && n.fract() == 0.0 && n.abs() >= 9.223372036854775808e18) {{ {range} }} else {{ {proper} }}")
 }
 
 /// A missing non-optional field refuses as "{type}.{field} expects {expected}, got nil".
@@ -274,6 +276,9 @@ pub fn emit_from_json_flat(
     aggregates_by_name: Option<&HashMap<String, &Json>>,
 ) -> String {
     let command_name = command_name.unwrap_or(struct_name);
+    // A refusal names the command (`Write.slugs expects ...`), as Ruby's `Value.for_attribute`
+    // does, not the generated `WriteArgs` struct that holds its arguments.
+    let error_name = if struct_name == format!("{command_name}Args") { command_name } else { struct_name };
     let idents: Vec<String> = attributes.iter().map(|attr| naming::rust_ident_field(crate::attr::name(attr))).collect();
     let field_exprs: Vec<String> = attributes
         .iter()
@@ -285,33 +290,33 @@ pub fn emit_from_json_flat(
             let optional = crate::attr::optional(attr);
 
             let rhs = if list && optional {
-                let mapper = list_element_from_json_mapper(struct_name, &key, attr, value_objects_by_name);
-                let array_error = json_type_error(struct_name, &key, "an array");
+                let mapper = list_element_from_json_mapper(error_name, &key, attr, value_objects_by_name);
+                let array_error = json_type_error(error_name, &key, "an array");
                 format!(
                     "match v.get({}) {{ Some(crate::kernel::Json::Null) | None => None, Some(x) => Some(x.as_array().ok_or_else(|| {array_error})?.iter().map({mapper}).collect::<Result<Vec<_>, crate::kernel::Refusal>>()?) }}",
                     naming::ruby_inspect_string(&key)
                 )
             } else if list {
-                let mapper = list_element_from_json_mapper(struct_name, &key, attr, value_objects_by_name);
+                let mapper = list_element_from_json_mapper(error_name, &key, attr, value_objects_by_name);
                 // A list argument is an array: a lone scalar is refused, as Ruby's
                 // `Value.refuse_scalar_list` does; null and an absent key are the empty list.
-                let shape_error = list_shape_error(struct_name, &key, crate::attr::type_name(attr), "x");
+                let shape_error = list_shape_error(error_name, &key, crate::attr::type_name(attr), "x");
                 format!(
                     "match v.get({}) {{ Some(crate::kernel::Json::Null) | None => Vec::new(), Some(x) => x.as_array().ok_or_else(|| {shape_error})?.iter().map({mapper}).collect::<Result<Vec<_>, crate::kernel::Refusal>>()?, }}",
                     naming::ruby_inspect_string(&key)
                 )
             } else if optional && scalar.is_some() {
                 // An optional argument offered as null is the same absence as an omitted key.
-                format!("match v.get({}) {{ Some(crate::kernel::Json::Null) | None => None, Some(x) => Some({}) }}", naming::ruby_inspect_string(&key), scalar_from_json_value_expr(struct_name, &key, scalar.unwrap(), "x"))
+                format!("match v.get({}) {{ Some(crate::kernel::Json::Null) | None => None, Some(x) => Some({}) }}", naming::ruby_inspect_string(&key), scalar_from_json_value_expr(error_name, &key, scalar.unwrap(), "x"))
             } else if optional {
                 format!("match v.get({}) {{ Some(crate::kernel::Json::Null) | None => None, Some(x) => Some({}) }}", naming::ruby_inspect_string(&key), composite_from_json_expr(attr, value_objects_by_name, "x"))
             } else if let Some(scalar) = scalar {
-                scalar_from_json_expr(struct_name, &key, scalar, crate::attr::default(attr))
+                scalar_from_json_expr(error_name, &key, scalar, crate::attr::default(attr))
             } else if absent_argument_check {
-                // The argument door only; see `required_composite_argument_expr`.
-                required_composite_argument_expr(struct_name, &key, attr, value_objects_by_name)
+                // The argument entry point only; see `required_composite_argument_expr`.
+                required_composite_argument_expr(error_name, &key, attr, value_objects_by_name)
             } else {
-                composite_from_json_expr(attr, value_objects_by_name, &required_field_expr(struct_name, &key, crate::attr::type_name(attr)))
+                composite_from_json_expr(attr, value_objects_by_name, &required_field_expr(error_name, &key, crate::attr::type_name(attr)))
             };
 
             if interleave_checks {
@@ -588,6 +593,35 @@ pub fn emit_closed_set_table_codec(exemplar: &Exemplar, vo: &Json) -> String {
         })
         .collect();
 
+    let type_name = vo.get("name").and_then(Json::as_str).unwrap_or("").to_string();
+    let field_names: Vec<String> = attributes.iter().map(|attr| naming::ruby_inspect_string(&naming::rust_field(crate::attr::name(attr)))).collect();
+    // A field left out (or null) refuses as "{type}.{field} expects {expected}, got nil", before
+    // membership is judged.
+    let absent_checks: Vec<String> = attributes
+        .iter()
+        .map(|attr| {
+            let key = naming::rust_field(crate::attr::name(attr));
+            let message = format!("{type_name}.{} expects {}, got nil", crate::attr::name(attr), crate::attr::type_name(attr));
+            format!(
+                "        if matches!(v.get({}), None | Some(crate::kernel::Json::Null)) {{\n            return Err(crate::kernel::Refusal::TypeMismatch({}.to_string()));\n        }}",
+                naming::ruby_inspect_string(&key),
+                naming::ruby_inspect_string(&message)
+            )
+        })
+        .collect();
+    // The refusal quotes the first column of every row, as Ruby's `refuse_non_member!` does.
+    let admitted: Vec<String> = vo
+        .get("members")
+        .map(Json::each)
+        .unwrap_or(&[])
+        .iter()
+        .map(|row| {
+            let first = row.as_array().unwrap_or(&[]).first().and_then(Json::as_array).unwrap_or(&[]);
+            naming::ruby_inspect_string(&first.get(1).map(Json::to_s).unwrap_or_default())
+        })
+        .collect();
+    let first_field = attributes.first().map(|attr| naming::rust_field(crate::attr::name(attr))).unwrap_or_default();
+
     exemplar.render(
         "closed_set_table_codec",
         &[
@@ -595,6 +629,11 @@ pub fn emit_closed_set_table_codec(exemplar: &Exemplar, vo: &Json) -> String {
             ("tmpl_to_json_fields_block()", to_json_fields_block),
             ("TMPL_TABLE", const_name),
             ("tmpl_from_json_conditions()", match_conditions.join(" && ")),
+            ("\"tmpl_table_type\"", naming::ruby_inspect_string(&type_name)),
+            ("TMPL_DECLARED_NAMES", format!("[{}]", field_names.join(", "))),
+            ("TMPL_ADMITTED", format!("[{}]", admitted.join(", "))),
+            ("tmpl_absent_field_checks();", absent_checks.join("\n")),
+            ("\"tmpl_first_field\"", naming::ruby_inspect_string(&first_field)),
         ],
     )
 }

data/rust/codegen/src/main.rs

@@ -3,6 +3,7 @@
 // Some ported `naming.rs` helpers are not called yet.
 #![allow(dead_code)]
 
+mod asks;
 mod attr;
 mod bridging;
 mod commands;
@@ -73,7 +74,7 @@ fn run_prelude(args: &[String]) -> Result<(), String> {
         let name = aggregate.get("name").and_then(Json::as_str).unwrap_or("");
         match prelude::aggregate_prelude(&ex, &ir, aggregate, source_label) {
             Some(text) => {
-                let path = format!("{out_dir}/{}.rs", name.to_lowercase());
+                let path = format!("{out_dir}/{}.rs", naming::aggregate_module(name));
                 std::fs::write(&path, text).map_err(|e| format!("writing {path}: {e}"))?;
                 println!("wrote {path}");
             }