hecks 2.9.0 → 3.0.1

data/rust/codegen/src/domain_generator.rs

@@ -0,0 +1,1288 @@
+//! Port of `rust/project/domain_generator.rb`'s `DomainGenerator.call`: the per-aggregate
+//! `.rs` files plus `registry.rs`. `metadata.rs` and `ir.json` are not emitted here.
+
+use crate::exemplar::Exemplar;
+use crate::json::Json;
+use crate::manifest::{ruby_inspect, Manifest};
+use crate::registry::{
+    AggregateEntry, CommandEntry, EntityCommandEntry, EntityIdentityEntry, NestedEntityCommandEntry, PortEntry,
+    ReferenceCheck, TenantBoundaryCheck,
+};
+use crate::{commands, json_codec, mutations, ports, queries, reactions, read_models, types};
+use std::collections::HashMap;
+
+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())"),
+            )]
+        }
+    }
+}
+
+pub struct GeneratedFile {
+    pub name: String,
+    pub content: String,
+}
+
+pub struct GeneratedDomain {
+    /// One entry per not-skipped aggregate: `<name_downcase>.rs`.
+    pub aggregate_files: Vec<GeneratedFile>,
+    pub registry_rs: String,
+    pub mod_rs: String,
+    /// Returned so a multi-chapter caller can union aggregates, queries and read models.
+    pub registry_aggregates: Vec<AggregateEntry>,
+    pub query_defs: Vec<crate::queries::QueryDef>,
+    pub read_model_defs: Vec<crate::read_models::ReadModelDef>,
+    /// The exact `manifest.json` bytes.
+    pub manifest_json: String,
+}
+
+fn node_name(node: &Json) -> &str {
+    node.get("name").and_then(Json::as_str).unwrap_or("")
+}
+
+fn reference_checks(
+    command: &Json,
+    aggregates_by_name: &HashMap<String, &Json>,
+    unsupported_names: &[String],
+) -> Vec<ReferenceCheck> {
+    let attrs = command.get("attributes").map(Json::each).unwrap_or(&[]);
+    attrs
+        .iter()
+        .filter_map(|attr| {
+            let target_name = crate::naming::reference_target(crate::attr::type_name(attr))?;
+            let target = aggregates_by_name.get(target_name)?;
+            if unsupported_names.iter().any(|n| n == target_name) {
+                return None;
+            }
+            let identified_by = target.get("identified_by").map(Json::each).unwrap_or(&[]);
+            let heads = identified_by
+                .iter()
+                .map(|p| p.to_s().split('.').next().unwrap_or("").to_string())
+                .collect::<Vec<_>>()
+                .join(", ");
+            Some(ReferenceCheck {
+                field: crate::attr::name(attr).to_string(),
+                optional: crate::attr::optional(attr),
+                list_item: None,
+                target_mod: target
+                    .get("name")
+                    .and_then(Json::as_str)
+                    .unwrap_or("")
+                    .to_lowercase(),
+                target_name: target
+                    .get("name")
+                    .and_then(Json::as_str)
+                    .unwrap_or("")
+                    .to_string(),
+                heads,
+            })
+        })
+        .collect()
+}
+
+/// Reference checks for a command that sets an aggregate `Reference<X>` field from a plain
+/// value-object argument (`sets :member`), which `reference_checks` cannot see.
+///
+/// Sources already typed `Reference<X>` are skipped; `reference_checks` covers them.
+fn state_reference_checks(
+    aggregate: &Json,
+    command: &Json,
+    aggregates_by_name: &HashMap<String, &Json>,
+    unsupported_names: &[String],
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> Vec<ReferenceCheck> {
+    let agg_attrs = aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
+    let cmd_mutations = command.get("mutations").map(Json::each).unwrap_or(&[]);
+    let cmd_attrs = command.get("attributes").map(Json::each).unwrap_or(&[]);
+
+    agg_attrs
+        .iter()
+        .filter_map(|attr| {
+            let target_name = crate::naming::reference_target(crate::attr::type_name(attr))?;
+            let attr_name = crate::attr::name(attr);
+
+            let mutation = cmd_mutations.iter().find(|m| {
+                m.get("op").map(Json::to_s).as_deref() == Some("set")
+                    && m.get("target").map(Json::to_s).as_deref() == Some(attr_name)
+                    && m.get("source").and_then(|s| s.get("kind")).map(Json::to_s).as_deref() == Some("argument")
+            })?;
+
+            let source_name = mutation.get("source").and_then(|s| s.get("name")).map(Json::to_s).unwrap_or_default();
+            let source_attr = cmd_attrs.iter().find(|a| crate::attr::name(a) == source_name)?;
+            if crate::naming::reference_target(crate::attr::type_name(source_attr)).is_some() {
+                return None;
+            }
+
+            // A `has_many` field gets one `check_reference` per element.
+            let (accessor, list_item) = if crate::attr::list(attr) {
+                let item = list_reference_check_item(source_attr, value_objects_by_name)?;
+                (crate::attr::name(source_attr).to_string(), Some(item))
+            } else {
+                (
+                    state_reference_check_accessor(source_attr, value_objects_by_name)?,
+                    None,
+                )
+            };
+
+            let target = aggregates_by_name.get(target_name)?;
+            if unsupported_names.iter().any(|n| n == target_name) {
+                return None;
+            }
+
+            let identified_by = target.get("identified_by").map(Json::each).unwrap_or(&[]);
+            let heads = identified_by
+                .iter()
+                .map(|p| p.to_s().split('.').next().unwrap_or("").to_string())
+                .collect::<Vec<_>>()
+                .join(", ");
+
+            Some(ReferenceCheck {
+                field: accessor,
+                optional: crate::attr::optional(source_attr),
+                list_item,
+                target_mod: target
+                    .get("name")
+                    .and_then(Json::as_str)
+                    .unwrap_or("")
+                    .to_lowercase(),
+                target_name: target
+                    .get("name")
+                    .and_then(Json::as_str)
+                    .unwrap_or("")
+                    .to_string(),
+                heads,
+            })
+        })
+        .collect()
+}
+
+/// The tenant field read off the first query that declares `authorize ..., tenant:`.
+fn tenant_field_for(aggregate: &Json) -> Option<String> {
+    aggregate
+        .get("queries")
+        .map(Json::each)
+        .unwrap_or(&[])
+        .iter()
+        .find_map(|q| q.get("authorization").and_then(|a| a.get("tenant")).map(Json::to_s))
+}
+
+/// Write-side tenant boundary checks for a command's references.
+///
+/// Only emitted when both aggregates declare a tenant field and both tenant attributes have
+/// `state_reference_check_accessor`'s shape; any other shape is left unchecked.
+fn tenant_boundary_checks(
+    aggregate: &Json,
+    command: &Json,
+    aggregates_by_name: &HashMap<String, &Json>,
+    unsupported_names: &[String],
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> Vec<TenantBoundaryCheck> {
+    let Some(own_tenant_field) = tenant_field_for(aggregate) else {
+        return Vec::new();
+    };
+    let cmd_attrs = command.get("attributes").map(Json::each).unwrap_or(&[]);
+    let Some(own_tenant_attr) = cmd_attrs.iter().find(|a| crate::attr::name(a) == own_tenant_field) else {
+        return Vec::new();
+    };
+    let Some(own_accessor) = state_reference_check_accessor(own_tenant_attr, value_objects_by_name) else {
+        return Vec::new();
+    };
+    let aggregate_name = aggregate.get("name").and_then(Json::as_str).unwrap_or("").to_string();
+
+    cmd_attrs
+        .iter()
+        .filter_map(|attr| {
+            let target_name = crate::naming::reference_target(crate::attr::type_name(attr))?;
+            let target = aggregates_by_name.get(target_name)?;
+            if unsupported_names.iter().any(|n| n == target_name) {
+                return None;
+            }
+            let target_tenant_field = tenant_field_for(target)?;
+            let target_attrs = target.get("attributes").map(Json::each).unwrap_or(&[]);
+            let target_tenant_attr = target_attrs
+                .iter()
+                .find(|a| crate::attr::name(a) == target_tenant_field)?;
+            let target_accessor = state_reference_check_accessor(target_tenant_attr, value_objects_by_name)?;
+            let target_decl_name = target.get("name").and_then(Json::as_str).unwrap_or("").to_string();
+
+            Some(TenantBoundaryCheck {
+                reference_field: crate::attr::name(attr).to_string(),
+                target_mod: target_decl_name.to_lowercase(),
+                target_name: target_decl_name,
+                aggregate_name: aggregate_name.clone(),
+                own_tenant_field: own_tenant_field.clone(),
+                own_accessor: own_accessor.clone(),
+                target_tenant_field,
+                target_accessor,
+            })
+        })
+        .collect()
+}
+
+/// Per-element key expression for a list argument: `item` for `list_of(String)`,
+/// `&item.<field>` for single-String-attribute value objects, `None` otherwise.
+fn list_reference_check_item(
+    source_attr: &Json,
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> Option<String> {
+    if !crate::attr::list(source_attr) {
+        return None;
+    }
+    let type_name = crate::attr::type_name(source_attr);
+    if type_name == "String" {
+        return Some("item".to_string());
+    }
+    let vo = value_objects_by_name.get(type_name)?;
+    let vo_attrs = vo.get("attributes").map(Json::each).unwrap_or(&[]);
+    if vo_attrs.len() != 1 || crate::attr::type_name(&vo_attrs[0]) != "String" {
+        return None;
+    }
+    Some(format!(
+        "&item.{}",
+        crate::naming::rust_ident_field(crate::attr::name(&vo_attrs[0]))
+    ))
+}
+
+/// Accessor path for the value a reference check reads off a source argument.
+///
+/// `None` for a multi-attribute value object, or an optional one: `check_reference`'s
+/// optional template assumes `Option<String>`.
+fn state_reference_check_accessor(source_attr: &Json, value_objects_by_name: &HashMap<String, &Json>) -> Option<String> {
+    let name = crate::attr::name(source_attr);
+    if crate::naming::effective_scalar_type(crate::attr::type_name(source_attr)).is_some() {
+        return Some(name.to_string());
+    }
+
+    let vo = value_objects_by_name.get(crate::attr::type_name(source_attr))?;
+    if crate::attr::optional(source_attr) {
+        return None;
+    }
+    let vo_attrs = vo.get("attributes").map(Json::each).unwrap_or(&[]);
+    if vo_attrs.len() != 1 {
+        return None;
+    }
+
+    Some(format!("{name}.{}", crate::naming::rust_ident_field(crate::attr::name(&vo_attrs[0]))))
+}
+
+pub fn generate(
+    exemplar: &Exemplar,
+    ir: &Json,
+    source_label: &str,
+    mod_name: &str,
+) -> GeneratedDomain {
+    let domain_name = ir.get("name").and_then(Json::as_str).unwrap_or("");
+    let all_aggregates = ir.get("aggregates").map(Json::each).unwrap_or(&[]);
+    let aggregates_by_name: HashMap<String, &Json> = all_aggregates
+        .iter()
+        .map(|a| {
+            (
+                a.get("name")
+                    .and_then(Json::as_str)
+                    .unwrap_or("")
+                    .to_string(),
+                a,
+            )
+        })
+        .collect();
+
+    let unsupported_names: Vec<String> = all_aggregates
+        .iter()
+        .filter(|a| {
+            let vos = a.get("value_objects").map(Json::each).unwrap_or(&[]);
+            let vo_by_name: HashMap<String, &Json> = vos
+                .iter()
+                .map(|vo| {
+                    (
+                        vo.get("name")
+                            .and_then(Json::as_str)
+                            .unwrap_or("")
+                            .to_string(),
+                        vo,
+                    )
+                })
+                .collect();
+            !types::unsupported_attribute_types(a, &vo_by_name).is_empty()
+        })
+        .map(|a| {
+            a.get("name")
+                .and_then(Json::as_str)
+                .unwrap_or("")
+                .to_string()
+        })
+        .collect();
+
+    let mut aggregate_files: Vec<GeneratedFile> = Vec::new();
+    let mut registry_aggregates: Vec<AggregateEntry> = Vec::new();
+    let mut manifest = Manifest::default();
+    let process_managers: Vec<Json> = ir
+        .get("process_managers")
+        .map(Json::each)
+        .unwrap_or(&[])
+        .to_vec();
+
+    // Owner of each value object across the whole domain: a command attribute can name a value
+    // object declared by another aggregate. Last writer wins per name.
+    let mut domain_value_object_owner: HashMap<String, String> = HashMap::new();
+    for a in all_aggregates {
+        let owner = a.get("name").and_then(Json::as_str).unwrap_or("").to_string();
+        for vo in a.get("value_objects").map(Json::each).unwrap_or(&[]) {
+            domain_value_object_owner.insert(
+                vo.get("name").and_then(Json::as_str).unwrap_or("").to_string(),
+                owner.clone(),
+            );
+        }
+    }
+    // The value objects themselves, domain-wide; `bridging.rs` needs the definition to bridge
+    // a cross-aggregate argument. Each aggregate's own map wins a name collision.
+    let mut domain_value_objects_by_name: HashMap<String, &Json> = HashMap::new();
+    for a in all_aggregates {
+        for vo in a.get("value_objects").map(Json::each).unwrap_or(&[]) {
+            domain_value_objects_by_name.insert(vo.get("name").and_then(Json::as_str).unwrap_or("").to_string(), vo);
+        }
+    }
+
+    for aggregate in all_aggregates {
+        let agg_name = aggregate.get("name").and_then(Json::as_str).unwrap_or("");
+
+        let value_objects = aggregate
+            .get("value_objects")
+            .map(Json::each)
+            .unwrap_or(&[]);
+        let mut value_objects_by_name: HashMap<String, &Json> = domain_value_objects_by_name.clone();
+        value_objects_by_name.extend(value_objects.iter().map(|vo| {
+            (
+                vo.get("name")
+                    .and_then(Json::as_str)
+                    .unwrap_or("")
+                    .to_string(),
+                vo,
+            )
+        }));
+
+        // A skipped aggregate cascades into the manifest: everything it owns gets an entry
+        // tracing back to the same root cause.
+        let unsupported = types::unsupported_attribute_types(aggregate, &value_objects_by_name);
+        if !unsupported.is_empty() {
+            let aggregate_reason = format!(
+                "attribute type(s) {} not generated yet (a bare, non-list entity-typed attribute isn't resolved to a Rust type)",
+                unsupported.join(", ")
+            );
+            manifest.skipped_as("aggregate", format!("{domain_name}::{agg_name}"), "attribute_type", aggregate_reason.clone());
+            let cascade = format!("owning aggregate not generated: {aggregate_reason}");
+            for command in aggregate.get("commands").map(Json::each).unwrap_or(&[]) {
+                manifest.skipped_as("command", format!("{domain_name}::{agg_name}.{}", node_name(command)), "owning_aggregate", cascade.clone());
+            }
+            for entity in aggregate.get("entities").map(Json::each).unwrap_or(&[]) {
+                let entity_verb = format!("{domain_name}::{agg_name}.{}", node_name(entity));
+                manifest.skipped_as("entity", entity_verb.clone(), "owning_aggregate", cascade.clone());
+                for command in entity.get("commands").map(Json::each).unwrap_or(&[]) {
+                    manifest.skipped_as("entity_command", format!("{entity_verb}.{}", node_name(command)), "owning_aggregate", cascade.clone());
+                }
+            }
+            for port in aggregate.get("ports").map(Json::each).unwrap_or(&[]) {
+                for operation in port.get("operations").map(Json::each).unwrap_or(&[]) {
+                    manifest.skipped_as(
+                        "port_operation",
+                        format!("{domain_name}::{agg_name}.{}.{}", node_name(port), node_name(operation)),
+                        "owning_aggregate",
+                        cascade.clone(),
+                    );
+                }
+            }
+            continue;
+        }
+        manifest.generated("aggregate", format!("{domain_name}::{agg_name}"));
+
+        let record_name = crate::naming::rust_ident(agg_name);
+        let can_route = json_codec::extract_id_supported(aggregate);
+
+        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;");
+        for line in crate::bridging::cross_aggregate_vo_imports(aggregate, &domain_value_object_owner, mod_name) {
+            puts_str(&mut out, &line);
+        }
+        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);
+                // `Some(&[])` refuses unknown keys: without it a mistyped nested field (`value`
+                // for a declared `count`) silently falls through to the field's `default:`.
+                let empty_allowlist: [String; 0] = [];
+                puts_str(
+                    &mut out,
+                    &json_codec::emit_from_json_flat(
+                        exemplar,
+                        &name,
+                        attrs,
+                        &value_objects_by_name,
+                        Some(&empty_allowlist),
+                        None,
+                        false,
+                        false,
+                        None,
+                    ),
+                );
+            }
+            puts_blank(&mut out);
+        }
+
+        let mut entity_commands: Vec<EntityCommandEntry> = Vec::new();
+        let mut nested_entity_commands: Vec<NestedEntityCommandEntry> = Vec::new();
+        // Every entity this aggregate declares, routable or not: `reactions.rs` needs its
+        // identity shape, not its command routability.
+        let mut registry_entities: Vec<EntityIdentityEntry> = Vec::new();
+
+        for entity in aggregate.get("entities").map(Json::each).unwrap_or(&[]) {
+            let entity_verb = format!("{domain_name}::{agg_name}.{}", node_name(entity));
+            manifest.generated("entity", entity_verb.clone());
+            registry_entities.push(EntityIdentityEntry {
+                name: entity.get("name").and_then(Json::as_str).unwrap_or("").to_string(),
+                identified_by: entity.get("identified_by").map(Json::each).unwrap_or(&[]).iter().map(Json::to_s).collect(),
+            });
+            puts_str(
+                &mut out,
+                &types::emit_entity(exemplar, entity, &value_objects_by_name),
+            );
+            puts_blank(&mut out);
+            let entity_name_ident =
+                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_ident,
+                    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_ident,
+                    entity_attrs,
+                    &value_objects_by_name,
+                    false,
+                    &extra,
+                    None,
+                ),
+            );
+            puts_blank(&mut out);
+
+            // Entities nested one level deeper get a struct, JSON codec and routed commands
+            // (`to: { aggregate:, entities: [...] }`). Not generalized past two levels.
+            //
+            // `entity_can_route` gates `extract_id`/`extract_wants` for `entity`; flat-args
+            // dispatch at depth 2 additionally needs the same check on `nested`.
+            let entity_can_route = json_codec::extract_id_supported(entity);
+
+            for nested in entity.get("entities").map(Json::each).unwrap_or(&[]) {
+                let nested_verb = format!("{entity_verb}.{}", node_name(nested));
+                manifest.generated("entity", nested_verb.clone());
+                puts_str(
+                    &mut out,
+                    &types::emit_entity(exemplar, nested, &value_objects_by_name),
+                );
+                puts_blank(&mut out);
+                let nested_name_ident = crate::naming::rust_ident(
+                    nested.get("name").and_then(Json::as_str).unwrap_or(""),
+                );
+                let nested_attrs = nested.get("attributes").map(Json::each).unwrap_or(&[]);
+                let nested_extra = lifecycle_extra_field(nested);
+                puts_str(
+                    &mut out,
+                    &json_codec::emit_to_json_flat(
+                        exemplar,
+                        &nested_name_ident,
+                        nested_attrs,
+                        &value_objects_by_name,
+                        false,
+                        &nested_extra,
+                        None,
+                    ),
+                );
+                puts_blank(&mut out);
+                puts_str(
+                    &mut out,
+                    &json_codec::emit_from_json_state(
+                        exemplar,
+                        &nested_name_ident,
+                        nested_attrs,
+                        &value_objects_by_name,
+                        false,
+                        &nested_extra,
+                        None,
+                    ),
+                );
+                puts_blank(&mut out);
+                // `identity()` is what a routed dispatch matches a doubly-nested element by.
+                puts_str(&mut out, &json_codec::emit_self_identity(exemplar, nested));
+                puts_blank(&mut out);
+
+                // Flat-args addressing resolves `hop1_id` off `entity`'s own `extract_id` too, so
+                // both hops must support it.
+                let nested_can_route = json_codec::extract_id_supported(nested);
+                let unrouted_supported = entity_can_route && nested_can_route;
+                if unrouted_supported {
+                    puts_str(&mut out, &json_codec::emit_extract_id(exemplar, nested));
+                    puts_blank(&mut out);
+                    puts_str(&mut out, &json_codec::emit_extract_id_lenient(exemplar, nested));
+                    puts_blank(&mut out);
+                    puts_str(&mut out, &json_codec::emit_extract_wants(exemplar, nested));
+                    puts_blank(&mut out);
+                }
+
+                let nested_identified_by = nested.get("identified_by").map(Json::each).unwrap_or(&[]);
+                for command in nested.get("commands").map(Json::each).unwrap_or(&[]) {
+                    let nested_command_verb = format!("{nested_verb}.{}", node_name(command));
+                    if let Some(reason) = commands::entity_command_skip_reason(command, nested, &value_objects_by_name) {
+                        manifest.skipped("entity_command", nested_command_verb, reason);
+                        continue;
+                    }
+
+                    puts_str(
+                        &mut out,
+                        &commands::emit_nested_entity_command(
+                            exemplar,
+                            command,
+                            nested,
+                            entity,
+                            aggregate,
+                            domain_name,
+                            &value_objects_by_name,
+                            &aggregates_by_name,
+                            &process_managers,
+                        ),
+                    );
+                    puts_blank(&mut out);
+
+                    manifest.record(
+                        "entity_command",
+                        nested_command_verb,
+                        true,
+                        Some(true),
+                        None,
+                        None,
+                        Some(if unrouted_supported {
+                            "routed (`to: { entities: [...] }`) and flat-args (one identity head per hop) both supported (BUG#19)".to_string()
+                        } else {
+                            "routed (`to: { entities: [...] }`) only — no legacy/flat-argument fallback at this depth (identity shape isn't extract_id-supported at one or both hops; BUG#19's own gate)".to_string()
+                        }),
+                    );
+
+                    let nested_command_name = command.get("name").and_then(Json::as_str).unwrap_or("");
+                    let entity_name_str = entity.get("name").and_then(Json::as_str).unwrap_or("");
+                    let nested_name_str = nested.get("name").and_then(Json::as_str).unwrap_or("");
+                    nested_entity_commands.push(NestedEntityCommandEntry {
+                        verb: format!("{domain_name}::{agg_name}.{entity_name_str}.{nested_name_str}.{nested_command_name}"),
+                        name: nested_command_name.to_string(),
+                        entity_record: entity_name_ident.clone(),
+                        nested_record: nested_name_ident.clone(),
+                        fn_name: format!(
+                            "{}_{}_{}",
+                            entity_name_str.to_lowercase(),
+                            nested_name_str.to_lowercase(),
+                            crate::naming::dispatch_fn_name(&crate::naming::rust_ident(nested_command_name))
+                        ),
+                        args_struct: format!(
+                            "{nested_name_ident}{}NestedEntityArgs",
+                            crate::naming::rust_ident(nested_command_name)
+                        ),
+                        reference_checks: reference_checks(command, &aggregates_by_name, &unsupported_names),
+                        reference_specs: crate::reference_specs::reference_specs(
+                            domain_name,
+                            command.get("attributes").map(Json::each).unwrap_or(&[]),
+                        ),
+                        attributes: command
+                            .get("attributes")
+                            .map(Json::each)
+                            .unwrap_or(&[])
+                            .iter()
+                            .map(|a| a.get("name").map(Json::to_s).unwrap_or_default())
+                            .collect(),
+                        invariant_check_lines: commands::invariant_checks_for(
+                            exemplar,
+                            command,
+                            &aggregates_by_name,
+                            &value_objects_by_name,
+                        ),
+                        role: command.get("role").map(Json::to_s),
+                        entity_name: entity_name_str.to_string(),
+                        entity_identity_reading: entity
+                            .get("identified_by")
+                            .map(Json::each)
+                            .unwrap_or(&[])
+                            .iter()
+                            .map(Json::to_s)
+                            .collect::<Vec<_>>()
+                            .join(", "),
+                        nested_name: nested_name_str.to_string(),
+                        nested_identity_reading: nested_identified_by
+                            .iter()
+                            .map(Json::to_s)
+                            .collect::<Vec<_>>()
+                            .join(", "),
+                        unrouted_supported,
+                    });
+                }
+            }
+
+            if entity_can_route {
+                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);
+            }
+
+            for command in entity.get("commands").map(Json::each).unwrap_or(&[]) {
+                let entity_command_verb = format!("{entity_verb}.{}", node_name(command));
+                if let Some(reason) = commands::entity_command_skip_reason(command, entity, &value_objects_by_name) {
+                    manifest.skipped("entity_command", entity_command_verb, reason);
+                    continue;
+                }
+
+                puts_str(
+                    &mut out,
+                    &commands::emit_entity_command(
+                        exemplar,
+                        command,
+                        entity,
+                        aggregate,
+                        domain_name,
+                        &value_objects_by_name,
+                        &aggregates_by_name,
+                        &process_managers,
+                    ),
+                );
+                puts_blank(&mut out);
+
+                // The function above is generated, but the JSON router cannot reach it unless the
+                // entity identity is `extract_id`-supported.
+                if !entity_can_route {
+                    manifest.unrouted(
+                        "entity_command",
+                        entity_command_verb,
+                        "router_identity",
+                        format!(
+                            "generated as a real Rust function, but not JSON-dispatchable — identity {} isn't a shape extract_id resolves yet (json_codec.rb)",
+                            ruby_inspect(entity.get_raw("identified_by"))
+                        ),
+                    );
+                    continue;
+                }
+                manifest.routed("entity_command", entity_command_verb);
+
+                let entity_command_name = command.get("name").and_then(Json::as_str).unwrap_or("");
+                let identified_by = entity.get("identified_by").map(Json::each).unwrap_or(&[]);
+                entity_commands.push(EntityCommandEntry {
+                    verb: format!(
+                        "{domain_name}::{agg_name}.{entity_name_ident}.{entity_command_name}",
+                        entity_name_ident = entity.get("name").and_then(Json::as_str).unwrap_or("")
+                    ),
+                    name: entity_command_name.to_string(),
+                    entity_record: entity_name_ident.clone(),
+                    fn_name: format!(
+                        "{}_{}",
+                        entity
+                            .get("name")
+                            .and_then(Json::as_str)
+                            .unwrap_or("")
+                            .to_lowercase(),
+                        crate::naming::dispatch_fn_name(&crate::naming::rust_ident(
+                            entity_command_name
+                        ))
+                    ),
+                    args_struct: format!(
+                        "{entity_name_ident}{}EntityArgs",
+                        crate::naming::rust_ident(entity_command_name)
+                    ),
+                    reference_checks: reference_checks(
+                        command,
+                        &aggregates_by_name,
+                        &unsupported_names,
+                    ),
+                    reference_specs: crate::reference_specs::reference_specs(
+                        domain_name,
+                        command.get("attributes").map(Json::each).unwrap_or(&[]),
+                    ),
+                    attributes: command
+                        .get("attributes")
+                        .map(Json::each)
+                        .unwrap_or(&[])
+                        .iter()
+                        .map(|a| a.get("name").map(Json::to_s).unwrap_or_default())
+                        .collect(),
+                    invariant_check_lines: commands::invariant_checks_for(
+                        exemplar,
+                        command,
+                        &aggregates_by_name,
+                        &value_objects_by_name,
+                    ),
+                    role: command.get("role").map(Json::to_s),
+                    entity_name: entity
+                        .get("name")
+                        .and_then(Json::as_str)
+                        .unwrap_or("")
+                        .to_string(),
+                    entity_identity_reading: identified_by
+                        .iter()
+                        .map(Json::to_s)
+                        .collect::<Vec<_>>()
+                        .join(", "),
+                });
+            }
+        }
+
+        // The record carries a pseudo-attribute per `projects` field; a command's Args struct
+        // never sees it.
+        let record_for_struct = types::with_projected_field_pseudo_attributes(aggregate);
+        puts_str(
+            &mut out,
+            &types::emit_record(exemplar, &record_for_struct, &value_objects_by_name),
+        );
+        puts_blank(&mut out);
+        let record_attrs_owned = record_for_struct.get("attributes").map(Json::each).unwrap_or(&[]).to_vec();
+        let record_attrs = record_attrs_owned.as_slice();
+        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);
+        puts_str(&mut out, &types::emit_set_projected_field(aggregate));
+        puts_blank(&mut out);
+        puts_str(&mut out, &types::emit_projected_field_table(aggregate));
+        puts_blank(&mut out);
+
+        if can_route {
+            puts_str(&mut out, &json_codec::emit_extract_id(exemplar, aggregate));
+            puts_blank(&mut out);
+        }
+
+        puts_str(&mut out, &commands::emit_invariants_fn(aggregate));
+        puts_blank(&mut out);
+
+        let mut registry_commands: Vec<CommandEntry> = Vec::new();
+        for command in aggregate.get("commands").map(Json::each).unwrap_or(&[]) {
+            let command_verb = format!("{domain_name}::{agg_name}.{}", node_name(command));
+            if let Some(reason) = commands::command_skip_reason(command, aggregate, &value_objects_by_name) {
+                manifest.skipped("command", command_verb, reason);
+                continue;
+            }
+
+            puts_str(
+                &mut out,
+                &commands::emit_command(
+                    exemplar,
+                    command,
+                    aggregate,
+                    domain_name,
+                    &value_objects_by_name,
+                    &aggregates_by_name,
+                ),
+            );
+            puts_blank(&mut out);
+
+            let command_name = command.get("name").and_then(Json::as_str).unwrap_or("");
+            let args_struct = format!("{}Args", crate::naming::rust_ident(command_name));
+            let cmd_attrs = command.get("attributes").map(Json::each).unwrap_or(&[]);
+            puts_str(
+                &mut out,
+                &json_codec::emit_to_json_flat_sparse(exemplar, &args_struct, cmd_attrs, &value_objects_by_name),
+            );
+            puts_blank(&mut out);
+            let allowlist =
+                json_codec::command_argument_allowlist(aggregate, command, &process_managers, &[]);
+            puts_str(
+                &mut out,
+                &json_codec::emit_from_json_flat(
+                    exemplar,
+                    &args_struct,
+                    cmd_attrs,
+                    &value_objects_by_name,
+                    Some(&allowlist),
+                    Some(command_name),
+                    true,
+                    true,
+                    Some(&aggregates_by_name),
+                ),
+            );
+            puts_blank(&mut out);
+            // One generated gate function per declared argument-gate step, called in vocabulary
+            // order by `kernel::decode_aggregate_arguments`.
+            puts_str(
+                &mut out,
+                &json_codec::emit_argument_gates(&args_struct, command_name, cmd_attrs, Some(&allowlist)),
+            );
+            puts_blank(&mut out);
+
+            let creates = crate::shared::creates_owner(aggregate, command, &value_objects_by_name);
+            let identity = mutations::identity_components(aggregate, command);
+            let identity_extra_params: Vec<String> = if creates {
+                identity.iter().filter_map(|c| c.head.clone()).collect()
+            } else {
+                Vec::new()
+            };
+
+            if !creates && !can_route {
+                manifest.unrouted(
+                    "command",
+                    command_verb,
+                    "router_identity",
+                    format!(
+                        "generated as a real Rust function, but not JSON-dispatchable — identity {} isn't a shape extract_id resolves yet (json_codec.rb)",
+                        ruby_inspect(aggregate.get_raw("identified_by"))
+                    ),
+                );
+                continue;
+            }
+            manifest.routed("command", command_verb);
+
+            registry_commands.push(CommandEntry {
+                verb: format!("{domain_name}::{agg_name}.{command_name}"),
+                name: command_name.to_string(),
+                fn_name: crate::naming::dispatch_fn_name(&crate::naming::rust_ident(command_name)),
+                args_struct,
+                creates,
+                identity_extra_params,
+                // `state_reference_checks` only adds entries `reference_checks` did not cover.
+                reference_checks: {
+                    let mut checks = reference_checks(command, &aggregates_by_name, &unsupported_names);
+                    checks.extend(state_reference_checks(aggregate, command, &aggregates_by_name, &unsupported_names, &value_objects_by_name));
+                    checks
+                },
+                tenant_boundary_checks: tenant_boundary_checks(
+                    aggregate,
+                    command,
+                    &aggregates_by_name,
+                    &unsupported_names,
+                    &value_objects_by_name,
+                ),
+                reference_specs: crate::reference_specs::reference_specs(domain_name, cmd_attrs),
+                attributes: cmd_attrs
+                    .iter()
+                    .map(|a| a.get("name").map(Json::to_s).unwrap_or_default())
+                    .collect(),
+                invariant_check_lines: commands::invariant_checks_for(
+                    exemplar,
+                    command,
+                    &aggregates_by_name,
+                    &value_objects_by_name,
+                ),
+                role: command.get("role").map(Json::to_s),
+            });
+        }
+
+        let mut port_operations: Vec<PortEntry> = Vec::new();
+        for port in aggregate.get("ports").map(Json::each).unwrap_or(&[]) {
+            let port_name = port.get("name").and_then(Json::as_str).unwrap_or("");
+            for operation in port.get("operations").map(Json::each).unwrap_or(&[]) {
+                let operation_verb = format!("{domain_name}::{agg_name}.{port_name}.{}", node_name(operation));
+                if let Some(reason) = ports::port_operation_skip_reason(operation, agg_name, &value_objects_by_name) {
+                    manifest.skipped("port_operation", operation_verb, reason);
+                    continue;
+                }
+                manifest.routed("port_operation", operation_verb);
+
+                puts_str(
+                    &mut out,
+                    &ports::emit_port_operation(
+                        exemplar,
+                        operation,
+                        port_name,
+                        agg_name,
+                        domain_name,
+                        &value_objects_by_name,
+                        &aggregates_by_name,
+                    ),
+                );
+                puts_blank(&mut out);
+
+                let operation_name = operation.get("name").and_then(Json::as_str).unwrap_or("");
+                let operation_attrs = operation.get("attributes").map(Json::each).unwrap_or(&[]);
+                let legacy_receiver_field = operation_attrs
+                    .iter()
+                    .find(|attr| {
+                        crate::naming::reference_target(crate::attr::type_name(attr))
+                            == Some(agg_name)
+                    })
+                    .map(|attr| crate::attr::name(attr).to_string());
+                // A `to:`-declared operation has no Reference-typed attribute; its receiver is a
+                // plain attribute named for the aggregate's identified_by field. Kept apart from
+                // legacy_receiver_field because `split_aggregate_receiver` must not strip it.
+                let to_receiver_field = if operation.get("to").and_then(Json::as_str) == Some(agg_name) {
+                    // `identified_by` holds identity paths: a value-object identity is dotted
+                    // ("reference.value"), while the attribute is named "reference".
+                    aggregate
+                        .get("identified_by")
+                        .map(Json::each)
+                        .unwrap_or(&[])
+                        .first()
+                        .map(Json::to_s)
+                        .and_then(|s| s.split('.').next().map(str::to_string))
+                } else {
+                    None
+                };
+                let operation_reference_checks =
+                    reference_checks(operation, &aggregates_by_name, &unsupported_names)
+                        .into_iter()
+                        .filter(|check| check.target_name != agg_name)
+                        .collect();
+                port_operations.push(PortEntry {
+                    verb: format!("{domain_name}::{agg_name}.{port_name}.{operation_name}"),
+                    name: operation_name.to_string(),
+                    fn_name: format!(
+                        "{}_{}",
+                        port_name.to_lowercase(),
+                        crate::naming::dispatch_fn_name(&crate::naming::rust_ident(operation_name))
+                    ),
+                    args_struct: format!(
+                        "{}{}Args",
+                        crate::naming::rust_ident(port_name),
+                        crate::naming::rust_ident(operation_name)
+                    ),
+                    reference_checks: operation_reference_checks,
+                    legacy_receiver_field,
+                    to_receiver_field,
+                });
+            }
+        }
+
+        aggregate_files.push(GeneratedFile {
+            name: format!("{}.rs", agg_name.to_lowercase()),
+            content: out,
+        });
+
+        registry_aggregates.push(AggregateEntry {
+            name: agg_name.to_string(),
+            module_name: agg_name.to_lowercase(),
+            record: record_name,
+            commands: registry_commands,
+            entity_commands,
+            nested_entity_commands,
+            ports: port_operations,
+            chapter_mod: mod_name.to_string(),
+            domain_name: domain_name.to_string(),
+            reference_specs: crate::reference_specs::reference_specs(
+                domain_name,
+                aggregate.get("attributes").map(Json::each).unwrap_or(&[]),
+            ),
+            identified_by: aggregate.get("identified_by").map(Json::each).unwrap_or(&[]).iter().map(Json::to_s).collect(),
+            entities: registry_entities,
+        });
+    }
+
+    let mut query_defs: Vec<queries::QueryDef> = Vec::new();
+    let assignments_verb = queries::provided_assignments(ir);
+    for aggregate in all_aggregates {
+        let agg_name = aggregate.get("name").and_then(Json::as_str).unwrap_or("");
+        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();
+
+        for query in aggregate.get("queries").map(Json::each).unwrap_or(&[]) {
+            let query_name = query.get("name").and_then(Json::as_str).unwrap_or("");
+            if let Some(reason) = queries::query_skip_reason(query, aggregate, &value_objects_by_name, &aggregates_by_name) {
+                manifest.skipped("query", format!("{domain_name}::{agg_name}.{query_name}"), reason);
+                continue;
+            }
+            manifest.generated("query", format!("{domain_name}::{agg_name}.{query_name}"));
+
+            let (conditions, reference_hop_conditions) = queries::query_conditions_and_hops(domain_name, query, aggregate, &aggregates_by_name);
+            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),
+                conditions,
+                reference_hop_conditions,
+                order_by: query.get("order_by").map(|ob| queries::emit_query_order_by(ob, query.get("null_semantics"))),
+                offset: query.get("offset").map(queries::emit_query_offset),
+                limit: query.get("limit").map(queries::emit_query_limit),
+                authorization: queries::emit_query_authorization(query_name, query.get("authorization")),
+                assignments: assignments_verb.as_deref() == Some(format!("{agg_name}.{query_name}").as_str()),
+                entity: None,
+            });
+        }
+
+        // Entity queries, one level down.
+        let aggregate_id = format!("{domain_name}::{agg_name}");
+        let attrs = aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
+        for entity in aggregate.get("entities").map(Json::each).unwrap_or(&[]) {
+            let entity_name = entity.get("name").and_then(Json::as_str).unwrap_or("");
+            let list_attr = attrs.iter().find(|a| crate::attr::list(a) && crate::attr::type_name(a) == entity_name);
+            for query in entity.get("queries").map(Json::each).unwrap_or(&[]) {
+                let query_name = query.get("name").and_then(Json::as_str).unwrap_or("");
+                let query_verb = format!("{aggregate_id}.{entity_name}.{query_name}");
+                if let Some(reason) = queries::entity_query_skip_reason(query, entity, list_attr.is_some(), &value_objects_by_name) {
+                    manifest.skipped("query", query_verb, reason);
+                    continue;
+                }
+                let Some(list_attr) = list_attr else { continue };
+                manifest.generated("query", query_verb);
+                let identity_keys = entity
+                    .get("identified_by")
+                    .map(Json::each)
+                    .unwrap_or(&[])
+                    .iter()
+                    .map(|path| Json::to_s(path).split('.').next().unwrap_or("").to_string())
+                    .collect();
+                query_defs.push(queries::QueryDef {
+                    verb: format!("{aggregate_id}.{entity_name}.{query_name}"),
+                    aggregate: aggregate_id.clone(),
+                    arg_checks: Vec::new(),
+                    conditions: queries::query_conditions(query),
+                    reference_hop_conditions: Vec::new(),
+                    order_by: query.get("order_by").map(|ob| queries::emit_query_order_by(ob, query.get("null_semantics"))),
+                    offset: query.get("offset").map(queries::emit_query_offset),
+                    limit: query.get("limit").map(queries::emit_query_limit),
+                    authorization: None,
+                    assignments: false,
+                    entity: Some(queries::EntityScope {
+                        list_field: crate::attr::name(list_attr).to_string(),
+                        parent_key: crate::naming::snake(agg_name),
+                        identity_keys,
+                    }),
+                });
+            }
+            manifest.entity_query_gaps(&format!("{aggregate_id}.{entity_name}"), entity.get("entities").map(Json::each).unwrap_or(&[]));
+        }
+    }
+
+    let mut read_model_defs: Vec<read_models::ReadModelDef> = Vec::new();
+    for read_model in ir.get("read_models").map(Json::each).unwrap_or(&[]) {
+        let read_model_id = format!("{domain_name}::{}", node_name(read_model));
+        if let Some(reason) = read_models::read_model_skip_reason(read_model, &aggregates_by_name, &unsupported_names) {
+            manifest.skipped("read_model", read_model_id, reason);
+            continue;
+        }
+        manifest.generated("read_model", read_model_id);
+        read_model_defs.push(read_models::read_model_def(
+            domain_name,
+            read_model,
+            &aggregates_by_name,
+        ));
+    }
+
+    // Policies and process managers have no per-instance skip condition.
+    for policy in ir.get("policies").map(Json::each).unwrap_or(&[]) {
+        manifest.routed("policy", format!("{domain_name}::{}", node_name(policy)));
+    }
+    for pm in &process_managers {
+        manifest.routed("process_manager", format!("{domain_name}::{}", node_name(pm)));
+    }
+    // Lineage-capable aggregates are always generated and routed; the journal path is generic.
+    let lineage_aggregates = ir.get("lineage").and_then(|l| l.get("capable_aggregates")).map(Json::each).unwrap_or(&[]);
+    for lineage_aggregate in lineage_aggregates {
+        manifest.record(
+            "lineage_aggregate",
+            format!("{domain_name}::{}", node_name(lineage_aggregate)),
+            true,
+            Some(true),
+            None,
+            None,
+            Some(format!(
+                "read via rust/host's journal::read_lineage_head_all/_by_id, written via journal::append_lineage_mutation — both generic over storage_name (\"{}\"), dispatched OUTSIDE the WASM kernel/InMemoryRepository path entirely, matching Ruby's own CommandInterpreter routing for a Postgres-bound aggregate (rust/project.rb's own header)",
+                lineage_aggregate.get("storage_name").map(Json::to_s).unwrap_or_default()
+            )),
+        );
+    }
+
+    let policies: Vec<Json> = ir.get("policies").map(Json::each).unwrap_or(&[]).to_vec();
+    // Raw aggregate JSON: a fan-out's addressing key comes from the target command's declared
+    // `references`/`attributes`, which `AggregateEntry` does not carry.
+    let policy_aggregates: Vec<Json> = ir.get("aggregates").map(Json::each).unwrap_or(&[]).to_vec();
+
+    let mut registry_rs = String::new();
+    puts_str(
+        &mut registry_rs,
+        &crate::registry::emit_registry(exemplar, &registry_aggregates),
+    );
+    puts_blank(&mut registry_rs);
+    puts_str(
+        &mut registry_rs,
+        &crate::registry::emit_reference_lookup(&registry_aggregates),
+    );
+    puts_blank(&mut registry_rs);
+    puts_str(
+        &mut registry_rs,
+        &reactions::emit_policy_table(exemplar, domain_name, &policies, &policy_aggregates),
+    );
+    puts_blank(&mut registry_rs);
+    puts_str(
+        &mut registry_rs,
+        &reactions::emit_cross_domain_policy_table(exemplar, domain_name, &policies),
+    );
+    puts_blank(&mut registry_rs);
+    puts_str(
+        &mut registry_rs,
+        &reactions::emit_process_manager_table(exemplar, &process_managers),
+    );
+    puts_blank(&mut registry_rs);
+    let generated_names: Vec<String> = registry_aggregates.iter().map(|a| a.name.clone()).collect();
+    puts_str(
+        &mut registry_rs,
+        &reactions::emit_reference_key_table(
+            exemplar,
+            &[(domain_name.to_string(), generated_names)],
+        ),
+    );
+    puts_blank(&mut registry_rs);
+    puts_str(
+        &mut registry_rs,
+        &reactions::emit_creates_table(exemplar, &registry_aggregates),
+    );
+    puts_blank(&mut registry_rs);
+    puts_str(
+        &mut registry_rs,
+        &reactions::emit_identity_head_table(exemplar, &registry_aggregates),
+    );
+    puts_blank(&mut registry_rs);
+    puts_str(
+        &mut registry_rs,
+        &reactions::emit_entity_identity_head_table(exemplar, &registry_aggregates),
+    );
+    puts_blank(&mut registry_rs);
+    puts_str(
+        &mut registry_rs,
+        &reactions::emit_command_attributes_table(exemplar, &registry_aggregates),
+    );
+    puts_blank(&mut registry_rs);
+    puts_str(
+        &mut registry_rs,
+        &queries::emit_query_table(exemplar, &query_defs),
+    );
+    puts_blank(&mut registry_rs);
+    puts_str(&mut registry_rs, &queries::emit_query_arg_check_table(&query_defs));
+    puts_blank(&mut registry_rs);
+    for rmd in &read_model_defs {
+        if let Some(body) = &rmd.group_by_fn_body {
+            puts_str(&mut registry_rs, body);
+            puts_blank(&mut registry_rs);
+        }
+    }
+    puts_str(
+        &mut registry_rs,
+        &read_models::emit_read_model_table(exemplar, &read_model_defs),
+    );
+
+    let mut mod_rs = String::new();
+    puts_str(
+        &mut mod_rs,
+        "// GENERATED by hecks project_rust — re-run it to refresh this list.",
+    );
+    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()));
+    }
+
+    GeneratedDomain {
+        aggregate_files,
+        registry_rs,
+        mod_rs,
+        registry_aggregates,
+        query_defs,
+        read_model_defs,
+        manifest_json: manifest.to_json_text(),
+    }
+}