hecks 3.9.1 → 3.10.0

data/rust/Cargo.toml

@@ -5,7 +5,9 @@
 # domain was generated most recently; any other stays reachable via
 # `--no-default-features --features <name>`.
 [features]
-default = ["read_model_on_target_fixture"]
+default = ["reserved_names_fixture"]
+optional_value_object_fixture = []
+reserved_names_fixture = []
 composite_line_ledger = []
 read_model_on_target_fixture = []
 group_by_collision_fixture = []

data/rust/codegen/src/bridging.rs

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

data/rust/codegen/src/domain_generator.rs

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

data/rust/codegen/src/main.rs

@@ -73,7 +73,7 @@ fn run_prelude(args: &[String]) -> Result<(), String> {
         let name = aggregate.get("name").and_then(Json::as_str).unwrap_or("");
         match prelude::aggregate_prelude(&ex, &ir, aggregate, source_label) {
             Some(text) => {
-                let path = format!("{out_dir}/{}.rs", name.to_lowercase());
+                let path = format!("{out_dir}/{}.rs", naming::aggregate_module(name));
                 std::fs::write(&path, text).map_err(|e| format!("writing {path}: {e}"))?;
                 println!("wrote {path}");
             }

data/rust/codegen/src/mutations.rs

@@ -455,6 +455,16 @@ pub fn lifecycle_transition_for(command: &Json, aggregate: &Json) -> Option<Tran
     Some(Transition { field, to_state, from_states, unconstrained })
 }
 
+/// Whether a `state(:field)` source reads an `Option` out of the pre-dispatch record: the field
+/// is declared optional, or the record holds every field as an `Option` (`record_optional`).
+/// Such a source already has the target's wrapping, so it must not be wrapped in `Some` again.
+fn state_source_is_option(source: Option<&Json>, aggregate: &Json, record_optional: bool) -> bool {
+    let Some(source) = source.filter(|s| s.get("kind").map(Json::to_s).unwrap_or_default() == "state") else { return false };
+    let name = source.get("name").map(Json::to_s).unwrap_or_default();
+    let attrs = aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
+    record_optional || attrs.iter().any(|a| crate::attr::name(a) == name && crate::attr::optional(a))
+}
+
 /// Right-hand side for a `set`, coercing the source into the target attribute's declared type.
 ///
 /// `target_list` routes list-to-list sets through `list_value_rhs`; `value_rhs` is scalar-only.
@@ -731,7 +741,8 @@ fn emit_mutation_line_body(
                     let (guard, effective_rhs) = entity_list_replace_guard(aggregate, target_attr, &target_field, &rhs, value_objects_by_name);
                     format!("{guard}{}", exemplar.render("mutation_set_plain", &[("tmpl_field", target_field.to_string()), ("tmpl_rhs_placeholder2()", effective_rhs)]))
                 } else {
-                    let wrap = (optional || crate::attr::optional(target_attr)) && !source_attr.map(crate::attr::optional).unwrap_or(false);
+                    let source_is_option = source_attr.map(crate::attr::optional).unwrap_or(false) || state_source_is_option(source, aggregate, optional);
+                    let wrap = (optional || crate::attr::optional(target_attr)) && !source_is_option;
                     if wrap {
                         exemplar.render("mutation_set_wrapped", &[("tmpl_field", target_field.to_string()), ("tmpl_rhs_placeholder2()", rhs)])
                     } else {
@@ -851,3 +862,37 @@ mod transition_tests {
         assert_eq!(transition_check_arg(Some(&transition)), "None");
     }
 }
+
+#[cfg(test)]
+mod state_source_tests {
+    use super::*;
+
+    fn aggregate() -> Json {
+        Json::parse(r#"{"name":"Page","attributes":[{"name":"body","type":"Body"},{"name":"draft_body","type":"Body","optional":true}]}"#).unwrap()
+    }
+
+    fn state(name: &str) -> Json {
+        Json::parse(&format!(r#"{{"kind":"state","name":"{name}"}}"#)).unwrap()
+    }
+
+    #[test]
+    fn a_state_source_in_an_all_optional_record_is_already_an_option() {
+        assert!(state_source_is_option(Some(&state("body")), &aggregate(), true));
+    }
+
+    #[test]
+    fn a_state_source_reads_an_option_where_it_is_declared_optional() {
+        assert!(state_source_is_option(Some(&state("draft_body")), &aggregate(), false));
+    }
+
+    #[test]
+    fn a_required_state_source_in_a_plain_record_is_not_an_option() {
+        assert!(!state_source_is_option(Some(&state("body")), &aggregate(), false));
+    }
+
+    #[test]
+    fn an_argument_source_is_never_a_state_option() {
+        let argument = Json::parse(r#"{"kind":"argument","name":"draft_body"}"#).unwrap();
+        assert!(!state_source_is_option(Some(&argument), &aggregate(), true));
+    }
+}

data/rust/codegen/src/naming.rs

@@ -70,6 +70,23 @@ pub fn dispatch_fn_name(cmd: &str) -> String {
 /// `hecks project_reserved_names` — the same tables `naming.rb` reads.
 pub use crate::reserved_names::{CARGO_RESERVED_DOMAIN_NAMES, RUST_KEYWORDS};
 
+/// The modules every generated chapter declares itself, beside its aggregates' modules: the
+/// sidecar `metadata`, the `registry` table, and the `merged` router. An aggregate whose
+/// downcased name is one of these would declare the module twice and overwrite the file.
+pub const CHAPTER_OWNED_MODULES: &[&str] = &["metadata", "registry", "merged"];
+
+/// The module (and file stem) one aggregate's generated Rust lives in: its downcased name, or
+/// `<name>_aggregate` when that name is one the chapter declares itself. A downcased name never
+/// holds an underscore, so the suffixed form cannot meet another aggregate's module.
+pub fn aggregate_module(name: &str) -> String {
+    let module = name.to_lowercase();
+    if CHAPTER_OWNED_MODULES.contains(&module.as_str()) {
+        format!("{module}_aggregate")
+    } else {
+        module
+    }
+}
+
 /// `/\A[a-z_][a-z0-9_]*\z/` — a plain lowercase Rust identifier.
 fn plain_lower_identifier(name: &str) -> bool {
     let mut chars = name.chars();
@@ -336,6 +353,19 @@ mod tests {
         assert_eq!(scalar_to_value("String", &deref_scalar("String", "v")).as_deref(), Some("Value::Str(v.clone())"));
     }
 
+    #[test]
+    fn an_aggregate_named_for_a_chapter_module_gets_a_suffixed_module() {
+        assert_eq!(aggregate_module("Metadata"), "metadata_aggregate");
+        assert_eq!(aggregate_module("Registry"), "registry_aggregate");
+        assert_eq!(aggregate_module("Merged"), "merged_aggregate");
+    }
+
+    #[test]
+    fn any_other_aggregate_keeps_its_downcased_module() {
+        assert_eq!(aggregate_module("LineItem"), "lineitem");
+        assert_eq!(aggregate_module("MetadataEntry"), "metadataentry");
+    }
+
     #[test]
     fn refuses_an_aggregate_whose_module_name_is_a_rust_keyword() {
         let refusal = reserved_name_refusal("shop", "shop", &["Pizza", "Match", "Type"]).expect("refused");

data/rust/host/HECKS_RELEASE

@@ -1 +1 @@
-3.9.1
+3.10.0

data/rust/src/kernel/expr.rs

@@ -328,6 +328,12 @@ fn dispatch_operator(category: OperatorCategory, expr: &Expr, ctx: &EvalContext)
 /// refuse here — canonical text is validated at boot, so any refusal
 /// past this point is a codegen bug, not a real business refusal.
 fn lookup(path: &str, ctx: &EvalContext) -> Result<Value, Refusal> {
+    composite::finish(lookup_field(path, ctx)?, path)
+}
+
+/// `lookup`'s walk, stopped before the last field collapses to a scalar: a path may end on a
+/// nested object, which `.set?` reads as present without needing it to be one value.
+pub(crate) fn lookup_field<'a>(path: &str, ctx: &EvalContext<'a>) -> Result<Field<'a>, Refusal> {
     let mut segments = path.split('.');
     let head = segments.next().unwrap();
     let mut current = ctx
@@ -340,7 +346,7 @@ fn lookup(path: &str, ctx: &EvalContext) -> Result<Value, Refusal> {
         current = composite::step(current, seg, head)?;
     }
 
-    composite::finish(current, path)
+    Ok(current)
 }
 
 /// The list-elements reading of a `Lookup` path — same head resolution

data/rust/src/kernel/expression_operators/presence.rs

@@ -1,7 +1,7 @@
 //! Interprets `.present?`/`.blank?` and `.set?`/`.unset?`.
 //! The two pairs share one operator category and differ in how they treat empty values.
 
-use crate::kernel::expr::{interpret as eval, EvalContext, Expr, Value};
+use crate::kernel::expr::{interpret as eval, lookup_field, EvalContext, Expr, Field, Value};
 use crate::kernel::Refusal;
 
 pub fn interpret(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
@@ -20,8 +20,14 @@ pub fn interpret_assignment(expr: &Expr, ctx: &EvalContext) -> Result<Value, Ref
         return Err(Refusal::TypeMismatch(format!("presence::interpret_assignment called with a non-assignment node {expr:?} — a router bug")));
     };
 
-    let v = eval(receiver, ctx)?;
-    let set = !matches!(v, Value::Nil);
+    let set = match &**receiver {
+        // A nested object (an optional value-object attribute) is set whenever it is present.
+        Expr::Lookup(path) => match lookup_field(path, ctx)? {
+            Field::Nested(_) => true,
+            Field::Value(v) => !matches!(v, Value::Nil),
+        },
+        other => !matches!(eval(other, ctx)?, Value::Nil),
+    };
     Ok(Value::Bool(if *negated { !set } else { set }))
 }
 
@@ -93,6 +99,38 @@ mod tests {
         assert_eq!(set(Expr::Array(vec![]), false), Value::Bool(true));
     }
 
+    // A record with one value-object field (`body`, holding a nested object or nothing).
+    struct Draft {
+        body: Option<Body>,
+    }
+    struct Body;
+    impl crate::kernel::expr::Fielded for Body {
+        fn field(&self, _name: &str) -> Option<Field<'_>> {
+            None
+        }
+    }
+    impl crate::kernel::expr::Fielded for Draft {
+        fn field(&self, name: &str) -> Option<Field<'_>> {
+            match (name, &self.body) {
+                ("body", Some(body)) => Some(Field::Nested(body)),
+                ("body", None) => Some(Field::Value(Value::Nil)),
+                _ => None,
+            }
+        }
+    }
+
+    fn set_on(draft: &Draft, negated: bool) -> Value {
+        let expr = Expr::Assignment { receiver: Box::new(Expr::Lookup("body")), negated };
+        eval(&expr, &EvalContext { args: &NoFields, instance: draft }).expect("evaluates")
+    }
+
+    #[test]
+    fn a_nested_object_field_is_set_and_an_absent_one_is_not() {
+        assert_eq!(set_on(&Draft { body: Some(Body) }, false), Value::Bool(true));
+        assert_eq!(set_on(&Draft { body: None }, false), Value::Bool(false));
+        assert_eq!(set_on(&Draft { body: Some(Body) }, true), Value::Bool(false));
+    }
+
     #[test]
     fn unset_negates_set() {
         assert_eq!(set(Expr::Nil, true), Value::Bool(true));

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hecks
 version: !ruby/object:Gem::Version
-  version: 3.9.1
+  version: 3.10.0
 platform: ruby
 authors:
 - Chris Young
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-07 00:00:00.000000000 Z
+date: 2026-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -604,6 +604,7 @@ files:
 - lib/hecks/hecks/adapters/deploy_toolchain.adapter
 - lib/hecks/hecks/adapters/deploy_toolchain.rb
 - lib/hecks/hecks/adapters/deploy_toolchain/answers.rb
+- lib/hecks/hecks/adapters/deploy_toolchain/clearing.rb
 - lib/hecks/hecks/adapters/deploy_toolchain/scripts.rb
 - lib/hecks/hecks/adapters/deploy_toolchain/statuses.rb
 - lib/hecks/hecks/adapters/finding_github.adapter
@@ -645,8 +646,10 @@ files:
 - lib/hecks/hecks/adapters/site_toolchain.adapter
 - lib/hecks/hecks/adapters/site_toolchain.rb
 - lib/hecks/hecks/adapters/site_toolchain/prober.rb
+- lib/hecks/hecks/adapters/site_toolchain/role_prober.rb
 - lib/hecks/hecks/adapters/terminal.adapter
 - lib/hecks/hecks/adapters/terminal.rb
+- lib/hecks/hecks/adapters/world_clearing.rb
 - lib/hecks/hecks/codebase.behaviors
 - lib/hecks/hecks/codebase.bluebook
 - lib/hecks/hecks/context_map.hecksagon
@@ -1043,6 +1046,37 @@ files:
 - lib/hecks/projections/site/admin_cms/templates/sso.rb
 - lib/hecks/projections/site/admin_cms/templates/sso_tail.rb
 - lib/hecks/projections/site/admin_cms/templates/users.rb
+- lib/hecks/projections/site/cms_editor.rb
+- lib/hecks/projections/site/cms_editor/attributes.rb
+- lib/hecks/projections/site/cms_editor/checks.rb
+- lib/hecks/projections/site/cms_editor/media.rb
+- lib/hecks/projections/site/cms_editor/pretty.rb
+- lib/hecks/projections/site/cms_editor/schema.rb
+- lib/hecks/projections/site/cms_editor/setting.rb
+- lib/hecks/projections/site/cms_editor/templates/package.json.tmpl
+- lib/hecks/projections/site/cms_editor/templates/src/app.ts.tmpl
+- lib/hecks/projections/site/cms_editor/templates/src/auth/membership.ts.tmpl
+- lib/hecks/projections/site/cms_editor/templates/src/auth/session.ts.tmpl
+- lib/hecks/projections/site/cms_editor/templates/src/auth/sso.ts.tmpl
+- lib/hecks/projections/site/cms_editor/templates/src/commands.ts.tmpl
+- lib/hecks/projections/site/cms_editor/templates/src/config.ts.tmpl
+- lib/hecks/projections/site/cms_editor/templates/src/host.ts.tmpl
+- lib/hecks/projections/site/cms_editor/templates/src/media/handler.ts.tmpl
+- lib/hecks/projections/site/cms_editor/templates/src/media/multipart.ts.tmpl
+- lib/hecks/projections/site/cms_editor/templates/src/media/sniff.ts.tmpl
+- lib/hecks/projections/site/cms_editor/templates/src/media/storage.ts.tmpl
+- lib/hecks/projections/site/cms_editor/templates/src/schema.ts.tmpl
+- lib/hecks/projections/site/cms_editor/templates/src/server.ts.tmpl
+- lib/hecks/projections/site/cms_editor/templates/src/ui/body_model.js.tmpl
+- lib/hecks/projections/site/cms_editor/templates/src/ui/body_parse.js.tmpl
+- lib/hecks/projections/site/cms_editor/templates/src/ui/body_widget.js.tmpl
+- lib/hecks/projections/site/cms_editor/templates/src/ui/fields.ts.tmpl
+- lib/hecks/projections/site/cms_editor/templates/src/ui/html.ts.tmpl
+- lib/hecks/projections/site/cms_editor/templates/src/ui/input.ts.tmpl
+- lib/hecks/projections/site/cms_editor/templates/src/ui/media_picker.js.tmpl
+- lib/hecks/projections/site/cms_editor/templates/src/ui/outline.ts.tmpl
+- lib/hecks/projections/site/cms_editor/templates/src/ui/pages.ts.tmpl
+- lib/hecks/projections/site/cms_editor/templates/tsconfig.json.tmpl
 - lib/hecks/projections/site/edge.rb
 - lib/hecks/projections/site/edge/behaviours.rb
 - lib/hecks/projections/site/edge/checks.rb
@@ -1064,6 +1098,7 @@ files:
 - lib/hecks/projections/site/payload_driver.rb
 - lib/hecks/projections/site/probe.rb
 - lib/hecks/projections/site/regions.rb
+- lib/hecks/projections/site/role_probe.rb
 - lib/hecks/projections/site/root_rows.rb
 - lib/hecks/projections/site/routes_ts.rb
 - lib/hecks/projections/site/routes_ts/helpers.rb
@@ -1455,6 +1490,7 @@ files:
 - lib/hecks/tools/sequence_script.rb
 - lib/hecks/tools/site_routes.rb
 - lib/hecks/tools/site_routes/cli.rb
+- lib/hecks/tools/site_routes/editor_files.rb
 - lib/hecks/tools/site_routes/root_files.rb
 - lib/hecks/tools/site_routes/templates.rb
 - lib/hecks/tools/tail_merge.rb
@@ -1474,9 +1510,9 @@ files:
 - lib/rubocop/cop/hecks/fallback_hash_lookup.rb
 - lib/rubocop/cop/hecks/sequential_hash_rename_in_loop.rb
 - lib/rubocop/cop/hecks/thread_shared_ivar_mutation.rb
-- prebuilt/0ee7f83cba59ce7d1c45c65ba166b071779f70143449f584f33ff7989f64eccb.marshal
-- prebuilt/6e4a6bcf0aa880e2e6b056e1846b70e5a768090b9dc998bbadeaf5d6bcfd3db8.marshal
-- prebuilt/verdicts-91aaf93ce8981bd9a754948f075d95650dc2ec6435015376f5c60992b36a24b1.json
+- prebuilt/c28d6d9db14eea3e17161e9d9c262efee30b256cf97693a7cfd552bce24b2f7f.marshal
+- prebuilt/cb375cba61ca0dbe8ddb9739c306510fe05e5f4b7a9b6955caff8224c63ea0e0.marshal
+- prebuilt/verdicts-d6d584ad43b5f3cebf88aafbbdbf024c38574acf18e06adffbc555f7786b1c2f.json
 - qa/settings.yml
 - rust/.cargo/config.toml
 - rust/.cargo/mutants.toml