hecks 6.0.0 → 7.0.0

data/rust/build/src/pipeline.rs

@@ -24,6 +24,8 @@ pub struct Options {
 
 struct Declaration {
     mod_name: String,
+    // The bluebook's own name, as `hecks project_rust` labels it: whoever attached it, its files
+    // read the same.
     source_label: String,
     ir_text: String,
 }
@@ -146,7 +148,7 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
             let files = resolve::other_gem_bluebook_files(root, fw_name)?;
             declarations.push(Declaration {
                 mod_name: fw_name.to_lowercase(),
-                source_label: format!("{domain} (attaches {fw_name:?})"),
+                source_label: fw_name.clone(),
                 ir_text: parse_bluebook(&parser_bin, fw_name, &files)?,
             });
             continue;
@@ -175,7 +177,7 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
         )?;
         declarations.push(Declaration {
             mod_name: fw_name.to_lowercase(),
-            source_label: format!("{domain} (attaches {fw_name:?})"),
+            source_label: fw_name.clone(),
             ir_text: fw_ir_text,
         });
     }
@@ -206,7 +208,7 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
             // `expected_bluebook_name` above), not the raw `pkg_name` — that
             // would diverge the moment a package name has an underscore.
             mod_name: expected_bluebook_name.to_lowercase(),
-            source_label: format!("{domain} (attaches {pkg_name:?}, from: :vendor)"),
+            source_label: pkg_bluebook_name,
             ir_text: pkg_ir_text,
         });
     }
@@ -221,7 +223,7 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
         sources.extend(hecksagon_path.iter().cloned());
         siblings.push(Declaration {
             mod_name: name.to_lowercase(),
-            source_label: format!("{domain} (attaches {name:?})"),
+            source_label: name.clone(),
             ir_text: parse_bluebook(&parser_bin, name, &sources)?,
         });
     }

data/rust/build/src/resolve.rs

@@ -117,6 +117,7 @@ const OTHER_GEM_BLUEBOOK_DIRS: &[&str] = &[
     "composer/bluebook",
     "quality_control",
     "bulk/bluebook",
+    "ci_pipeline",
 ];
 
 // Every bluebook the gem carries beside the framework members, with the bluebook its header names.

data/rust/codegen/Cargo.toml

@@ -20,7 +20,7 @@ path = "src/main.rs"
 debug = 0
 
 # Clippy beyond its defaults: pedantic and nursery, plus the restriction lints that keep a panic
-# out of library code. `hecks gate_run.gate stage=ci only=rust_clippy` makes each of these an error.
+# out of library code. `hecks gate_run.gate! stage=ci only=rust_clippy` makes each of these an error.
 # The same table is in every crate's Cargo.toml; change them together.
 [lints.clippy]
 pedantic = { level = "warn", priority = -1 }

data/rust/codegen/src/domain_generator.rs

@@ -68,6 +68,7 @@ fn reference_checks(
                 optional: crate::attr::optional(attr),
                 list_item: None,
                 union_tag: None,
+                settled: false,
                 target_mod: target
                     .get("name")
                     .and_then(Json::as_str)
@@ -155,6 +156,7 @@ fn state_reference_checks(
                 optional: crate::attr::optional(source_attr),
                 list_item,
                 union_tag: None,
+                settled: true,
                 target_mod: target
                     .get("name")
                     .and_then(Json::as_str)
@@ -1217,6 +1219,7 @@ pub fn generate(
                 aggregate: format!("{domain_name}::{agg_name}"),
                 arg_checks: queries::query_arg_checks(
                     query,
+                    agg_name,
                     &format!(
                         "crate::generated::{mod_name}::{}",
                         crate::naming::aggregate_module(agg_name)

data/rust/codegen/src/json_codec.rs

@@ -84,6 +84,78 @@ pub fn scalar_json_accessor(scalar_type: &str) -> &'static str {
     }
 }
 
+/// The refusal for a reference argument offered as anything but an id string, worded as Ruby's
+/// `Value.refuse_object_reference` (`reference_wrong_shape`): an object is "an object", any other
+/// value is described as it arrived. `known_by` is the target's `" (X is known by heads)"` tail.
+/// `" (Target is known by heads)"` for a single reference attribute whose target aggregate is
+/// known, `""` for one whose target lives in another domain (Ruby words that refusal too, with
+/// no tail), or `None` when `attr` is no reference or no aggregates were given.
+fn reference_known_by(
+    attr: &Json,
+    aggregates_by_name: Option<&HashMap<String, &Json>>,
+) -> Option<String> {
+    let target_name = naming::reference_target(crate::attr::type_name(attr))?;
+    let Some(target) = aggregates_by_name?.get(target_name) else {
+        return Some(String::new());
+    };
+    let mut heads: Vec<String> = Vec::new();
+    for path in target.get("identified_by").map_or_default(Json::each) {
+        let head = path.to_s().split('.').next().unwrap_or("").to_string();
+        if !heads.contains(&head) {
+            heads.push(head);
+        }
+    }
+    let known = if heads.is_empty() {
+        String::new()
+    } else {
+        format!(" ({target_name} is known by {})", heads.join(", "))
+    };
+    Some(known)
+}
+
+pub fn reference_shape_error(command: &str, key: &str, known_by: &str, value_var: &str) -> String {
+    format!(
+        "crate::kernel::Refusal::TypeMismatch(crate::kernel::refusal_wording::TypeMismatchReferenceWrongShapeArgs {{ command: {}, attribute: {}, offered: &(if matches!({value_var}, crate::kernel::Json::Object(_)) {{ \"an object\".to_string() }} else {{ {value_var}.describe() }}), known_by: {} }}.render_args())",
+        naming::ruby_inspect_string(command),
+        naming::ruby_inspect_string(key),
+        naming::ruby_inspect_string(known_by),
+    )
+}
+
+/// A required reference argument read as its id string; see `reference_shape_error`.
+pub fn reference_from_json_expr(
+    command: &str,
+    key: &str,
+    known_by: &str,
+    default: Option<&Json>,
+) -> String {
+    let error = reference_shape_error(command, key, known_by, "x");
+    if let Some(default) = default {
+        let default_rhs = naming::literal_rhs(default);
+        return format!(
+            "match v.get({}) {{ Some(x) => x.as_str().map(ToString::to_string).ok_or_else(|| {error})?, None => {default_rhs} }}",
+            naming::ruby_inspect_string(key),
+        );
+    }
+    format!(
+        "{{ let x = {}; x.as_str().map(ToString::to_string).ok_or_else(|| {error})? }}",
+        required_field_expr(command, key, "String"),
+    )
+}
+
+/// An already-fetched optional reference argument read as its id string.
+pub fn reference_from_json_value_expr(
+    command: &str,
+    key: &str,
+    known_by: &str,
+    value_expr: &str,
+) -> String {
+    format!(
+        "{value_expr}.as_str().map(ToString::to_string).ok_or_else(|| {})?",
+        reference_shape_error(command, key, known_by, value_expr)
+    )
+}
+
 pub fn scalar_from_json_expr(
     struct_name: &str,
     key: &str,
@@ -302,7 +374,8 @@ pub fn command_argument_allowlist(
 }
 
 /// `ArgumentGate#refuse_absent_arguments`, generated: every declared non-optional name the JSON
-/// omits, sorted, refuses as `AbsentArgument` before any field is built.
+/// omits, sorted, refuses as `AbsentArgument` before any field is built. An argument with a
+/// `default:` is not required: Ruby fills the default for an omitted one (`fill_defaults`).
 ///
 /// Goes through the site's `<Variant>Args` struct, so leaving an argument out does not compile.
 ///
@@ -312,7 +385,7 @@ pub fn command_argument_allowlist(
 fn emit_absent_argument_check(command_name: &str, attributes: &[Json], collect: bool) -> String {
     let mut required: Vec<String> = attributes
         .iter()
-        .filter(|a| !crate::attr::optional(a))
+        .filter(|a| !crate::attr::optional(a) && crate::attr::default(a).is_none())
         .map(|a| naming::rust_field(crate::attr::name(a)))
         .collect();
     required.sort();
@@ -492,7 +565,14 @@ pub fn emit_from_json_flat(
             let list = crate::attr::list(attr);
             let optional = crate::attr::optional(attr);
 
-            let rhs = if list && optional {
+            let known_by = reference_known_by(attr, aggregates_by_name);
+            let rhs = if let (false, Some(known_by)) = (list, known_by.as_deref()) {
+                if optional {
+                    format!("match v.get({}) {{ Some(crate::kernel::Json::Null) | None => None, Some(x) => Some({}) }}", naming::ruby_inspect_string(&key), reference_from_json_value_expr(command_name, &key, known_by, "x"))
+                } else {
+                    reference_from_json_expr(command_name, &key, known_by, crate::attr::default(attr))
+                }
+            } else if list && optional {
                 let mapper = list_element_from_json_mapper(error_name, &key, attr, value_objects_by_name);
                 let array_error = json_type_error(error_name, &key, "an array");
                 format!(
@@ -515,6 +595,11 @@ pub fn emit_from_json_flat(
                 format!("match v.get({}) {{ Some(crate::kernel::Json::Null) | None => None, Some(x) => Some({}) }}", naming::ruby_inspect_string(&key), composite_from_json_expr(attr, value_objects_by_name, "x"))
             } else if let Some(scalar) = scalar {
                 scalar_from_json_expr(scalar_error_name, &key, scalar, crate::attr::default(attr))
+            } else if let Some(default_rhs) = crate::attr::default(attr).and_then(|_| crate::bridging::creation_default_rhs(attr, value_objects_by_name)) {
+                // A composite argument the caller leaves out takes its declared default, as Ruby's
+                // `fill_defaults` gives it. A null the caller sends is a value, not an omission:
+                // it builds the composite from its own fields, as a required composite does.
+                format!("match v.get({}) {{ None => {default_rhs}, Some(x) => {} }}", naming::ruby_inspect_string(&key), composite_from_json_expr(attr, value_objects_by_name, "x"))
             } else if absent_argument_check {
                 // The argument entry point only; see `required_composite_argument_expr`.
                 required_composite_argument_expr(error_name, &key, attr, value_objects_by_name)
@@ -1052,17 +1137,19 @@ pub fn extract_id_supported(aggregate: &Json) -> bool {
 }
 
 pub fn emit_extract_id(exemplar: &Exemplar, aggregate: &Json) -> String {
-    emit_extract_id_shaped(exemplar, aggregate, "extract_id", "to_id_component")
+    emit_extract_id_shaped(exemplar, aggregate, "extract_id", "to_id_component", true)
 }
 
 /// `extract_id` minted as `extract_id_lenient` on `to_id_component_lenient`; entity addressing
-/// only, never a root aggregate's hydrate.
+/// only, never a root aggregate's hydrate. It reads the entity's declared identity alone, as
+/// Ruby's `EntityElement` does: no `id` or reference-key fallback.
 pub fn emit_extract_id_lenient(exemplar: &Exemplar, entity: &Json) -> String {
     emit_extract_id_shaped(
         exemplar,
         entity,
         "extract_id_lenient",
         "to_id_component_lenient",
+        false,
     )
 }
 
@@ -1071,6 +1158,7 @@ fn emit_extract_id_shaped(
     aggregate: &Json,
     method_name: &str,
     coercion: &str,
+    routing_fallbacks: bool,
 ) -> String {
     let name = naming::rust_ident(aggregate.get("name").and_then(Json::as_str).unwrap_or(""));
     let identified_by: Vec<String> = aggregate
@@ -1109,27 +1197,43 @@ fn emit_extract_id_shaped(
     };
 
     let mut tried = identified_by.clone();
-    tried.push("id".to_string());
-    tried.push(reference_key.clone());
+    if routing_fallbacks {
+        tried.push("id".to_string());
+        tried.push(reference_key.clone());
+    }
     let tried = tried.join(", ");
+    let template = if routing_fallbacks {
+        "extract_id"
+    } else {
+        "extract_id_exact"
+    };
 
+    // The exact shape has no reference-key slot, and its type is its own struct.
+    let type_marker = if routing_fallbacks {
+        "TmplExtractIdType"
+    } else {
+        "TmplExtractExactType"
+    };
+    let mut subs: Vec<(&str, String)> = vec![
+        (type_marker, name.clone()),
+        ("tmpl_extract_id_name", method_name.to_string()),
+    ];
+    if routing_fallbacks {
+        subs.push(("tmpl_id_coercion", coercion.to_string()));
+        subs.push((
+            "\"tmpl_reference_key\"",
+            naming::ruby_inspect_string(&reference_key),
+        ));
+    }
+    subs.push(("tmpl_tier1_join_placeholder()", tier1_join));
+    subs.push((
+        "\"tmpl_error_text\"",
+        naming::ruby_inspect_string(&format!("{name}: no identity found (tried {tried})")),
+    ));
     exemplar.compose(
-        "extract_id",
-        &[
-            ("TmplExtractIdType", name.clone()),
-            ("tmpl_extract_id_name", method_name.to_string()),
-            ("tmpl_id_coercion", coercion.to_string()),
-            (
-                "\"tmpl_reference_key\"",
-                naming::ruby_inspect_string(&reference_key),
-            ),
-            ("tmpl_tier1_join_placeholder()", tier1_join),
-            (
-                "\"tmpl_error_text\"",
-                naming::ruby_inspect_string(&format!("{name}: no identity found (tried {tried})")),
-            ),
-        ],
-        "extract_id:TIER1_LINE",
+        template,
+        &subs,
+        &format!("{template}:TIER1_LINE"),
         &tier1_subs,
         "\n",
     )
@@ -1211,3 +1315,58 @@ pub fn emit_self_identity(exemplar: &Exemplar, entity: &Json) -> String {
         ],
     )
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn argument(name: &str, default: Json) -> Json {
+        Json::Object(vec![
+            ("name".to_string(), Json::String(name.to_string())),
+            ("type".to_string(), Json::String("Integer".to_string())),
+            ("optional".to_string(), Json::Bool(false)),
+            ("default".to_string(), default),
+        ])
+    }
+
+    #[test]
+    fn absent_gate_requires_each_argument_without_a_default_and_no_defaulted_one() {
+        let attributes = vec![
+            argument("key", Json::Null),
+            argument("grace", Json::Number("0".to_string())),
+        ];
+        let gate = emit_absent_argument_check("Reap", &attributes, false);
+        assert!(
+            gate.contains("let required: &[&str] = &[\"key\"];"),
+            "{gate}"
+        );
+    }
+
+    #[test]
+    fn a_reference_to_another_domain_is_worded_as_a_reference_with_no_tail() {
+        let attr = Json::Object(vec![
+            ("name".to_string(), Json::String("parcel".to_string())),
+            (
+                "type".to_string(),
+                Json::String("Reference<Parcel>".to_string()),
+            ),
+        ]);
+        let in_this_domain = HashMap::new();
+        assert_eq!(
+            reference_known_by(&attr, Some(&in_this_domain)),
+            Some(String::new())
+        );
+        assert_eq!(reference_known_by(&attr, None), None);
+    }
+
+    #[test]
+    fn a_reference_argument_refuses_in_the_reference_wrong_shape_wording() {
+        let error = reference_shape_error("Open", "parcel", " (Parcel is known by code)", "x");
+        assert!(
+            error.contains("TypeMismatchReferenceWrongShapeArgs"),
+            "{error}"
+        );
+        assert!(error.contains("\"an object\""), "{error}");
+        assert!(error.contains("\" (Parcel is known by code)\""), "{error}");
+    }
+}

data/rust/codegen/src/one_of_references.rs

@@ -117,6 +117,7 @@ fn variant_check(
         optional: crate::attr::optional(source),
         list_item: None,
         union_tag: Some(variant.to_string()),
+        settled: false,
         target_mod: crate::naming::aggregate_module(variant),
         target_name: variant.to_string(),
         heads,

data/rust/codegen/src/queries.rs

@@ -1051,9 +1051,15 @@ pub fn emit_query_table(exemplar: &Exemplar, query_defs: &[QueryDef]) -> String
     )
 }
 
-// One `if let` per value-object argument: built and invariant-checked, then dropped (ADR 0037).
+// The bare scalar types a query argument is shape-checked as, the types `mistyped?` names.
+const SCALAR_ARG_TYPES: [&str; 3] = ["String", "Integer", "Float"];
+
+// One `if let` per argument that is checked: a value object is built and invariant-checked, then
+// dropped (ADR 0037); a bare scalar must hold the shape its declared type names. `owner` is the
+// aggregate's bare name, which a refusal quotes as Ruby's `aggregate.hecks_name` does.
 pub fn query_arg_checks(
     query: &Json,
+    owner: &str,
     mod_path: &str,
     value_objects_by_name: &HashMap<String, &Json>,
 ) -> Vec<String> {
@@ -1067,8 +1073,20 @@ pub fn query_arg_checks(
             {
                 return None;
             }
-            let vo = value_objects_by_name.get(crate::attr::type_name(attr))?;
+            let type_name = crate::attr::type_name(attr);
             let key = naming::rust_field(crate::attr::name(attr));
+            if !value_objects_by_name.contains_key(type_name) {
+                return SCALAR_ARG_TYPES.contains(&type_name).then(|| {
+                    format!(
+                        "if let Some(x) = args.get({}) {{ x.expect_scalar_shape({}, {}, {})?; }}",
+                        naming::ruby_inspect_string(&key),
+                        naming::ruby_inspect_string(owner),
+                        naming::ruby_inspect_string(crate::attr::name(attr)),
+                        naming::ruby_inspect_string(type_name)
+                    )
+                });
+            }
+            let vo = value_objects_by_name.get(type_name)?;
             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) {

data/rust/codegen/src/registry.rs

@@ -15,6 +15,10 @@ pub struct ReferenceCheck {
     /// `Some(variant)` for a tagged `one_of` reference: the check runs only when the argument's
     /// `type` names this variant (ADR 0127).
     pub union_tag: Option<String>,
+    /// True for a reference a command sets through a plain value object: Ruby checks it on the
+    /// settled state at `save`, after hydrate, givens and invariants, so the router defers it
+    /// to `Save` beside the tenant boundary instead of running it with the argument gates.
+    pub settled: bool,
     pub target_mod: String,
     pub target_name: String,
     pub heads: String,
@@ -509,6 +513,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
                     emit_role_check(exemplar, c.role.as_deref(), &c.roles, &c.name),
                     &c.reference_checks
                         .iter()
+                        .filter(|check| !check.settled)
                         .map(|check| emit_reference_check(exemplar, check))
                         .collect::<Vec<_>>()
                 )
@@ -521,9 +526,15 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
 
             // Checks come from `ir.json` at codegen time; none means `Ok(())`, else one closure.
             let tenant_boundary_check_bodies: Vec<String> = c
-                .tenant_boundary_checks
+                .reference_checks
                 .iter()
-                .map(emit_tenant_boundary_check)
+                .filter(|check| check.settled)
+                .map(|check| emit_reference_check(exemplar, check))
+                .chain(
+                    c.tenant_boundary_checks
+                        .iter()
+                        .map(emit_tenant_boundary_check),
+                )
                 .collect();
             let tenant_boundary_check_line = if tenant_boundary_check_bodies.is_empty() {
                 "let tenant_boundary_check: Result<(), crate::kernel::Refusal> = Ok(());"
@@ -616,14 +627,19 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
                 c.name, c.entity_name, c.entity_identity_reading
             );
             // `element_id` uses `extract_id_lenient` (absent vs blank element identity);
-            // `parent_id` stays strict.
+            // `parent_id` stays strict. An element identity the arguments lack refuses as the
+            // missing parent when there is none, since Ruby hydrates the parent before it
+            // locates the element.
             let body_entity_match = format!(
-                "let (parent_id, element_id, element_wants) = match route {{ Some(route) => {{ let element_id = route.entities()[0].clone(); (route.aggregate().to_string(), element_id.clone(), element_id) }}, None => {{ let parent_id = {mod_path}::{}::extract_id(facts_json).map_err(|_| crate::kernel::Refusal::NotFound({}.to_string()))?; let element_id = {mod_path}::{}::extract_id_lenient(facts_json).map_err(|_| crate::kernel::Refusal::NotFound({}.to_string()))?; let element_wants = {mod_path}::{}::extract_wants(facts_json); (parent_id, element_id, element_wants) }}, }};",
+                "let (parent_id, element_id, element_wants) = match route {{ Some(route) => {{ let element_id = route.entities()[0].clone(); (route.aggregate().to_string(), element_id.clone(), element_id) }}, None => {{ let parent_id = {mod_path}::{}::extract_id(facts_json).map_err(|_| crate::kernel::Refusal::NotFound({}.to_string()))?; let element_id = {mod_path}::{}::extract_id_lenient(facts_json).map_err(|_| {{ if store.{module}.find(&parent_id).is_none() {{ crate::kernel::Refusal::NotFound(crate::kernel::refusal_wording::NotFoundRecordMissingArgs {{ aggregate: {record_name}, identity: {identity_reading}, offered: &format!(\"{{parent_id:?}}\") }}.render_args()) }} else {{ crate::kernel::Refusal::NotFound({}.to_string()) }} }})?; let element_wants = {mod_path}::{}::extract_wants(facts_json); (parent_id, element_id, element_wants) }}, }};",
                 a.record,
                 naming::ruby_inspect_string(&entity_parent_no_identity_message),
                 c.entity_record,
                 naming::ruby_inspect_string(&entity_element_no_identity_message),
-                c.entity_record
+                c.entity_record,
+                module = a.module_name,
+                record_name = naming::ruby_inspect_string(&a.record),
+                identity_reading = naming::ruby_inspect_string(&a.identified_by.join(", ")),
             );
 
             let mut body: Vec<String> = vec![

data/rust/expr/Cargo.toml

@@ -16,7 +16,7 @@ path = "src/lib.rs"
 regex = { version = "1", default-features = false, features = ["std", "unicode"] }
 
 # Clippy beyond its defaults: pedantic and nursery, plus the restriction lints that keep a panic
-# out of library code. `hecks gate_run.gate stage=ci only=rust_clippy` makes each of these an error.
+# out of library code. `hecks gate_run.gate! stage=ci only=rust_clippy` makes each of these an error.
 # The same table is in every crate's Cargo.toml; change them together.
 [lints.clippy]
 pedantic = { level = "warn", priority = -1 }

data/rust/host/Cargo.toml

@@ -74,7 +74,7 @@ debug = 0
 opt-level = 2
 
 # Clippy beyond its defaults: pedantic and nursery, plus the restriction lints that keep a panic
-# out of library code. `hecks gate_run.gate stage=ci only=rust_clippy` makes each of these an error.
+# out of library code. `hecks gate_run.gate! stage=ci only=rust_clippy` makes each of these an error.
 # The same table is in every crate's Cargo.toml; change them together.
 [lints.clippy]
 pedantic = { level = "warn", priority = -1 }

data/rust/host/HECKS_RELEASE

@@ -1 +1 @@
-6.0.0
+7.0.0

data/rust/host/core/Cargo.toml

@@ -28,7 +28,7 @@ base64 = "0.22"
 async-trait = "0.1.92"
 
 # Clippy beyond its defaults: pedantic and nursery, plus the restriction lints that keep a panic
-# out of library code. `hecks gate_run.gate stage=ci only=rust_clippy` makes each of these an error.
+# out of library code. `hecks gate_run.gate! stage=ci only=rust_clippy` makes each of these an error.
 # The same table is in every crate's Cargo.toml; change them together.
 [lints.clippy]
 pedantic = { level = "warn", priority = -1 }

data/rust/host/src/bin/mint_harness.rs

@@ -127,6 +127,7 @@ async fn main() -> anyhow::Result<()> {
                 ordinal,
                 &my_hash,
                 &my_label,
+                &storage_shape::canonical(&ir),
                 held_text,
                 &aggregates,
                 &chain,

data/rust/host/src/boot.rs

@@ -589,6 +589,7 @@ async fn boot_postgres(
                     ordinal,
                     my_hash,
                     my_label,
+                    &storage_shape::canonical(ir),
                     held_text,
                     &aggregates,
                     &chain,

data/rust/host/src/store/mint.rs

@@ -365,6 +365,10 @@ pub async fn ensure_base<C: GenericClient>(client: &C, domain: &str) -> anyhow::
     client
         .batch_execute("ALTER TABLE hecks_eras ADD COLUMN IF NOT EXISTS canon_form int")
         .await?;
+    // Ruby's era reader selects `edge`; the Rust mint leaves it NULL (no implicit-edge record).
+    client
+        .batch_execute("ALTER TABLE hecks_eras ADD COLUMN IF NOT EXISTS edge jsonb")
+        .await?;
     client
         .batch_execute(
             "CREATE TABLE IF NOT EXISTS hecks_era_texts (\
@@ -1124,13 +1128,14 @@ async fn hold_first_body<C: GenericClient>(
 ) -> anyhow::Result<()> {
     let hash = storage_shape::mint_hash(ir);
     let label = storage_shape::mint_label(ir);
+    let projection = storage_shape::canonical(ir);
     let digest = format!("{:x}", Sha256::digest(held_text.as_bytes()));
 
     client
         .execute(
-            "INSERT INTO hecks_eras (domain, ordinal, hash, label, held_text, watermark, held_digest, canon_form) \
-             VALUES ($1, 1, $2, $3, $4, 0, $5, $6) ON CONFLICT DO NOTHING",
-            &[&domain, &hash, &label, &held_text, &digest, &storage_shape::FORM_VERSION],
+            "INSERT INTO hecks_eras (domain, ordinal, hash, label, held_text, watermark, held_digest, canon_form, \
+             held_projection) VALUES ($1, 1, $2, $3, $4, 0, $5, $6, $7::text::jsonb) ON CONFLICT DO NOTHING",
+            &[&domain, &hash, &label, &held_text, &digest, &storage_shape::FORM_VERSION, &projection],
         )
         .await?;
     archive_text(client, domain, 1, held_text, &digest).await?;
@@ -1268,6 +1273,7 @@ pub async fn mint_era<C: GenericClient>(
     ordinal: i32,
     hash: &str,
     label: &str,
+    projection: &str,
     held_text: &str,
     aggregates: &[Aggregate],
     edges: &[&Edge],
@@ -1281,6 +1287,7 @@ pub async fn mint_era<C: GenericClient>(
         ordinal,
         hash,
         label,
+        projection,
         held_text,
         aggregates,
         edges,
@@ -1308,6 +1315,7 @@ async fn mint_era_body<C: GenericClient>(
     ordinal: i32,
     hash: &str,
     label: &str,
+    projection: &str,
     held_text: &str,
     aggregates: &[Aggregate],
     edges: &[&Edge],
@@ -1341,9 +1349,9 @@ async fn mint_era_body<C: GenericClient>(
     let digest = format!("{:x}", Sha256::digest(held_text.as_bytes()));
     client
         .execute(
-            "INSERT INTO hecks_eras (domain, ordinal, hash, label, held_text, watermark, held_digest, canon_form) \
-             VALUES ($1, $2, $3, $4, $5, $6, $7, $8)",
-            &[&domain, &ordinal, &hash, &label, &held_text, &watermark, &digest, &storage_shape::FORM_VERSION],
+            "INSERT INTO hecks_eras (domain, ordinal, hash, label, held_text, watermark, held_digest, canon_form, \
+             held_projection) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9::text::jsonb)",
+            &[&domain, &ordinal, &hash, &label, &held_text, &watermark, &digest, &storage_shape::FORM_VERSION, &projection],
         )
         .await?;
     archive_text(client, domain, ordinal, held_text, &digest).await?;
@@ -1895,6 +1903,7 @@ mod tests {
             2,
             &storage_shape::mint_hash(&v2_ir),
             &to_label,
+            &storage_shape::canonical(&v2_ir),
             "v2 source text",
             &[aggregate],
             &[&edge],
@@ -1923,6 +1932,29 @@ mod tests {
                 ),
             ]
         );
+        assert_projections_stored(&client, domain, &[(1, &v1_ir), (2, &v2_ir)]).await;
+    }
+
+    // Each era's `held_projection` is the parsed canonical shape of the IR it was minted from.
+    async fn assert_projections_stored(
+        client: &tokio_postgres::Client,
+        domain: &str,
+        expected: &[(i32, &Value)],
+    ) {
+        for (ordinal, ir) in expected {
+            let row = client
+                .query_one(
+                    "SELECT held_projection::text FROM hecks_eras WHERE domain = $1 AND ordinal = $2",
+                    &[&domain, ordinal],
+                )
+                .await
+                .expect("era row");
+            let stored: Option<String> = row.get(0);
+            let stored: Value =
+                serde_json::from_str(&stored.expect("held_projection set")).expect("json");
+            let wanted: Value = serde_json::from_str(&storage_shape::canonical(ir)).expect("json");
+            assert_eq!(stored, wanted, "era {ordinal} held_projection");
+        }
     }
 
     fn registration_default() -> LifecycleDefault {
@@ -2130,6 +2162,7 @@ mod tests {
             2,
             &storage_shape::mint_hash(&v2_ir),
             &to_label,
+            &storage_shape::canonical(&v2_ir),
             "v2 source",
             &[aggregate],
             &[&edge],
@@ -2436,6 +2469,7 @@ mod tests {
                     era + 1,
                     &"h".repeat(64),
                     &format!("e{}", era + 1),
+                    "{}",
                     "text",
                     &aggregates,
                     &chain,

data/rust/lsp/Cargo.toml

@@ -16,7 +16,7 @@ path = "src/main.rs"
 [dependencies]
 
 # Clippy beyond its defaults: pedantic and nursery, plus the restriction lints that keep a panic
-# out of library code. `hecks gate_run.gate stage=ci only=rust_clippy` makes each of these an error.
+# out of library code. `hecks gate_run.gate! stage=ci only=rust_clippy` makes each of these an error.
 # The same table is in every crate's Cargo.toml; change them together.
 [lints.clippy]
 pedantic = { level = "warn", priority = -1 }

data/rust/parser/Cargo.toml

@@ -21,7 +21,7 @@ path = "src/main.rs"
 debug = 0
 
 # Clippy beyond its defaults: pedantic and nursery, plus the restriction lints that keep a panic
-# out of library code. `hecks gate_run.gate stage=ci only=rust_clippy` makes each of these an error.
+# out of library code. `hecks gate_run.gate! stage=ci only=rust_clippy` makes each of these an error.
 # The same table is in every crate's Cargo.toml; change them together.
 [lints.clippy]
 pedantic = { level = "warn", priority = -1 }