hecks 3.10.0 → 3.12.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/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

@@ -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

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;

data/rust/codegen/src/mutations.rs

@@ -176,10 +176,11 @@ pub fn append_field_source(source: &str) -> Literal {
     literal::read(source)
 }
 
-/// Whether any effect reads the record's own state, so the closure must bind `let pre`.
+/// Whether any effect reads the record's own state (a `state(:field)` source, or an expression that
+/// may name a field), so the closure must bind `let pre`.
 pub fn reads_pre_state(mutations: &[Json]) -> bool {
     mutations.iter().any(|m| match m.get("op").map(Json::to_s).unwrap_or_default().as_str() {
-        "set" => m.get("source").and_then(|s| s.get("kind")).map(Json::to_s).unwrap_or_default() == "state",
+        "set" => matches!(m.get("source").and_then(|s| s.get("kind")).map(Json::to_s).unwrap_or_default().as_str(), "state" | "expression"),
         "append" => match m.get("fields") {
             Some(Json::Object(pairs)) => pairs.iter().any(|(_, source)| source.to_s().starts_with("state(:")),
             _ => false,
@@ -251,6 +252,66 @@ pub fn state_source_problems(command: &Json, aggregate: &Json, value_objects_by_
         .collect()
 }
 
+/// Problems with `set` mutations sourced from arithmetic: the target must be a scalar
+/// (non-list) attribute typed by a single-field Integer or Float value object, the one shape the
+/// generated code can rebuild a computed number into.
+pub fn expression_source_problems(command: &Json, aggregate: &Json, value_objects_by_name: &HashMap<String, &Json>) -> Vec<String> {
+    let attrs = aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
+    command
+        .get("mutations")
+        .map(Json::each)
+        .unwrap_or(&[])
+        .iter()
+        .filter(|m| m.get("op").map(Json::to_s).as_deref() == Some("set"))
+        .filter(|m| m.get("source").and_then(|s| s.get("kind")).map(Json::to_s).as_deref() == Some("expression"))
+        .filter_map(|m| {
+            let target = m.get("target").map(Json::to_s).unwrap_or_default();
+            let attr = attrs.iter().find(|a| crate::attr::name(a) == target);
+            match attr.and_then(|a| computed_field_type(a, value_objects_by_name)) {
+                Some(_) => None,
+                None => Some(format!("{target}: a computed value needs a scalar attribute typed by a single-field Integer or Float value object — not generated yet")),
+            }
+        })
+        .collect()
+}
+
+// The scalar type (`Integer` or `Float`) of the one field of a non-list, single-field value object.
+fn computed_field_type<'a>(attr: &Json, value_objects_by_name: &HashMap<String, &'a Json>) -> Option<(&'a Json, &'static str)> {
+    if crate::attr::list(attr) {
+        return None;
+    }
+    let vo = value_objects_by_name.get(crate::attr::type_name(attr)).copied()?;
+    let fields = vo.get("attributes").map(Json::each).unwrap_or(&[]);
+    if vo.get("closed_set").map(Json::as_bool).unwrap_or(false) || fields.len() != 1 || crate::attr::list(&fields[0]) {
+        return None;
+    }
+    match crate::attr::type_name(&fields[0]) {
+        "Integer" => Some((vo, "Integer")),
+        "Float" => Some((vo, "Float")),
+        _ => None,
+    }
+}
+
+/// Right-hand side for a `set` sourced from arithmetic: evaluates the expression through the
+/// kernel over the command's arguments and then the pre-dispatch record, and rebuilds the number
+/// into the target's single-field value object. A fault returns from the mutation closure.
+pub fn expression_set_rhs(source: &Json, target_attr: &Json, value_objects_by_name: &HashMap<String, &Json>) -> String {
+    let (vo, scalar) = computed_field_type(target_attr, value_objects_by_name).expect("expression_source_problems already confirmed the target");
+    let ast = source.get("ast").expect("an expression source carries its ast");
+    let field = naming::rust_ident_field(crate::attr::name(&vo.get("attributes").map(Json::each).unwrap_or(&[])[0]));
+    let vo_type = naming::rust_ident(crate::attr::type_name(target_attr));
+    let arms = if scalar == "Integer" {
+        "crate::kernel::Value::Int(number) => number,".to_string()
+    } else {
+        "crate::kernel::Value::Float(number) => number,\n            crate::kernel::Value::Int(number) => number as f64,".to_string()
+    };
+    let target = crate::attr::name(target_attr);
+    format!(
+        "{{\n            let number = match crate::kernel::interpret(&{}, &crate::kernel::EvalContext {{ args: &args, instance: &pre }})? {{\n            {arms}\n            other => return Err(crate::kernel::Refusal::TypeMismatch(format!(\"{target} expects a {scalar}, computed {{other:?}}\"))),\n            }};\n            {vo_type} {{ {field}: number }}\n        }}",
+        crate::expr_emitter::emit_ast(ast)
+    )
+}
+
 fn state_source_problem(label: &str, state_name: &str, aggregate: &Json, target_attr: Option<&Json>) -> Option<String> {
     let attrs = aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
     let Some(state_attr) = attrs.iter().find(|a| crate::attr::name(a) == state_name) else {
@@ -722,8 +783,12 @@ fn emit_mutation_line_body(
             } else {
                 let attrs = aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
                 let target_attr = attrs.iter().find(|a| crate::attr::name(a) == target_name).expect("set target must be a declared aggregate attribute");
-                let rhs = mutation_set_rhs(mutation.get("source").unwrap_or(&Json::Null), crate::attr::type_name(target_attr), command, value_objects_by_name, crate::attr::list(target_attr));
                 let source = mutation.get("source");
+                let rhs = if source.and_then(|s| s.get("kind")).map(Json::to_s).as_deref() == Some("expression") {
+                    expression_set_rhs(source.unwrap(), target_attr, value_objects_by_name)
+                } else {
+                    mutation_set_rhs(mutation.get("source").unwrap_or(&Json::Null), crate::attr::type_name(target_attr), command, value_objects_by_name, crate::attr::list(target_attr))
+                };
                 let source_attr = if source.map(|s| s.get("kind").map(Json::to_s).unwrap_or_default()) == Some("argument".to_string()) {
                     let name = source.unwrap().get("name").map(Json::to_s).unwrap_or_default();
                     let cmd_attrs = command.get("attributes").map(Json::each).unwrap_or(&[]);
@@ -896,3 +961,63 @@ mod state_source_tests {
         assert!(!state_source_is_option(Some(&argument), &aggregate(), true));
     }
 }
+
+#[cfg(test)]
+mod expression_source_tests {
+    use super::*;
+
+    fn aggregate() -> Json {
+        Json::parse(r#"{"name":"Settlement","attributes":[
+            {"name":"paid","type":"Cents","list":false},
+            {"name":"refund","type":"Cents","list":false},
+            {"name":"note","type":"Note","list":false}]}"#)
+        .unwrap()
+    }
+
+    fn vos() -> Vec<Json> {
+        vec![
+            Json::parse(r#"{"name":"Cents","attributes":[{"name":"value","type":"Integer","list":false}]}"#).unwrap(),
+            Json::parse(r#"{"name":"Note","attributes":[{"name":"value","type":"String","list":false}]}"#).unwrap(),
+        ]
+    }
+
+    fn command(target: &str) -> Json {
+        let source = r#"{"kind":"expression","text":"paid * 2","ast":{"op":"mul","left":{"op":"lookup","path":["paid"]},"right":{"op":"int","value":2}}}"#;
+        Json::parse(&format!(r#"{{"mutations":[{{"target":"{target}","op":"set","source":{source}}}]}}"#)).unwrap()
+    }
+
+    fn by_name(vos: &[Json]) -> HashMap<String, &Json> {
+        vos.iter().map(|vo| (vo.get("name").map(Json::to_s).unwrap_or_default(), vo)).collect()
+    }
+
+    #[test]
+    fn an_expression_source_binds_the_pre_dispatch_record() {
+        assert!(reads_pre_state(command("refund").get("mutations").map(Json::each).unwrap_or(&[])));
+    }
+
+    #[test]
+    fn a_target_typed_by_an_integer_value_object_is_generated() {
+        let vos = vos();
+
+        assert!(expression_source_problems(&command("refund"), &aggregate(), &by_name(&vos)).is_empty());
+    }
+
+    #[test]
+    fn a_target_typed_by_a_text_value_object_is_not_generated_yet() {
+        let vos = vos();
+
+        assert_eq!(expression_source_problems(&command("note"), &aggregate(), &by_name(&vos)).len(), 1);
+    }
+
+    #[test]
+    fn the_right_hand_side_evaluates_through_the_kernel_and_rebuilds_the_value_object() {
+        let vos = vos();
+        let aggregate = aggregate();
+        let attrs = aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
+        let source = command("refund").get("mutations").map(Json::each).unwrap_or(&[])[0].get("source").cloned().unwrap();
+
+        let rhs = expression_set_rhs(&source, &attrs[1], &by_name(&vos));
+
+        assert!(rhs.contains("crate::kernel::interpret(&Expr::Mul(") && rhs.contains("Cents { value: number }"));
+    }
+}

data/rust/codegen/src/queries.rs

@@ -313,8 +313,17 @@ pub fn query_skip_reason(query: &Json, aggregate: &Json, value_objects_by_name:
     // field itself is validated afterward by `declared_authorization_skip_reason`.
     let declared_tenant = query.get("authorization").and_then(|a| a.get("tenant")).is_some();
     let wheres = query.get("wheres").map(Json::each).unwrap_or(&[]);
-    if wheres.is_empty() && !declared_tenant {
-        return Some(skip("no_wheres", "declares no where clauses at all — nothing for filter_entries to bake in"));
+    // A query with no `where` answers every record, ordered and bounded as declared, as Ruby's
+    // `QueryInterpreter` does. Ruby refuses at boot one that takes arguments yet filters, orders
+    // and bounds nothing (`Registry::QueryVerification#derivable?`: it reads none of them), so no
+    // answer exists to generate for it.
+    let selects_nothing = query.get("order_by").is_none() && query.get("limit").is_none() && query.get("offset").is_none();
+    let takes_arguments = query.get("attributes").map(Json::each).is_some_and(|attributes| !attributes.is_empty());
+    if wheres.is_empty() && !declared_tenant && selects_nothing && takes_arguments {
+        return Some(skip(
+            "no_wheres",
+            "takes arguments but declares no where, order_by, limit or offset — it selects nothing, so Ruby refuses it at boot and there is no answer to generate",
+        ));
     }
 
     for where_clause in wheres {

data/rust/codegen/src/reactions.rs

@@ -60,7 +60,7 @@ fn where_fns(policies: &[Json]) -> Vec<String> {
 }
 
 fn local_policy_rows(domain_name: &str, policies: &[Json], aggregates: &[Json]) -> Vec<String> {
-    policies
+    crate::asks::resolve_asks(policies, aggregates)
         .iter()
         .filter_map(|policy| {
             let target_domain = policy.get("target_domain").map(Json::to_s).unwrap_or_else(|| domain_name.to_string());