hecks 3.14.0 → 5.0.0

data/rust/codegen/src/queries.rs

@@ -4,8 +4,10 @@ use crate::exemplar::Exemplar;
 use crate::json::Json;
 use crate::literal::{self, Literal};
 use crate::naming;
+use crate::shared::ruby_to_i;
 use crate::skip_reason::{reskip, skip, SkipReason};
 use std::collections::HashMap;
+use std::fmt::Write as _;
 
 const COMPARATORS_NEEDING_NUMERIC_FIDELITY: &[&str] = &["gt", "gte", "lt", "lte"];
 const COMPARATORS_EXEMPT_FROM_LITERAL_TYPING: &[&str] = &["in", "contains"];
@@ -18,160 +20,198 @@ pub enum FieldKind {
     Unknown,
 }
 
+/// Where a dotted field path ends.
+enum PathEnd<'a> {
+    /// The path lands on a member of this type.
+    Type(&'a str),
+    /// The path's head is a list attribute.
+    HeadList,
+    /// The path names nothing: an undeclared attribute or member, a list member, or a step
+    /// through a type with no members (a scalar, or a reference, which is never a value object).
+    Broken,
+}
+
+/// Walks `field` from `aggregate`: its head names an attribute, and any later segments step
+/// through nested value objects. The one walk the kind, boolean and numeric classifiers share;
+/// each then judges the type it lands on.
+fn path_end<'a>(
+    aggregate: &'a Json,
+    field: &str,
+    value_objects_by_name: &HashMap<String, &'a Json>,
+) -> PathEnd<'a> {
+    let mut segments = field.split('.');
+    let head = segments.next().unwrap_or("");
+    let attrs = aggregate.get("attributes").map_or_default(Json::each);
+    let Some(attr) = attrs.iter().find(|a| crate::attr::name(a) == head) else {
+        return PathEnd::Broken;
+    };
+    if crate::attr::list(attr) {
+        return PathEnd::HeadList;
+    }
+    let mut type_name = crate::attr::type_name(attr);
+    for segment in segments {
+        let Some(vo) = value_objects_by_name.get(type_name) else {
+            return PathEnd::Broken;
+        };
+        let members = vo.get("attributes").map_or_default(Json::each);
+        let Some(member) = members.iter().find(|a| crate::attr::name(a) == segment) else {
+            return PathEnd::Broken;
+        };
+        if crate::attr::list(member) {
+            return PathEnd::Broken;
+        }
+        type_name = crate::attr::type_name(member);
+    }
+    PathEnd::Type(type_name)
+}
+
 /// Classifies `field`: its head names an attribute or the lifecycle field, and any
 /// later segments walk nested value objects.
-pub fn query_field_kind(aggregate: &Json, field: &str, value_objects_by_name: &HashMap<String, &Json>) -> FieldKind {
+pub fn query_field_kind(
+    aggregate: &Json,
+    field: &str,
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> FieldKind {
     let mut segments = field.split('.');
     let head = segments.next().unwrap_or("");
-    let rest: Vec<&str> = segments.collect();
 
-    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);
     if let Some(lf) = &lifecycle_field {
         if lf == head {
-            return if rest.is_empty() { FieldKind::String } else { FieldKind::Unknown };
+            return if segments.next().is_none() {
+                FieldKind::String
+            } else {
+                FieldKind::Unknown
+            };
         }
     }
 
-    let attrs = aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
-    let Some(attr) = attrs.iter().find(|a| crate::attr::name(a) == head) else { return FieldKind::Unknown };
-    if crate::attr::list(attr) {
-        return FieldKind::Other;
+    match path_end(aggregate, field, value_objects_by_name) {
+        PathEnd::HeadList => FieldKind::Other,
+        PathEnd::Broken => FieldKind::Unknown,
+        PathEnd::Type(type_name) => type_kind(type_name, value_objects_by_name),
     }
-
-    query_type_kind(crate::attr::type_name(attr), &rest, value_objects_by_name)
 }
 
-fn query_type_kind(type_name: &str, segments: &[&str], value_objects_by_name: &HashMap<String, &Json>) -> FieldKind {
+fn type_kind(type_name: &str, value_objects_by_name: &HashMap<String, &Json>) -> FieldKind {
     if naming::reference_type(type_name) {
-        return if segments.is_empty() { FieldKind::String } else { FieldKind::Unknown };
-    }
-
-    if segments.is_empty() {
-        return query_scalar_or_vo_kind(type_name, value_objects_by_name);
+        return FieldKind::String;
     }
-
-    let Some(vo) = value_objects_by_name.get(type_name) else { return FieldKind::Unknown };
-    let attrs = vo.get("attributes").map(Json::each).unwrap_or(&[]);
-    let Some(member) = attrs.iter().find(|a| crate::attr::name(a) == segments[0]) else { return FieldKind::Unknown };
-    if crate::attr::list(member) {
-        return FieldKind::Unknown;
-    }
-    query_type_kind(crate::attr::type_name(member), &segments[1..], value_objects_by_name)
+    query_scalar_or_vo_kind(type_name, value_objects_by_name)
 }
 
-fn query_scalar_or_vo_kind(type_name: &str, value_objects_by_name: &HashMap<String, &Json>) -> FieldKind {
+fn query_scalar_or_vo_kind(
+    type_name: &str,
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> FieldKind {
     match type_name {
         "String" => FieldKind::String,
         "Integer" | "Float" => FieldKind::Number,
         "TrueClass" | "FalseClass" => FieldKind::Other,
-        _ => match value_objects_by_name.get(type_name) {
-            Some(vo) => query_vo_collapse_kind(vo, value_objects_by_name),
-            None => FieldKind::Unknown,
-        },
+        _ => value_objects_by_name
+            .get(type_name)
+            .map_or(FieldKind::Unknown, |vo| {
+                query_vo_collapse_kind(vo, value_objects_by_name)
+            }),
     }
 }
 
 fn query_vo_collapse_kind(vo: &Json, value_objects_by_name: &HashMap<String, &Json>) -> FieldKind {
-    let attrs = vo.get("attributes").map(Json::each).unwrap_or(&[]);
-    if attrs.iter().any(|a| matches!(crate::attr::type_name(a), "Integer" | "Float")) {
+    let attrs = vo.get("attributes").map_or_default(Json::each);
+    if attrs
+        .iter()
+        .any(|a| matches!(crate::attr::type_name(a), "Integer" | "Float"))
+    {
         return FieldKind::Number;
     }
     if attrs.len() == 1 {
-        return query_type_kind(crate::attr::type_name(&attrs[0]), &[], value_objects_by_name);
+        return type_kind(crate::attr::type_name(&attrs[0]), value_objects_by_name);
     }
     FieldKind::Other
 }
 
 /// Whether a field (or dotted path) reduces specifically to a `TrueClass`/`FalseClass` —
 /// `any`/`all` need this, distinct from `query_field_kind`'s coarser `Other` bucket (ADR 0078).
-pub fn query_field_boolean(aggregate: &Json, field: &str, value_objects_by_name: &HashMap<String, &Json>) -> bool {
-    let mut segments = field.split('.');
-    let head = segments.next().unwrap_or("");
-    let rest: Vec<&str> = segments.collect();
-
-    let attrs = aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
-    let Some(attr) = attrs.iter().find(|a| crate::attr::name(a) == head) else { return false };
-    if crate::attr::list(attr) {
-        return false;
+pub fn query_field_boolean(
+    aggregate: &Json,
+    field: &str,
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> bool {
+    match path_end(aggregate, field, value_objects_by_name) {
+        PathEnd::Type(type_name) => type_boolean(type_name, value_objects_by_name),
+        PathEnd::HeadList | PathEnd::Broken => false,
     }
-    query_type_boolean(crate::attr::type_name(attr), &rest, value_objects_by_name)
 }
 
-fn query_type_boolean(type_name: &str, segments: &[&str], value_objects_by_name: &HashMap<String, &Json>) -> bool {
-    if segments.is_empty() {
-        if matches!(type_name, "TrueClass" | "FalseClass") {
-            return true;
-        }
-        if naming::reference_type(type_name) {
-            return false;
-        }
-        let Some(vo) = value_objects_by_name.get(type_name) else { return false };
-        let attrs = vo.get("attributes").map(Json::each).unwrap_or(&[]);
-        if attrs.len() == 1 {
-            return query_type_boolean(crate::attr::type_name(&attrs[0]), &[], value_objects_by_name);
-        }
-        false
-    } else {
-        let Some(vo) = value_objects_by_name.get(type_name) else { return false };
-        let attrs = vo.get("attributes").map(Json::each).unwrap_or(&[]);
-        let Some(member) = attrs.iter().find(|a| crate::attr::name(a) == segments[0]) else { return false };
-        if crate::attr::list(member) {
-            return false;
-        }
-        query_type_boolean(crate::attr::type_name(member), &segments[1..], value_objects_by_name)
+fn type_boolean(type_name: &str, value_objects_by_name: &HashMap<String, &Json>) -> bool {
+    if matches!(type_name, "TrueClass" | "FalseClass") {
+        return true;
+    }
+    if naming::reference_type(type_name) {
+        return false;
     }
+    let Some(vo) = value_objects_by_name.get(type_name) else {
+        return false;
+    };
+    let attrs = vo.get("attributes").map_or_default(Json::each);
+    attrs.len() == 1 && type_boolean(crate::attr::type_name(&attrs[0]), value_objects_by_name)
 }
 
 /// The winning member's own type name for a numeric field ("the sole numeric member wins",
 /// mirroring `query_vo_collapse_kind`) — "Integer" or "Float" distinctly, where
 /// `query_field_kind`'s own `Number` collapses both. `sum`/`avg` need the distinction
 /// (ADR 0078).
-pub fn query_field_numeric_type(aggregate: &Json, field: &str, value_objects_by_name: &HashMap<String, &Json>) -> Option<String> {
-    let mut segments = field.split('.');
-    let head = segments.next().unwrap_or("");
-    let rest: Vec<&str> = segments.collect();
-
-    let attrs = aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
-    let attr = attrs.iter().find(|a| crate::attr::name(a) == head)?;
-    if crate::attr::list(attr) {
-        return None;
+pub fn query_field_numeric_type(
+    aggregate: &Json,
+    field: &str,
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> Option<String> {
+    match path_end(aggregate, field, value_objects_by_name) {
+        PathEnd::Type(type_name) => type_numeric(type_name, value_objects_by_name),
+        PathEnd::HeadList | PathEnd::Broken => None,
     }
-    query_type_numeric_type(crate::attr::type_name(attr), &rest, value_objects_by_name)
 }
 
-fn query_type_numeric_type(type_name: &str, segments: &[&str], value_objects_by_name: &HashMap<String, &Json>) -> Option<String> {
-    if segments.is_empty() {
-        if matches!(type_name, "Integer" | "Float") {
-            return Some(type_name.to_string());
-        }
-        if naming::reference_type(type_name) {
-            return None;
-        }
-        let vo = value_objects_by_name.get(type_name)?;
-        let attrs = vo.get("attributes").map(Json::each).unwrap_or(&[]);
-        if let Some(numeric_member) = attrs.iter().find(|a| matches!(crate::attr::type_name(a), "Integer" | "Float")) {
-            return Some(crate::attr::type_name(numeric_member).to_string());
-        }
-        if attrs.len() == 1 {
-            return query_type_numeric_type(crate::attr::type_name(&attrs[0]), &[], value_objects_by_name);
-        }
-        None
-    } else {
-        let vo = value_objects_by_name.get(type_name)?;
-        let attrs = vo.get("attributes").map(Json::each).unwrap_or(&[]);
-        let member = attrs.iter().find(|a| crate::attr::name(a) == segments[0])?;
-        if crate::attr::list(member) {
-            return None;
-        }
-        query_type_numeric_type(crate::attr::type_name(member), &segments[1..], value_objects_by_name)
+fn type_numeric(type_name: &str, value_objects_by_name: &HashMap<String, &Json>) -> Option<String> {
+    if matches!(type_name, "Integer" | "Float") {
+        return Some(type_name.to_string());
+    }
+    if naming::reference_type(type_name) {
+        return None;
+    }
+    let vo = value_objects_by_name.get(type_name)?;
+    let attrs = vo.get("attributes").map_or_default(Json::each);
+    if let Some(numeric_member) = attrs
+        .iter()
+        .find(|a| matches!(crate::attr::type_name(a), "Integer" | "Float"))
+    {
+        return Some(crate::attr::type_name(numeric_member).to_string());
+    }
+    if attrs.len() == 1 {
+        return type_numeric(crate::attr::type_name(&attrs[0]), value_objects_by_name);
     }
+    None
 }
 
-pub fn query_where_skip_reason(where_clause: &Json, aggregate: &Json, value_objects_by_name: &HashMap<String, &Json>) -> Option<SkipReason> {
-    let field = where_clause.get("field").map(Json::to_s).unwrap_or_default();
+pub fn query_where_skip_reason(
+    where_clause: &Json,
+    aggregate: &Json,
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> Option<SkipReason> {
+    let field = where_clause
+        .get("field")
+        .map(Json::to_s)
+        .unwrap_or_default();
     let kind = query_field_kind(aggregate, &field, value_objects_by_name);
     if kind == FieldKind::Unknown {
-        let construct = if field.contains('/') { "reference_hop_where" } else { "where_unrecognized_field" };
+        let construct = if field.contains('/') {
+            "reference_hop_where"
+        } else {
+            "where_unrecognized_field"
+        };
         return Some(skip(
             construct,
             format!(
@@ -181,7 +221,10 @@ pub fn query_where_skip_reason(where_clause: &Json, aggregate: &Json, value_obje
         ));
     }
 
-    let raw_value = where_clause.get("value").map(Json::to_s).unwrap_or_default();
+    let raw_value = where_clause
+        .get("value")
+        .map(Json::to_s)
+        .unwrap_or_default();
     if raw_value.starts_with(':') {
         return None;
     }
@@ -232,7 +275,7 @@ pub fn query_where_skip_reason(where_clause: &Json, aggregate: &Json, value_obje
     ))
 }
 
-fn kind_name(kind: FieldKind) -> &'static str {
+const fn kind_name(kind: FieldKind) -> &'static str {
     match kind {
         FieldKind::String => "string",
         FieldKind::Number => "number",
@@ -254,7 +297,11 @@ pub struct HopPlan<'a> {
 // Matches `HopPath::MAX_HOPS`.
 const HOP_CHAIN_LIMIT: usize = 8;
 
-pub fn query_hop_plan<'a>(aggregate: &'a Json, field: &str, aggregates_by_name: &HashMap<String, &'a Json>) -> Option<HopPlan<'a>> {
+pub fn query_hop_plan<'a>(
+    aggregate: &'a Json,
+    field: &str,
+    aggregates_by_name: &HashMap<String, &'a Json>,
+) -> Option<HopPlan<'a>> {
     let segments: Vec<&str> = field.split('/').collect();
     if segments.len() < 2 || segments.len() - 1 > HOP_CHAIN_LIMIT {
         return None;
@@ -262,7 +309,11 @@ pub fn query_hop_plan<'a>(aggregate: &'a Json, field: &str, aggregates_by_name:
     let mut steps: Vec<(String, String)> = Vec::new();
     let mut current: &'a Json = aggregate;
     for segment in &segments[..segments.len() - 1] {
-        let via = current.get("attributes").map(Json::each).unwrap_or(&[]).iter().find(|a| crate::attr::name(a) == *segment)?;
+        let via = current
+            .get("attributes")
+            .map_or_default(Json::each)
+            .iter()
+            .find(|a| crate::attr::name(a) == *segment)?;
         let type_name = crate::attr::type_name(via);
         if !naming::reference_type(type_name) {
             return None;
@@ -273,7 +324,13 @@ pub fn query_hop_plan<'a>(aggregate: &'a Json, field: &str, aggregates_by_name:
         current = target;
     }
     let (via_field, target_aggregate) = steps.remove(0);
-    Some(HopPlan { via_field, target_aggregate, through: steps, target: current, inner_field: segments[segments.len() - 1].to_string() })
+    Some(HopPlan {
+        via_field,
+        target_aggregate,
+        through: steps,
+        target: current,
+        inner_field: segments[segments.len() - 1].to_string(),
+    })
 }
 
 pub fn with_field(where_clause: &Json, field: &str) -> Json {
@@ -281,7 +338,13 @@ pub fn with_field(where_clause: &Json, field: &str) -> Json {
         Json::Object(pairs) => Json::Object(
             pairs
                 .iter()
-                .map(|(key, value)| if key == "field" { (key.clone(), Json::String(field.to_string())) } else { (key.clone(), value.clone()) })
+                .map(|(key, value)| {
+                    if key == "field" {
+                        (key.clone(), Json::String(field.to_string()))
+                    } else {
+                        (key.clone(), value.clone())
+                    }
+                })
                 .collect(),
         ),
         other => other.clone(),
@@ -291,34 +354,66 @@ pub fn with_field(where_clause: &Json, field: &str) -> Json {
 pub fn value_objects_of(aggregate: &Json) -> HashMap<String, &Json> {
     aggregate
         .get("value_objects")
-        .map(Json::each)
-        .unwrap_or(&[])
+        .map_or_default(Json::each)
         .iter()
-        .map(|vo| (vo.get("name").and_then(Json::as_str).unwrap_or("").to_string(), vo))
+        .map(|vo| {
+            (
+                vo.get("name")
+                    .and_then(Json::as_str)
+                    .unwrap_or("")
+                    .to_string(),
+                vo,
+            )
+        })
         .collect()
 }
 
-pub fn query_skip_reason(query: &Json, aggregate: &Json, value_objects_by_name: &HashMap<String, &Json>, aggregates_by_name: &HashMap<String, &Json>) -> Option<SkipReason> {
+pub fn query_skip_reason(
+    query: &Json,
+    aggregate: &Json,
+    value_objects_by_name: &HashMap<String, &Json>,
+    aggregates_by_name: &HashMap<String, &Json>,
+) -> Option<SkipReason> {
     let extra_keys = ["cursor", "consistency", "freshness", "inspection"];
-    let extras: Vec<&str> = extra_keys.iter().filter(|k| query.get(k).is_some()).copied().collect();
+    let extras: Vec<&str> = extra_keys
+        .iter()
+        .filter(|k| query.get(k).is_some())
+        .copied()
+        .collect();
     if !extras.is_empty() {
         return Some(skip(extras[0], format!("declares {} — out of scope for this generator (rust/codegen/src/queries.rs's own header has the full argument)", extras.join(", "))));
     }
-    if query.get("index_hints").map(Json::each).unwrap_or(&[]).iter().any(|_| true) {
-        return Some(skip("index_hints", "declares use_index, out of scope for the same reason the extras above are"));
+    if query
+        .get("index_hints")
+        .map_or_default(Json::each)
+        .iter()
+        .any(|_| true)
+    {
+        return Some(skip(
+            "index_hints",
+            "declares use_index, out of scope for the same reason the extras above are",
+        ));
     }
 
     // A declared tenant synthesizes its own where clause (`query_conditions_with_authorization`),
     // so a query with no ordinary wheres but a tenant gate is still generable. The tenant
     // 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(&[]);
+    let declared_tenant = query
+        .get("authorization")
+        .and_then(|a| a.get("tenant"))
+        .is_some();
+    let wheres = query.get("wheres").map_or_default(Json::each);
     // 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());
+    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",
@@ -327,24 +422,45 @@ pub fn query_skip_reason(query: &Json, aggregate: &Json, value_objects_by_name:
     }
 
     for where_clause in wheres {
-        let field = where_clause.get("field").map(Json::to_s).unwrap_or_default();
+        let field = where_clause
+            .get("field")
+            .map(Json::to_s)
+            .unwrap_or_default();
         if let Some(plan) = query_hop_plan(aggregate, &field, aggregates_by_name) {
             let target_value_objects_by_name = value_objects_of(plan.target);
-            if let Some(reason) = query_where_skip_reason(&with_field(where_clause, &plan.inner_field), plan.target, &target_value_objects_by_name) {
-                return Some(reskip(&reason, format!("hop through {} to {}'s own {reason}", plan.via_field, plan.target_aggregate)));
+            if let Some(reason) = query_where_skip_reason(
+                &with_field(where_clause, &plan.inner_field),
+                plan.target,
+                &target_value_objects_by_name,
+            ) {
+                return Some(reskip(
+                    &reason,
+                    format!(
+                        "hop through {} to {}'s own {reason}",
+                        plan.via_field, plan.target_aggregate
+                    ),
+                ));
             }
             continue;
         }
-        if let Some(reason) = query_where_skip_reason(where_clause, aggregate, value_objects_by_name) {
+        if let Some(reason) =
+            query_where_skip_reason(where_clause, aggregate, value_objects_by_name)
+        {
             return Some(reason);
         }
     }
 
-    if let Some(reason) = declared_authorization_skip_reason(query.get("authorization"), aggregate, value_objects_by_name) {
+    if let Some(reason) = declared_authorization_skip_reason(
+        query.get("authorization"),
+        aggregate,
+        value_objects_by_name,
+    ) {
         return Some(reason);
     }
 
-    if let Some(reason) = declared_order_by_skip_reason(query.get("order_by"), aggregate, value_objects_by_name) {
+    if let Some(reason) =
+        declared_order_by_skip_reason(query.get("order_by"), aggregate, value_objects_by_name)
+    {
         return Some(reason);
     }
 
@@ -355,7 +471,11 @@ pub fn query_skip_reason(query: &Json, aggregate: &Json, value_objects_by_name:
     declared_limit_skip_reason(query.get("limit"))
 }
 
-pub fn declared_order_by_skip_reason(order_by: Option<&Json>, aggregate: &Json, value_objects_by_name: &HashMap<String, &Json>) -> Option<SkipReason> {
+pub fn declared_order_by_skip_reason(
+    order_by: Option<&Json>,
+    aggregate: &Json,
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> Option<SkipReason> {
     let order_by = order_by?;
     let field = order_by.get("field").map(Json::to_s).unwrap_or_default();
     let kind = query_field_kind(aggregate, &field, value_objects_by_name);
@@ -401,18 +521,29 @@ fn is_plain_integer(raw: &str) -> bool {
 
 // A `nil` tenant is a no-op, never disqualifying. A real tenant is checked by running a
 // synthetic arg-bound where through `query_where_skip_reason`.
-pub fn declared_authorization_skip_reason(authorization: Option<&Json>, aggregate: &Json, value_objects_by_name: &HashMap<String, &Json>) -> Option<SkipReason> {
-    let tenant = authorization.and_then(|a| a.get("tenant")).map(Json::to_s)?;
+pub fn declared_authorization_skip_reason(
+    authorization: Option<&Json>,
+    aggregate: &Json,
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> Option<SkipReason> {
+    let tenant = authorization
+        .and_then(|a| a.get("tenant"))
+        .map(Json::to_s)?;
     let synthetic_where = Json::Object(vec![
         ("field".to_string(), Json::String(tenant.clone())),
         ("op".to_string(), Json::String("eq".to_string())),
         ("value".to_string(), Json::String(format!(":{tenant}"))),
     ]);
-    query_where_skip_reason(&synthetic_where, aggregate, value_objects_by_name).map(|reason| skip("authorization", reason.text))
+    query_where_skip_reason(&synthetic_where, aggregate, value_objects_by_name)
+        .map(|reason| skip("authorization", reason.text))
 }
 
 pub fn emit_query_order_by(order_by: &Json, null_semantics: Option<&Json>) -> String {
-    let descending = order_by.get("direction").map(Json::to_s).unwrap_or_default() == "desc";
+    let descending = order_by
+        .get("direction")
+        .map(Json::to_s)
+        .unwrap_or_default()
+        == "desc";
     format!(
         "crate::kernel::query_ordering::OrderBy {{ field: {}, descending: {descending}, nulls: {} }}",
         naming::ruby_inspect_string(&order_by.get("field").map(Json::to_s).unwrap_or_default()),
@@ -423,7 +554,10 @@ pub fn emit_query_order_by(order_by: &Json, null_semantics: Option<&Json>) -> St
 // `nulls(mode)` is unvalidated, so an unrecognized mode falls back to `Native`
 // like `NullPolicy.order`'s `else` arm.
 pub fn null_semantics_variant(null_semantics: Option<&Json>) -> &'static str {
-    let mode = null_semantics.and_then(|ns| ns.get("mode")).map(Json::to_s).unwrap_or_default();
+    let mode = null_semantics
+        .and_then(|ns| ns.get("mode"))
+        .map(Json::to_s)
+        .unwrap_or_default();
     match mode.as_str() {
         "first" => "crate::kernel::query_ordering::NullsMode::First",
         "last" => "crate::kernel::query_ordering::NullsMode::Last",
@@ -434,9 +568,15 @@ pub fn null_semantics_variant(null_semantics: Option<&Json>) -> &'static str {
 pub fn emit_query_limit(limit: &Json) -> String {
     let raw = limit.get("value").map(Json::to_s).unwrap_or_default();
     if let Some(arg) = raw.strip_prefix(':') {
-        return format!("crate::kernel::query_ordering::Limit::Arg({})", naming::ruby_inspect_string(arg));
+        return format!(
+            "crate::kernel::query_ordering::Limit::Arg({})",
+            naming::ruby_inspect_string(arg)
+        );
     }
-    format!("crate::kernel::query_ordering::Limit::Literal({})", ruby_to_i(&raw))
+    format!(
+        "crate::kernel::query_ordering::Limit::Literal({})",
+        ruby_to_i(&raw)
+    )
 }
 
 // `Offset` aliases `Limit`; only the spelled type name is swapped so a generated
@@ -445,23 +585,6 @@ pub fn emit_query_offset(offset: &Json) -> String {
     emit_query_limit(offset).replace("query_ordering::Limit::", "query_ordering::Offset::")
 }
 
-fn ruby_to_i(s: &str) -> i64 {
-    let trimmed = s.trim_start();
-    let bytes = trimmed.as_bytes();
-    let mut end = 0;
-    if end < bytes.len() && (bytes[end] == b'-' || bytes[end] == b'+') {
-        end += 1;
-    }
-    let digits_start = end;
-    while end < bytes.len() && bytes[end].is_ascii_digit() {
-        end += 1;
-    }
-    if end == digits_start {
-        return 0;
-    }
-    trimmed[..end].parse().unwrap_or(0)
-}
-
 pub struct Condition {
     pub field: String,
     pub op: String,
@@ -471,7 +594,7 @@ pub struct Condition {
 
 // Assumes `query_skip_reason` already accepted the query.
 pub fn query_conditions(query: &Json) -> Vec<Condition> {
-    let wheres = query.get("wheres").map(Json::each).unwrap_or(&[]);
+    let wheres = query.get("wheres").map_or_default(Json::each);
     wheres.iter().map(condition_for).collect()
 }
 
@@ -481,8 +604,16 @@ fn condition_for(w: &Json) -> Condition {
     Condition {
         field: w.get("field").map(Json::to_s).unwrap_or_default(),
         op: w.get("op").map(Json::to_s).unwrap_or_default(),
-        arg: if symbol { Some(raw_value.trim_start_matches(':').to_string()) } else { None },
-        literal: if symbol { None } else { Some(literal::read(&raw_value)) },
+        arg: if symbol {
+            Some(raw_value.trim_start_matches(':').to_string())
+        } else {
+            None
+        },
+        literal: if symbol {
+            None
+        } else {
+            Some(literal::read(&raw_value))
+        },
     }
 }
 
@@ -495,28 +626,51 @@ pub struct HopCondition {
     pub condition: Condition,
 }
 
-pub fn query_conditions_and_hops(domain_name: &str, query: &Json, aggregate: &Json, aggregates_by_name: &HashMap<String, &Json>) -> (Vec<Condition>, Vec<HopCondition>) {
+pub fn query_conditions_and_hops(
+    domain_name: &str,
+    query: &Json,
+    aggregate: &Json,
+    aggregates_by_name: &HashMap<String, &Json>,
+) -> (Vec<Condition>, Vec<HopCondition>) {
     let mut local = Vec::new();
     let mut hops = Vec::new();
-    for w in query.get("wheres").map(Json::each).unwrap_or(&[]) {
+    for w in query.get("wheres").map_or_default(Json::each) {
         let field = w.get("field").map(Json::to_s).unwrap_or_default();
         match query_hop_plan(aggregate, &field, aggregates_by_name) {
             Some(plan) => hops.push(hop_condition(domain_name, plan, w)),
             None => local.push(condition_for(w)),
         }
     }
-    if let Some(tenant) = query.get("authorization").and_then(|a| a.get("tenant")).map(Json::to_s) {
-        local.push(Condition { field: tenant.clone(), op: "eq".to_string(), arg: Some(tenant), literal: None });
+    if let Some(tenant) = query
+        .get("authorization")
+        .and_then(|a| a.get("tenant"))
+        .map(Json::to_s)
+    {
+        local.push(Condition {
+            field: tenant.clone(),
+            op: "eq".to_string(),
+            arg: Some(tenant),
+            literal: None,
+        });
     }
     (local, hops)
 }
 
 // Assumes the skip check already confirmed every `hop_wheres` entry resolves.
-pub fn read_model_hop_conditions(domain_name: &str, hop_wheres: &[&Json], aggregate: &Json, aggregates_by_name: &HashMap<String, &Json>) -> Vec<HopCondition> {
+pub fn read_model_hop_conditions(
+    domain_name: &str,
+    hop_wheres: &[&Json],
+    aggregate: &Json,
+    aggregates_by_name: &HashMap<String, &Json>,
+) -> Vec<HopCondition> {
     hop_wheres
         .iter()
         .filter_map(|w| {
-            let plan = query_hop_plan(aggregate, &w.get("field").map(Json::to_s).unwrap_or_default(), aggregates_by_name)?;
+            let plan = query_hop_plan(
+                aggregate,
+                &w.get("field").map(Json::to_s).unwrap_or_default(),
+                aggregates_by_name,
+            )?;
             Some(hop_condition(domain_name, plan, w))
         })
         .collect()
@@ -525,15 +679,30 @@ pub fn read_model_hop_conditions(domain_name: &str, hop_wheres: &[&Json], aggreg
 fn hop_condition(domain_name: &str, plan: HopPlan<'_>, w: &Json) -> HopCondition {
     let mut condition = condition_for(w);
     condition.field = plan.inner_field;
-    let through = plan.through.into_iter().map(|(via, target)| (via, format!("{domain_name}::{target}"))).collect();
-    HopCondition { via_field: plan.via_field, target_aggregate: format!("{domain_name}::{}", plan.target_aggregate), through, condition }
+    let through = plan
+        .through
+        .into_iter()
+        .map(|(via, target)| (via, format!("{domain_name}::{target}")))
+        .collect();
+    HopCondition {
+        via_field: plan.via_field,
+        target_aggregate: format!("{domain_name}::{}", plan.target_aggregate),
+        through,
+        condition,
+    }
 }
 
 pub fn emit_reference_hop_condition(hop: &HopCondition) -> String {
     let through = hop
         .through
         .iter()
-        .map(|(via, target)| format!("crate::kernel::read_model::HopStep {{ via_field: {}, target_aggregate: {} }}", naming::ruby_inspect_string(via), naming::ruby_inspect_string(target)))
+        .map(|(via, target)| {
+            format!(
+                "crate::kernel::read_model::HopStep {{ via_field: {}, target_aggregate: {} }}",
+                naming::ruby_inspect_string(via),
+                naming::ruby_inspect_string(target)
+            )
+        })
         .collect::<Vec<_>>()
         .join(", ");
     format!(
@@ -549,8 +718,17 @@ pub fn emit_reference_hop_condition(hop: &HopCondition) -> String {
 // Adds `Runtime::TenantScope.apply`'s synthetic tenant clause at codegen time.
 pub fn query_conditions_with_authorization(query: &Json) -> Vec<Condition> {
     let mut conditions = query_conditions(query);
-    if let Some(tenant) = query.get("authorization").and_then(|a| a.get("tenant")).map(Json::to_s) {
-        conditions.push(Condition { field: tenant.clone(), op: "eq".to_string(), arg: Some(tenant), literal: None });
+    if let Some(tenant) = query
+        .get("authorization")
+        .and_then(|a| a.get("tenant"))
+        .map(Json::to_s)
+    {
+        conditions.push(Condition {
+            field: tenant.clone(),
+            op: "eq".to_string(),
+            arg: Some(tenant),
+            literal: None,
+        });
     }
     conditions
 }
@@ -558,8 +736,13 @@ pub fn query_conditions_with_authorization(query: &Json) -> Vec<Condition> {
 // `None` unless a tenant is declared. `policy` is carried on the wire but not enforced,
 // matching Ruby's `TenantScope.apply`; an absent policy becomes `""`.
 pub fn emit_query_authorization(query_name: &str, authorization: Option<&Json>) -> Option<String> {
-    let tenant = authorization.and_then(|a| a.get("tenant")).map(Json::to_s)?;
-    let policy = authorization.and_then(|a| a.get("policy")).map(Json::to_s).unwrap_or_default();
+    let tenant = authorization
+        .and_then(|a| a.get("tenant"))
+        .map(Json::to_s)?;
+    let policy = authorization
+        .and_then(|a| a.get("policy"))
+        .map(Json::to_s)
+        .unwrap_or_default();
     Some(format!(
         "crate::kernel::named_query::TenantAuth {{ query_name: {}, tenant_field: {}, policy: {} }}",
         naming::ruby_inspect_string(query_name),
@@ -572,9 +755,16 @@ pub fn emit_query_authorization(query_name: &str, authorization: Option<&Json>)
 // cross-domain search list, so it would answer every row `true`. `query_where_skip_reason`
 // checks this first, making the `panic!` in `query_comparator_variant` a backstop.
 fn known_query_comparator(op: &str) -> bool {
-    matches!(op, "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "in" | "contains")
+    matches!(
+        op,
+        "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "in" | "contains"
+    )
 }
 
+#[allow(
+    clippy::panic,
+    reason = "a drifted exemplar or invalid IR aborts generation on purpose"
+)]
 fn query_comparator_variant(op: &str) -> &'static str {
     match op {
         "eq" => "Eq",
@@ -600,8 +790,22 @@ fn literal_inspect(lit: &Literal) -> String {
         Literal::Bool(b) => b.to_string(),
         Literal::Nil => "nil".to_string(),
         Literal::Symbol(s) => format!(":{s}"),
-        Literal::Hash(pairs) => format!("{{{}}}", pairs.iter().map(|(k, v)| format!("{k}: {}", literal_inspect(v))).collect::<Vec<_>>().join(", ")),
-        Literal::Array(items) => format!("[{}]", items.iter().map(literal_inspect).collect::<Vec<_>>().join(", ")),
+        Literal::Hash(pairs) => format!(
+            "{{{}}}",
+            pairs
+                .iter()
+                .map(|(k, v)| format!("{k}: {}", literal_inspect(v)))
+                .collect::<Vec<_>>()
+                .join(", ")
+        ),
+        Literal::Array(items) => format!(
+            "[{}]",
+            items
+                .iter()
+                .map(literal_inspect)
+                .collect::<Vec<_>>()
+                .join(", ")
+        ),
     }
 }
 
@@ -615,24 +819,47 @@ fn ruby_float_inspect(n: f64) -> String {
     }
 }
 
+#[allow(
+    clippy::option_if_let_else,
+    clippy::unwrap_used,
+    reason = "a map_or_else closure would bury this long body; the value was checked just before; None would mean invalid IR"
+)]
 pub fn emit_query_condition_value(condition: &Condition) -> String {
-    match &condition.arg {
-        Some(arg) => format!("crate::kernel::QueryConditionValue::Arg({})", naming::ruby_inspect_string(arg)),
-        None => {
-            let lit = condition.literal.as_ref().unwrap();
-            // The skip check already proved a numeric literal targets a numeric field.
-            match lit {
-                Literal::Int(n) => format!("crate::kernel::QueryConditionValue::NumericLiteral({})", ruby_float_inspect(*n as f64)),
-                Literal::Float(n) => format!("crate::kernel::QueryConditionValue::NumericLiteral({})", ruby_float_inspect(*n)),
-                _ => format!("crate::kernel::QueryConditionValue::Literal({})", literal_inspect(lit)),
-            }
+    if let Some(arg) = &condition.arg {
+        format!(
+            "crate::kernel::QueryConditionValue::Arg({})",
+            naming::ruby_inspect_string(arg)
+        )
+    } else {
+        let lit = condition.literal.as_ref().unwrap();
+        // The skip check already proved a numeric literal targets a numeric field.
+        match lit {
+            Literal::Int(n) => format!(
+                "crate::kernel::QueryConditionValue::NumericLiteral({})",
+                ruby_float_inspect(*n as f64)
+            ),
+            Literal::Float(n) => format!(
+                "crate::kernel::QueryConditionValue::NumericLiteral({})",
+                ruby_float_inspect(*n)
+            ),
+            _ => format!(
+                "crate::kernel::QueryConditionValue::Literal({})",
+                literal_inspect(lit)
+            ),
         }
     }
 }
 
 pub fn emit_query_condition(condition: &Condition) -> String {
-    let comparator_expr = format!("crate::kernel::query_comparators::QueryComparator::{}", query_comparator_variant(&condition.op));
-    format!("crate::kernel::QueryCondition {{ field: {}, comparator: {comparator_expr}, value: {} }},", naming::ruby_inspect_string(&condition.field), emit_query_condition_value(condition))
+    let comparator_expr = format!(
+        "crate::kernel::query_comparators::QueryComparator::{}",
+        query_comparator_variant(&condition.op)
+    );
+    format!(
+        "crate::kernel::QueryCondition {{ field: {}, comparator: {comparator_expr}, value: {} }},",
+        naming::ruby_inspect_string(&condition.field),
+        emit_query_condition_value(condition)
+    )
 }
 
 pub struct QueryDef {
@@ -653,8 +880,7 @@ pub struct QueryDef {
 
 pub fn provided_assignments(ir: &Json) -> Option<String> {
     ir.get("provides")
-        .map(Json::each)
-        .unwrap_or(&[])
+        .map_or_default(Json::each)
         .iter()
         .find(|row| {
             row.get("capability").and_then(Json::as_str) == Some("authorization")
@@ -665,10 +891,10 @@ pub fn provided_assignments(ir: &Json) -> Option<String> {
 }
 
 pub fn emit_authorization_assignments(query_defs: &[QueryDef]) -> String {
-    let value = match query_defs.iter().find(|q| q.assignments) {
-        Some(q) => format!("Some({})", naming::ruby_inspect_string(&q.verb)),
-        None => "None".to_string(),
-    };
+    let value = query_defs.iter().find(|q| q.assignments).map_or_else(
+        || "None".to_string(),
+        |q| format!("Some({})", naming::ruby_inspect_string(&q.verb)),
+    );
     format!(
         "/// `provides \"authorization\", assignments:` — the query `kernel::check_role_via` reads; `None` when no chapter here declares one.\npub const AUTHORIZATION_ASSIGNMENTS: Option<&str> = {value};\n"
     )
@@ -681,19 +907,40 @@ pub struct EntityScope {
 }
 
 pub fn emit_entity_query_table(entity_defs: &[&QueryDef]) -> String {
-    let rows: String = entity_defs.iter().map(|q| format!("{}\n", emit_entity_query_def(q))).collect();
+    let rows: String = entity_defs.iter().fold(String::new(), |mut rows, q| {
+        let _ = writeln!(rows, "{}", emit_entity_query_def(q));
+        rows
+    });
     format!(
         "/// Declared entity queries (`Aggregate.Entity.Query`) — `kernel::named_query::run_entity`.\npub const ENTITY_QUERIES: &[crate::kernel::named_query::EntityQueryDef] = &[\n{rows}];\n"
     )
 }
 
+#[allow(
+    clippy::expect_used,
+    reason = "the message names an invariant an earlier check in this generator established"
+)]
 fn emit_entity_query_def(query_def: &QueryDef) -> String {
-    let entity = query_def.entity.as_ref().expect("an entity query def carries its scope");
-    let conditions = query_def.conditions.iter().map(|c| format!("        {}", emit_query_condition(c))).collect::<Vec<_>>().join("\n");
-    let keys = entity.identity_keys.iter().map(|key| naming::ruby_inspect_string(key)).collect::<Vec<_>>().join(", ");
-    let wrap = |value: &Option<String>| match value {
-        Some(v) => format!("Some({v})"),
-        None => "None".to_string(),
+    let entity = query_def
+        .entity
+        .as_ref()
+        .expect("an entity query def carries its scope");
+    let conditions = query_def
+        .conditions
+        .iter()
+        .map(|c| format!("        {}", emit_query_condition(c)))
+        .collect::<Vec<_>>()
+        .join("\n");
+    let keys = entity
+        .identity_keys
+        .iter()
+        .map(|key| naming::ruby_inspect_string(key))
+        .collect::<Vec<_>>()
+        .join(", ");
+    let wrap = |value: &Option<String>| {
+        value
+            .as_ref()
+            .map_or_else(|| "None".to_string(), |v| format!("Some({v})"))
     };
     format!(
         "crate::kernel::named_query::EntityQueryDef {{\n    verb: {},\n    aggregate: {},\n    list_field: {},\n    parent_key: {},\n    identity_keys: &[{keys}],\n    conditions: &[\n{conditions}\n    ],\n    order_by: {},\n    offset: {},\n    limit: {},\n}},",
@@ -707,36 +954,59 @@ fn emit_entity_query_def(query_def: &QueryDef) -> String {
     )
 }
 
-pub fn entity_query_skip_reason(query: &Json, entity: &Json, holds_list: bool, value_objects_by_name: &HashMap<String, &Json>) -> Option<SkipReason> {
+pub fn entity_query_skip_reason(
+    query: &Json,
+    entity: &Json,
+    holds_list: bool,
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> Option<SkipReason> {
     let entity_name = entity.get("name").map(Json::to_s).unwrap_or_default();
     if !holds_list {
-        return Some(skip("entity_query", format!("{entity_name} is held in no list attribute on its aggregate — nothing to flatten")));
+        return Some(skip(
+            "entity_query",
+            format!(
+                "{entity_name} is held in no list attribute on its aggregate — nothing to flatten"
+            ),
+        ));
     }
     if query.get("authorization").is_some() {
-        return Some(skip("entity_query_authorization", "declares authorize — an entity query's tenant scope is not generated yet"));
+        return Some(skip(
+            "entity_query_authorization",
+            "declares authorize — an entity query's tenant scope is not generated yet",
+        ));
     }
     query_skip_reason(query, entity, value_objects_by_name, &HashMap::new())
 }
 
 pub fn emit_query_def(query_def: &QueryDef) -> String {
-    let conditions = query_def.conditions.iter().map(|c| format!("        {}", emit_query_condition(c))).collect::<Vec<_>>().join("\n");
-    let reference_hop_conditions = query_def.reference_hop_conditions.iter().map(|h| format!("        {}", emit_reference_hop_condition(h))).collect::<Vec<_>>().join("\n");
-    let order_by = match &query_def.order_by {
-        Some(o) => format!("Some({o})"),
-        None => "None".to_string(),
-    };
-    let offset = match &query_def.offset {
-        Some(o) => format!("Some({o})"),
-        None => "None".to_string(),
-    };
-    let limit = match &query_def.limit {
-        Some(l) => format!("Some({l})"),
-        None => "None".to_string(),
-    };
-    let authorization = match &query_def.authorization {
-        Some(a) => format!("Some({a})"),
-        None => "None".to_string(),
-    };
+    let conditions = query_def
+        .conditions
+        .iter()
+        .map(|c| format!("        {}", emit_query_condition(c)))
+        .collect::<Vec<_>>()
+        .join("\n");
+    let reference_hop_conditions = query_def
+        .reference_hop_conditions
+        .iter()
+        .map(|h| format!("        {}", emit_reference_hop_condition(h)))
+        .collect::<Vec<_>>()
+        .join("\n");
+    let order_by = query_def
+        .order_by
+        .as_ref()
+        .map_or_else(|| "None".to_string(), |o| format!("Some({o})"));
+    let offset = query_def
+        .offset
+        .as_ref()
+        .map_or_else(|| "None".to_string(), |o| format!("Some({o})"));
+    let limit = query_def
+        .limit
+        .as_ref()
+        .map_or_else(|| "None".to_string(), |l| format!("Some({l})"));
+    let authorization = query_def
+        .authorization
+        .as_ref()
+        .map_or_else(|| "None".to_string(), |a| format!("Some({a})"));
 
     format!(
         "crate::kernel::QueryDef {{\n    verb: {},\n    aggregate: {},\n    conditions: &[\n{conditions}\n    ],\n    reference_hop_conditions: &[\n{reference_hop_conditions}\n    ],\n    order_by: {order_by},\n    offset: {offset},\n    limit: {limit},\n    authorization: {authorization},\n}},",
@@ -748,32 +1018,49 @@ pub fn emit_query_def(query_def: &QueryDef) -> String {
 const QUERY_TABLE_ROW_PLACEHOLDER: &str = "crate::kernel::QueryDef {\n    verb: \"tmpl_verb\",\n    aggregate: \"tmpl_aggregate\",\n    conditions: &[\n        crate::kernel::QueryCondition {\n            field: \"tmpl_field\",\n            comparator: crate::kernel::query_comparators::QueryComparator::Eq,\n            value: crate::kernel::QueryConditionValue::Literal(\"tmpl_literal\"),\n        },\n    ],\n    reference_hop_conditions: &[\n        crate::kernel::read_model::ReferenceHopCondition {\n            via_field: \"tmpl_via_field\",\n            target_aggregate: \"tmpl_target_aggregate\",\n            through: &[crate::kernel::read_model::HopStep { via_field: \"tmpl_via_field\", target_aggregate: \"tmpl_target_aggregate\" }],\n            inner_field: \"tmpl_inner_field\",\n            inner_comparator: crate::kernel::query_comparators::QueryComparator::Eq,\n            inner_value: crate::kernel::QueryConditionValue::Literal(\"tmpl_literal\"),\n        },\n    ],\n    order_by: Some(crate::kernel::query_ordering::OrderBy { field: \"tmpl_order_field\", descending: true, nulls: crate::kernel::query_ordering::NullsMode::Last }),\n    offset: Some(crate::kernel::query_ordering::Offset::Literal(1)),\n    limit: Some(crate::kernel::query_ordering::Limit::Literal(5)),\n    authorization: Some(crate::kernel::named_query::TenantAuth { query_name: \"tmpl_query_name\", tenant_field: \"tmpl_tenant_field\", policy: \"tmpl_policy\" }),\n},";
 
 pub fn emit_query_table(exemplar: &Exemplar, query_defs: &[QueryDef]) -> String {
-    let (entity_defs, aggregate_defs): (Vec<&QueryDef>, Vec<&QueryDef>) = query_defs.iter().partition(|q| q.entity.is_some());
+    let (entity_defs, aggregate_defs): (Vec<&QueryDef>, Vec<&QueryDef>) =
+        query_defs.iter().partition(|q| q.entity.is_some());
     let rows: Vec<String> = aggregate_defs.into_iter().map(emit_query_def).collect();
     format!(
         "{}\n{}{}",
-        exemplar.render("query_table", &[(QUERY_TABLE_ROW_PLACEHOLDER, rows.join("\n"))]),
+        exemplar.render(
+            "query_table",
+            &[(QUERY_TABLE_ROW_PLACEHOLDER, rows.join("\n"))]
+        ),
         emit_authorization_assignments(query_defs),
         emit_entity_query_table(&entity_defs)
     )
 }
 
 // One `if let` per value-object argument: built and invariant-checked, then dropped (ADR 0037).
-pub fn query_arg_checks(query: &Json, mod_path: &str, value_objects_by_name: &HashMap<String, &Json>) -> Vec<String> {
+pub fn query_arg_checks(
+    query: &Json,
+    mod_path: &str,
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> Vec<String> {
     query
         .get("attributes")
-        .map(Json::each)
-        .unwrap_or(&[])
+        .map_or_default(Json::each)
         .iter()
         .filter_map(|attr| {
-            if crate::attr::list(attr) || !matches!(attr.get("relationship"), None | Some(Json::Null)) {
+            if crate::attr::list(attr)
+                || !matches!(attr.get("relationship"), None | Some(Json::Null))
+            {
                 return None;
             }
             let vo = value_objects_by_name.get(crate::attr::type_name(attr))?;
             let key = naming::rust_field(crate::attr::name(attr));
-            let build = crate::json_codec::composite_from_json_expr(attr, value_objects_by_name, "x");
-            let check = if vo.get("closed_set").map(Json::as_bool).unwrap_or(false) { "" } else { ".check_invariants()?" };
-            Some(format!("if let Some(x) = args.get({}) {{ {mod_path}::{build}{check}; }}", naming::ruby_inspect_string(&key)))
+            let build =
+                crate::json_codec::composite_from_json_expr(attr, value_objects_by_name, "x");
+            let check = if vo.get("closed_set").is_some_and(Json::as_bool) {
+                ""
+            } else {
+                ".check_invariants()?"
+            };
+            Some(format!(
+                "if let Some(x) = args.get({}) {{ {mod_path}::{build}{check}; }}",
+                naming::ruby_inspect_string(&key)
+            ))
         })
         .collect()
 }
@@ -784,8 +1071,16 @@ pub fn emit_query_arg_check_table(query_defs: &[QueryDef]) -> String {
         .iter()
         .filter(|q| !q.arg_checks.is_empty())
         .map(|q| {
-            let lines = q.arg_checks.iter().map(|line| format!("            {line}")).collect::<Vec<_>>().join("\n");
-            format!("        {} => {{\n{lines}\n            Ok(())\n        }}", naming::ruby_inspect_string(&q.verb))
+            let lines = q
+                .arg_checks
+                .iter()
+                .map(|line| format!("            {line}"))
+                .collect::<Vec<_>>()
+                .join("\n");
+            format!(
+                "        {} => {{\n{lines}\n            Ok(())\n        }}",
+                naming::ruby_inspect_string(&q.verb)
+            )
         })
         .collect();
     format!(
@@ -793,3 +1088,83 @@ pub fn emit_query_arg_check_table(query_defs: &[QueryDef]) -> String {
         arms.join("\n")
     )
 }
+
+#[cfg(test)]
+mod path_tests {
+    use super::*;
+
+    const AGGREGATE: &str = r#"{"lifecycle":{"field":"status"},"attributes":[
+        {"name":"status","type":"String","list":false},
+        {"name":"title","type":"String","list":false},
+        {"name":"count","type":"Integer","list":false},
+        {"name":"flag","type":"TrueClass","list":false},
+        {"name":"owner","type":"Reference<Person>","list":false},
+        {"name":"tags","type":"String","list":true},
+        {"name":"money","type":"Money","list":false},
+        {"name":"nest","type":"Nest","list":false}]}"#;
+    const VALUE_OBJECTS: [&str; 3] = [
+        r#"{"name":"Money","attributes":[{"name":"amount","type":"Float","list":false},{"name":"currency","type":"String","list":false}]}"#,
+        r#"{"name":"Nest","attributes":[{"name":"items","type":"Money","list":true},{"name":"flag","type":"Flag","list":false}]}"#,
+        r#"{"name":"Flag","attributes":[{"name":"on","type":"TrueClass","list":false}]}"#,
+    ];
+
+    /// Runs `check` over the classifiers' common inputs.
+    fn with_schema(check: impl Fn(&Json, &HashMap<String, &Json>)) {
+        let aggregate = Json::parse(AGGREGATE).unwrap();
+        let parsed: Vec<Json> = VALUE_OBJECTS
+            .iter()
+            .map(|text| Json::parse(text).unwrap())
+            .collect();
+        let by_name: HashMap<String, &Json> = parsed
+            .iter()
+            .map(|vo| {
+                (
+                    vo.get("name").and_then(Json::as_str).unwrap().to_string(),
+                    vo,
+                )
+            })
+            .collect();
+        check(&aggregate, &by_name);
+    }
+
+    #[test]
+    fn a_path_is_classified_by_the_type_it_lands_on() {
+        with_schema(|aggregate, vos| {
+            let kind = |path: &str| query_field_kind(aggregate, path, vos);
+            assert_eq!(kind("title"), FieldKind::String);
+            assert_eq!(kind("owner"), FieldKind::String);
+            assert_eq!(kind("status"), FieldKind::String);
+            assert_eq!(kind("count"), FieldKind::Number);
+            assert_eq!(kind("money"), FieldKind::Number);
+            assert_eq!(kind("nest.flag"), FieldKind::Other);
+        });
+    }
+
+    #[test]
+    fn a_path_that_names_nothing_is_unknown_and_a_list_head_is_other() {
+        with_schema(|aggregate, vos| {
+            let kind = |path: &str| query_field_kind(aggregate, path, vos);
+            assert_eq!(kind("missing"), FieldKind::Unknown);
+            assert_eq!(kind("status.x"), FieldKind::Unknown);
+            assert_eq!(kind("owner.x"), FieldKind::Unknown);
+            assert_eq!(kind("nest.items"), FieldKind::Unknown);
+            assert_eq!(kind("tags"), FieldKind::Other);
+        });
+    }
+
+    #[test]
+    fn booleans_and_numeric_types_follow_a_single_member_down() {
+        with_schema(|aggregate, vos| {
+            assert!(query_field_boolean(aggregate, "flag", vos));
+            assert!(query_field_boolean(aggregate, "nest.flag", vos));
+            assert!(query_field_boolean(aggregate, "nest.flag.on", vos));
+            assert!(!query_field_boolean(aggregate, "money", vos));
+            assert!(!query_field_boolean(aggregate, "tags", vos));
+            let numeric = |path: &str| query_field_numeric_type(aggregate, path, vos);
+            assert_eq!(numeric("count").as_deref(), Some("Integer"));
+            assert_eq!(numeric("money").as_deref(), Some("Float"));
+            assert_eq!(numeric("title"), None);
+            assert_eq!(numeric("tags"), None);
+        });
+    }
+}