hecks 3.1.3 → 3.2.1

data/rust/host/src/needs.rs

@@ -110,21 +110,34 @@ pub fn table(domain_ir: &Value) -> Value {
     Value::Object(verbs)
 }
 
+fn list<'a>(value: &'a Value, key: &str) -> &'a [Value] {
+    value.get(key).and_then(Value::as_array).map(Vec::as_slice).unwrap_or(&[])
+}
+
+fn named(value: &Value, name: &str) -> bool {
+    value.get("name").and_then(Value::as_str) == Some(name)
+}
+
+/// The command a verb names: `Domain::Aggregate.Command` on the aggregate itself, or
+/// `Domain::Aggregate.Entity[.Entity].Command` on an entity nested inside it.
+fn command_for<'a>(domain_ir: &'a Value, verb: &str) -> Option<&'a Value> {
+    let mut segments = verb.split('.');
+    let aggregate = segments.next()?.rsplit("::").next()?;
+    let mut path: Vec<&str> = segments.collect();
+    let command_name = path.pop()?;
+    let mut node = list(domain_ir, "aggregates").iter().find(|a| named(a, aggregate))?;
+    for entity in path {
+        node = list(node, "entities").iter().find(|e| named(e, entity))?;
+    }
+    list(node, "commands").iter().find(|c| named(c, command_name))
+}
+
 /// The command's attributes that declare a default (`attribute :runs, Count, default: 30`), each
 /// with the declared value. An attribute whose default is null declares none.
 fn declared_defaults<'a>(domain_ir: &'a Value, verb: &str) -> Vec<(&'a str, &'a Value)> {
-    let Some((qualified_aggregate, command_name)) = verb.rsplit_once('.') else { return Vec::new() };
-    let aggregate = qualified_aggregate.rsplit("::").next().unwrap_or(qualified_aggregate);
-    let named = |value: &Value, name: &str| value.get("name").and_then(Value::as_str) == Some(name);
-    let list = |value: &'a Value, key: &str| -> Vec<&'a Value> {
-        value.get(key).and_then(Value::as_array).map(|a| a.iter().collect()).unwrap_or_default()
-    };
-    list(domain_ir, "aggregates")
-        .into_iter()
-        .filter(|a| named(a, aggregate))
-        .flat_map(|a| list(a, "commands"))
-        .filter(|c| named(c, command_name))
-        .flat_map(|c| list(c, "attributes"))
+    let Some(command) = command_for(domain_ir, verb) else { return Vec::new() };
+    list(command, "attributes")
+        .iter()
         .filter_map(|a| {
             let default = a.get("default").filter(|d| !d.is_null())?;
             Some((a.get("name").and_then(Value::as_str)?, default))
@@ -133,29 +146,35 @@ fn declared_defaults<'a>(domain_ir: &'a Value, verb: &str) -> Vec<(&'a str, &'a
 }
 
 /// Every command's declared defaults as the kernel's input `"defaults"` reads them:
-/// `{ verb: { attribute: value } }`. The kernel fills a reaction's command from this the same way
-/// the host fills the outermost one.
+/// `{ verb: { attribute: value } }`, entity commands included. The kernel fills a reaction's
+/// command from this the same way the host fills the outermost one.
 pub fn defaults_table(domain_ir: &Value) -> Value {
     let domain = domain_ir.get("name").and_then(Value::as_str).unwrap_or_default();
     let mut verbs = serde_json::Map::new();
-    let aggregates = domain_ir.get("aggregates").and_then(Value::as_array).into_iter().flatten();
-    for aggregate in aggregates {
+    for aggregate in list(domain_ir, "aggregates") {
         let aggregate_name = aggregate.get("name").and_then(Value::as_str).unwrap_or_default();
-        for command in aggregate.get("commands").and_then(Value::as_array).into_iter().flatten() {
-            let command_name = command.get("name").and_then(Value::as_str).unwrap_or_default();
-            let verb = format!("{domain}::{aggregate_name}.{command_name}");
-            let defaults: serde_json::Map<String, Value> = declared_defaults(domain_ir, &verb)
-                .into_iter()
-                .map(|(name, value)| (name.to_string(), value.clone()))
-                .collect();
-            if !defaults.is_empty() {
-                verbs.insert(verb, Value::Object(defaults));
-            }
-        }
+        collect_defaults(domain_ir, aggregate, &format!("{domain}::{aggregate_name}"), &mut verbs);
     }
     Value::Object(verbs)
 }
 
+/// Adds the defaults of `node`'s commands, then of each entity nested in it, under `prefix`.
+fn collect_defaults(domain_ir: &Value, node: &Value, prefix: &str, verbs: &mut serde_json::Map<String, Value>) {
+    for command in list(node, "commands") {
+        let command_name = command.get("name").and_then(Value::as_str).unwrap_or_default();
+        let verb = format!("{prefix}.{command_name}");
+        let defaults: serde_json::Map<String, Value> =
+            declared_defaults(domain_ir, &verb).into_iter().map(|(name, value)| (name.to_string(), value.clone())).collect();
+        if !defaults.is_empty() {
+            verbs.insert(verb, Value::Object(defaults));
+        }
+    }
+    for entity in list(node, "entities") {
+        let entity_name = entity.get("name").and_then(Value::as_str).unwrap_or_default();
+        collect_defaults(domain_ir, entity, &format!("{prefix}.{entity_name}"), verbs);
+    }
+}
+
 /// The facts of a command invocation: the `with` object when the call carries one, else the
 /// flat object itself (the kernel's `CommandInvocation` reads both shapes).
 fn facts_mut(args: &mut Value) -> Option<&mut serde_json::Map<String, Value>> {
@@ -351,4 +370,52 @@ mod tests {
         assert_eq!(defaults_table(&defaulted_ir()), json!({"Qc::Check.Start": {"runs": 30}}));
         assert_eq!(defaults_table(&integer_ir()), json!({}));
     }
+
+    // A board entity with a defaulted command, and a card nested inside it with another.
+    fn nested_ir() -> Value {
+        json!({"name": "Np", "aggregates": [{"name": "Workspace", "commands": [], "entities": [
+            {"name": "Board", "commands": [
+                {"name": "Retitle", "attributes": [
+                    {"name": "label", "type": "BoardLabel", "default": {"value": "untitled"}}], "needs": []}
+            ], "entities": [
+                {"name": "Card", "commands": [
+                    {"name": "Remark", "attributes": [
+                        {"name": "note", "type": "CardNote", "default": {"text": "none"}}], "needs": []}
+                ]}
+            ]}
+        ]}]})
+    }
+
+    #[test]
+    fn an_entity_command_is_filled_from_its_own_declared_default() {
+        let mut args = json!({"reference": {"value": "W1"}, "number": {"value": 1}});
+        fill_defaults(&nested_ir(), "Np::Workspace.Board.Retitle", &mut args);
+        assert_eq!(args["label"], json!({"value": "untitled"}));
+    }
+
+    #[test]
+    fn a_command_on_an_entity_nested_in_an_entity_is_filled_too() {
+        let mut args = json!({"with": {"reference": {"value": "W1"}}});
+        fill_defaults(&nested_ir(), "Np::Workspace.Board.Card.Remark", &mut args);
+        assert_eq!(args["with"]["note"], json!({"text": "none"}));
+    }
+
+    #[test]
+    fn an_entity_path_that_names_nothing_is_left_untouched() {
+        let mut args = json!({"number": 1});
+        fill_defaults(&nested_ir(), "Np::Workspace.Shelf.Retitle", &mut args);
+        fill_defaults(&nested_ir(), "Np::Workspace.Board.Remark", &mut args);
+        assert_eq!(args, json!({"number": 1}));
+    }
+
+    #[test]
+    fn the_kernel_table_lists_entity_commands_under_their_full_path() {
+        assert_eq!(
+            defaults_table(&nested_ir()),
+            json!({
+                "Np::Workspace.Board.Retitle": {"label": {"value": "untitled"}},
+                "Np::Workspace.Board.Card.Remark": {"note": {"text": "none"}}
+            })
+        );
+    }
 }

data/rust/host/src/web.rs

@@ -369,7 +369,10 @@ async fn active_session_email(
 
 async fn accounts_me_route(domain_ir: &Value, cookies: &HashMap<String, String>, secret: &str, client: &Mutex<Client>) -> Value {
     match active_session_email(domain_ir, cookies, secret, client).await {
-        Ok(email) => respond(200, "application/json", &json!({"email": email}).to_string()),
+        Ok(email) => match auth::member_identity_id(client, domain_ir, &email).await {
+            Ok(identity_id) => respond(200, "application/json", &json!({"email": email, "identity_id": identity_id}).to_string()),
+            Err(e) => respond(500, "application/json", &json!({"error": format!("members lookup failed: {e}")}).to_string()),
+        },
         Err(response) => response,
     }
 }
@@ -434,7 +437,7 @@ pub(crate) async fn add_member_route(
         Ok(true) => respond(
             201,
             "application/json",
-            &json!({"name": name, "email": email, "role": role, "linked": false, "granted": true, "disabled": false}).to_string(),
+            &json!({"name": name, "email": email, "role": role, "linked": false, "granted": true, "disabled": false, "identity_id": null}).to_string(),
         ),
         Ok(false) => json_error(500, &format!("the person was admitted but the {role} role was not granted")),
         Err(e) => json_error(500, &format!("the person was admitted but the {role} role was not granted: {e}")),
@@ -2173,6 +2176,7 @@ mod tests {
         assert_eq!(response["statusCode"], 200, "{response:?}");
         let body: Value = serde_json::from_str(response["body"].as_str().unwrap()).unwrap();
         assert_eq!(body["email"], "zed@example.com");
+        assert_eq!(body["identity_id"], "id-1", "the signed-in account's Governance identity id");
 
         let empty = HashMap::new();
         assert_eq!(accounts_me_route(&domain_ir, &empty, secret, &client).await["statusCode"], 401);
@@ -2273,11 +2277,11 @@ mod tests {
         assert_eq!(names, ["amy", "Zed"], "sorted case-insensitively by name");
         assert_eq!(
             people[1],
-            json!({"name": "Zed", "email": "zed@example.com", "role": "Admin", "linked": true, "granted": true, "disabled": false})
+            json!({"name": "Zed", "email": "zed@example.com", "role": "Admin", "linked": true, "granted": true, "disabled": false, "identity_id": "id-1"})
         );
         assert_eq!(
             people[0],
-            json!({"name": "amy", "email": "amy@example.com", "role": null, "linked": false, "granted": false, "disabled": false})
+            json!({"name": "amy", "email": "amy@example.com", "role": null, "linked": false, "granted": false, "disabled": false, "identity_id": null})
         );
     }
 
@@ -2465,7 +2469,7 @@ mod tests {
         let created: Value = serde_json::from_str(response["body"].as_str().unwrap()).unwrap();
         assert_eq!(
             created,
-            json!({"name": "New Person", "email": "new@example.com", "role": "Admin", "linked": false, "granted": true, "disabled": false})
+            json!({"name": "New Person", "email": "new@example.com", "role": "Admin", "linked": false, "granted": true, "disabled": false, "identity_id": null})
         );
 
         let listing = members_route(&domain_ir, &cookies, secret, &client).await;

data/rust/src/exemplar/commands.rs

@@ -1,4 +1,4 @@
-//! Exemplar shapes for rust/project/commands.rb (see mod.rs).
+//! Exemplar shapes for rust/codegen/src/commands.rs (see mod.rs).
 //!
 //! `dispatch_fn` proves the outer `pub fn .. -> DispatchResult { .. dispatch(..) .. }` wrapper.
 #![allow(dead_code, unused_variables)]

data/rust/src/exemplar/constraints.rs

@@ -1,4 +1,4 @@
-//! Exemplar shapes for rust/project/constraints.rb (see mod.rs).
+//! Exemplar shapes for rust/codegen/src/constraints.rs (see mod.rs).
 //!
 //! Both shapes are single-line refusal checks spliced into a `Result`-returning body.
 #![allow(dead_code, unused_variables)]

data/rust/src/exemplar/fielded.rs

@@ -1,4 +1,4 @@
-//! Exemplar shapes for rust/project/fielded.rb (see mod.rs).
+//! Exemplar shapes for rust/codegen/src/fielded.rs (see mod.rs).
 //!
 //! Each `Fielded::field` arm shape is a standalone leaf so both outer skeletons can reuse it.
 #![allow(dead_code, unused_variables)]

data/rust/src/exemplar/json.rs

@@ -1,4 +1,4 @@
-// Exemplar shapes for rust/project/json_codec.rb; see mod.rs.
+// Exemplar shapes for rust/codegen/src/json_codec.rs; see mod.rs.
 // Kept out of the fenced region so its prose is not baked into every generated codec.
 #![allow(dead_code, unused_variables)]
 

data/rust/src/exemplar/mod.rs

@@ -1,4 +1,4 @@
-// Compile-checked Rust for every shape rust/project/*.rb emits; exemplar.rb slices the fenced
+// Compile-checked Rust for every shape rust/codegen/src/*.rs emits; exemplar.rs slices the fenced
 // `// TMPL:<id> BEGIN` / `END` regions and substitutes real names for the `tmpl_` vocabulary.
 //
 // `tmpl_*_host` functions only give fenced fragments real types and are never called, hence

data/rust/src/exemplar/mutations.rs

@@ -1,4 +1,4 @@
-// Exemplar shapes for rust/project/mutations.rb; see mod.rs.
+// Exemplar shapes for rust/codegen/src/mutations.rs; see mod.rs.
 // Hosts take `record: &mut Tmpl...`, not `&mut self`, as the generated mutation closures do.
 #![allow(dead_code, unused_variables)]
 

data/rust/src/exemplar/queries.rs

@@ -1,4 +1,4 @@
-// Exemplar shape for rust/project/registry.rb's `emit_query_table`; see mod.rs.
+// Exemplar shape for rust/codegen/src/registry.rs's `emit_query_table`; see mod.rs.
 #![allow(dead_code, unused_variables)]
 
 // A `const` cannot call a function, so the row is a real literal substituted wholesale.

data/rust/src/exemplar/reactions.rs

@@ -1,4 +1,4 @@
-// Exemplar shapes that rust/project/reactions.rb slices into generated tables;
+// Exemplar shapes that rust/codegen/src/reactions.rs slices into generated tables;
 // see mod.rs for how they are used.
 #![allow(dead_code, unused_variables)]
 

data/rust/src/exemplar/read_models.rs

@@ -1,4 +1,4 @@
-// Exemplar shapes for rust/project/read_models.rb's `emit_read_model_table`
+// Exemplar shapes for rust/codegen/src/read_models.rs's `emit_read_model_table`
 // — see mod.rs's own header. `ReadModelDef`/`ReadModelHead`/`FilteredHead`/
 // `ReferenceField` are real kernel types (`rust/src/kernel/read_model.rs`).
 #![allow(dead_code, unused_variables)]

data/rust/src/exemplar/registry.rs

@@ -1,4 +1,4 @@
-// Exemplar shapes for rust/project/registry.rb; see mod.rs.
+// Exemplar shapes for rust/codegen/src/registry.rs; see mod.rs.
 // `InMemoryRepository<T>` only needs `T: Clone`, so an `i64` record type suffices.
 #![allow(dead_code, unused_variables)]
 

data/rust/src/exemplar/types.rs

@@ -1,4 +1,4 @@
-// Exemplar shapes for rust/project/types.rb; see mod.rs.
+// Exemplar shapes for rust/codegen/src/types.rs; see mod.rs.
 // `closed_set_enum` is a one-field closed set (one variant per member); a multi-field closed
 // set is a fixed data table instead.
 #![allow(dead_code, unused_variables)]

data/rust/src/kernel/cli.rs

@@ -159,7 +159,7 @@ pub fn run(input: &str) -> String {
                              real declared query whose shape this generator's codegen doesn't cover yet (order_by/limit/\
                              cursor/consistency/freshness/authorization/null_semantics/inspection/index_hints, a where \
                              clause hopping through a reference, or a literal comparator value whose true JSON type \
-                             can't be recovered from the exported IR — rust/project/queries.rb's own header has the \
+                             can't be recovered from the exported IR — rust/codegen/src/queries.rs's own header has the \
                              full argument); the wheres-only, single-aggregate field-comparator subset and the ad hoc \
                              filter shape ({{\"aggregate\",\"field\",\"op\",\"value\"}}) both execute for real"
                         )),
@@ -195,7 +195,7 @@ pub fn run(input: &str) -> String {
                              or a real declared read model whose shape this generator's codegen doesn't cover yet \
                              (anything beyond a root aggregate fetched by reference id plus reference-matched sibling \
                              heads — where/order_by/limit/offset/cursor/consistency/freshness/authorize(TenantScope)/\
-                             nulls/inspect_query/use_index — rust/project/read_models.rb's own header has the full \
+                             nulls/inspect_query/use_index — rust/codegen/src/read_models.rs's own header has the full \
                              argument, including why where/order_by/limit specifically can never be recovered from the \
                              canonical IR at all); the named/declared AGGREGATE query form (\"Domain::Aggregate.Query\") \
                              and the ad hoc filter shape ({{\"aggregate\",\"field\",\"op\",\"value\"}}) both execute for \

data/rust/src/kernel/read_model.rs

@@ -1,5 +1,5 @@
 //! Interprets a compiled `report` block (`ReadModelDef`) against a domain's generated
-//! `READ_MODELS` table — the hand-written counterpart to `rust/project/read_models.rb`.
+//! `READ_MODELS` table — the hand-written counterpart to the retired Ruby generator's `read_models.rb`.
 
 use super::refusal_wording::{InvariantViolationGroupByCollisionArgs, NotFoundReadModelReferenceMissingArgs, UnauthorizedTenantRequiredArgs};
 use super::{named_query, query_comparators, query_ordering, repository, AggregateScan, Json, QueryCondition, QueryConditionValue, Refusal};

data/rust/src/lib.rs

@@ -3,6 +3,6 @@
 pub mod generated;
 pub mod kernel;
 
-// Test-only: rust/project/exemplar.rb slices shapes out of this; never in a release build.
+// Test-only: rust/codegen/src/exemplar.rs slices shapes out of this; never in a release build.
 #[cfg(test)]
 pub mod exemplar;

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hecks
 version: !ruby/object:Gem::Version
-  version: 3.1.3
+  version: 3.2.1
 platform: ruby
 authors:
 - Chris Young
@@ -273,6 +273,7 @@ files:
 - lib/hecks/doors/launcher_options.rb
 - lib/hecks/doors/mcp_door.rb
 - lib/hecks/doors/mcp_door_scope.rb
+- lib/hecks/doors/mcp_guide_cache.rb
 - lib/hecks/doors/ruby_door.rb
 - lib/hecks/doors/ruby_door/aggregate_door.rb
 - lib/hecks/doors/ruby_door/chapter.rb
@@ -380,6 +381,8 @@ files:
 - lib/hecks/hecks/adapters/codebase/test_suite.rb
 - lib/hecks/hecks/adapters/codebase/tree.rb
 - lib/hecks/hecks/adapters/console_capture.rb
+- lib/hecks/hecks/adapters/cost_explorer.adapter
+- lib/hecks/hecks/adapters/cost_explorer.rb
 - lib/hecks/hecks/adapters/deploy_toolchain.adapter
 - lib/hecks/hecks/adapters/deploy_toolchain.rb
 - lib/hecks/hecks/adapters/finding_github.adapter
@@ -614,6 +617,7 @@ files:
 - lib/hecks/projections/site/site_cdn.rb
 - lib/hecks/projections/site/table.rb
 - lib/hecks/projections/site/table/checks.rb
+- lib/hecks/projections/site/table/link_builder.rb
 - lib/hecks/projections/site/table/row_builder.rb
 - lib/hecks/projections/statements.rb
 - lib/hecks/projections/vocabulary.rb
@@ -971,28 +975,6 @@ files:
 - rust/parser/src/parse/read_model.rs
 - rust/parser/src/parse/value_object.rs
 - rust/parser/src/ruby_value.rs
-- rust/project.rb
-- rust/project/bridging.rb
-- rust/project/commands.rb
-- rust/project/constraints.rb
-- rust/project/dependency_planning.rb
-- rust/project/domain_generator.rb
-- rust/project/exemplar.rb
-- rust/project/expr_emitter.rb
-- rust/project/fielded.rb
-- rust/project/json_codec.rb
-- rust/project/mutations.rb
-- rust/project/naming.rb
-- rust/project/ports.rb
-- rust/project/queries.rb
-- rust/project/reactions.rb
-- rust/project/read_models.rb
-- rust/project/reference_specs.rb
-- rust/project/registry.rb
-- rust/project/skip_reason.rb
-- rust/project/types.rb
-- rust/project/write_if_changed.rb
-- rust/project_rust_pipeline.rb
 - rust/src/exemplar/commands.rs
 - rust/src/exemplar/constraints.rs
 - rust/src/exemplar/fielded.rs

data/rust/project/bridging.rb

@@ -1,257 +0,0 @@
-module RustProjection
-  module Projector
-    module_function
-
-    # `use` statements for value-object types this aggregate's commands
-    # reference by name but don't declare locally (same chapter only).
-    def cross_aggregate_vo_imports(aggregate, domain_value_object_owner, mod_name)
-      local_names = aggregate[:value_objects].map { |vo| vo[:name] }.to_set
-      attrs = (aggregate[:commands] + aggregate[:entities].flat_map { |e| e[:commands] } +
-               aggregate[:ports].flat_map { |p| p[:operations] })
-              .flat_map { |c| c[:attributes] }
-
-      # A locally-declared type is never "foreign", even if some other
-      # aggregate owns a VO of the same name domain-wide.
-      foreign_types = attrs.map { |a| a[:type] }.uniq.reject { |type| local_names.include?(type) }
-      foreign_types.filter_map { |type| domain_value_object_owner[type] && [type, domain_value_object_owner[type]] }
-                   .sort_by { |(type, owner)| [owner, type] }
-                   .map { |(type, owner)| "use crate::generated::#{mod_name}::#{owner.downcase}::#{rust_ident(type)};" }
-    end
-
-    # Whether target_vo's fields can all be filled from source_vo's fields
-    # (matched by name) or the target's own defaults.
-    def vo_field_bridgeable?(source_vo, target_vo)
-      return false unless source_vo && target_vo
-      return closed_sets_bridgeable?(source_vo, target_vo) if source_vo[:closed_set] || target_vo[:closed_set]
-
-      target_vo[:attributes].all? do |t_attr|
-        source_vo[:attributes].any? { |s_attr| s_attr[:name] == t_attr[:name] } || !t_attr[:default].nil?
-      end
-    end
-
-    # Source closed-set members mappable to target members, or nil unless
-    # every source member is also a target member (so the bridge can't fail).
-    def closed_set_bridge_members(source_vo, target_vo)
-      return nil unless source_vo[:closed_set] && target_vo[:closed_set]
-      return nil unless source_vo[:attributes].size == 1 && target_vo[:attributes].size == 1
-
-      target_values = target_vo[:members].map { |row| row.to_h.values.first.to_s }
-      source_rows   = source_vo[:members]
-      return nil unless source_rows.all? { |row| target_values.include?(row.to_h.values.first.to_s) }
-
-      source_rows
-    end
-
-    def closed_sets_bridgeable?(source_vo, target_vo)
-      !closed_set_bridge_members(source_vo, target_vo).nil?
-    end
-
-    def vo_field_rhs(source_expr, source_vo, target_type, value_objects_by_name)
-      target_vo = value_objects_by_name[target_type]
-      if (rows = closed_set_bridge_members(source_vo, target_vo))
-        arms = rows.map { |row| "#{rust_ident(source_vo[:name])}::#{closed_set_variant(row)} => #{rust_ident(target_type)}::#{closed_set_variant(row)}" }
-        return "match &#{source_expr} { #{arms.join(', ')} }"
-      end
-
-      fields = target_vo[:attributes].map do |t_attr|
-        field = rust_ident_field(t_attr[:name])
-        if source_vo[:attributes].any? { |s_attr| s_attr[:name] == t_attr[:name] }
-          "#{field}: #{source_expr}.#{field}.clone()"
-        else
-          "#{field}: #{literal_rhs(t_attr[:default])}"
-        end
-      end
-      "#{rust_ident(target_type)} { #{fields.join(', ')} }"
-    end
-
-    # Whether a value can move from source_type to target_type. Shared
-    # with `value_rhs`, which performs the bridge this checks for.
-    def bridgeable_value_types?(source_type, target_type, value_objects_by_name)
-      return true if source_type == target_type
-      # Compares Rust representations, not declared type names: a
-      # `Reference<T>` and a bare `String` are both just `String`.
-      return true if effective_scalar_type(source_type) && effective_scalar_type(source_type) == effective_scalar_type(target_type)
-
-      source_vo = value_objects_by_name[source_type]
-      target_vo = value_objects_by_name[target_type]
-      return vo_field_bridgeable?(source_vo, target_vo) if target_vo
-
-      # A single-field source VO unwraps into a bare scalar target when
-      # that one field's own Rust representation already matches it.
-      return false unless source_vo && !source_vo[:closed_set] && source_vo[:attributes].size == 1
-
-      unwrapped_type = source_vo[:attributes].first[:type]
-      unwrapped_type == target_type ||
-        (effective_scalar_type(unwrapped_type) && effective_scalar_type(unwrapped_type) == effective_scalar_type(target_type))
-    end
-
-    def value_rhs(source_expr, source_type, target_type, value_objects_by_name)
-      return "#{source_expr}.clone()" if source_type == target_type
-      return "#{source_expr}.clone()" if effective_scalar_type(source_type) && effective_scalar_type(source_type) == effective_scalar_type(target_type)
-
-      source_vo = value_objects_by_name[source_type]
-      target_vo = value_objects_by_name[target_type]
-      return vo_field_rhs(source_expr, source_vo, target_type, value_objects_by_name) if target_vo
-
-      raise "unsupported coercion #{source_type} -> #{target_type} — bridgeable_value_types? should have caught this" unless source_vo && !source_vo[:closed_set] && source_vo[:attributes].size == 1
-
-      "#{source_expr}.#{rust_ident_field(source_vo[:attributes].first[:name])}.clone()"
-    end
-
-    # Whether a list `:set` needs per-element rebuilding, rather than one
-    # `.clone()`, because source and target elements differ in representation.
-    def list_bridge_requires_element_mapping?(source_type, target_type)
-      return false if source_type == target_type
-
-      !(effective_scalar_type(source_type) && effective_scalar_type(source_type) == effective_scalar_type(target_type))
-    end
-
-    # `value_rhs`, mapped over each element of a list `:set` whose source
-    # and target element types differ.
-    def list_value_rhs(source_expr, source_type, target_type, value_objects_by_name)
-      "#{source_expr}.iter().map(|item| #{value_rhs('item', source_type, target_type, value_objects_by_name)}).collect()"
-    end
-
-    def literal_set_bridgeable?(value, target_type, value_objects_by_name)
-      return literal_hash_bridgeable?(value, target_type, value_objects_by_name) if value.is_a?(Hash) && target_type
-      return false if value.is_a?(Hash)
-      return false unless value.is_a?(String) || value.is_a?(Numeric) || value == true || value == false
-      return true unless target_type && value_objects_by_name[target_type]
-
-      # A scalar literal into a single-field VO stands for that field's
-      # value (mirrors `Value.for_attribute`'s runtime rewrap).
-      sole = sole_field_of(target_type, value_objects_by_name)
-      return false unless sole
-
-      literal_hash_bridgeable?({ sole => value }, target_type, value_objects_by_name)
-    end
-
-    # The right-hand side for a literal into target_type: a Hash, a
-    # scalar rewrapped into a single-field VO, or the scalar itself.
-    def literal_rhs_for(value, target_type, value_objects_by_name)
-      return literal_hash_rhs(value, target_type, value_objects_by_name) if value.is_a?(Hash)
-
-      sole = target_type && value_objects_by_name[target_type] && sole_field_of(target_type, value_objects_by_name)
-      return literal_hash_rhs({ sole => value }, target_type, value_objects_by_name) if sole
-
-      literal_rhs(value)
-    end
-
-    # Whether a literal Hash supplies every field a target VO (or one
-    # of its closed-set members) needs.
-    def literal_hash_bridgeable?(hash, target_type, value_objects_by_name)
-      vo = value_objects_by_name[target_type]
-      return false unless vo
-
-      if vo[:closed_set]
-        vo[:members].any? { |member| member.all? { |field, value| [hash[field.to_sym], hash[field.to_s]].include?(value) } }
-      else
-        vo[:attributes].all? { |attr| hash.key?(attr[:name].to_sym) || hash.key?(attr[:name].to_s) }
-      end
-    end
-
-    def literal_hash_rhs(hash, target_type, value_objects_by_name)
-      vo = value_objects_by_name[target_type]
-      raise "unsupported literal hash source #{hash.inspect} -> #{target_type} — literal_hash_bridgeable? should have caught this" unless vo
-
-      if vo[:closed_set]
-        row = vo[:members].find { |member| member.all? { |field, value| [hash[field.to_sym], hash[field.to_s]].include?(value) } }
-        raise "literal #{hash.inspect} matches no member of #{target_type} — literal_hash_bridgeable? should have caught this" unless row
-
-        "#{rust_ident(target_type)}::#{closed_set_variant(row)}"
-      else
-        fields = vo[:attributes].map do |attr|
-          key = [attr[:name].to_sym, attr[:name].to_s].find { |k| hash.key?(k) }
-          raise "literal #{hash.inspect} missing field #{attr[:name]} for #{target_type} — literal_hash_bridgeable? should have caught this" unless key
-
-          "#{rust_ident_field(attr[:name])}: #{literal_rhs(hash[key])}"
-        end
-        "#{rust_ident(target_type)} { #{fields.join(', ')} }"
-      end
-    end
-
-    def integer_field_of(vo)
-      return nil unless vo && !vo[:closed_set]
-
-      attr = vo[:attributes].find { |a| a[:type] == "Integer" }
-      attr && attr[:name]
-    end
-
-    # The attribute and its one Integer field an `:increment`/`:decrement`
-    # touches, or nil unless the target is a single-field integer VO.
-    def arithmetic_target_field(mutation, aggregate, value_objects_by_name)
-      target_attr = aggregate[:attributes].find { |a| a[:name].to_s == mutation[:target].to_s }
-      return nil unless target_attr && !target_attr[:list]
-
-      field = integer_field_of(value_objects_by_name[target_attr[:type]])
-      field && [target_attr, field]
-    end
-
-    # The amount side of an `:increment`/`:decrement` as a raw Rust
-    # integer expression. Returns nil, not raise, when nothing bridges.
-    def arithmetic_amount_expr(source, command, value_objects_by_name, target_integer_field)
-      if source[:kind] == "literal"
-        value = source[:value]
-        return literal_rhs(value) if value.is_a?(Integer)
-        return nil unless value.is_a?(Hash)
-
-        key = [target_integer_field.to_sym, target_integer_field.to_s].find { |k| value.key?(k) }
-        key && value[key].is_a?(Integer) ? literal_rhs(value[key]) : nil
-      elsif source[:kind] == "argument"
-        arg_attr = command[:attributes].find { |a| a[:name].to_s == source[:name] }
-        return nil unless arg_attr
-        return "args.#{rust_ident_field(arg_attr[:name])}" if arg_attr[:type] == "Integer"
-
-        field = integer_field_of(value_objects_by_name[arg_attr[:type]])
-        field && "args.#{rust_ident_field(arg_attr[:name])}.#{rust_ident_field(field)}"
-      end
-    end
-
-    # `clamp:`'s literal `[min, max]` bounds, or nil for anything else
-    # (non-literal source, wrong length, non-Integer bound).
-    def clamp_bounds_ints(source)
-      return nil unless source[:kind] == "literal"
-
-      value = source[:value]
-      return nil unless value.is_a?(Array) && value.size == 2 && value.all? { |v| v.is_a?(Integer) }
-
-      value
-    end
-
-    # The default for an attribute a creating command's arguments don't
-    # mention: its own default, or one built from its VO's field defaults.
-    def creation_default_rhs(attr, value_objects_by_name)
-      default = attr[:default]
-      unless default.nil?
-        return literal_rhs(default) unless default.is_a?(Hash)
-
-        # Completes a partial Hash default with the target VO's own
-        # per-field defaults first; `literal_hash_rhs` requires every
-        # field present.
-        return literal_hash_rhs(complete_hash_default(default, attr[:type], value_objects_by_name), attr[:type], value_objects_by_name)
-      end
-
-      vo = value_objects_by_name[attr[:type]]
-      return nil unless vo && !vo[:closed_set] && vo[:attributes].all? { |f| !f[:default].nil? }
-
-      fields = vo[:attributes].map { |f| "#{rust_ident_field(f[:name])}: #{literal_rhs(f[:default])}" }
-      "#{rust_ident(attr[:type])} { #{fields.join(', ')} }"
-    end
-
-    # Fields present in `hash`, plus any the target VO defaults on its
-    # own; a field with neither is left out, not set to nil.
-    def complete_hash_default(hash, target_type, value_objects_by_name)
-      vo = value_objects_by_name[target_type]
-      return hash unless vo && !vo[:closed_set]
-
-      vo[:attributes].each_with_object({}) do |field, completed|
-        key = [field[:name].to_sym, field[:name].to_s].find { |k| hash.key?(k) }
-        if key
-          completed[field[:name].to_sym] = hash[key]
-        elsif !field[:default].nil?
-          completed[field[:name].to_sym] = field[:default]
-        end
-      end
-    end
-  end
-end