hecks 3.14.0 → 5.0.0

data/rust/codegen/src/literal.rs

@@ -2,6 +2,8 @@
 //! `Literal::from_json` covers values embedded raw in ir.json, which were never rendered.
 
 use crate::json::{Json, Number};
+use crate::ruby_value::{self, Value};
+use crate::shared::ruby_to_i;
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum Literal {
@@ -12,73 +14,71 @@ pub enum Literal {
     /// A Symbol, which JSON cannot represent; only `read` produces one (leading-colon strings).
     Symbol(String),
     Str(String),
-    Hash(Vec<(String, Literal)>),
-    Array(Vec<Literal>),
+    Hash(Vec<(String, Self)>),
+    Array(Vec<Self>),
 }
 
 impl Literal {
     /// Converts a raw `Json` value structurally, with no text parsing and no Symbol case.
-    pub fn from_json(value: &Json) -> Literal {
+    pub fn from_json(value: &Json) -> Self {
         match value {
-            Json::Null => Literal::Nil,
-            Json::Bool(b) => Literal::Bool(*b),
+            Json::Null => Self::Nil,
+            Json::Bool(b) => Self::Bool(*b),
             Json::Number(_) => match value.number() {
-                Some(Number::Int(n)) => Literal::Int(n),
-                Some(Number::Float(n)) => Literal::Float(n),
-                None => Literal::Nil,
+                Some(Number::Int(n)) => Self::Int(n),
+                Some(Number::Float(n)) => Self::Float(n),
+                None => Self::Nil,
             },
-            Json::String(s) => Literal::Str(s.clone()),
-            Json::Array(items) => Literal::Array(items.iter().map(Literal::from_json).collect()),
-            Json::Object(pairs) => Literal::Hash(pairs.iter().map(|(k, v)| (k.clone(), Literal::from_json(v))).collect()),
+            Json::String(s) => Self::Str(s.clone()),
+            Json::Array(items) => Self::Array(items.iter().map(Self::from_json).collect()),
+            Json::Object(pairs) => Self::Hash(
+                pairs
+                    .iter()
+                    .map(|(k, v)| (k.clone(), Self::from_json(v)))
+                    .collect(),
+            ),
         }
     }
 
-    pub fn as_hash(&self) -> Option<&[(String, Literal)]> {
+    pub const fn as_hash(&self) -> Option<&[(String, Self)]> {
         match self {
-            Literal::Hash(pairs) => Some(pairs.as_slice()),
+            Self::Hash(pairs) => Some(pairs.as_slice()),
             _ => None,
         }
     }
 
-    pub fn get(&self, key: &str) -> Option<&Literal> {
-        self.as_hash()?.iter().find(|(k, _)| k == key).map(|(_, v)| v)
+    pub fn get(&self, key: &str) -> Option<&Self> {
+        self.as_hash()?
+            .iter()
+            .find(|(k, _)| k == key)
+            .map(|(_, v)| v)
     }
 }
 
 /// `Literal.read`: parses a rendered wire string back to a `Literal`.
 ///
-/// Anything not matching a more specific shape, including a bare word, becomes a `Str`.
+/// Reads through the parser's shared `ruby_value::read`. A bare word becomes a `Str`. An integer
+/// too large for `i64` (the shared reader returns it as `Bare`) becomes `Int(0)`, as `ruby_to_i`
+/// always did: no corpus domain holds one, and a stable `0` keeps generation total.
 pub fn read(text: &str) -> Literal {
-    let raw = text.trim();
-    if raw.is_empty() || raw == "nil" {
-        return Literal::Nil;
-    }
-    if raw == "true" {
-        return Literal::Bool(true);
-    }
-    if raw == "false" {
-        return Literal::Bool(false);
-    }
-    if is_integer(raw) {
-        return Literal::Int(ruby_to_i(raw));
-    }
-    if is_float(raw) {
-        return Literal::Float(raw.parse::<f64>().unwrap_or(0.0));
-    }
-    if let Some(rest) = raw.strip_prefix(':') {
-        return Literal::Symbol(rest.to_string());
-    }
-    if is_quoted(raw) {
-        return Literal::Str(unquote(raw));
-    }
-    if raw.starts_with('{') && raw.ends_with('}') {
-        return read_hash(raw);
-    }
-    if raw.starts_with('[') && raw.ends_with(']') {
-        return read_array(raw);
-    }
+    from_value(ruby_value::read(text))
+}
 
-    Literal::Str(raw.to_string())
+fn from_value(value: Value) -> Literal {
+    match value {
+        Value::Nil => Literal::Nil,
+        Value::Bool(b) => Literal::Bool(b),
+        Value::Int(n) => Literal::Int(n),
+        Value::Float(n) => Literal::Float(n),
+        Value::Str(s) => Literal::Str(s),
+        Value::Symbol(s) => Literal::Symbol(s),
+        Value::Hash(pairs) => {
+            Literal::Hash(pairs.into_iter().map(|(k, v)| (k, from_value(v))).collect())
+        }
+        Value::Array(items) => Literal::Array(items.into_iter().map(from_value).collect()),
+        Value::Bare(text) if is_integer(&text) => Literal::Int(ruby_to_i(&text)),
+        Value::Bare(text) => Literal::Str(text),
+    }
 }
 
 /// `/\A-?\d+\z/`
@@ -87,63 +87,11 @@ fn is_integer(raw: &str) -> bool {
     !s.is_empty() && s.bytes().all(|b| b.is_ascii_digit())
 }
 
-/// `/\A-?\d+\.\d+\z/`
-fn is_float(raw: &str) -> bool {
-    let s = raw.strip_prefix('-').unwrap_or(raw);
-    let Some((int_part, frac_part)) = s.split_once('.') else { return false };
-    !int_part.is_empty() && !frac_part.is_empty() && int_part.bytes().all(|b| b.is_ascii_digit()) && frac_part.bytes().all(|b| b.is_ascii_digit())
-}
-
-fn ruby_to_i(raw: &str) -> i64 {
-    raw.parse().unwrap_or(0)
-}
-
-fn is_quoted(raw: &str) -> bool {
-    raw.len() >= 2 && raw.starts_with('"') && raw.ends_with('"')
-}
-
-/// Drops the surrounding quotes, then unescapes any backslash-escaped character.
-fn unquote(raw: &str) -> String {
-    let inner = &raw[1..raw.len() - 1];
-    let mut out = String::with_capacity(inner.len());
-    let mut chars = inner.chars().peekable();
-    while let Some(c) = chars.next() {
-        if c == '\\' {
-            if let Some(next) = chars.next() {
-                out.push(next);
-                continue;
-            }
-        }
-        out.push(c);
-    }
-    out
-}
-
-fn read_hash(raw: &str) -> Literal {
-    let inner = &raw[1..raw.len() - 1];
-    let pairs = split_items(inner)
-        .into_iter()
-        .map(|item| {
-            // Splits at the first ":" only, like Ruby's `partition`; field names have none.
-            match item.find(':') {
-                Some(idx) => {
-                    let key = item[..idx].trim().to_string();
-                    let held = &item[idx + 1..];
-                    (key, read(held))
-                }
-                None => (item.trim().to_string(), read("")),
-            }
-        })
-        .collect();
-    Literal::Hash(pairs)
-}
-
-fn read_array(raw: &str) -> Literal {
-    let inner = &raw[1..raw.len() - 1];
-    Literal::Array(split_items(inner).into_iter().map(|item| read(&item)).collect())
-}
-
 /// `naming.rb#literal_rhs` for a `Literal`: String/Integer/Float/Boolean, else panics.
+#[allow(
+    clippy::panic,
+    reason = "a drifted exemplar or invalid IR aborts generation on purpose"
+)]
 pub fn literal_rhs(literal: &Literal) -> String {
     match literal {
         Literal::Str(s) => format!("{}.to_string()", crate::naming::ruby_inspect_string(s)),
@@ -168,43 +116,61 @@ fn ruby_float_to_s(literal: &Literal) -> String {
     }
 }
 
-/// Splits on commas outside quoted strings and nested braces/brackets.
-fn split_items(body: &str) -> Vec<String> {
-    let mut items: Vec<String> = Vec::new();
-    let mut current = String::new();
-    let mut depth: i32 = 0;
-    let mut quoting = false;
-    let mut escaping = false;
-
-    for ch in body.chars() {
-        current.push(ch);
-        if escaping {
-            escaping = false;
-            continue;
-        }
-        if quoting && ch == '\\' {
-            escaping = true;
-            continue;
-        }
-        if ch == '"' {
-            quoting = !quoting;
-            continue;
-        }
-        if quoting {
-            continue;
-        }
+#[cfg(test)]
+mod tests {
+    use super::*;
 
-        if ch == '{' || ch == '[' {
-            depth += 1;
-        }
-        if ch == '}' || ch == ']' {
-            depth -= 1;
-        }
-        if ch == ',' && depth == 0 {
-            current.pop();
-            items.push(std::mem::take(&mut current));
-        }
+    fn s(text: &str) -> Literal {
+        Literal::Str(text.to_string())
+    }
+
+    #[test]
+    fn reads_scalars() {
+        assert_eq!(read(""), Literal::Nil);
+        assert_eq!(read("nil"), Literal::Nil);
+        assert_eq!(read("true"), Literal::Bool(true));
+        assert_eq!(read("-12"), Literal::Int(-12));
+        assert_eq!(read("1.5"), Literal::Float(1.5));
+        assert_eq!(read(":name"), Literal::Symbol("name".to_string()));
+        assert_eq!(read(r#""a\"b""#), s("a\"b"));
+    }
+
+    #[test]
+    fn reads_collections() {
+        assert_eq!(
+            read(r#"[1, "x"]"#),
+            Literal::Array(vec![Literal::Int(1), s("x")])
+        );
+        assert_eq!(
+            read("{a: 1, b: :c}"),
+            Literal::Hash(vec![
+                ("a".to_string(), Literal::Int(1)),
+                ("b".to_string(), Literal::Symbol("c".to_string()))
+            ])
+        );
+    }
+
+    #[test]
+    fn bare_word_is_a_string() {
+        assert_eq!(read("Widget"), s("Widget"));
+    }
+
+    #[test]
+    fn overflowing_integer_is_zero_like_ruby_to_i() {
+        assert_eq!(read("99999999999999999999"), Literal::Int(0));
+        assert_eq!(read("-99999999999999999999"), Literal::Int(0));
+    }
+
+    #[test]
+    fn adjacent_and_single_quoted_strings() {
+        assert_eq!(read(r#""a" "b""#), s("ab"));
+        assert_eq!(read(r"'it\'s'"), s("it's"));
+    }
+
+    #[test]
+    fn from_json_and_get() {
+        let hash = read("{a: 1}");
+        assert_eq!(hash.get("a"), Some(&Literal::Int(1)));
+        assert_eq!(Literal::from_json(&Json::Null), Literal::Nil);
     }
-    items.push(current);
-    items.into_iter().map(|s| s.trim().to_string()).filter(|s| !s.is_empty()).collect()
 }

data/rust/codegen/src/main.rs

@@ -1,7 +1,5 @@
 //! `hecks-codegen` — the IR-to-Rust-source generator, the only one (ADR 0086).
 //! Usage: `hecks-codegen <prelude|domain|full> ...`, one subcommand per function below.
-// Some ported `naming.rs` helpers are not called yet.
-#![allow(dead_code)]
 
 mod asks;
 mod attr;
@@ -13,7 +11,12 @@ mod domain_generator;
 mod exemplar;
 mod expr_emitter;
 mod fielded;
+// The one `Hecks::Naming` port, compiled by path into the other Cargo projects too; codegen uses
+// only part of it.
+#[allow(dead_code)]
 mod hecks_naming;
+#[cfg(test)]
+mod hecks_naming_tests;
 mod json;
 mod json_codec;
 mod literal;
@@ -23,18 +26,26 @@ mod naming;
 mod optional_pass;
 mod ports;
 mod prelude;
+mod presenters;
 mod queries;
 mod reactions;
 mod read_models;
 mod reference_specs;
 mod registry;
 mod reserved_names;
+#[path = "../../parser/src/ruby_value.rs"]
+#[allow(
+    dead_code,
+    reason = "shared with the parser, which uses parts codegen does not"
+)]
+mod ruby_value;
 mod shared;
 mod sidecars;
 mod skip_reason;
 mod types;
 
 use json::Json;
+use shared::{puts_blank, puts_str};
 use std::process::ExitCode;
 
 fn main() -> ExitCode {
@@ -69,7 +80,7 @@ fn run_prelude(args: &[String]) -> Result<(), String> {
 
     let ex = exemplar::Exemplar::load();
 
-    let aggregates = ir.get("aggregates").map(Json::each).unwrap_or(&[]);
+    let aggregates = ir.get("aggregates").map_or_default(Json::each);
     for aggregate in aggregates {
         let name = aggregate.get("name").and_then(Json::as_str).unwrap_or("");
         match prelude::aggregate_prelude(&ex, &ir, aggregate, source_label) {
@@ -92,7 +103,9 @@ fn run_prelude(args: &[String]) -> Result<(), String> {
 /// sidecars into `out_dir`.
 fn run_domain(args: &[String]) -> Result<(), String> {
     let [ir_path, source_label, mod_name, out_dir] = args else {
-        return Err("usage: hecks-codegen domain <ir.json> <source_label> <mod_name> <out_dir>".to_string());
+        return Err(
+            "usage: hecks-codegen domain <ir.json> <source_label> <mod_name> <out_dir>".to_string(),
+        );
     };
 
     let ir = read_ir(ir_path)?;
@@ -123,8 +136,7 @@ fn write_domain(
     // Refuse before writing anything, so a name collision is reported before any file exists.
     let aggregate_names: Vec<&str> = ir
         .get("aggregates")
-        .map(Json::each)
-        .unwrap_or(&[])
+        .map_or_default(Json::each)
         .iter()
         .map(|a| a.get("name").and_then(Json::as_str).unwrap_or(""))
         .collect();
@@ -146,7 +158,8 @@ fn write_domain(
     }
 
     let registry_path = format!("{out_dir}/registry.rs");
-    std::fs::write(&registry_path, &generated.registry_rs).map_err(|e| format!("writing {registry_path}: {e}"))?;
+    std::fs::write(&registry_path, &generated.registry_rs)
+        .map_err(|e| format!("writing {registry_path}: {e}"))?;
     println!("wrote {registry_path}");
 
     let mod_path = format!("{out_dir}/mod.rs");
@@ -154,34 +167,25 @@ fn write_domain(
     println!("wrote {mod_path}");
 
     let manifest_path = format!("{out_dir}/manifest.json");
-    std::fs::write(&manifest_path, &generated.manifest_json).map_err(|e| format!("writing {manifest_path}: {e}"))?;
+    std::fs::write(&manifest_path, &generated.manifest_json)
+        .map_err(|e| format!("writing {manifest_path}: {e}"))?;
     println!("wrote {manifest_path}");
 
-    let (ir_json_path, metadata_path) = sidecars::write(std::path::Path::new(out_dir), ir, source_label)?;
+    let (ir_json_path, metadata_path) =
+        sidecars::write(std::path::Path::new(out_dir), ir, source_label)?;
     println!("wrote {}", ir_json_path.display());
     println!("wrote {}", metadata_path.display());
 
     Ok(generated)
 }
 
-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');
-}
-
 /// `hecks-codegen full <out_root> <target_mod_name> <target_source_label> <target_ir.json>
 /// [<chapter_mod_name> <chapter_source_label> <chapter_ir.json>]...`
 ///
 /// Writes the target chapter's directory, each attached chapter's own directory, and the
 /// target's `merged.rs`: one `Store`/`dispatch_by_name` table spanning every chapter given.
 fn run_full(args: &[String]) -> Result<(), String> {
-    if args.len() < 4 || (args.len() - 4) % 3 != 0 {
+    if args.len() < 4 || !(args.len() - 4).is_multiple_of(3) {
         return Err(
             "usage: hecks-codegen full <out_root> <target_mod_name> <target_source_label> <target_ir.json> [<chapter_mod_name> <chapter_source_label> <chapter_ir.json>]..."
                 .to_string(),
@@ -196,19 +200,38 @@ fn run_full(args: &[String]) -> Result<(), String> {
     let ex = exemplar::Exemplar::load();
 
     let target_ir = read_ir(target_ir_path)?;
-    let target_domain_name = target_ir.get("name").and_then(Json::as_str).unwrap_or("").to_string();
+    let target_domain_name = target_ir
+        .get("name")
+        .and_then(Json::as_str)
+        .unwrap_or("")
+        .to_string();
 
     let target_out_dir = format!("{out_root}/{target_mod_name}");
-    let target_gen = write_domain(&ex, &target_ir, target_source_label, target_mod_name, &target_out_dir)?;
+    let target_gen = write_domain(
+        &ex,
+        &target_ir,
+        target_source_label,
+        target_mod_name,
+        &target_out_dir,
+    )?;
 
     // Target first, then each attached chapter in command-line order.
-    let mut reference_key_pairs: Vec<(String, Vec<String>)> =
-        vec![(target_domain_name.clone(), target_gen.registry_aggregates.iter().map(|a| a.name.clone()).collect())];
+    let mut reference_key_pairs: Vec<(String, Vec<String>)> = vec![(
+        target_domain_name.clone(),
+        target_gen
+            .registry_aggregates
+            .iter()
+            .map(|a| a.name.clone())
+            .collect(),
+    )];
 
     let mut merged_aggregates = target_gen.registry_aggregates;
     let mut merged_queries = target_gen.query_defs;
     let mut merged_read_models = target_gen.read_model_defs;
-    let mut merged_process_managers: Vec<Json> = target_ir.get("process_managers").map(Json::each).unwrap_or(&[]).to_vec();
+    let mut merged_process_managers: Vec<Json> = target_ir
+        .get("process_managers")
+        .map_or_default(Json::each)
+        .to_vec();
 
     // Policies and process managers merge across chapters; `chapter_irs` keeps each parsed
     // chapter alive so `policy_sources` can borrow from it.
@@ -223,60 +246,127 @@ fn run_full(args: &[String]) -> Result<(), String> {
         i += 3;
 
         let chapter_ir = read_ir(chapter_ir_path)?;
-        let chapter_domain_name = chapter_ir.get("name").and_then(Json::as_str).unwrap_or("").to_string();
+        let chapter_domain_name = chapter_ir
+            .get("name")
+            .and_then(Json::as_str)
+            .unwrap_or("")
+            .to_string();
 
         let chapter_out_dir = format!("{out_root}/{chapter_mod_name}");
-        let chapter_gen = write_domain(&ex, &chapter_ir, chapter_source_label, chapter_mod_name, &chapter_out_dir)?;
-
-        reference_key_pairs.push((chapter_domain_name.clone(), chapter_gen.registry_aggregates.iter().map(|a| a.name.clone()).collect()));
+        let chapter_gen = write_domain(
+            &ex,
+            &chapter_ir,
+            chapter_source_label,
+            chapter_mod_name,
+            &chapter_out_dir,
+        )?;
+
+        reference_key_pairs.push((
+            chapter_domain_name.clone(),
+            chapter_gen
+                .registry_aggregates
+                .iter()
+                .map(|a| a.name.clone())
+                .collect(),
+        ));
         merged_aggregates.extend(chapter_gen.registry_aggregates);
         merged_queries.extend(chapter_gen.query_defs);
         merged_read_models.extend(chapter_gen.read_model_defs);
-        merged_process_managers.extend(chapter_ir.get("process_managers").map(Json::each).unwrap_or(&[]).to_vec());
+        merged_process_managers.extend(
+            chapter_ir
+                .get("process_managers")
+                .map_or_default(Json::each)
+                .to_vec(),
+        );
 
         chapter_domain_names.push(chapter_domain_name);
         chapter_irs.push(chapter_ir);
     }
 
     // One entry per chapter, so its policies qualify against its own domain and aggregates.
-    let policies: Vec<Json> = target_ir.get("policies").map(Json::each).unwrap_or(&[]).to_vec();
-    let policy_aggregates: Vec<Json> = target_ir.get("aggregates").map(Json::each).unwrap_or(&[]).to_vec();
-
-    let mut policy_sources: Vec<reactions::PolicySource> =
-        vec![reactions::PolicySource { domain_name: &target_domain_name, policies: &policies, aggregates: &policy_aggregates }];
+    let policies: Vec<Json> = target_ir
+        .get("policies")
+        .map_or_default(Json::each)
+        .to_vec();
+    let policy_aggregates: Vec<Json> = target_ir
+        .get("aggregates")
+        .map_or_default(Json::each)
+        .to_vec();
+
+    let mut policy_sources: Vec<reactions::PolicySource> = vec![reactions::PolicySource {
+        domain_name: &target_domain_name,
+        policies: &policies,
+        aggregates: &policy_aggregates,
+    }];
     for (name, ir) in chapter_domain_names.iter().zip(chapter_irs.iter()) {
         policy_sources.push(reactions::PolicySource {
             domain_name: name,
-            policies: ir.get("policies").map(Json::each).unwrap_or(&[]),
-            aggregates: ir.get("aggregates").map(Json::each).unwrap_or(&[]),
+            policies: ir.get("policies").map_or_default(Json::each),
+            aggregates: ir.get("aggregates").map_or_default(Json::each),
         });
     }
 
     let mut merged_rs = String::new();
-    puts_str(&mut merged_rs, &crate::registry::emit_registry(&ex, &merged_aggregates));
+    puts_str(
+        &mut merged_rs,
+        &crate::registry::emit_registry(&ex, &merged_aggregates),
+    );
     puts_blank(&mut merged_rs);
-    puts_str(&mut merged_rs, &crate::registry::emit_reference_lookup(&merged_aggregates));
+    puts_str(
+        &mut merged_rs,
+        &crate::registry::emit_reference_lookup(&merged_aggregates),
+    );
     puts_blank(&mut merged_rs);
-    puts_str(&mut merged_rs, &reactions::emit_merged_policy_table(&ex, &policy_sources));
+    puts_str(
+        &mut merged_rs,
+        &reactions::emit_merged_policy_table(&ex, &policy_sources),
+    );
     puts_blank(&mut merged_rs);
-    puts_str(&mut merged_rs, &reactions::emit_merged_cross_domain_policy_table(&ex, &policy_sources));
+    puts_str(
+        &mut merged_rs,
+        &reactions::emit_merged_cross_domain_policy_table(&ex, &policy_sources),
+    );
     puts_blank(&mut merged_rs);
-    puts_str(&mut merged_rs, &reactions::emit_process_manager_table(&ex, &merged_process_managers));
+    puts_str(
+        &mut merged_rs,
+        &reactions::emit_process_manager_table(&ex, &merged_process_managers),
+    );
     puts_blank(&mut merged_rs);
-    puts_str(&mut merged_rs, &reactions::emit_reference_key_table(&ex, &reference_key_pairs));
+    puts_str(
+        &mut merged_rs,
+        &reactions::emit_reference_key_table(&ex, &reference_key_pairs),
+    );
     puts_blank(&mut merged_rs);
-    puts_str(&mut merged_rs, &reactions::emit_creates_table(&ex, &merged_aggregates));
+    puts_str(
+        &mut merged_rs,
+        &reactions::emit_creates_table(&ex, &merged_aggregates),
+    );
     puts_blank(&mut merged_rs);
-    puts_str(&mut merged_rs, &reactions::emit_identity_head_table(&ex, &merged_aggregates));
+    puts_str(
+        &mut merged_rs,
+        &reactions::emit_identity_head_table(&ex, &merged_aggregates),
+    );
     puts_blank(&mut merged_rs);
     // Section order is part of the output: `hecks regenerate_corpus --check` diffs this file byte for byte.
-    puts_str(&mut merged_rs, &reactions::emit_entity_identity_head_table(&ex, &merged_aggregates));
+    puts_str(
+        &mut merged_rs,
+        &reactions::emit_entity_identity_head_table(&ex, &merged_aggregates),
+    );
     puts_blank(&mut merged_rs);
-    puts_str(&mut merged_rs, &reactions::emit_command_attributes_table(&ex, &merged_aggregates));
+    puts_str(
+        &mut merged_rs,
+        &reactions::emit_command_attributes_table(&ex, &merged_aggregates),
+    );
     puts_blank(&mut merged_rs);
-    puts_str(&mut merged_rs, &queries::emit_query_table(&ex, &merged_queries));
+    puts_str(
+        &mut merged_rs,
+        &queries::emit_query_table(&ex, &merged_queries),
+    );
     puts_blank(&mut merged_rs);
-    puts_str(&mut merged_rs, &queries::emit_query_arg_check_table(&merged_queries));
+    puts_str(
+        &mut merged_rs,
+        &queries::emit_query_arg_check_table(&merged_queries),
+    );
     puts_blank(&mut merged_rs);
     for rmd in &merged_read_models {
         if let Some(body) = &rmd.group_by_fn_body {
@@ -284,7 +374,15 @@ fn run_full(args: &[String]) -> Result<(), String> {
             puts_blank(&mut merged_rs);
         }
     }
-    puts_str(&mut merged_rs, &read_models::emit_read_model_table(&ex, &merged_read_models));
+    puts_str(
+        &mut merged_rs,
+        &read_models::emit_read_model_table(&ex, &merged_read_models),
+    );
+    puts_blank(&mut merged_rs);
+    puts_str(
+        &mut merged_rs,
+        &presenters::emit_present_router(&merged_aggregates),
+    );
 
     let merged_path = format!("{target_out_dir}/merged.rs");
     std::fs::write(&merged_path, &merged_rs).map_err(|e| format!("writing {merged_path}: {e}"))?;
@@ -292,7 +390,8 @@ fn run_full(args: &[String]) -> Result<(), String> {
 
     // `write_domain` already wrote `mod.rs`; only the target directory gets a `merged` module.
     let mod_path = format!("{target_out_dir}/mod.rs");
-    let mut mod_rs = std::fs::read_to_string(&mod_path).map_err(|e| format!("reading {mod_path}: {e}"))?;
+    let mut mod_rs =
+        std::fs::read_to_string(&mod_path).map_err(|e| format!("reading {mod_path}: {e}"))?;
     if !mod_rs.ends_with('\n') {
         mod_rs.push('\n');
     }