hecks 2.8.0 → 3.0.0

data/rust/codegen/src/naming.rs

@@ -0,0 +1,286 @@
+//! Port of `rust/project/naming.rb`, mirrored function for function.
+
+pub fn scalar_rust_type(type_name: &str) -> Option<&'static str> {
+    match type_name {
+        "String" => Some("String"),
+        "Integer" => Some("i64"),
+        "Float" => Some("f64"),
+        _ => None,
+    }
+}
+
+pub fn reference_type(type_name: &str) -> bool {
+    type_name.starts_with("Reference<")
+}
+
+/// `X` out of `Reference<X>` — `None` for anything that isn't a reference
+/// type at all.
+pub fn reference_target(type_name: &str) -> Option<&str> {
+    type_name.strip_prefix("Reference<").and_then(|rest| rest.strip_suffix('>'))
+}
+
+pub fn effective_scalar_type(type_name: &str) -> Option<&'static str> {
+    if reference_type(type_name) {
+        return Some("String");
+    }
+    match type_name {
+        "String" => Some("String"),
+        "Integer" => Some("Integer"),
+        "Float" => Some("Float"),
+        _ => None,
+    }
+}
+
+pub fn rust_type(type_name: &str, list: bool) -> String {
+    let scalar = effective_scalar_type(type_name);
+    let inner = match scalar {
+        Some(s) => scalar_rust_type(s).unwrap().to_string(),
+        None => rust_ident(type_name),
+    };
+    if list {
+        format!("Vec<{inner}>")
+    } else {
+        inner
+    }
+}
+
+pub fn rust_ident(name: &str) -> String {
+    name.chars().filter(|c| c.is_ascii_alphanumeric()).collect()
+}
+
+/// `cmd.gsub(/(?<=.)([A-Z])/, '_\1').downcase` — insert `_` before every
+/// uppercase letter that isn't the very first character, then lowercase.
+pub fn dispatch_fn_name(cmd: &str) -> String {
+    let mut out = String::new();
+    for (i, c) in cmd.chars().enumerate() {
+        if i > 0 && c.is_ascii_uppercase() {
+            out.push('_');
+        }
+        out.push(c);
+    }
+    out.to_lowercase()
+}
+
+/// Generated from the `RustReservedWord`/`CargoReservedName` vocabularies by
+/// `hecks project_reserved_names` — the same tables `naming.rb` reads.
+pub use crate::reserved_names::{CARGO_RESERVED_DOMAIN_NAMES, RUST_KEYWORDS};
+
+/// `/\A[a-z_][a-z0-9_]*\z/` — a plain lowercase Rust identifier.
+fn plain_lower_identifier(name: &str) -> bool {
+    let mut chars = name.chars();
+    matches!(chars.next(), Some(c) if c == '_' || c.is_ascii_lowercase())
+        && chars.all(|c| c == '_' || c.is_ascii_lowercase() || c.is_ascii_digit())
+}
+
+/// Mirrors `legal_aggregate_mod_identifier?` — the identifier-shape half
+/// only, against the downcased name.
+pub fn legal_aggregate_mod_identifier(name: &str) -> bool {
+    plain_lower_identifier(&name.to_lowercase())
+}
+
+/// Mirrors `valid_domain_mod_name?` — shape, and neither a Rust keyword nor
+/// a reserved Cargo.toml key.
+pub fn valid_domain_mod_name(name: &str) -> bool {
+    plain_lower_identifier(name) && !RUST_KEYWORDS.contains(&name) && !CARGO_RESERVED_DOMAIN_NAMES.contains(&name)
+}
+
+/// `None` when every aggregate name and the domain's module name are usable, else the
+/// refusal text the Ruby generator raises, byte for byte. Aggregates are checked first.
+pub fn reserved_name_refusal(source_label: &str, mod_name: &str, aggregate_names: &[&str]) -> Option<String> {
+    let refused: Vec<&str> = aggregate_names
+        .iter()
+        .copied()
+        .filter(|name| {
+            let module = name.to_lowercase();
+            RUST_KEYWORDS.contains(&module.as_str()) || !legal_aggregate_mod_identifier(name)
+        })
+        .collect();
+    if let Some(first) = refused.first() {
+        let names = refused.iter().map(|name| format!("{name:?}")).collect::<Vec<_>>().join(", ");
+        return Some(format!(
+            "{source_label}: aggregate name(s) {names} can't be used as-is — downcased, each becomes a bare Rust \
+             module identifier (`pub mod {};`) and a generated file name, and at least one is not a plain identifier \
+             or is a Rust keyword (RustReservedWord). Module names get no raw-identifier (r#name) escape hatch — \
+             rename the aggregate.",
+            first.to_lowercase()
+        ));
+    }
+    if valid_domain_mod_name(mod_name) {
+        return None;
+    }
+    Some(format!(
+        "{source_label}: domain module name {mod_name:?} can't be used as-is — it has to double as a Rust module \
+         identifier and a Cargo feature name, and this one is either not a plain lowercase identifier, is a Rust \
+         keyword (RustReservedWord), or is a reserved Cargo.toml key (CargoReservedName). Rename the domain."
+    ))
+}
+
+pub fn rust_field(name: &str) -> String {
+    name.to_string()
+}
+
+pub fn rust_ident_field(name: &str) -> String {
+    let field = rust_field(name);
+    if RUST_KEYWORDS.contains(&field.as_str()) {
+        format!("r#{field}")
+    } else {
+        field
+    }
+}
+
+/// Variant name for a closed-set member: splits on any run of non-alphanumerics, so
+/// glob-shaped values like `"*.port"` work. `Self` becomes `SelfType` / `SelfValue`.
+pub fn closed_set_variant(value: &str) -> String {
+    let variant = value
+        .split(|c: char| !c.is_ascii_alphanumeric())
+        .filter(|s| !s.is_empty())
+        .map(capitalize)
+        .collect::<Vec<_>>()
+        .join("");
+    if variant != "Self" {
+        return variant;
+    }
+    if value.starts_with('S') { "SelfType".to_string() } else { "SelfValue".to_string() }
+}
+
+fn capitalize(word: &str) -> String {
+    let mut chars = word.chars();
+    match chars.next() {
+        None => String::new(),
+        Some(first) => first.to_uppercase().collect::<String>() + &chars.as_str().to_lowercase(),
+    }
+}
+
+/// Port of `Hecks::Naming.snake` —
+/// `gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase`.
+pub fn snake(text: &str) -> String {
+    let chars: Vec<char> = text.chars().collect();
+    let mut first = String::new();
+    for (i, &c) in chars.iter().enumerate() {
+        let next_upper = chars.get(i + 1).is_some_and(|n| n.is_ascii_uppercase());
+        let then_lower = chars.get(i + 2).is_some_and(|n| n.is_ascii_lowercase());
+        first.push(c);
+        if c.is_ascii_uppercase() && next_upper && then_lower {
+            first.push('_');
+        }
+    }
+    let chars: Vec<char> = first.chars().collect();
+    let mut second = String::new();
+    for (i, &c) in chars.iter().enumerate() {
+        second.push(c);
+        let next_upper = chars.get(i + 1).is_some_and(|n| n.is_ascii_uppercase());
+        if (c.is_ascii_lowercase() || c.is_ascii_digit()) && next_upper {
+            second.push('_');
+        }
+    }
+    second.to_lowercase()
+}
+
+/// `name.to_s.gsub(/([a-z0-9])([A-Z])/, '\1_\2').upcase`
+pub fn screaming_snake(name: &str) -> String {
+    let chars: Vec<char> = name.chars().collect();
+    let mut out = String::new();
+    for (i, &c) in chars.iter().enumerate() {
+        if i > 0 {
+            let prev = chars[i - 1];
+            if (prev.is_ascii_lowercase() || prev.is_ascii_digit()) && c.is_ascii_uppercase() {
+                out.push('_');
+            }
+        }
+        out.push(c);
+    }
+    out.to_uppercase()
+}
+
+pub fn scalar_to_value(type_name: &str, rust_expr: &str) -> Option<String> {
+    match type_name {
+        "String" => Some(format!("Value::Str({rust_expr}.clone())")),
+        "Integer" => Some(format!("Value::Int({rust_expr})")),
+        "Float" => Some(format!("Value::Float({rust_expr})")),
+        _ => None,
+    }
+}
+
+/// Mirrors `fielded_capable_nested?`: ordinary value objects and
+/// single-field closed-set enums implement `Fielded`; multi-field closed-set
+/// tables do not.
+pub fn fielded_capable_nested(vo: &crate::json::Json) -> bool {
+    !vo.get("closed_set").map(crate::json::Json::as_bool).unwrap_or(false)
+        || vo.get("attributes").map(crate::json::Json::each).unwrap_or(&[]).len() == 1
+}
+
+/// The `Fielded` impl emitted beside a single-field closed-set enum, exposing `"value"`.
+pub fn emit_closed_set_fielded_impl(vo: &crate::json::Json) -> String {
+    let name = rust_ident(vo.get("name").and_then(crate::json::Json::as_str).unwrap_or(""));
+    let arms = vo.get("members").map(crate::json::Json::each).unwrap_or(&[]).iter().filter_map(|row| {
+        let pair = row.as_array()?.first()?.as_array()?;
+        let raw = pair.get(1)?.to_s();
+        Some(format!("{name}::{} => {}.to_string(),", closed_set_variant(&raw), ruby_inspect_string(&raw)))
+    }).collect::<Vec<_>>().join(" ");
+
+    format!(
+        "impl crate::kernel::Fielded for {name} {{\n    fn field(&self, name: &str) -> Option<crate::kernel::Field<'_>> {{\n        use crate::kernel::{{Field, Value}};\n        match name {{\n            \"value\" => Some(Field::Value(Value::Str(match self {{ {arms} }}))),\n            _ => None,\n        }}\n    }}\n    fn as_scalar(&self) -> Option<crate::kernel::Value> {{\n        match self.field(\"value\") {{ Some(crate::kernel::Field::Value(v)) => Some(v), _ => None }}\n    }}\n}}"
+    )
+}
+
+/// A literal mutation-source RHS; `literal` is a String/Integer/Float/Bool read from `ir.json`.
+pub fn literal_rhs(literal: &crate::json::Json) -> String {
+    match literal {
+        crate::json::Json::String(s) => format!("{}.to_string()", ruby_inspect_string(s)),
+        // Separate arms so a whole-number Float renders as `0.0`, not an integer-typed `0`.
+        crate::json::Json::Int(n) => n.to_string(),
+        crate::json::Json::Float(_) => literal.to_s(),
+        crate::json::Json::Bool(b) => b.to_string(),
+        other => panic!("unsupported literal mutation source {other:?} — not one of String/Integer/Float/Boolean"),
+    }
+}
+
+/// Ruby's `String#inspect`: a double-quoted, backslash/quote-escaped literal.
+pub fn ruby_inspect_string(s: &str) -> String {
+    let mut out = String::with_capacity(s.len() + 2);
+    out.push('"');
+    for c in s.chars() {
+        match c {
+            '"' => out.push_str("\\\""),
+            '\\' => out.push_str("\\\\"),
+            '\n' => out.push_str("\\n"),
+            '\t' => out.push_str("\\t"),
+            '\r' => out.push_str("\\r"),
+            _ => out.push(c),
+        }
+    }
+    out.push('"');
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn refuses_an_aggregate_whose_module_name_is_a_rust_keyword() {
+        let refusal = reserved_name_refusal("shop", "shop", &["Pizza", "Match", "Type"]).expect("refused");
+        assert!(refusal.starts_with("shop: aggregate name(s) \"Match\", \"Type\" can't be used as-is"), "{refusal}");
+        assert!(refusal.contains("`pub mod match;`"), "{refusal}");
+        assert!(refusal.contains("Rust keyword"), "{refusal}");
+    }
+
+    #[test]
+    fn refuses_an_aggregate_name_that_is_not_a_plain_identifier() {
+        assert!(reserved_name_refusal("shop", "shop", &["My-App"]).is_some());
+        assert!(reserved_name_refusal("shop", "shop", &[""]).is_some());
+    }
+
+    #[test]
+    fn refuses_a_domain_module_name_that_is_a_keyword_or_a_cargo_key() {
+        for name in ["crate", "type", "package", "default", "version"] {
+            let refusal = reserved_name_refusal("label", name, &["Widget"]).expect("refused");
+            assert!(refusal.starts_with(&format!("label: domain module name {name:?} can't be used as-is")), "{refusal}");
+        }
+    }
+
+    #[test]
+    fn accepts_ordinary_names_and_cargo_keys_as_aggregate_names() {
+        assert_eq!(reserved_name_refusal("shop", "shop", &["Pizza", "Version", "Default"]), None);
+    }
+}

data/rust/codegen/src/ports.rs

@@ -0,0 +1,208 @@
+//! Port of `rust/project/ports.rb` — read that file's own header comments
+//! in full; this mirrors its algorithm directly, function for function.
+
+use crate::exemplar::Exemplar;
+use crate::json::Json;
+use crate::naming;
+use crate::skip_reason::{skip, SkipReason};
+use std::collections::HashMap;
+
+/// A list attribute carrying `admits:`/`pattern:` is not refused here
+/// (docs/decisions/0051): confirmed against Ruby's real dispatch
+/// pipeline that neither is ever enforced on a list attribute
+/// regardless, so refusing to generate the operation at all would be
+/// more restrictive than Ruby, not a real gap.
+pub fn port_operation_skip_reason(
+    operation: &Json,
+    _owner_name: &str,
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> Option<SkipReason> {
+    let attrs = operation.get("attributes").map(Json::each).unwrap_or(&[]);
+    let unresolved: Vec<&Json> = attrs
+        .iter()
+        .filter(|attr| {
+            if crate::attr::list(attr) {
+                return false;
+            }
+            if naming::reference_type(crate::attr::type_name(attr)) {
+                return false;
+            }
+            if naming::scalar_rust_type(crate::attr::type_name(attr)).is_some() {
+                return false;
+            }
+            !value_objects_by_name.contains_key(crate::attr::type_name(attr))
+        })
+        .collect();
+    if !unresolved.is_empty() {
+        let mut types: Vec<&str> = Vec::new();
+        for a in &unresolved {
+            let t = crate::attr::type_name(a);
+            if !types.contains(&t) {
+                types.push(t);
+            }
+        }
+        return Some(skip("port_attribute_type", format!("attribute type(s) {} not generated yet (a value object this aggregate's own attributes never resolved a Rust type for)", types.join(", "))));
+    }
+
+    None
+}
+
+/// ── One emitter per port operation.
+pub fn emit_port_operation(
+    exemplar: &Exemplar,
+    operation: &Json,
+    port_name: &str,
+    owner_name: &str,
+    domain_name: &str,
+    value_objects_by_name: &HashMap<String, &Json>,
+    aggregates_by_name: &HashMap<String, &Json>,
+) -> String {
+    let args_struct = format!(
+        "{}{}Args",
+        naming::rust_ident(port_name),
+        naming::rust_ident(operation.get("name").and_then(Json::as_str).unwrap_or(""))
+    );
+    let qualified = format!("{domain_name}::{owner_name}");
+    let attrs = operation.get("attributes").map(Json::each).unwrap_or(&[]);
+    // A self-reference on a port operation is a migration-era spelling of
+    // its receiver, never an external fact. Keep accepting old IR while
+    // excluding that field from the typed args and event payload.
+    let fact_attrs: Vec<Json> = attrs
+        .iter()
+        .filter(|attr| naming::reference_target(crate::attr::type_name(attr)) != Some(owner_name))
+        .cloned()
+        .collect();
+
+    let mut struct_lines = vec![format!("pub struct {args_struct} {{")];
+    for attr in &fact_attrs {
+        let mut ty = naming::rust_type(crate::attr::type_name(attr), crate::attr::list(attr));
+        if crate::attr::optional(attr) {
+            ty = format!("Option<{ty}>");
+        }
+        struct_lines.push(format!(
+            "    {}",
+            exemplar.render(
+                "struct_field",
+                &[
+                    ("TmplFieldType", ty),
+                    (
+                        "tmpl_field",
+                        naming::rust_ident_field(crate::attr::name(attr))
+                    )
+                ]
+            )
+        ));
+    }
+    struct_lines.push("}".to_string());
+
+    let invariant_checks = crate::commands::invariant_checks_for(
+        exemplar,
+        operation,
+        aggregates_by_name,
+        value_objects_by_name,
+    );
+    let fn_name = format!(
+        "{}_{}",
+        port_name.to_lowercase(),
+        naming::dispatch_fn_name(&naming::rust_ident(
+            operation.get("name").and_then(Json::as_str).unwrap_or("")
+        ))
+    );
+
+    let emits = operation.get("emits").map(Json::each).unwrap_or(&[]);
+    let events: Vec<String> = emits
+        .iter()
+        .map(|event_name| {
+            format!(
+                "        crate::kernel::Event {{ name: {}.to_string(), aggregate: {}.to_string(), id: receiver_id.to_string(), payload: crate::kernel::Json::Null, occurred_at: None, correlation: None }},",
+                naming::ruby_inspect_string(&event_name.to_s()),
+                naming::ruby_inspect_string(&qualified)
+            )
+        })
+        .collect();
+
+    let dispatch_fn = format!(
+        "pub fn dispatch_operation_{fn_name}(receiver_id: &str, args: {args_struct}) -> Result<Vec<crate::kernel::Event>, crate::kernel::Refusal> {{\n{}\n    Ok(vec![\n{}\n    ])\n}}",
+        invariant_checks.join("\n"),
+        events.join("\n")
+    );
+
+    let operation_name = operation.get("name").and_then(Json::as_str).unwrap_or("");
+    [
+        format!("#[derive(Debug, Clone)]\n{}", struct_lines.join("\n")),
+        crate::json_codec::emit_to_json_flat(exemplar, &args_struct, &fact_attrs, value_objects_by_name, false, &[], None),
+        crate::json_codec::emit_from_json_flat(
+            exemplar,
+            &args_struct,
+            &fact_attrs,
+            value_objects_by_name,
+            None,
+            Some(&format!("{port_name}.{operation_name}")),
+            false,
+            true,
+            Some(aggregates_by_name),
+        ),
+        dispatch_fn,
+    ]
+    .join("\n\n")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn owner_receiver_is_not_a_port_fact_or_event_payload_field() {
+        let operation = Json::parse(
+            r#"{
+              "name":"Receive",
+              "attributes":[
+                {"name":"order","type":"Reference<Order>","list":false,"optional":false},
+                {"name":"amount","type":"Integer","list":false,"optional":false}
+              ],
+              "emits":["PaymentReceived"]
+            }"#,
+        )
+        .unwrap();
+        let value_objects = HashMap::new();
+        let aggregates = HashMap::new();
+
+        assert_eq!(
+            port_operation_skip_reason(&operation, "Order", &value_objects),
+            None
+        );
+        let generated = emit_port_operation(
+            &Exemplar::load(),
+            &operation,
+            "PaymentGateway",
+            "Order",
+            "Pizzas",
+            &value_objects,
+            &aggregates,
+        );
+
+        assert!(generated.contains(
+            "dispatch_operation_paymentgateway_receive(receiver_id: &str, args: PaymentGatewayReceiveArgs)"
+        ));
+        assert!(generated.contains("id: receiver_id.to_string()"));
+        assert!(generated.contains("pub amount: i64"));
+        assert!(!generated.contains("pub order:"));
+        assert!(!generated.contains("v.require(\"order\""));
+    }
+
+    #[test]
+    fn owner_operation_without_a_transitional_reference_is_generated() {
+        let operation = Json::parse(
+            r#"{
+              "name":"Receive",
+              "attributes":[{"name":"amount","type":"Integer","list":false,"optional":false}],
+              "emits":["PaymentReceived"]
+            }"#,
+        )
+        .unwrap();
+        assert_eq!(
+            port_operation_skip_reason(&operation, "Order", &HashMap::new()),
+            None
+        );
+    }
+}

data/rust/codegen/src/prelude.rs

@@ -0,0 +1,116 @@
+//! The prelude of a per-aggregate generated `.rs` file: everything
+//! `domain_generator.rb` writes before the commands loop, byte for byte.
+
+use crate::exemplar::Exemplar;
+use crate::json::Json;
+use crate::{json_codec, types};
+use std::collections::HashMap;
+
+// Mirrors Ruby's `puts`: appends "\n" only when the string does not already end in one.
+fn puts_str(out: &mut String, s: &str) {
+    out.push_str(s);
+    if !s.ends_with('\n') {
+        out.push('\n');
+    }
+}
+
+fn puts_blank(out: &mut String) {
+    out.push('\n');
+}
+
+fn lifecycle_extra_field(node: &Json) -> Vec<(String, String)> {
+    match node.get("lifecycle") {
+        None => vec![],
+        Some(lifecycle) => {
+            let field = lifecycle.get("field").and_then(Json::as_str).unwrap_or("");
+            let ident = crate::naming::rust_ident_field(field);
+            vec![(crate::naming::rust_field(field), format!("crate::kernel::Json::Str(self.{ident}.clone())"))]
+        }
+    }
+}
+
+/// One aggregate's prelude text, or `None` when the aggregate has unsupported attribute
+/// types and no `.rs` file is generated for it.
+pub fn aggregate_prelude(exemplar: &Exemplar, ir: &Json, aggregate: &Json, source_label: &str) -> Option<String> {
+    let value_objects = aggregate.get("value_objects").map(Json::each).unwrap_or(&[]);
+    let value_objects_by_name: HashMap<String, &Json> = value_objects.iter().map(|vo| (vo.get("name").and_then(Json::as_str).unwrap_or("").to_string(), vo)).collect();
+
+    if !types::unsupported_attribute_types(aggregate, &value_objects_by_name).is_empty() {
+        return None;
+    }
+
+    let aggregates_by_name: HashMap<String, &Json> = ir.get("aggregates").map(Json::each).unwrap_or(&[]).iter().map(|a| (a.get("name").and_then(Json::as_str).unwrap_or("").to_string(), a)).collect();
+
+    let mut out = String::new();
+    puts_str(&mut out, &format!("// GENERATED by hecks project_rust from {source_label}'s canonical IR."));
+    puts_str(&mut out, "// Do not hand-edit — re-run hecks project_rust instead.");
+    puts_str(&mut out, "#![allow(dead_code, unused_variables)]");
+    puts_str(&mut out, "use crate::kernel::Expr;");
+    puts_blank(&mut out);
+
+    for vo in value_objects {
+        puts_str(&mut out, &types::emit_value_object(exemplar, vo, &value_objects_by_name, &aggregates_by_name));
+        puts_blank(&mut out);
+
+        let closed_set = vo.get("closed_set").map(Json::as_bool).unwrap_or(false);
+        let attrs = vo.get("attributes").map(Json::each).unwrap_or(&[]);
+        if closed_set && attrs.len() == 1 {
+            puts_str(&mut out, &json_codec::emit_closed_set_codec(exemplar, vo));
+        } else if closed_set {
+            puts_str(&mut out, &json_codec::emit_closed_set_table_codec(exemplar, vo));
+        } else {
+            let name = crate::naming::rust_ident(vo.get("name").and_then(Json::as_str).unwrap_or(""));
+            puts_str(&mut out, &json_codec::emit_to_json_flat(exemplar, &name, attrs, &value_objects_by_name, false, &[], None));
+            puts_blank(&mut out);
+            puts_str(&mut out, &json_codec::emit_from_json_flat(exemplar, &name, attrs, &value_objects_by_name, None, None, false, false, None));
+        }
+        puts_blank(&mut out);
+    }
+
+    for entity in aggregate.get("entities").map(Json::each).unwrap_or(&[]) {
+        puts_str(&mut out, &types::emit_entity(exemplar, entity, &value_objects_by_name));
+        puts_blank(&mut out);
+
+        let entity_name = crate::naming::rust_ident(entity.get("name").and_then(Json::as_str).unwrap_or(""));
+        let entity_attrs = entity.get("attributes").map(Json::each).unwrap_or(&[]);
+        let extra = lifecycle_extra_field(entity);
+        puts_str(&mut out, &json_codec::emit_to_json_flat(exemplar, &entity_name, entity_attrs, &value_objects_by_name, false, &extra, None));
+        puts_blank(&mut out);
+        puts_str(&mut out, &json_codec::emit_from_json_state(exemplar, &entity_name, entity_attrs, &value_objects_by_name, false, &extra, None));
+        puts_blank(&mut out);
+
+        if json_codec::extract_id_supported(entity) {
+            puts_str(&mut out, &json_codec::emit_extract_id(exemplar, entity));
+            puts_blank(&mut out);
+            puts_str(&mut out, &json_codec::emit_extract_id_lenient(exemplar, entity));
+            puts_blank(&mut out);
+            puts_str(&mut out, &json_codec::emit_extract_wants(exemplar, entity));
+            puts_blank(&mut out);
+            puts_str(&mut out, &json_codec::emit_self_identity(exemplar, entity));
+            puts_blank(&mut out);
+        }
+    }
+
+    puts_str(&mut out, &types::emit_record(exemplar, aggregate, &value_objects_by_name));
+    puts_blank(&mut out);
+
+    let record_name = crate::naming::rust_ident(aggregate.get("name").and_then(Json::as_str).unwrap_or(""));
+    let record_attrs = aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
+    let extra = lifecycle_extra_field(aggregate);
+    puts_str(&mut out, &json_codec::emit_to_json_flat(exemplar, &record_name, record_attrs, &value_objects_by_name, true, &extra, Some(aggregate)));
+    puts_blank(&mut out);
+    puts_str(&mut out, &json_codec::emit_from_json_state(exemplar, &record_name, record_attrs, &value_objects_by_name, true, &extra, Some(aggregate)));
+    puts_blank(&mut out);
+    puts_str(
+        &mut out,
+        &format!("impl crate::kernel::ToJson for {record_name} {{\n    fn to_json(&self) -> crate::kernel::Json {{\n        {record_name}::to_json(self)\n    }}\n}}\n"),
+    );
+    puts_blank(&mut out);
+
+    if json_codec::extract_id_supported(aggregate) {
+        puts_str(&mut out, &json_codec::emit_extract_id(exemplar, aggregate));
+        puts_blank(&mut out);
+    }
+
+    Some(out)
+}